{"id":67460,"date":"2016-08-26T14:39:32","date_gmt":"2016-08-26T14:39:32","guid":{"rendered":"https:\/\/www.simple-talk.com\/?p=67460"},"modified":"2026-04-15T18:38:53","modified_gmt":"2026-04-15T18:38:53","slug":"going-interactive-c","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/going-interactive-c\/","title":{"rendered":"C# Interactive Window and .csx Scripts in Visual Studio: REPL for .NET"},"content":{"rendered":"\n

Executive Summary<\/h2>\n\n\n\n

C# Interactive is a REPL (Read-Eval-Print Loop) built into Visual Studio that lets you run C# code snippets immediately without creating a project, writing a Main method, or waiting for a compile cycle. Type a line of C#, press Enter, see the result. It is particularly useful for quickly testing an API’s behaviour, exploring a new library, prototyping algorithm logic, or debugging a tricky computation interactively. C# Interactive also supports .csx script files – C# scripts that can be saved, resumed, and referenced like lightweight standalone programs. This article covers the REPL basics, the differences from standard C# compilation, .csx file workflow, assembly referencing, and a complete end-to-end example of using C# Interactive to prototype an API client.<\/strong><\/p>\n\n\n\n

It became easier to explore both C# code snippets and APIs with the release of Visual Studio 2015 C#<\/em> Interactive<\/em>, which arrived with Update 1<\/a>. If you think that it is just a scripting utility then it is likely that you are missing out on a valuable way of becoming more productive as a developer.<\/p>\n\n\n\n

It might be more accurate to classify it as C# REPL<\/a> tool with scripting support. As such, it has obvious value as a great time-saver. Within a REPL environment, C# developers can rapidly do such things as code prototypes, explore unfamiliar data, learn APIs and write complex tests. Readers who are familiar with languages such as F#, PowerShell and Python, already enjoy such capabilities. It\u2019s now available to the C# developer as well.<\/p>\n\n\n\n

This article introduces C#<\/em> Interactive <\/em>and aims to show how it can boost any C# developer\u2019s productivity.<\/p>\n\n\n\n

The Basics<\/h2>\n\n\n\n

Before showing how developers can take full advantage of C# Interactive<\/em>, I must first cover some of the basics of getting started with C# Interactive<\/em>, just in case you are new to it.<\/p>\n\n\n\n

Getting Started<\/h3>\n\n\n\n

C#<\/em> Interactive<\/em> is new to Visual Studio 2015 with Update 1. The feature can be loaded either through the Developer Command Prompt for VS2015<\/em> command line and executing csi.exe,<\/em> or from within the Visual Studio IDE via the menu sequence \u2018View | Other Windows | C# Interactive<\/em>\u2019 as pictured below.<\/p>\n\n\n\n

\"\"\/<\/figure>\n\n\n\n

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

Because the Window version of C# Interactive<\/em> has IntelliSense, this may be more suitable for you than the command line version. However, csi.exe<\/em> has some valuable uses because, for example, it doesn\u2019t require you to load the Visual Studio IDE in order to execute C# scripts.<\/p>\n\n\n\n

Life in a Window<\/h3>\n\n\n\n

C# code behaves a little differently in the C# Interactive<\/em> window and some of these differences may be confusing if not frustrating. For example, you\u2019ll find that all top-level variables and members in the C# Interactive <\/em>window have public modifiers by default. Although this makes sense in a REPL world, it differs from the behavior of statically complied code. You\u2019ll also find that everything executes asynchronously in the interactive mode, even if it appears to be synchronous. We\u2019ll be showing how this may require some tweaks when moving static code to the interactive window..<\/p>\n\n\n\n

The Interactive Window<\/a> GitHub repository summarizes the features.<\/p>\n\n\n\n

CSX Files<\/h3>\n\n\n\n

When Roslyn<\/a> arrived, so did C# scripts. But until the introduction of C# Interactive, <\/em>scripting CSX files weren\u2019t much used. It is hardly surprising when you consider the abundance of other more widely-known and mature scripting languages such as PowerShell.<\/p>\n\n\n\n

This has now changed, because developers can now cut and paste code between their solution\u2019s CSX files and C# Interactive<\/em> windows. This allows us to write complex snippets, saving work and rehydrating it later. It also allows us to create test cases that are executable from either Visual Studio or the command line.<\/p>\n\n\n\n

The Power Demonstration<\/h1>\n\n\n\n

This demonstration of the value of using C# Interactive<\/em> in development is more about developing the end-to-end process. It will allow us to sketch out and assess how the process will work rather than provide the final system. C# Interactive <\/em>is unlikely to impact the code that is delivered to the customer, but it can make it quicker and easier to prototype, and determine, the best solution. We\u2019ll choose a typical enterprise application assignment to show what we mean.<\/p>\n\n\n\n

Getting the Data<\/h2>\n\n\n\n

Imagine we have been engaged by an energy analytics provider to construct an API that allows them to access electric power consumption data that is provided by the U.S. Energy Information Administration<\/a> (EIA). To get started with this exercise of prototyping a solution, we first need to complete the brief access request<\/a> and, in turn, receive our API KEY. With this key, we then need to decide on the most appropriate http request on the Demand<\/a> page. After viewing a few series, we choose to select the Demand for Portland General Electric Company, Hourly<\/a> dataset:<\/p>\n\n\n

\n
    \n
  1. http:\/\/api.eia.gov\/series\/?api_key=YOUR_API_KEY_HERE&series_id=EBA.PGE-ALL.D.H<\/a><\/li>\n<\/ol>\n<\/div>\n\n\n
    \n

    Note:<\/em> Readers wishing to learn more about the EIA API may find their BETA User Guide helpful.<\/p>\n<\/div>\n\n\n\n

    Building the Solution<\/h2>\n\n\n\n

    We\u2019ll start off by using conventional C#. The solution starts out with the DemoLibrary<\/em><\/strong> component referenced and called by a console consumer entitled DemoClient<\/em>.<\/strong><\/p>\n\n\n\n

    \"\"\/<\/figure>\n\n\n\n

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

    GetDemandRaw<\/em><\/strong> walks a familiar path for executing an asynchronous http get request. The method leverages the System.Net.Http<\/em>\u2019s HttpClient<\/em> to execute our demand query laced via string interpolation with the target company\u2019s seriesId<\/em><\/strong> and API key that we obtained earlier from the EAI. Our secret API key is saved in the library because at this stage we are just prototyping.<\/p>\n\n\n\n

    using System.Net.Http;\nusing System.Threading.Tasks;\n\nnamespace DemoLibrary\n{\n    public static class EnergyData\n    {\n\/\/ Running this code requires replacing \"YOUR REQUESTED KEY\" with a key\n\/\/ obtained from U.S. Energy Information Administration.\n\n        private const string ApiKey = \"YOUR REQUESTED KEY\";\n\n        \/\/\/ <summary>\n        \/\/\/ Data Source: U.S. Energy Information Administration; see http:\/\/www.eia.gov\/.\n        \/\/\/ <\/summary>\n        public static async Task<string> GetDemandRaw(string seriesId)\n        {\n            using (var httpClient = new HttpClient())\n            {\n                var response = await httpClient.GetAsync(\n                $\"http:\/\/api.eia.gov\/series\/?api_key={ApiKey}&series_id={seriesId}\");\n\n              return await response.Content.ReadAsStringAsync();\n            }\n        }\n    }\n}\n<\/pre>\n\n\n\n
    The consuming Main<\/em><\/strong> method in DemoClient<\/em><\/strong> indicates that our handiwork proved adequate as shown by the displayed JSON when we execute the compiled command-line program.<\/p>\n\n\n\n
    using System;\nusing System.Linq;\nusing DemoLibrary;\n\nnamespace DemoClient\n{\n    public class Program\n    {\n        public static void Main(string[] args)\n        {\n            \/\/ Demand for Portland General Electric Company\n            const string seriesId = \"EBA.PGE-ALL.D.H\";\n\n            var energyDemandRaw = EnergyData.GetDemandRaw(seriesId).Result;\n            Console.WriteLine(\"Raw Data:\");\n            Console.WriteLine(energyDemandRaw.Substring(1, 1000) + \"...\");\n\n            Console.ReadKey();\n        }\n    }\n}<\/pre>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    Well, there the story could easily end without the need for any more significant development work. However, while we are packing up our laptop for the next assignment, the client\u2019s development team reports dismay. They do not like the JSON data provided by GetDemandRaw<\/em><\/strong>. They expected a more digestible .NET version of the data as .NET objects.<\/p>\n\n\n\n
    GetDemand<\/em><\/strong> reflects that wish. Someday it will return a list of lightweight EnergyDemand<\/em><\/strong> objects, until then we will settle for an empty one.<\/p>\n\n\n\n
        public class EnergyDemand\n    {\n        public string ReportDateTime { get; set; }\n        public int Demand { get; set; }\n    }\n\n    public static IEnumerable<EnergyDemand> GetDemand(string seriesId)\n    {\n        \/\/ TODO\n        return Enumerable.Empty<EnergyDemand>();\n    }<\/pre>\n\n\n\n
    It\u2019s at this stage that the development process begins to crawl. While some may find converting raw JSON into a list of .NET objects institutively obvious, others (like me) do not. Traditionally we\u2019d be faced with checking debugger state, probing in the Intermediate<\/em> window, tweaking code, recompiling the solution, reloading data, either directly or in directly, until happy. It\u2019s not an insurmountable process, just tedious and slow. Time for C# Interactive<\/em>!<\/p>\n\n\n\n
    Exploring<\/h2>\n\n\n\n
    We will now switch to using C# Interactive. The process of executing code in C#<\/em> Interactive <\/em>does not differ much from that of a console application. The first difference is in telling it how to load DemoLibrary<\/em><\/strong>.<\/em> Once that\u2019s done, we just copy the DemoClient<\/em><\/strong> code into the window as shown below.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    An odd thing happens after we enter the last line of code; odd in that nothing happens. The window just sits. Did we forget that C# Interactive<\/em> executes asynchronously while looking synchronous? With that detail in mind a fix becomes obvious. GetDemandRaw<\/em><\/strong> needs \u201cprompting\u201d before yielding any secrets as the revised code shows.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    Now the fun, in terms of productivity, begins. We can explore the energyDemandRaw<\/em><\/strong> object without reloading it or recompiling any code. All we need to do to convert the output JSON string into a dynamic object is to load a serializer<\/em><\/strong>. While many libraries serve this function, we keep it simple by using the readily available .NET library, System.Web.Script.Serialization<\/em>.<\/p>\n\n\n\n
    Loading System.Web.Script.Serialization<\/em> follows a similar pattern to the DemoLibrary<\/em><\/strong> component. The difference is that we do not specify a file path. After we have created the serializer<\/em><\/strong>, we can now explore data with C# as a familiar object-oriented workout. For example, as shown below, after we discover that energyDemand<\/em><\/strong> is a dictionary, then the process of identifying keys only requires a C# foreach<\/em> loop.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    Saving Progress<\/h2>\n\n\n\n
    How can we save our work in progress? Imagine that we\u2019ve just been asked to pause working on our current chore in order to address a late-breaking emergency. We have a slight problem though. How do we avoid losing what we just learned about the demand output? Where should we safely save the code snippet? There are some rather awkward-seeming choices such as saving it to DropBox in a text file or hiding it in the library. There\u2019s now a better option \u2013 adding it to a C# script file.<\/p>\n\n\n\n
    In order to save code with the C# Interactive<\/em> feature, all we need to do is to create a CSX file as noted earlier. Unfortunately, Visual Studio does not make this easy because we have to add the file and change its extension to CSX. Once we\u2019ve done this, we can paste code into it from the C# Interactive <\/em>window.<\/p>\n\n\n\n
    In order to save our work, we create the CreateGetDemand.csx<\/em> file and copy the REPL code onto it. Sadly, pesky red squiggles on lines 9 and 10 inform us of some code issues.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    We again encounter one of those quirks that come about because C# lives in slighty different environments. CSX files behave more like compiled code and less like its REPL brethern. In this instance the fix only requires us to move the offending lines to top of the file as suggested by Visual Studio.<\/p>\n\n\n\n
    The fixed CreateGetDemand.csx<\/em> that follows now displays without error.<\/p>\n\n\n\n
    #r \"System.Web.Extensions\"\n#r \".\\bin\\Debug\\DemoLibrary.dll\"\n\nusing DemoLibrary;\nusing System.Web.Script.Serialization;\n\nconst string seriesId = \"EBA.PGE-ALL.D.H\";\nvar energyDemandRaw = (await EnergyData.GetDemandRaw(seriesId));\nConsole.WriteLine(energyDemandRaw.Substring(1, 100) + \"...\");\n\nvar serializer = new JavaScriptSerializer();\nvar energyDemand = serializer.Deserialize<dynamic>(energyDemandRaw);\nConsole.WriteLine(energyDemand.GetType());\n\nforeach (string s in energyDemand.Keys)\n    Console.WriteLine(s);<\/pre>\n\n\n\n
    Resuming<\/h2>\n\n\n\n
    Our imaginary emergency passes. How do we resume where we left off, deciphering JSON output in order to complete GetDemand<\/em><\/strong>? The value of having saved our prototype work to a C# script file now becomes evident. We effortlessly reload it into an open C# Interactive <\/em>with the following command.<\/p>\n\n\n\n
    #load “C:\\Temp\\DemoScript\\DemoLibrary\\CreateGetDemand.csx”<\/p>\n\n\n\n
    The window shows that we have reconstituted energyDemand<\/em><\/strong>. This can be seen <\/em>in the series<\/em> <\/strong>value assignment that follows it, and our subsequent proddings.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    We continue to determine object types, and inspecting values, until we are satisfied that we have a set of data for the Portland General Electric Company\u2019s hourly power-demand.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    We update CreateGetDemand.csx<\/em> to record how we unwrapped the JSON document.<\/p>\n\n\n\n
    #r \"System.Web.Extensions\"\n#r \".\\bin\\Debug\\DemoLibrary.dll\"\nusing System.Web.Script.Serialization;\nusing DemoLibrary;\n\nconst string seriesId = \"EBA.PGE-ALL.D.H\";\nvar energyDemandRaw = (await EnergyData.GetDemandRaw(seriesId));\nConsole.WriteLine(energyDemandRaw.Substring(1, 100) + \"...\");\n\nvar serializer = new JavaScriptSerializer();\nvar energyDemand = serializer.Deserialize<dynamic>(energyDemandRaw);\nConsole.WriteLine(energyDemand.GetType());\n\nforeach (string s in energyDemand.Keys)\n    Console.WriteLine(s);\n\nvar series = energyDemand[\"series\"];\nConsole.WriteLine(series.GetType());\n\nvar seriesDataSet = series[0];\nConsole.WriteLine(seriesDataSet.GetType());\n\nforeach (var item in seriesDataSet)\n    Console.WriteLine(string.Format(\"{0} - {1}\", item.Key, item.Value));\nvar data = seriesDataSet[\"data\"];\nforeach (var item in data)\n{\n    if (item[1] != null)\n        Console.WriteLine(string.Format(\"{0} - {1}\", item[0], item[1]));\n}<\/pre>\n\n\n\n
    With this prototyping code, our implementation of GetDemand<\/em> <\/strong>can proceed quickly. We start by adding the Microsoft.CSharp<\/em> and System.Web.Extensions<\/em> component references to the solution.<\/p>\n\n\n\n
    \n
    Note:<\/em>Microsoft.CSharp helps read the serialized object that System.Web.Extensions created. C# Interactive did not require it for reasons that we will cover shortly.<\/p>\n<\/div>\n\n\n\n
    Notice how our investigatory REPL eased the data<\/em><\/strong> variable assignment. Transitioning from the complex JSON string in energyDemandRaw<\/em><\/strong> to data<\/em><\/strong> (almost) makes us look like EIA API experts.<\/p>\n\n\n\n
    public static IEnumerable<EnergyDemand> GetDemand(string seriesId)\n{\n    var energyDemandRaw = GetDemandRaw(seriesId).Result;\n\n    var serializer = new JavaScriptSerializer();\n    var energyDemand = serializer.Deserialize<dynamic>(energyDemandRaw);\n\n    var data = energyDemand[\"series\"][0][\"data\"];\n\n    foreach (var item in data)\n        if (item[1] != null)\n            yield return new EnergyDemand { ReportDateTime = item[0], Demand = item[1] };\n}<\/pre>\n\n\n\n
    After updating DemoClient <\/strong>to call GetDemand<\/strong>, we see everything behaving as expected.<\/p>\n\n\n\n
    public static void Main(string[] args)\n{\n    \/\/ Demand for Portland General Electric Company\n    const string seriesId = \"EBA.PGE-ALL.D.H\";\n    var energyDemandRaw = EnergyData.GetDemandRaw(seriesId).Result;\n    Console.WriteLine(\"Raw Data:\");\n    Console.WriteLine(energyDemandRaw.Substring(1, 1000) + \"...\");\n\n    Console.WriteLine();\n\n    var energyDemandList = EnergyData.GetDemand(seriesId);\n    Console.WriteLine(\"Enumerable<EnergyDemand>:\");\n    foreach (var energyDemand in energyDemandList.Take(5))\n        Console.WriteLine(\n            $\"{energyDemand.ReportDateTime} | {energyDemand.Demand}\");\n\n    Console.ReadKey();\n}<\/pre>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    Only one problem remains. How can we more thoroughly test our API?<\/p>\n\n\n\n
    Testing<\/h2>\n\n\n\n
    For testing, C# Interactive<\/em> can to the rescue again! After writing some test code via REPL we add it the following TestGetDemand.<\/em>csx<\/em><\/strong> file. While the tests are far from rigorous, they do check a few different companies and some different values. It also allows us to alter and add new tests as warranted.<\/p>\n\n\n\n
    #r \"System.Core\"\n#r \".\\bin\\Debug\\DemoLibrary.dll\"\n#r \".\\bin\\Debug\\DemoLibrary.dll\"\nusing System.Threading.Tasks;\nusing DemoLibrary;\n\n\/\/ Arizona Public Service Company\nvar seriesId = \"EBA.AZPS-ALL.D.H\";\nawait Task.Run(() =>\n    Console.WriteLine(\n        \"SeriesId \" + seriesId + \" record count: \" +\n            EnergyData.GetDemand(seriesId).Count()));\n\n\/\/ Los Angeles Department of Water and Power\nseriesId = \"EBA.LDWP-ALL.D.H\";\nawait Task.Run(() =>\n    Console.WriteLine(\n        \"SeriesId \" + seriesId + \" first ReportDateTime: \" +\n            EnergyData.GetDemand(seriesId).First().ReportDateTime));\n\n\/\/ Portland General Electric Company\nseriesId = \"EBA.PGE-ALL.D.H\";\nawait Task.Run(() =>\n    Console.WriteLine(\n        \"SeriesId \" + seriesId + \" maximum Demand: \" +\n            EnergyData.GetDemand(seriesId)\n                .OrderByDescending(x => x.Demand).FirstOrDefault().Demand));<\/pre>\n\n\n\n
    Another bonus of having a CSX script file is that there are options for running it. Earlier we saw how they can be executed in a C# Interactive<\/em> window. This time we run it via Developer Command Prompt for VS2015 by calling csi.exe<\/strong> with the link to the script file as a parameter.<\/p>\n\n\n\n
    C:\\Temp\\DemoScript\\DemoLibray>csi TestGetDemand.csx<\/code><\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    The demonstration\u2019s solution as shown below is completed. Our imaginary energy analytics company developers can now obtain the data from the U.S. Energy Information Administration API, formatted just as they wanted it.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    Referencing<\/h2>\n\n\n\n
    It is sometimes confusing to figuring out references when working within C# Interactive<\/em>. For example, has anyone who<\/em> is reading this noticed that the REPL code never included the obligatory System <\/em>enabling Console.WriteLine<\/em>? Nonetheless, it certainly does write. Turns out that C# Interactive<\/em> creates and manages its own environment as evidenced by the second line that is displayed after first loading the window.<\/p>\n\n\n\n
    \"\"\/<\/figure>\n\n\n\n
    <\/p>\n\n\n\n
    A quick visit to the Roslyn<\/a> GitHub site informs us that CSharpInteractive.rsp<\/em> loads three components: System<\/em>, System.Core<\/em>, and Microsoft.CSharp.<\/em> (Remember that we had to manually add it to our solution for GetDemand<\/em><\/strong>?) It also takes care of inserting several common using<\/em> statements.<\/p>\n\n\n\n
    Conclusion<\/h1>\n\n\n\n
    With Interactive C#, d<\/em>evelopers are no longer constrained to statically-compiled code. They can now apply their .NET expertise within scripting and REPL environments. Unfortunately, these different environments are not completely compatible with each other and Visual Studio only offers some help to address the incompatibilities. Nonetheless, .NET developers comfortable with Interactive C# <\/em>are likely to find themselves writing code faster and having more fun doing so.<\/p>\n\n\n\n
    \n    
    FAQs: Going Interactive with C#<\/h2>\n\n                        
    1. What is C# Interactive in Visual Studio?<\/h3>\n            
    \n                
    C# Interactive is a REPL (Read-Eval-Print Loop) available in Visual Studio through View > Other Windows > C# Interactive. It evaluates C# expressions and statements immediately and prints results – no project, no compilation step, no Main method. You can reference NuGet packages with #r “nuget: PackageName”, load other .csx files with #load, and interact with objects across multiple lines as if in a persistent session. It is the same Roslyn-based engine used by .NET Interactive (Jupyter notebooks for .NET).<\/p>\n            <\/div>\n                    
    2. What are .csx files in C#?<\/h3>\n            
    \n                
    .csx files are C# script files – C# code that runs as a script rather than as compiled assembly. Unlike standard .cs files, .csx files don’t require a namespace, class, or Main method – code at the top level executes directly. They support #r for assembly\/NuGet references and #load for including other .csx files. Run them with the dotnet-script tool (dotnet tool install -g dotnet-script) or execute them from C# Interactive with #load. They are useful for automation scripts, utility tools, and prototyping where a full project is overkill.<\/p>\n            <\/div>\n                    
    3. How is C# Interactive different from LINQPad?<\/h3>\n            
    \n                
    LINQPad is a separate third-party application (with free and paid tiers) that provides a richer REPL experience than C# Interactive: multi-tab sessions, built-in database query connections, a NuGet package manager GUI, and result visualisation. C# Interactive is built into Visual Studio at no extra cost and integrates directly with the current solution (giving access to types from loaded projects). For quick exploration within a Visual Studio project, C# Interactive is more convenient. For standalone data exploration or database querying, LINQPad’s additional features are valuable.<\/p>\n            <\/div>\n                    
    4. Can I use .NET Interactive notebooks instead of C# Interactive?<\/h3>\n            
    \n                
    .NET Interactive notebooks (available through VS Code with the Polyglot Notebooks extension or Jupyter with the .NET kernel) are the evolution of the C# scripting concept – supporting C#, F#, PowerShell, and SQL in the same notebook, with rich output formatting and inline visualisation. For documentation, teaching, or exploratory analysis where you want to share the code and its output, .NET Interactive notebooks are more powerful than .csx files. For quick in-Visual Studio prototyping, C# Interactive remains the faster tool.<\/p>\n            <\/div>\n            <\/section>\n","protected":false},"excerpt":{"rendered":"
    C# Interactive Window and .csx script files let you explore .NET APIs and prototype code without a full compile-run cycle. Covers the REPL basics, saving work as .csx files, referencing assemblies, and a practical API exploration workflow.…<\/p>\n","protected":false},"author":200451,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":true,"footnotes":""},"categories":[143538],"tags":[],"coauthors":[17935],"class_list":["post-67460","post","type-post","status-publish","format-standard","hentry","category-dotnet-development"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/67460","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/200451"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=67460"}],"version-history":[{"count":9,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/67460\/revisions"}],"predecessor-version":[{"id":109808,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/67460\/revisions\/109808"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=67460"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=67460"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=67460"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=67460"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}