{"id":29404,"date":"2020-08-25T06:31:10","date_gmt":"2020-08-25T13:31:10","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=29404"},"modified":"2020-08-26T08:35:44","modified_gmt":"2020-08-26T15:35:44","slug":"new-c-source-generator-samples","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/new-c-source-generator-samples\/","title":{"rendered":"New C# Source Generator Samples"},"content":{"rendered":"

Phillip introduced C# Source Generators here<\/a>. This post describes two new generators that we added to the samples project<\/a> in the Roslyn SDK github repo.<\/p>\n

The first generator gives you strongly typed access to CSV<\/a> data. The second one creates string constants based on Mustache<\/a> specifications.<\/p>\n

<\/a>Source Generators Overview<\/h2>\n

It is important to have a good mental picture of how source generators operate. Conceptually, a generator is a function that takes some input (more on that later) and generates C# code as output. This ‘function’ runs before<\/em> the code for the main project is compiled. In fact, its output becomes part of the project.<\/p>\n

The inputs to a generator must be available at compile time, because that’s when generators run. In this post we explore two different ways to provide it.<\/p>\n

You use a generator in your project by either referencing a generator project or by referencing the generator assembly directly. In the samples project this is achieved by the following instruction in the project file:<\/p>\n

\n
<ItemGroup<\/span>>\r\n    <ProjectReference<\/span> Include<\/span>=\"<\/span>..\\SourceGeneratorSamples\\SourceGeneratorSamples.csproj\"<\/span><\/span>\r\n                            OutputItemType<\/span>=\"<\/span>Analyzer\"<\/span><\/span> ReferenceOutputAssembly<\/span>=\"<\/span>false\"<\/span><\/span> \/>\r\n<\/ItemGroup<\/span>><\/pre>\n<\/div>\n
<\/a>CSV Generator Usage<\/h2>\n
The CSV Generator takes as an input CSV files and returns strongly typed C# representations of them as output. You specify the CSV files with the following lines in the project file:<\/p>\n
\n
<ItemGroup<\/span>>\r\n    <AdditionalFiles<\/span> Include<\/span>=\"<\/span>People.csv\"<\/span><\/span> CsvLoadType<\/span>=\"<\/span>Startup\"<\/span><\/span> \/>\r\n    <AdditionalFiles<\/span> Include<\/span>=\"<\/span>Cars.csv\"<\/span><\/span> CsvLoadType<\/span>=\"<\/span>OnDemand\"<\/span><\/span> CacheObjects<\/span>=\"<\/span>true\"<\/span><\/span> \/>\r\n<\/ItemGroup<\/span>><\/pre>\n<\/div>\n
Where the People.csv<\/code> file looks like so:<\/p>\n
Name, address, 11Age\r\n\"Luca Bol\", \"23 Bell Street\", 90\r\n\"john doe\", \"32 Carl street\", 45\r\n<\/code><\/pre>\n
There are two additional arguments that get passed as part of the input in the project file AdditionalFiles<\/code> tag: CsvLoadType<\/code> and CacheObjects<\/code>. CsvLoadType<\/code> can take the value of Startup<\/code> or OnDemand<\/code>: the former instruct the code to load the objects representing the CSV file when the program starts; the latter loads them at first usage. CacheObjects<\/code> is a bool<\/code> indicating if the objects need to be cached after creation.<\/p>\n
It can be a little confusing to keep straight when exactly every phase runs. The generation of classes representing the shape of the CSV file happens at compile time<\/em>, while the creation of the objects for each row of the file happens at run time<\/em> according to the policy specified by CsvLoadType<\/code> and CacheObjects<\/code>.<\/p>\n
BTW: the 11Age<\/code> column name came about as a way to test that the C# generation is correct in case of columns starting with a number.<\/p>\n
Given such input, the generator creates a CSV<\/code> namespace that you can import in your code with:<\/p>\n
\n
using<\/span> CSV<\/span>;<\/pre>\n<\/div>\n
In the namespace there is one class for each CSV file. Each class contains an All<\/code> static property that can be used like so:<\/p>\n
\n
WriteLine<\/span>(\"<\/span>## CARS\"<\/span><\/span>);\r\nCars<\/span>.All<\/span>.ToList<\/span>().ForEach<\/span>(c<\/span> =><\/span> WriteLine<\/span>($\"<\/span>{c<\/span>.Brand<\/span>}\\t<\/span>{c<\/span>.Model<\/span>}\\t<\/span>{c<\/span>.Year<\/span>}\\t<\/span>{c<\/span>.Cc<\/span>}\"<\/span><\/span>));\r\nWriteLine<\/span>(\"<\/span>\\n<\/span>## PEOPLE\"<\/span><\/span>);\r\nPeople<\/span>.All<\/span>.ToList<\/span>().ForEach<\/span>(p<\/span> =><\/span> WriteLine<\/span>($\"<\/span>{p<\/span>.Name<\/span>}\\t<\/span>{p<\/span>.Address<\/span>}\\t<\/span>{p<\/span>._11Age<\/span>}\"<\/span><\/span>));<\/pre>\n<\/div>\n
So that’s how you use the generator. Let’s now look at how it is implemented.<\/p>\n
<\/a>CSV Generator Implementation<\/h2>\n
Inside the generator project<\/a> you need a class implementing the ISourceGenerator<\/code> interface with a Generator<\/code> attribute.<\/p>\n
\n
[Generator<\/span>]\r\npublic<\/span> class<\/span> CSVGenerator<\/span> : ISourceGenerator<\/span><\/pre>\n<\/div>\n
The Execute<\/code> method is the entry point. It gets called by the compiler to start the generation process. Ours looks like this:<\/p>\n
\n
public<\/span> void<\/span> Execute<\/span>(SourceGeneratorContext<\/span> context<\/span>)\r\n{\r\n    IEnumerable<\/span><(CsvLoadType<\/span>, bool<\/span>, AdditionalText<\/span>)> options<\/span> =<\/span> GetLoadOptions<\/span>(context<\/span>);\r\n    IEnumerable<\/span><(string<\/span>, string<\/span>)> nameCodeSequence<\/span> =<\/span> SourceFilesFromAdditionalFiles<\/span>(options<\/span>);\r\n    foreach<\/span> ((string<\/span> name<\/span>, string<\/span> code<\/span>) in<\/span> nameCodeSequence<\/span>)\r\n        context<\/span>.AddSource<\/span>($\"<\/span>Csv_{name<\/span>}\"<\/span><\/span>, SourceText<\/span>.From<\/span>(code<\/span>, Encoding<\/span>.UTF8<\/span>));\r\n}<\/pre>\n<\/div>\n
We first get the options – CsvLoadType<\/code> and CacheObjects<\/code> from the project file – we then generate the source files by reading the additional files and add them to the project.<\/p>\n
Getting the options is just a few easy calls to the analyzer apis:<\/p>\n
\n
static<\/span> IEnumerable<\/span><(CsvLoadType<\/span>, bool<\/span>, AdditionalText<\/span>)> GetLoadOptions<\/span>(SourceGeneratorContext<\/span> context<\/span>)\r\n{\r\n    foreach<\/span> (AdditionalText<\/span> file<\/span> in<\/span> context<\/span>.AdditionalFiles<\/span>)\r\n    {\r\n        if<\/span> (Path<\/span>.GetExtension<\/span>(file<\/span>.Path<\/span>).Equals<\/span>(\"<\/span>.csv\"<\/span><\/span>, StringComparison<\/span>.OrdinalIgnoreCase<\/span>))\r\n        {\r\n            \/\/<\/span> are there any options for it?<\/span>\r\n            context<\/span>.AnalyzerConfigOptions<\/span>.GetOptions<\/span>(file<\/span>)\r\n                .TryGetValue<\/span>(\"<\/span>build_metadata.additionalfiles.CsvLoadType\"<\/span><\/span>, out<\/span> string<\/span>? loadTimeString<\/span>);\r\n            Enum<\/span>.TryParse<\/span>(loadTimeString<\/span>, ignoreCase<\/span>: true<\/span>, out<\/span> CsvLoadType<\/span> loadType<\/span>);\r\n\r\n            context<\/span>.AnalyzerConfigOptions<\/span>.GetOptions<\/span>(file<\/span>)\r\n                .TryGetValue<\/span>(\"<\/span>build_metadata.additionalfiles.CacheObjects\"<\/span><\/span>, out<\/span> string<\/span>? cacheObjectsString<\/span>);\r\n            bool<\/span>.TryParse<\/span>(cacheObjectsString<\/span>, out<\/span> bool<\/span> cacheObjects<\/span>);\r\n\r\n            yield<\/span> return<\/span> (loadType<\/span>, cacheObjects<\/span>, file<\/span>);\r\n        }\r\n    }\r\n}<\/pre>\n<\/div>\n
Once the options are retrieved, the process of generating C# source files to represent the CSV data can start.<\/p>\n
\n
static<\/span> IEnumerable<\/span><(string<\/span>, string<\/span>)> SourceFilesFromAdditionalFile<\/span>(CsvLoadType<\/span> loadTime<\/span>,\r\n    bool<\/span> cacheObjects<\/span>, AdditionalText<\/span> file<\/span>)\r\n{\r\n    string<\/span> className<\/span> =<\/span> Path<\/span>.GetFileNameWithoutExtension<\/span>(file<\/span>.Path<\/span>);\r\n    string<\/span> csvText<\/span> =<\/span> file<\/span>.GetText<\/span>()!<\/span>.ToString<\/span>();\r\n    return<\/span> new<\/span> (string<\/span>, string<\/span>)[] { (className<\/span>, GenerateClassFile<\/span>(className<\/span>, csvText<\/span>, loadTime<\/span>, cacheObjects<\/span>)) };\r\n}\r\n\r\nstatic<\/span> IEnumerable<\/span><(string<\/span>, string<\/span>)> SourceFilesFromAdditionalFiles<\/span>(IEnumerable<(CsvLoadType<\/span> loadTime<\/span>,\r\n    bool<\/span> cacheObjects<\/span>, AdditionalText<\/span> file<\/span>)> pathsData)\r\n    =><\/span> pathsData<\/span>.SelectMany<\/span>(d<\/span> =><\/span> SourceFilesFromAdditionalFile<\/span>(d<\/span>.loadTime<\/span>, d<\/span>.cacheObjects<\/span>, d<\/span>.file<\/span>));<\/pre>\n<\/div>\n
We iterate over all the CSV files and generate a class file for each one of them by calling GenerateClassFile<\/code>. This is where the magic happens: we look at the csv content and we generate the correct class file to add to the project.<\/p>\n
But this is a long function (code<\/a>), so let’s just look at the start and the end of it to get the flavour.<\/p>\n
\n
public<\/span> static<\/span> string<\/span> GenerateClassFile<\/span>(string<\/span> className<\/span>, string<\/span> csvText<\/span>, CsvLoadType<\/span> loadTime<\/span>,\r\n    bool<\/span> cacheObjects<\/span>)\r\n{\r\n    StringBuilder<\/span> sb<\/span> =<\/span> new<\/span> StringBuilder<\/span>();\r\n    using<\/span> CsvTextFieldParser<\/span> parser<\/span> =<\/span> new<\/span> CsvTextFieldParser<\/span>(new<\/span> StringReader<\/span>(csvText<\/span>));\r\n\r\n    \/\/<\/span>\/\/ Usings<\/span>\r\n    sb<\/span>.Append<\/span>(@\"<\/span><\/span>\r\n#nullable enable<\/span>\r\nnamespace CSV {<\/span>\r\nusing System.Collections.Generic;<\/span>\r\n\r\n\"<\/span><\/span>);\r\n    \/\/<\/span>\/\/ Class Definition<\/span>\r\n    sb<\/span>.Append<\/span>($\"<\/span>    public class {className<\/span>} {{\\n<\/span>\"<\/span><\/span>);<\/pre>\n<\/div>\n
First we add a new class to the CSV<\/code> namespace. The name of the class corresponds to the CSV file name. Then we generate the code for the class and return it.<\/p>\n
\n
    \/\/<\/span> CODE TO GENERATE C# FROM THE CSV FILE ...<\/span>\r\n\r\n    sb<\/span>.Append<\/span>(\"<\/span>            }\\n<\/span>        }\\n<\/span>    }\\n<\/span>}\\n<\/span>\"<\/span><\/span>);\r\n    return<\/span> sb<\/span>.ToString<\/span>();\r\n}<\/pre>\n<\/div>\n
In the end, the compiler adds to our project\na file called Csv_People.cs<\/code> containing the code below.<\/p>\n
\n
#nullable enable\r\nnamespace<\/span> CSV<\/span> {\r\n    using<\/span> System<\/span>.Collections<\/span>.Generic<\/span>;\r\n\r\n    public<\/span> class<\/span> People<\/span> {\r\n\r\n        static<\/span> People<\/span>() { var<\/span> x<\/span> =<\/span> All<\/span>; }\r\n        public<\/span> string<\/span> Name<\/span> { get<\/span>; set<\/span>;} =<\/span> default<\/span>!<\/span>;\r\n        public<\/span> string<\/span> Address<\/span> { get<\/span>; set<\/span>;} =<\/span> default<\/span>!<\/span>;\r\n        public<\/span> int<\/span> _11Age<\/span> { get<\/span>; set<\/span>;} =<\/span> default<\/span>!<\/span>;\r\n\r\n        static<\/span> IEnumerable<\/span><People<\/span>>? _all<\/span> =<\/span> null<\/span>;\r\n\r\n        public<\/span> static<\/span> IEnumerable<\/span><People<\/span>> All<\/span> {\r\n            get<\/span> {\r\n\r\n                List<\/span><People<\/span>> l<\/span> =<\/span> new<\/span> List<\/span><People<\/span>>();\r\n                People<\/span> c<\/span>;\r\n                c<\/span> =<\/span> new<\/span> People<\/span>();\r\n                c<\/span>.Name<\/span> =<\/span> \"<\/span>Luca Bol\"<\/span><\/span>;\r\n                c<\/span>.Address<\/span> =<\/span> \"<\/span>23 Bell Street\"<\/span><\/span>;\r\n                c<\/span>._11Age<\/span> =<\/span>  90<\/span>;\r\n                l<\/span>.Add<\/span>(c<\/span>);\r\n                c<\/span> =<\/span> new<\/span> People<\/span>();\r\n                c<\/span>.Name<\/span> =<\/span> \"<\/span>john doe\"<\/span><\/span>;\r\n                c<\/span>.Address<\/span> =<\/span> \"<\/span>32 Carl street\"<\/span><\/span>;\r\n                c<\/span>._11Age<\/span> =<\/span>  45<\/span>;\r\n                l<\/span>.Add<\/span>(c<\/span>);\r\n                _all<\/span> =<\/span> l<\/span>;\r\n                return<\/span> l<\/span>;\r\n            }\r\n        }\r\n    }\r\n}<\/pre>\n<\/div>\n
This is what gets compiled into your project, so that you can reference it from the code.<\/p>\n
<\/a>Mustache Generator Usage<\/h2>\n
For the Mustage Generator<\/a>, we use a different way to pass input arguments compared to the CSV Generator above.\nWe embed our input in assembly attributes and then, in the generator code, we fish them out of the assembly to\ndrive the generation process.<\/p>\n
In our client code, we pass the inputs to the generator as below:<\/p>\n
\n
using<\/span> Mustache<\/span>;\r\n\r\n[assembly<\/span>: Mustache<\/span>(\"<\/span>Lottery\"<\/span><\/span>, t1<\/span>, h1<\/span>)]\r\n[assembly<\/span>: Mustache<\/span>(\"<\/span>HR\"<\/span><\/span>, t2<\/span>, h2<\/span>)]\r\n[assembly<\/span>: Mustache<\/span>(\"<\/span>HTML\"<\/span><\/span>, t3<\/span>, h3<\/span>)]\r\n[assembly<\/span>: Mustache<\/span>(\"<\/span>Section\"<\/span><\/span>, t4<\/span>, h4<\/span>)]\r\n[assembly<\/span>: Mustache<\/span>(\"<\/span>NestedSection\"<\/span><\/span>, t5<\/span>, h5<\/span>)]<\/pre>\n<\/div>\n
The first argument to the Mustache<\/code> attribute is the name of a static property that gets generated in the Mustache.Constants<\/code> class.<\/p>\n
The second argument represents the mustache template to use. In the demo we use the templates from the manual<\/a>.\nFor example:<\/p>\n
\n
public<\/span> const<\/span> string<\/span> t1<\/span> =<\/span> @\"<\/span><\/span>\r\nHello {{name}}<\/span>\r\nYou have just won {{value}} dollars!<\/span>\r\n{{#in_ca}}<\/span>\r\nWell, {{taxed_value}} dollars, after taxes.<\/span>\r\n{{\/in_ca}}<\/span>\r\n\"<\/span><\/span>;<\/pre>\n<\/div>\n
The third argument is the hash to use with the template.<\/p>\n
\n
public<\/span> const<\/span> string<\/span> h1<\/span> =<\/span> @\"<\/span><\/span>\r\n{<\/span>\r\n\"\"<\/span>name\"\"<\/span>: \"\"<\/span>Chris\"\"<\/span>,<\/span>\r\n\"\"<\/span>value\"\"<\/span>: 10000,<\/span>\r\n\"\"<\/span>taxed_value\"\"<\/span>: 6000,<\/span>\r\n\"\"<\/span>in_ca\"\"<\/span>: true<\/span>\r\n}<\/span>\r\n\"<\/span><\/span>;<\/pre>\n<\/div>\n
Each attribute instance is a named pair (template, hash). Our generator uses it to generate a string constant that you can access like this:<\/p>\n
\n
WriteLine<\/span>(Mustache<\/span>.Constants<\/span>.Lottery<\/span>);<\/pre>\n<\/div>\n
The resulting output is good for Chris, as expected:<\/p>\n
\n
Hello Chris\r\nYou have just won 10000 dollars!<\/span>\r\nWell, 6000.0 dollars, after taxes.<\/pre>\n<\/div>\n
<\/a>Mustache Generator Implementation<\/h2>\n
The input to this generator is quite different from the previous one, but the implementation is similar. Or at least it has a familiar ‘shape’. As before there is a class implementing ISourceGenerator<\/code> with an Execute<\/code> method:<\/p>\n
\n
[Generator<\/span>]\r\npublic<\/span> class<\/span> MustacheGenerator<\/span> : ISourceGenerator<\/span>\r\n{\r\n    public<\/span> void<\/span> Execute<\/span>(SourceGeneratorContext<\/span> context<\/span>)\r\n    {\r\n        string<\/span> attributeSource<\/span> =<\/span> @\"<\/span><\/span>\r\n[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true)]<\/span>\r\ninternal sealed class MustacheAttribute: System.Attribute<\/span>\r\n{<\/span>\r\n    public string Name { get; }<\/span>\r\n    public string Template { get; }<\/span>\r\n    public string Hash { get; }<\/span>\r\n    public MustacheAttribute(string name, string template, string hash)<\/span>\r\n        => (Name, Template, Hash) = (name, template, hash);<\/span>\r\n}<\/span>\r\n\"<\/span><\/span>;\r\n        context<\/span>.AddSource<\/span>(\"<\/span>Mustache_MainAttributes__\"<\/span><\/span>, SourceText<\/span>.From<\/span>(attributeSource<\/span>, Encoding<\/span>.UTF8<\/span>));<\/pre>\n<\/div>\n
First we need to add a source file to the project to define the Mustache attribute that will be used by the clients to specify the inputs.<\/p>\n
Then we inspect the assembly to fish out all the usages of the Mustache<\/code> attribute.<\/p>\n
\n
        Compilation<\/span> compilation<\/span> =<\/span> context<\/span>.Compilation<\/span>;\r\n\r\n        IEnumerable<\/span><(string<\/span>, string<\/span>, string<\/span>)> options<\/span> =<\/span> GetMustacheOptions<\/span>(compilation<\/span>);<\/pre>\n<\/div>\n
The code to do so is in the GetMustacheOptions<\/code> function, that you can inspect here<\/a>.<\/p>\n
Once you have the options, it is time to generate the source files:<\/p>\n
\n
static<\/span> string<\/span> SourceFileFromMustachePath<\/span>(string<\/span> name<\/span>, string<\/span> template<\/span>, string<\/span> hash<\/span>)\r\n{\r\n    Func<\/span><object<\/span>, string<\/span>> tree<\/span> =<\/span> HandlebarsDotNet<\/span>.Handlebars<\/span>.Compile<\/span>(template<\/span>);\r\n    object<\/span> @object<\/span> =<\/span> Newtonsoft<\/span>.Json<\/span>.JsonConvert<\/span>.DeserializeObject<\/span>(hash<\/span>);\r\n    string<\/span> mustacheText<\/span> =<\/span> tree<\/span>(@object<\/span>);\r\n\r\n    return<\/span> GenerateMustacheClass<\/span>(name<\/span>, mustacheText<\/span>);\r\n}<\/pre>\n<\/div>\n
First we use Handlebars.net<\/a> to create the string constant text (first 3 lines above).\nWe then move on to the task of generating the property to contain it.<\/p>\n
\n
private<\/span> static<\/span> string<\/span> GenerateMustacheClass<\/span>(string<\/span> className<\/span>, string<\/span> mustacheText<\/span>)\r\n{\r\n    StringBuilder<\/span> sb<\/span> =<\/span> new<\/span> StringBuilder<\/span>();\r\n    sb<\/span>.Append<\/span>($@\"<\/span><\/span>\r\nnamespace Mustache {{<\/span>\r\n\r\npublic static partial class Constants {{<\/span>\r\n\r\npublic const string {className<\/span>} = @\"\"<\/span>{mustacheText<\/span>.Replace<\/span>(\"<\/span>\\\"<\/span>\"<\/span><\/span>, \"<\/span>\\\"\\\"<\/span>\"<\/span><\/span>)}\"\"<\/span>;<\/span>\r\n}}<\/span>\r\n}}<\/span>\r\n\"<\/span><\/span>);\r\n    return<\/span> sb<\/span>.ToString<\/span>();\r\n\r\n}<\/pre>\n<\/div>\n
That was easy, mainly thanks to C# partial classes. We generate a single class from multiple source files.<\/p>\n
<\/a>Conclusion<\/h2>\n
C# Source Generators are a great addition to the compiler. The ability to interject yourself in the middle of the compilation process and have access to the source tree, makes it possible, even simple, to enable all sorts of scenarios (i.e. domain languages, code interpolation, automatic optimizations …). We look forward to you surprising us with your own Source Generators!<\/p>\n","protected":false},"excerpt":{"rendered":"
This post describes two new generators that we added to the samples project in the Roslyn SDK github repo.<\/p>\n
The first generator gives you strongly typed access to CSV data. The second one creates string constants based on Mustache specifications.<\/p>\n","protected":false},"author":34619,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[685,196,195,756],"tags":[],"class_list":["post-29404","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dotnet","category-dotnet-core","category-dotnet-framework","category-csharp"],"acf":[],"blog_post_summary":"
This post describes two new generators that we added to the samples project in the Roslyn SDK github repo.<\/p>\n
The first generator gives you strongly typed access to CSV data. The second one creates string constants based on Mustache specifications.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/29404","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/34619"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=29404"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/29404\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=29404"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=29404"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=29404"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}