How to use Roslyn C # scripts in batch with multiple scripts?

As it seems - scripting for a mission can be wasteful overkill - you use many layers of applications and memory fills up.

Other solutions:

• How do you interact with the database? you can manipulate the request itself as per your needs, instead of writing entire script to do it.

• How to use generics? with enough T to suit your needs:

  public class ImportEngine<T1,T2,T3,T3,T5>
  
  

• Using Tuples (which is very similar to using generics)

But if you still think scripts are the right tool for you, I found that the use of in-memory scripts can be reduced by running the script inside your application (not with RunAsync), you can do this by going back from RunAsync to logic and reuse it instead of doing work inside a heavy and wasteful memory RunAsync

. Here's an example:

Instead of just (line script):

DoSomeWork();

      

        
        
        
      

    

You can do this (IHaveWork is an interface defined in your application, with just one method Work

):

public class ScriptWork : IHaveWork
{
    Work()
    {
        DoSomeWork();
    }
}
return new ScriptWork();

      

        
        
        
      

    

This way, you only call the heavy RunAsync for a short period of time, and it returns a worker that you can reuse inside your application (and you can of course extend it by adding parameters to the Work method and inheriting logic from your application, etc. .).

The sample also breaks the isolation between your application and the script, so you can easily provide and retrieve data from the script.

EDIT

Quick test:

This code:

    static void Main(string[] args)
    {
        Console.WriteLine("Compiling");
        string code = "System.Threading.Thread.SpinWait(100000000);  System.Console.WriteLine(\" Script end\");";
        List<Script<object>> scripts = Enumerable.Range(0, 50).Select(num =>
             CSharpScript.Create(code, ScriptOptions.Default.WithReferences(typeof(Control).Assembly))).ToList();

        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); // for fair-play

        for (int i = 0; i < 10; i++)
            Task.WaitAll(scripts.Select(script => script.RunAsync()).ToArray());
    }

      

        
        
        
      

    

Consumes about 600MB in my environment (just refer to System.Windows.Form ScriptOption

for script sizing). It is reusable Script<object>

- it does not consume more memory on the second call RunAsync

.

But we can do better:

    static void Main(string[] args)
    {
        Console.WriteLine("Compiling");
        string code = "return () => { System.Threading.Thread.SpinWait(100000000);  System.Console.WriteLine(\" Script end\"); };";

        List<Action> scripts = Enumerable.Range(0, 50).Select(async num =>
            await CSharpScript.EvaluateAsync<Action>(code, ScriptOptions.Default.WithReferences(typeof(Control).Assembly))).Select(t => t.Result).ToList();

        GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);

        for (int i = 0; i < 10; i++)
            Task.WaitAll(scripts.Select(script => Task.Run(script)).ToArray());
    }

      

        
        
        
      

    

In this script, I'm simplifying a bit the solution I suggested to return an object Action

, but I think the performance impact is small (but in real implementations, I really think you should use your own interface to make it flexible).

When the script is running, you can see a steep rise in memory to ~ 240MB, but after I call the garbage collector (for demo purpose, and I did the same in the previous code), memory usage drops to ~ 30MB. It's also faster.