Why do I get different behavior in CSharpScript than my code?

[Nefcanto]

I have a codebase (an ASP.NET Core API) that works. Now I want to run some C# scripts, based on this codebase.

This is my code to run the C# script:

            var usings = GetUsings(); // the same for the app, a list of "global using X;"
            var assemblies = AppDomain
                .CurrentDomain
                .GetAssemblies()
                .Where(asm => !asm.IsDynamic && !string.IsNullOrWhiteSpace(asm.Location))
                .ToList();
            var options = ScriptOptions
                .Default
                .AddImports(usings)
                .AddReferences(assemblies)
                .AddReferences(typeof(Microsoft.Data.SqlClient.SqlConnection).Assembly)
                .AddReferences(Assembly.Load("MoreLinq"))
                .AddReferences(Assembly.Load("Pomelo.EntityFrameworkCore.MySql.NetTopologySuite"))
                ;
            var result = CSharpScript.EvaluateAsync(code, options, globals: globals).Result;

Now I get this error:

error CS0234: The type or namespace name 'Imaging' does not exist in the namespace 'System.Drawing' (are you missing an assembly reference?)

I'm stuck here. I'm on Linux (Ubuntu 24.04) and inside Docker (Debian 12). I'm using .NET 8.

The same code, the same set of assemblies, and using statements work when I run my API. And this code snippet runs inside that API.

Why do I get two different behaviors? How should I solve this issue? Why do I not get that error when I run my API?

[Nefcanto]

To put it another way, inside my code (which works) I try to add all of the using statements and all assemblies to a C# script evaluator to run a C# script. Why it breaks?

[huoyaoyuan]

It's a common mistake to get reference assemblies from AppDomain.GetAssemblies(). It contains only the assemblies has been loaded. You need to use either the SDK pack, or the whole runtime pack to get everything that's available.

[jaredpar]

It is also a mistake because the runtime assemblies are not designed to be compiled against, they are designed to be run against. Compiling code against runtime assemblies can, and absolutely will, break between releases of .NET.

[Nefcanto]

@huoyaoyuan, I tried to use Directory.GetFiles to load all DLLs inside my bin and use Assemly.LoadFrom to load them. But that did not solve the issue either.

How can I add the SDK pack? Or runtime pack. To be hosent, I don't even know what those terms mean.

[Nefcanto]

@huoyaoyuan, is there an easy way to tell the C# script evaluator to use the same context as this code that is being run? Something like ScriptOptions.Default.TheSameAsTheCaller()?

[huoyaoyuan]

AppDomain.GetAssemblies() is basically the same context at that moment. However in .NET, loading is lazy, so everything not used until present time won't have been loaded. That's why proactively touch the assemblies via types in them is required.

[Nefcanto]

@huoyaoyuan, this is the point. All I want as a developer is to be able to run some C# code dynamically. To achieve this, I need to understand a lot about the assemblies, and the underlying way .NET works. You are good at that. But .NET consumers are not good at it. We are good at tackling business requirements, using the technologies you have provided.

So, I think it should be a logical request to ask the .NET team to make us run a code, just as it was running statically inside the codebase, against the current app, and make it easy for us. A flag should be there that I can set to true, and then you do all the heavy work of finding what and where, etc.

Where can I ask for this feature? Because I'm stuck and kindly, I can't use the information you provided to solve my issue.

[huoyaoyuan]

I'm aware of the requirement of knowledge when I was looking for the solution. I'm not sure whom is to ping for this. Maybe @jaredpar to help direct this to the right person?

A flag should be there that I can set to true, and then you do all the heavy work of finding what and where, etc.

Be aware of the nature of the feature request. It will make you incompatible with features like trimming.

the same context as this code that is being run

Highlight this again: you can't really be on the same context, because the code itself is impacting the context during building and deploying. All the approaches can only take you close to the context. This is the nature of non-scripting language.

[jaredpar]

A flag should be there that I can set to true, and then you do all the heavy work of finding what and where, etc.

Part of the reason this doesn't exist is that there isn't always an easy answer. Build is complicated and in order to compile + eval your application has to take on this complexity. For some subset of scenarios like compile against only assemblies in a given target framework there are fairly straight forward answers. The moment you start adding other assemblies to the equation though it gets complicated for all the reasons build is complicated.

In terms of having a simple eval loop against standard reference assemblies, you can use the code in roslyn-compile-and-run as a template to build off of. But your example uses other assemblies, including custom ones, integrating them might be easy or might be more challenging depending on their contents.

If you want to post the specific assemblies and the setup we can likely give better guidance.