Scripting API Samples

 

Scripting API Samples

Tomáš Matoušek edited this page on Jan 31 · 32 revisions

Pages 43

• Home
• API Changes
• Building Testing and Debugging
• C# Interactive Walkthrough
• Compiler release process
• Compiler supporting types
• Contributing Code
• Diagnosing Project System Build Errors
• EnC Supported Edits
• FAQ
• Getting Started C# Semantic Analysis
• Getting Started C# Syntax Analysis
• Getting Started C# Syntax Transformation
• Getting Started on Visual Studio 2015
• Getting Started on Visual Studio 2015 CTP 5
• Getting Started on Visual Studio 2015 CTP 6
• Getting Started on Visual Studio 2015 Preview
• Getting Started on Visual Studio 2015 RC
• Getting Started VB Semantic Analysis
• Getting Started VB Syntax Analysis
• Getting Started VB Syntax Transformation
• Getting Started Writing a Custom Analyzer & Code Fix
• How to support new C# language features by Edit And Continue (ENC)
• How To Write a C# Analyzer and Code Fix
• How To Write a Visual Basic Analyzer and Code Fix
• Interactive Window
• Labels used for issues
• Languages features in C# 6 and VB 14
• Linux Instructions
• New Language Features in C# 6
• New Language Features in VB 14
• NuGet packages
• Performance considerations for large solutions
• Roadmap
• Roslyn Overview
• Runtime code generation using Roslyn compilations in .NET Core App
• Samples and Walkthroughs
• Scripting API Samples
• Syntax Visualizer
• VS 2015 CTP 5 API Changes
• VS 2015 CTP 6 API Changes
• VS 2015 RC API Changes
• Walkthroughs
• Show 28 more pages…

  Home

  Project Overview

  Project Roadmap

  Labels used for Issues

  Performance considerations for large solutions

  Other documentation in the repo

  Contributors

  Building, Testing, and Debugging

  Contributing Code

  Tool Authors

  Getting Started

  Samples and Walkthroughs

  FAQ

  API Changelist

  Status

  Language feature status

  Edit-and-Continue Supported Edits

  .NET Core

  Runtime Code Generation

  Interactive and Scripting

  Interactive Window Documentation

  Scripting API Samples

  C# Interactive Walkthrough

  Clone this wiki locally

  

  Clone in Desktop

  The scripting APIs enable .NET applications to instatiate a C# engine and execute code snippets against host-supplied objects. Below are examples of how to get started with the scripting APIs and some common samples. You can also view the Scripting API source code.

  Supported Platforms

  Scripting APIs require desktop .NET Framework 4.6+, or .NET Core 1.1 (supported since Roslyn v2.0.0-rc3, Visual Studio 2017 RC3).

  Scripting APIs can't be used within Universal Windows Applications and .NET Native since the application model doesn't support loading code generated at runtime.

  Getting Started

  Install the Scripting API NuGet Package:

  Install-Package Microsoft.CodeAnalysis.CSharp.Scripting

  Code Samples

  Note: the samples require the following using:
  using Microsoft.CodeAnalysis.CSharp.Scripting;

  Scenarios

  • Evaluate a C# expression
  • Evaluate a C# expression (strongly-typed)
  • Evaluated a C# expression with error handling
  • Add references
  • Add imports
  • Parameterize a script
  • Create & build a C# script and execute it multiple times
  • Create a delegate to a script
  • Run a C# snippet and inspect defined script variables
  • Chain code snippets to form a script
  • Continue script execution from a previous state
  • Create and analyze a C# script
  • Customize assembly loading

  

  Evaluate a C# expression

  object result = await CSharpScript.EvaluateAsync("1 + 2");

  Evaluate a C# expression (strongly-typed)

  int result = await CSharpScript.EvaluateAsync<int>("1 + 2");

  Evaluate a C# expression with error handling

  try

  {

  Console.WriteLine(await CSharpScript.EvaluateAsync("2+2"));

  }

  catch (CompilationErrorException e)

  {

  Console.WriteLine(string.Join(Environment.NewLine, e.Diagnostics));

  }

  Add references

  var result = await CSharpScript.EvaluateAsync("System.Net.Dns.GetHostName()",

  ScriptOptions.Default.WithReferences(typeof(System.Net.Dns).Assembly));

  Add imports

  var result = await CSharpScript.EvaluateAsync("Sqrt(2)",

  ScriptOptions.Default.WithImports("System.Math"));

  Parameterize a script

  public class Globals

  {

  public int X;

  public int Y;

  }

  var globals = new Globals { X = 1, Y = 2 };

  Console.WriteLine(await CSharpScript.EvaluateAsync<int>("X+Y", globals: globals));

  Note: Currently the Globals type has to be defined in an assembly loaded from a file. If the assembly is in-memory (including e.g. when the sample is executed in Interactive Window) the script won't be able to access the type. See issue here.

  Create & build a C# script and execute it multiple times

  var script = CSharpScript.Create<int>("X*Y", globalsType: typeof(Globals));

  script.Compile();

  for (int i = 0; i < 10; i++)

  {

  Console.WriteLine((await script.RunAsync(new Globals { X = i, Y = i })).ReturnValue);

  }

  Create a delegate to a script

  The delegate doesn't hold compilation resources (syntax trees, etc.) alive.

  var script = CSharpScript.Create<int>("X*Y", globalsType: typeof(Globals));

  ScriptRunner<int> runner = script.CreateDelegate();

  for (int i = 0; i < 10; i++)

  {

  Console.WriteLine(await runner(new Globals { X = i, Y = i }));

  }

  Run a C# snippet and inspect defined script variables

  var state = await CSharpScript.RunAsync<int>("int answer = 42;");

  foreach (var variable in state.Variables)

  Console.WriteLine($"{variable.Name} = {variable.Value} of type {variable.Type}");

  Chain code snippets to form a script

  var script = CSharpScript.

  Create<int>("int x = 1;").

  ContinueWith("int y = 2;").

  ContinueWith("x + y");

   

  Console.WriteLine((await script.RunAsync()).ReturnValue);

  Continue script execution from a previous state

  var state = await CSharpScript.RunAsync("int x = 1;");

  state = await state.ContinueWithAsync("int y = 2;");

  state = await state.ContinueWithAsync("x+y");

  Console.WriteLine(state.ReturnValue);

  Create and analyze a C# script

  using Microsoft.CodeAnalysis;

   

  var script = CSharpScript.Create<int>("3");

  Compilation compilation = script.GetCompilation();

  //do stuff

  Compilation gives access to the full set of Roslyn APIs.

  Customize assembly loading

  using Microsoft.CodeAnalysis.Scripting.Hosting;

   

  using (var loader = new InteractiveAssemblyLoader())

  {

  var script = CSharpScript.Create<int>("1", assemblyLoader: loader);

  //do stuff

  }