C#dlr语言脚本运行时设置

请问有人知道如何使用Microsoft.CodeAnalysis.CSharp.Scripting设置C#脚本引擎吗

var runtimeSetup = new ScriptRuntimeSetup();
LanguageSetup languageSetup = new LanguageSetup(
    "CSharp.Runtime.Context, CSharp",
    "CSharp",
    new[] { "CSharp", "C#", "cs" },
    new[] { ".cs" }
);

runtimeSetup.LanguageSetups.Add(languageSetup);
var runtime = new ScriptRuntime(runtimeSetup);
Engine = runtime.GetEngine("CSharp")

---

谢谢。

最后在“CSharpScript”模块周围创建了一个包装器

//用例-执行脚本
公共枚举脚本类型
{
CSharp=0，
Python=1，
}
Model=newscripteditormodel（newscripttype[]{ScriptType.Python，ScriptType.CSharp}）；
Model.GetExecutionContextFor（ScriptType.Python）.ExecuteScript（“Python_script.py”）
Model.GetExecutionContextFor（ScriptType.CSharp.ExecuteScript（“CSharp_script.cs”）
...
//ScriptEditorModel-可能是
公共类ScriptEditorModel
{
公共脚本类型[]支持的脚本类型{get；set；}
公共ScriptEditorModel（ScriptType[]supportedScripts）
{
SupportedScriptTypes=supportedScripts；
foreach（SupportedScriptTypes中的ScriptType supportedScript）
{
AddSupportFor（supportedScript）；
}
}
public void AddSupportFor（ScriptType ScriptType）
{
开关（脚本类型）
{
case ScriptType.CSharp：
var cSharpExecutionContext=new cSharpExecutionContext（）
{
Options=ScriptOptions.Default
};
ExecutionContext[scriptType]=cSharpExecutionContext；
打破
case ScriptType.Python：
var pythonExecutionContext=newscriptexecutioncontext（）
{
Engine=Python.CreateEngine（），
Options=ScriptOptions.Default
};
//将标准库添加到引擎
ICollection searchpath=pythonExecutionContext.Engine.getSearchPath（）；
searchPaths.Add（“..\\..\\Lib”）；
pythonexectioncontext.Engine.setSearchPath（搜索路径）；
pythonExecutionContext.Scope=pythonExecutionContext.Engine.CreateScope（）；
ExecutionContext[scriptType]=Python执行上下文；
打破
违约：
返回；
}
ExecutionContext[scriptType].SetIOOutput（_memoryStream，StdOutputWriter）；
ExecutionContexts[scriptType].SetIOErrorOutput（_memoryStream，StdErrorWriter）；
}
public IScriptExecutionContext GetExecutionContextFor（ScriptType ScriptType）
{
尝试
{
返回ExecutionContexts[scriptType]；
}
catch（keynotfounde异常）
{
返回null；
}
}
}
//脚本执行上下文实现下面的接口
公共接口IscripteExecutionContext
{
ScriptOptions选项{get；set；}
任务执行脚本（ScriptDefinition scriptIn，CancellationToken ctIn）；
void SetIOOutput（流、文本编写器）；
void SetIOErrorOutput（流、TextWriter）；
字典全局变量{get；set；}
void SetGlobal（字符串accessName，对象全局）；
}
//范例
公共抽象类BaseScriptExecutionContext:IScriptExecutionContext
{
公共字典全局变量{get；set；}=new Dictionary（）；
公共脚本选项选项{get；set；}
公共抽象任务ExecuteScript（ScriptDefinition scriptIn，CancellationToken ctIn）；
公共摘要void SetIOErrorOutput（流、TextWriter）；
公共抽象void SetIOOutput（流、文本编写器）；
公共虚拟void SetGlobal（字符串访问名，对象全局）
{
Globals[accessName]=全局；
}
}
公共类ScriptExecutionContext:BaseScriptExecutionContext
{
公共编译码编译码；
公共脚本源代码；
公共脚本引擎；
公共脚本范围；
公共覆盖任务ExecuteScript（ScriptDefinition scriptIn，CancellationToken ctIn）
{
返回任务。运行（（）=>
{
尝试
{
SourceCode=Engine.CreateScriptSourceFromFile（scriptIn.FilePath）；
CompiledCode=SourceCode.Compile（）；
CompiledCode.Execute（范围）；
返回null；
}
捕获（例外e）
{
返回e；
}
}，肌动蛋白）；
}
public override void SetGlobal（字符串accessName，对象全局）
{
base.SetGlobal（accessName，global）；
Scope.SetVariable（accessName，全局）；
}
public override void SetIOErrorOutput（流、TextWriter）
{
Engine.Runtime.IO.SetOutput（流、写入器）；
Engine.Runtime.IO.SetErrorOutput（流、写入器）；
}
public override void SetIOOutput（流、文本编写器）
{
Engine.Runtime.IO.SetOutput（流、写入器）；
Engine.Runtime.IO.SetErrorOutput（流、写入器）；
}
}
公共类CSharpExecutionContext:BaseScriptExecutionContext
{
私有流_errorStream；
私有流_outputStream；
公共重写异步任务ExecuteScript（ScriptDefinition scriptIn，CancellationToken ctIn）
{
//var流程=新流程
//{
//}
返回等待任务。运行（异步（）=>
{
尝试
{
//var script=CSharpScript.Create(
//代码：File.ReadAllText（scriptIn.FilePath），
//选项，
//Globals.GetType（）
//    );
//Compilation=script.GetCompilation（）；
//汇编。
var result=await CSharpScript.evaluatesync(
代码：File.ReadAllText（scriptIn.FilePath），
选择权
// use case - executing scripts
public enum ScriptType
{
    CSharp = 0,
    Python = 1,
}


Model = new ScriptEditorModel(new ScriptType[] { ScriptType.Python, ScriptType.CSharp });
Model.GetExecutionContextFor(ScriptType.Python).ExecuteScript("python_script.py")
Model.GetExecutionContextFor(ScriptType.CSharp ).ExecuteScript("csharp_script.cs")
...


// ScriptEditorModel - could be
public class ScriptEditorModel
{
    public ScriptType[] SupportedScriptTypes { get; set; }

    public ScriptEditorModel(ScriptType[] supportedScripts)
    {

        SupportedScriptTypes = supportedScripts;
        foreach (ScriptType supportedScript in SupportedScriptTypes)
        {
            AddSupportFor(supportedScript);
        }
    }

    public void AddSupportFor(ScriptType scriptType)
    {
        switch (scriptType)
        {
            case ScriptType.CSharp:
                var cSharpExecutionContext = new CSharpExecutionContext()
                {
                    Options = ScriptOptions.Default
                };

                ExecutionContexts[scriptType] = cSharpExecutionContext;
                break;

            case ScriptType.Python:
                var pythonExecutionContext = new ScriptExecutionContext()
                {
                    Engine = Python.CreateEngine(),
                    Options = ScriptOptions.Default
                };

                // add the standard library to engine
                ICollection<string> searchPaths = pythonExecutionContext.Engine.GetSearchPaths();
                searchPaths.Add("..\\..\\Lib");
                pythonExecutionContext.Engine.SetSearchPaths(searchPaths);
                pythonExecutionContext.Scope = pythonExecutionContext.Engine.CreateScope();
                ExecutionContexts[scriptType] = pythonExecutionContext;
                break;

            default:
                return;
        }

        ExecutionContexts[scriptType].SetIOOutput(_memoryStream, StdOutputWriter);
        ExecutionContexts[scriptType].SetIOErrorOutput(_memoryStream, StdErrorWriter);
    }

    public IScriptExecutionContext GetExecutionContextFor(ScriptType scriptType)
    {
        try
        {
            return ExecutionContexts[scriptType];
        }
        catch (KeyNotFoundException e)
        {
            return null;
        }
    }
}



// and the Script Execution Contexts implement the interface below
public interface IScriptExecutionContext
{
    ScriptOptions Options { get; set; }
    Task<Exception> ExecuteScript(ScriptDefinition scriptIn, CancellationToken ctIn);
    void SetIOOutput(Stream stream, TextWriter writer);
    void SetIOErrorOutput(Stream stream, TextWriter writer);

    Dictionary<string, object> Globals { get; set; }
    void SetGlobal(string accessName, object global);
}


// Example

public abstract class BaseScriptExecutionContext : IScriptExecutionContext
    {
        public Dictionary<string, object> Globals { get; set; } = new Dictionary<string, object>();
        public ScriptOptions Options { get; set; }

        public abstract Task<Exception> ExecuteScript(ScriptDefinition scriptIn, CancellationToken ctIn);

        public abstract void SetIOErrorOutput(Stream stream, TextWriter writer);

        public abstract void SetIOOutput(Stream stream, TextWriter writer);

        public virtual void SetGlobal(string accessName, object global)
        {
            Globals[accessName] = global;
        }
    }

    public class ScriptExecutionContext : BaseScriptExecutionContext
    {
        public CompiledCode CompiledCode;
        public ScriptSource SourceCode;
        public ScriptEngine Engine;
        public ScriptScope Scope;

        public override Task<Exception> ExecuteScript(ScriptDefinition scriptIn, CancellationToken ctIn)
        {
            return Task.Run(() =>
            {
                try
                {
                    SourceCode = Engine.CreateScriptSourceFromFile(scriptIn.FilePath);
                    CompiledCode = SourceCode.Compile();
                    CompiledCode.Execute(Scope);

                    return null;
                }
                catch (Exception e)
                {
                    return e;
                }

            }, ctIn);
        }

        public override void SetGlobal(string accessName, object global)
        {
            base.SetGlobal(accessName, global);
            Scope.SetVariable(accessName, global);
        }

        public override void SetIOErrorOutput(Stream stream, TextWriter writer)
        {
            Engine.Runtime.IO.SetOutput(stream, writer);
            Engine.Runtime.IO.SetErrorOutput(stream, writer);
        }

        public override void SetIOOutput(Stream stream, TextWriter writer)
        {
            Engine.Runtime.IO.SetOutput(stream, writer);
            Engine.Runtime.IO.SetErrorOutput(stream, writer);
        }
    }

    public class CSharpExecutionContext : BaseScriptExecutionContext
    {
        private Stream _errorStream;
        private Stream _outputStream;

        public override async Task<Exception> ExecuteScript(ScriptDefinition scriptIn, CancellationToken ctIn)
        {
            //var process = new Process
            //{

            //}
            return await Task.Run(async () =>
            {
                try
                {
                    //var script = CSharpScript.Create(
                    //        code: File.ReadAllText(scriptIn.FilePath),
                    //        Options,
                    //        Globals.GetType()
                    //    );
                    //Compilation compilation = script.GetCompilation();
                    //compilation.

                    var result = await CSharpScript.EvaluateAsync(
                            code: File.ReadAllText(scriptIn.FilePath),
                            Options,
                            Globals,
                            Globals.GetType(),
                            ctIn
                        );

                    return null;
                }
                catch (Exception e)
                {
                    return e;
                }

            }, ctIn);
        }

        public override void SetIOErrorOutput(Stream stream, TextWriter writer)
        {
            _errorStream = stream;
        }

        public override void SetIOOutput(Stream stream, TextWriter writer)
        {
            _outputStream = stream;
        }
    }