{"id":6423,"date":"2007-03-23T19:31:00","date_gmt":"2007-03-23T19:31:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2007\/03\/23\/coding-a-euchre-game-part-8-remember-me-show-me-help-me-matt-gertz\/"},"modified":"2024-07-05T14:49:00","modified_gmt":"2024-07-05T21:49:00","slug":"coding-a-euchre-game-part-8-remember-me-show-me-help-me-matt-gertz","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/coding-a-euchre-game-part-8-remember-me-show-me-help-me-matt-gertz\/","title":{"rendered":"Coding a Euchre Game, Part 8: Remember Me, Show Me, Help Me (Matt Gertz)"},"content":{"rendered":"

Coding a Euchre Game, Part 8:  <\/span>Remember Me, Show Me, Help Me<\/span><\/font><\/font><\/font><\/h2>\n

We\u2019re getting close to wrapping up this series.  <\/span>In this post, I want to cover several \u201cclean up\u201d topics, and then in the following post, I\u2019ll talk about deployment and will attach the entire codebase for your perusal.<\/font><\/font><\/span><\/p>\n

Settings<\/font><\/font><\/font><\/span><\/h2>\n

You\u2019ll note, from earlier posts, that there are a lot of options around variations in the Euchre rules, options for AI personalities, options for sound, and even options for the names of the players.  <\/span>Obviously, it would be really annoying if you had to specify those at the beginning of each session!  <\/span>The best thing to do would be to persist the user\u2019s choices for each option and reload them whenever the game is launched.  <\/span>Now, in \u201cYe Olde Days,\u201d what you\u2019d typically do is create or open a user options file, figure out a format in which to store this data, and then write it or read it as appropriate.  <\/span>This was a mildly annoying process in that you\u2019d have to re-code your format (and potentially add code to be backwards-compatible) every time you added options, plus you\u2019d have to figure out where to store the options, etc.  <\/span>Fortunately, there\u2019s a better way to do this in VS2005 \u2013 it\u2019s so easy that once you start using it, you\u2019ll never go back to doing it the old way!<\/font><\/p>\n

The mechanism to use to implement setting persistence is My.Settings.  <\/span>Using this mechanism allows you to treat each setting as if it were a property, *plus* with one line of code you can save or retrieve settings from an application data file that is automatically created for you \u2013 and you don\u2019t even need to keep track of where the file is!  <\/span>There\u2019s also support for versioning, so that you can have different settings for different versions of your app.  <\/span>Here\u2019s how you do it:<\/font><\/p>\n

(1)<\/font>    <\/span><\/span><\/span>Bring up the project\u2019s properties (right-click the project, choose \u201cProperties\u201d), and click on the Settings tab.<\/font><\/p>\n

(2)<\/font>    <\/span><\/span><\/span>You\u2019ll notice a grid appears.  <\/span>In the grid, choose a name for the setting (e.g., \u201cPlayerName\u201d), the type of the setting  <\/span>(e.g., String), and the default value (e.g., \u201cPlayer 1\u201d).  <\/span>Leave the scope as user.  <\/span>(If you set it to \u201capplication,\u201d then everyone would share the same options, which would be annoying in this case.)  <\/span>Continue to do this for each setting, using Booleans for checkboxes, Integers for the voice indices, etc.  <\/span>I\u2019ve attached a picture of what mine look like.<\/font><\/p>\n

(3)<\/font>    <\/span><\/span><\/span>Now, open up the options dialog, and double-click it to automatically create the  <\/span>event handler for \u201cLoad.\u201d  <\/span>In that event handler, add the code to initialize the dialog with the user settings \u2013 for example:<\/font><\/p>\n

        <\/span>Me<\/span>.PlayerName.Text = My<\/span>.Settings.PlayerName<\/span><\/p>\n

        <\/span>Me<\/span>.LeftVoiceCombo.SelectedIndex = My<\/span>.Settings.LeftOpponentVoice<\/span><\/p>\n

        <\/span>Me<\/span>.SoundOn.Checked = My<\/span>.Settings.SoundOn<\/span><\/p>\n

        <\/span>Me<\/span>.LeftOpponentCrazy.Checked = (My<\/span>.Settings.LeftOpponentPlay = 1)<\/span><\/p>\n

        <\/span><\/span>‘ Etc\u2026 for brevity\u2019s sake, I\u2019ve left out a lot of these<\/span><\/p>\n

(4)<\/font>    <\/span><\/span><\/span>Then the other half of this is persisting out the settings, so double-click on the \u201cOK\u201d button to create its click event handler, and add code opposite of what you did before, such as the following:<\/font><\/font><\/span><\/p>\n

        <\/span>My<\/span>.Settings.PlayerName = Me<\/span>.PlayerName.Text<\/span><\/p>\n

        <\/span>My<\/span>.Settings.LeftOpponentVoice = Me<\/span>.LeftVoiceCombo.SelectedIndex<\/span><\/p>\n

        <\/span>My<\/span>.Settings.SoundOn = Me<\/span>.SoundOn.Checked<\/span><\/p>\n

        <\/span>If<\/span> Me<\/span>.LeftOpponentCrazy.Checked = True<\/span> Then<\/span><\/span><\/p>\n

            <\/span>My<\/span>.Settings.LeftOpponentPlay = 1<\/span><\/p>\n

        <\/span>ElseIf<\/span> LeftOpponentNormal.Checked = True<\/span> Then<\/span><\/span><\/p>\n

            <\/span>My<\/span>.Settings.LeftOpponentPlay = 2<\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>My<\/span>.Settings.LeftOpponentPlay = 3<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span><\/span>‘ Etc\u2026 again, for brevity\u2019s sake, I\u2019ve left out a lot of these<\/span><\/p>\n

 <\/font><\/span><\/p>\n

That\u2019s *it*; that\u2019s all you have to do.  <\/span>The settings will be persisted when the app closes, and loaded when the app is launched. You don\u2019t have to do anything.  <\/span>You can even hook up a \u201cReset\u201d button which will call My.Settings.Reset to return the setting to the \u201cfactory defaults.\u201d  <\/span>The code to handle this is autogenerated for you in the normally-hidden files settings.settings.vb, application.myapp, etc., and the settings themselves are persisted in a (similarly normally-hidden) application data file called user.config in the user\u2019s personal directory.  <\/span>(See <\/font>http:\/\/msdn2.microsoft.com\/en-us\/library\/a65txexh(VS.80).aspx<\/font><\/a> if you really want to know all of the gory details.) You can also turn off saving the settings at shutdown from the \u201cApplication\u201d tab in the project\u2019s properties (in which case you\u2019d use My.Settings.Save to save them programmatically.)<\/font><\/font><\/span><\/p>\n

One more note before we move on to the next topic \u2013 you should always think twice before storing sensitive information like passwords, etc., using user settings.  <\/span>Although nominally confined to the user\u2019s own directory, the data in the user file still stored in clear text, so why take the chance?<\/font><\/font><\/span><\/p>\n

<\/span><\/p>\n

Rich Text Box Controls & Help<\/font><\/font><\/font><\/span><\/h2>\n

Edit boxes have been a mainstay of applications since graphical interfaces first began, but let\u2019s face it; they\u2019re terrible to deal with regarding formatting.  <\/span>Rich Text Box controls are definitely the way to go if you need to do lots of fancy things with text.  <\/span>I use a couple of them in my Euchre application, so let\u2019s take a peek at those.<\/font><\/p>\n

The first one I use is on the table form itself.  <\/span>I use the rich text edit control to keep repeat back to the user what\u2019s happening in the game.  <\/span>For example, when Player 2 plays a card, I repeat back \u201cPlayer 2 plays the Left Bower\u201d or whatever the card was.  <\/span>The idea here is that the user can scroll back through history and see what\u2019s already happened.  <\/span>Now, in the actual game of Euchre, players are forbidden from looking through tricks that have already been played, and this might seem to fly in the face of that rule, but this sort of counterbalances the impersonality of the game \u2013 in real life, the player would probably yell \u201cAha! My Left Bower takes all of your pitiful little cards\u2026 come to daddy\u2026mine, mine, all mine\u2026,\u201d which would certainly stick in one\u2019s memory in a way which the AI could never do (at least as coded).<\/font><\/p>\n

So, I need a control that can take a lot of text and which can have a scroll bar.  <\/span>That pretty well eliminates the normal edit box as well as the label control, so I\u2019ve used a rich text box control here.  <\/span>The initialization is fairly simple:  <\/span>set ReadOnly to True, ScrollBars to Vertical, and the backcolor & font to whatever appeals to you (I\u2019ve gone for a light yellow background with Copperplate Gothic  <\/span>12pt. as the font).  <\/span>I don\u2019t need any validation on the control, so I set CausesValidation to False, and I\u2019ve also set DetectUrls to False since I won\u2019t have any and so I don\u2019t need the control wasting time trying to figure that out.<\/font><\/p>\n

Now, as far as using it goes \u2013 also very simple.  <\/span>The following code does the trick for me:<\/font><\/p>\n

    <\/span>Public<\/span> Sub<\/span> UpdateStatus(ByVal<\/span> s As<\/span> String<\/span>, _<\/span><\/p>\n

Optional<\/span> ByVal<\/span> WhiteSpace As<\/span> Integer<\/span> = 1)<\/span><\/p>\n

        <\/span>Me<\/span>.StatusArea.AppendText(s)<\/span><\/p>\n

        <\/span>If<\/span> WhiteSpace > 0 Then<\/span><\/span><\/p>\n

            <\/span>For<\/span> i As<\/span> Integer<\/span> = 1 To<\/span> WhiteSpace<\/span><\/p>\n

                <\/span>Me<\/span>.StatusArea.AppendText(vbCrLf)<\/span><\/p>\n

            <\/span>Next<\/span><\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

        <\/span>Me<\/span>.StatusArea.Update()<\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/font><\/p>\n

Where the usage is something like (in the EuchrePlayer class):<\/font><\/p>\n

  <\/span>Dim<\/span> s As<\/span> New<\/span> StringBuilder()<\/span><\/p>\n

  <\/span>s.AppendFormat(My<\/span>.Resources.Notice_IPickItUpAlone, GetDisplayName(Table), _<\/span><\/p>\n

  <\/span>   <\/span>My<\/span>.Resources.ResourceManager.GetString( _<\/span><\/p>\n

          <\/span>EuchreCard.GetSuitDisplayStringResourceName(Table.TrumpSuit)))<\/span><\/p>\n

  <\/span>Table.UpdateStatus(s.ToString)<\/span><\/p>\n

 <\/font><\/p>\n

To (in this example) format a string which says \u201cPlayer 1 says ‘I\u2019m picking it up and going alone \u2013 trump is spades’\u201d and then applying it to the control without adding extra line spacing after it.<\/font><\/p>\n

So far, so good \u2013 none of that seems earth-shattering.  <\/span>However, I\u2019ve got another rich text box that I use for Help.  <\/span>Rather than jump in with the control, let\u2019s start at the beginning and talk about Help.<\/font><\/p>\n

Help<\/font><\/h2>\n

There\u2019s nothing magic about supporting Help.  <\/span>Help is just another event, albeit one that everyone is familiar with.  <\/span>You may have noticed a few posts back that I added a \u201cHelp\u201d menu item to my menustrip control.  <\/span>I have two entries in that menu: \u201cAbout\u2026\u201d and \u201cRules\u2026\u201d  <\/span>Let\u2019s take these separately:<\/font><\/p>\n

\u201cAbout\u2026\u201d <\/font><\/h3>\n

 <\/span>Right-click the project, choose \u201cAdd\u201d and then \u201cWindows Form.\u201d  <\/span>Select \u201cAbout Box\u201d from the resulting dialog and give the file a name such as \u201cEuchreAboutBox.\u201d  <\/span>Click \u201cAdd\u201d to add it to the project.  <\/span>(The \u201cAbout\u201d box will auto populate with the typical application information at runtime, although you can tweak it however you like by opening the form in the usual way.)  <\/span>Now, double-click on the \u201cAbout\u2026\u201d menu item on the menustrip and add these two lines to the resulting event handler:<\/font><\/font><\/p>\n

                <\/font><\/span>  <\/span>Dim<\/span> dlg As<\/span> New<\/span> EuchreAboutBox<\/span><\/p>\n

          <\/span>dlg.ShowDialog()<\/span><\/p>\n

 <\/font><\/p>\n

That\u2019s it; all done.<\/font><\/p>\n

\u201cRules\u2026\u201d<\/font><\/h3>\n

This is very similar to \u201cAbout\u2026\u201d, but instead I\u2019m going to add a normal \u201cWindows Form\u201d to the project instead of an About Box.  <\/span>(You may prefer to have rules come up in the typical \u201csearch\/index\/contents\u201d sort of help, but that\u2019s a topic for a different time\u2026 I mean, it *is* just a card game, and anyway I want to demonstrate another property of the Rich Text Box.)  <\/span>To this form I\u2019m just going to add a rich text box and a button.  <\/span>The button is labeled \u201cClose,\u201d and all it does is dismiss the form, so I set its its click event to Me.Close(), and otherwise I pretty much leave it alone.  <\/span>The rich text box is similarly simple: I choose a font and background color that I like and set those in the properties, I set it to read-only, and give it a name such as \u201cRtfRules.\u201d  <\/span>(\u201cScroll Bars\u201d already defaults to \u201cBoth\u201d so I leave it alone.)  <\/span>Then, I add one line of code in the Form Load Event to leverage that property I alluded to before:<\/font><\/p>\n

     <\/span>   <\/span>Me<\/span>.RtfRules.Rtf = My<\/span>.Resources.VBEuchreRules<\/span><\/p>\n

 <\/font><\/p>\n

Which connects the Rich Text Box to an RTF file I have stored in my resource manager.  <\/span>Yes, you can add RTF files to the resource manager, the same way you add any other resource!  <\/span>In my case, I created a nice-looking “rules” file in Word, saved it as an RTF file, chucked it into the resource manager, and reference it as above.  If I need to change the RTF file, I just right-click the RTF file (which will show up in my project treeview) and choose “Open with Word,” then rebuild once I’ve saved the file again.  Using the Rich Text Box and the RTF file is <\/span>simple, it looks nice, and Rich Text Boxes already have a property which can accept RTF as a target so I\u2019m all set.  <\/span>I just need to bring up the Rules form when requested:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> RulesToolStripMenuItem_Click(ByVal<\/span> sender As<\/span> System.Object, _<\/span><\/p>\n

 <\/span>ByVal<\/span> e As<\/span> System.EventArgs) Handles<\/span> RulesToolStripMenuItem.Click<\/span><\/p>\n

        <\/span>Dim<\/span> rulesform As<\/span> Object<\/span> = My<\/span>.Application.OpenForms(“EuchreRules”<\/span>)<\/span><\/p>\n

        <\/span>If<\/span> rulesform Is<\/span> Nothing<\/span> Then<\/span><\/span><\/p>\n

            <\/span>Dim<\/span> x As<\/span> New<\/span> EuchreRules<\/span><\/p>\n

            <\/span>x.Show()<\/span><\/p>\n

        <\/span>Else<\/span><\/span><\/p>\n

            <\/span>CType<\/span>(rulesform, EuchreRules).Activate()<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/font><\/p>\n

This is a *modeless* dialog (so you can see the rules while playing), so I first check to see if the dialog already exists by leveraging the My.Application.OpenForms functionality.  <\/span>If it doesn\u2019t exist yet, I create it using Show() (not<\/b> ShowDialog(), which would make it modal).  <\/span>If it does exist, then I bring it to the front via Activate(), first casting the object to the form’s type so that I can access that method.<\/font><\/p>\n

Of course, you can link it up to the F1 key as well.  <\/span>Back in the form editor for the main form, select the \u201cRules\u2026\u201d item and set the ShortcutKeyDisplay property to \u201cF1\u201d (without quotes; that\u2019s the text that will display on the menu next to the item)  <\/span>and then also set the ShortcutKeys property to F1<\/b>, to indicate the keystroke that will trigger the menu item.  <\/span>That\u2019s all it takes!  <\/span><\/font><\/font><\/p>\n

(As an aside:  <\/span>you could also do this without setting the Shortcuts property by handling the KeyUp event yourself, though I don\u2019t recommend it.  <\/span>To do this, right-click on the EuchreTable file and choose \u201cView Code.\u201d  <\/span>Now, at the top of editor, you\u2019ll see two dropdowns.  <\/span>Change the left dropdown to say \u201c(EuchreTable Events).\u201d  <\/span>In the right dropdown, select \u201cKeyUp.\u201d  <\/span>A handler will be inserted for the KeyUp event, into which you could add this code:<\/font><\/p>\n

    <\/span>Private<\/span> Sub<\/span> EuchreTable_KeyUp(ByVal<\/span> sender As<\/span> Object<\/span>, _<\/span><\/p>\n

ByVal<\/span> e As<\/span> System.Windows.Forms.KeyEventArgs) Handles<\/span> Me<\/span>.KeyUp<\/span><\/p>\n

        <\/span>If<\/span> e.KeyCode = Keys.F2 Then<\/span><\/span><\/p>\n

            <\/span>NewGame()<\/span><\/p>\n

        <\/span>End<\/span> If<\/span><\/span><\/p>\n

    <\/span>End<\/span> Sub<\/span><\/span><\/p>\n

 <\/font><\/p>\n

That\u2019s not as good as using the ShortcutKeys property, though, because it will also accept Alt+F1, Ctrl+F1, etc, and you’d have to add more logic to check for these keys.  <\/span>However, it is useful to know how to add arbitrary event handlers to a form, which is why I mention it at all.)<\/font><\/p>\n

Are we there yet?<\/font><\/font><\/font><\/span><\/h2>\n

Almost!  <\/span>There are a couple of little clean-up things we need to do first that I thought I\u2019d mention:<\/font><\/p>\n

Tab stops<\/font><\/font><\/font><\/span><\/h3>\n

Many people use keystrokes to navigate around a form (instead of the mouse). To support this, we need to make sure that the tab order makes sense.  <\/span>For the Euchre game, we\u2019re mostly concerned about the options dialog and the bidding dialogs, to make sure that tabbing moves the selection appropriately.  <\/span>(Ideally, I should do this for the cards themselves, to make them selectable by the keyboard, but I\u2019ll leave that as an exercise for the reader. <\/font>J<\/span><\/span>)  <\/span><\/font><\/font><\/p>\n

To fix the tab order for any form, just choose \u201cTab Order\u201d from the View menu.  <\/span>The current order will be shown; just click controls in the order in which you wish tabbing to occur, and then choose \u201cTab Order\u201d again when you\u2019re done.  <\/span>You should note that you can nest tabbing orders next within groups of objects, so that (for example) you don\u2019t tab through all of the radio buttons in a group \u2013 the user then tab to the active one and then use arrow keys to select.  <\/span>The form editor will do this setup for you automatically when you\u2019re selecting the tab order \u2013 it understands that group boxes contain things and that radio buttons are special.  <\/span>I\u2019ve attached a picture of the tab order for the Euchre options dialog to this post so you can see what I mean.<\/font><\/p>\n

<\/span><\/p>\n

Application icons<\/font><\/font><\/font><\/span><\/h3>\n

Of course, you will want an icon for an application.  <\/span>Visual Studio has a built-in icon editor, and you can get to it by bringing up the resource manager and either adding a new icon (via Add Resource<\/font>\u00e0<\/span><\/span>Add New Icon) or simply adding an existing *.ico file via Add Resource<\/font>\u00e0<\/span><\/span>Add Existing File, which will copy it into your project folder.  (Actually, if you already have an existing icon file to be used with a form or application, you need not add it to the RM for reasons that will become apparent below.)  <\/span>I won\u2019t attempt to describe the use of the icon editor to you in this post, as it’s not radically different from any other drawing program and many of you are already familiar with it anyway.  <\/span>What\u2019s more important is *how* you use the resulting icon.  <\/span>What many people don\u2019t realize is that each form has its own icon property, plus the application has an icon property as well, and these all need to be set to your icon(s) or else you\u2019ll get the default Windows icon for them.<\/font><\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>To set the application\u2019s icon:  <\/span>Bring up the project properties, click the Application tab, select \u201cBrowse\u2026\u201d on the Icon field and point to your icon\u2019s file (which will have been copied into the project\u2019s folder).  <\/span>This icon is what people will see attached to the EXE.<\/font><\/p>\n

–<\/font>          <\/span><\/span><\/span>To set a form\u2019s icon, open the form and click the \u201c\u2026\u201d button in the Icon property in the grid.  <\/span>Again, browse to the appropriate file.  <\/span>This is the icon that people will see in the upper-left corner of the form.<\/font><\/p>\n

Note that both of these require you to browse to a file rather than use the resource, even though the resource may already be in the resource manager — this is an exception to the rule.  (The icons you point to get copied to separate resource managers which belong directly to the owning object — so don’t worry, you won’t be required to deploy a stand-along icon file!) <\/font><\/p>\n

I use one 32×32 color icon in my application; you should probably have a 16×16 color icon as well, since that\u2019s what the form is going to show.  <\/span>Windows does a pretty good job squishing a 32×32 icon into a 16×16 space, but you might not want to leave it to chance.<\/font><\/p>\n

So, I\u2019ve covered all of the points I wanted to touch on regarding the actual coding of the game.  <\/span>Next time, I\u2019ll discuss deployment and will then post the final code.  Talk to you then!<\/font><\/p>\n

–Matt–*<\/font><\/p>\n

EuchrePost8picture.zip<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

Coding a Euchre Game, Part 8:  Remember Me, Show Me, Help Me We\u2019re getting close to wrapping up this series.  In this post, I want to cover several \u201cclean up\u201d topics, and then in the following post, I\u2019ll talk about deployment and will attach the entire codebase for your perusal. Settings You\u2019ll note, from earlier […]<\/p>\n","protected":false},"author":258,"featured_media":8818,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[22,195],"tags":[101,165],"class_list":["post-6423","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-matt-gertz","category-visual-basic","tag-matt-gertz","tag-vb2005"],"acf":[],"blog_post_summary":"

Coding a Euchre Game, Part 8:  Remember Me, Show Me, Help Me We\u2019re getting close to wrapping up this series.  In this post, I want to cover several \u201cclean up\u201d topics, and then in the following post, I\u2019ll talk about deployment and will attach the entire codebase for your perusal. Settings You\u2019ll note, from earlier […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/6423","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/users\/258"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/comments?post=6423"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/posts\/6423\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media\/8818"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/media?parent=6423"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/categories?post=6423"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/vbteam\/wp-json\/wp\/v2\/tags?post=6423"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}