Could not load file or assembly 'Microsoft.CodeAnalysis, Version=4.14.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' or one of its dependencies

[maettu-this]

Similar issue as #378, but the other way around:

My host application contains analyzers of version 3.11.11.301, but I have not found a way to tell CS-Script this is OK. CSScript.CodeDomEvaluator.CompileAssemblyFromFile() keeps complaining about the 4.14.0.0 version.

Question 1: Is it possible to "downgrade"/"downbump" to version 3.11.11.301?
Question 2: Is it possible to tell CS-Script to compile without "Microsoft.CodeAnalysis"?
Question 3: What are the reasons for insisting on "Microsoft.CodeAnalysis", and even on a particular version?

Neither https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution nor https://github.com/oleg-shilo/cs-script/wiki/CS%E2%80%90Script-Runtime-Environment contains any information about "CodeAnalysis". https://github.com/oleg-shilo/cs-script/wiki/Choosing-Compiler-Engine states "Microsoft.CodeAnalysis.CSharp.Scripting.dll" but only for Roslyn.

[oleg-shilo]

• Microsoft.CodeAnalysis is a dependency of the Microsoft.CodeAnalysis.CSharp.Scripting.dll. Thus it is part of Roslyn.

• Question 1: Is it possible to "downgrade"/"downbump" to version 3.11.11.301?
  No, CLR does not provide the model for that, only for upgrading but not downgrading. The reason is that the upgraded version is backwards compatible (usually) and your component that expects the older version will normally work OK with the newer one. Thus, you can try to update the package to 4.14.0.0, and your host application may be just fine. If it insists on the older version during assembly probing, you can implement custom assembly probing:

       static void Main(string[] args)
       {
           AppDomain.CurrentDomain.AssemblyResolve += (s, e) =>
           {
               if (e.Name.Split(',')[0] == "Microsoft.CodeAnalysis")
                   return typeof(Microsoft.CodeAnalysis.MetadataReference).Assembly;
               return null;
           };
  
           run(args);
       }

• Question 2: Is it possible to tell CS-Script to compile without "Microsoft.CodeAnalysis"?
  No, it is part of Roslyn.

• Question 3: What are the reasons for insisting on "Microsoft.CodeAnalysis", and even on a particular version?
  It is Roslyn - one of the compiler engines CS-Script is using under the hood. This specific version (latest) is required to support the latest C# syntax.

[maettu-this]

I thought to understand the relation to Roslyn, but apparently haven't. I struggle with its dependencies within a .NET 4.8 Framework environment. Let's take a look at what confuses me:

... In most cases, Roslyn engine (default) is a good choice as it does not require any other dependencies on the hosting environment except .NET 5 runtime. Whereas CodeDom is more flexible but requires .NET SDK ...

Using CSScript.CodeDomEvaluator.CompileAssemblyFromFile(), I assume my host app uses the CodeDom engine and there should be no Roslyn specific dependencies.

And https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution does not state anything about hard dependencies to Microsoft.CodeAnalysis.*.

And looking at the dependencies of CSScriptLibrary.dll version 3.30.5.2, it also shows dependencies to Mono, but doesn't require them when compiling a script:

With version 3.30.5.2, my host app could simply refer to CSScriptLibrary.dll and .NET and things worked. Same with NuGet, no dependencies to Mono needed to be installed.

Now, as visible from #435 and #436, presumably I have managed to resolve all necessary dependencies in order to get CS-Script 4.13.1 compile within my host app. Still, I think the dependency related requirements should be better documented for .NET as well as .NET Framework (netstandard2_0) at the wiki.

[oleg-shilo]

Using CSScript.CodeDomEvaluator.CompileAssemblyFromFile(), I assume my host app uses the CodeDom engine and there should be no Roslyn-specific dependencies.

Most likely, one of the CS-Script routines is using some of the "Microsoft.CodeAnalysis" types, even though the Roslyn core assembly is not needed.
Update: I can confirm it now that the main Roslyn assemblies are not required to run CodeDom. You can delete them. But two lower-level dependencies (highlighted) are in fact shared by both Roslyn and CS-Script. Most likely, it's used to prepare the C# project tree.

Let's take a look at what confuses me...

This paragraph is saying is that if you have CS-Script package imported/deployed, you do not need any extra dependency. But in case of CodeDOM you will need to have the SDK present on the target system. Though in this case, you are trying to alter the content of the CS-Script package.

...also shows dependencies to Mono,...

CS-Script at runtime did not use any Mono types on Windows but did on Linux.

I think the dependency related requirements should be better documented for...

I am fully supporting the documentation improvements.
Can you help me to understand what is missing there? Though it is just an entry page. Maybe on other pages.

At the moment, we only established that the user needs to install .NET SDK for CodeDom execution. But it is documented.
Roslyn is not an extra dependency; it is a part of the CS-Script package and is resolved by .NET automatically.
I added this, but it does sound a little clumsy. Like stating the obvious:

[oleg-shilo]

And I just found at least one type form "Microsoft.CodeAnalysis" that is used in the cs-script:

public class EvaluatorConfig
{
    public DebugInformationFormat PdbFormat { get; set; } = DebugInformationFormat.PortablePdb;
    ...

[maettu-this]

In respect to potential documentation improvements, I propose to refine what's already at https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution.

In respect to...

The best way to bring scripting into your application is to add the corresponding NuGet package to your Visual Studio project :

...there could be a subsequent paragraph explaining what dependencies will be installed, or need to be added manually when not using NuGet.

For a .NET Framework 4.8 project this currently is:

And of course, if e.g. Microsoft.CodeAnalysis*Scripting* would not be necessary for a .NET Framework 4.8 project, this would ideally be reflected in the NuGet specs, or at least be documented at the location above.

Instead of burdening https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution with .NET 4.8 stuff, a separate https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution-DotNET4 or https://github.com/oleg-shilo/cs-script/wiki/Hosted-Script-Execution-CodeDom could provide further reading for those who need either or of these non-default approaches.

[maettu-this]

Alternative approach:

Let documentation refer to the .NET Framework samples https://github.com/oleg-shilo/cs-script/blob/master/src/CSScriptLib/src/Client.NET-Framework%20(CodeDom)/Client.NET_Framework%20(CodeDom).csproj and https://github.com/oleg-shilo/cs-script/blob/master/src/CSScriptLib/src/Client.NET-Framework%20(Roslyn%2BCodeDom)/Client.NET_Framework%20(Roslyn%2BCodeDom).csproj. Assuming these project get verified on each release, they should contain all required dependencies. (May a few too many, but better than too few.)

• PS1: Several references mismatch in version, e.g. 4.0.1.2 vs. 4.5.5:

    <Reference Include="System.Memory, Version=4.0.1.2, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\..\packages\System.Memory.4.5.5\lib\net461\System.Memory.dll</HintPath>
    </Reference>

Better reduce the reference to the necessary minimum:

    <Reference Include="System.Memory">
      <HintPath>..\..\..\packages\System.Memory.4.5.5\lib\net461\System.Memory.dll</HintPath>
    </Reference>

• PS2: I don't understand the difference among (CodeDom) vs. (Roslyn+CodeDom):
  • Both projects refer to the same assemblies.
  • Both NetCompiler.cs refer to "\MSBuild\Current\Bin\Roslyn\csc.exe"

A readme in https://github.com/oleg-shilo/cs-script/tree/master/src/CSScriptLib/src or some additional documentation could help.

[oleg-shilo]

I will reflect on the "alternative approach" later. But this is the sample for you, just out of the box:
UPDATE: I have added the identical implementation targeting .NET Framework. It also shows the performance of the script loading.

Sample.zip

The host app (sample.exe, .NET8, latest version of CS-Script package) loads a legacy app that references the old 3.11 Microsoft.CodeAnalysis:

The host app needs Microsoft.CodeAnalysis v4.14 as a transient dependency of cs-script.

Understandably, VS warns you about LegacyModule being on the older Microsoft.CodeAnalysis.

However, it's just a warning. When you run the host app, and it loads LegacyModule, both of them interact with the latest version of Microsoft.CodeAnalysis. Note, all this is without me touching any dependency configuration code at all:

[oleg-shilo]

PS2: I don't understand the difference among (CodeDom) vs. (Roslyn+CodeDom):

This is now covered by this wiki: https://github.com/oleg-shilo/cs-script/wiki/Hosting-on-.NET-Framework#how-to

[oleg-shilo]

Reference Include="System.Memory, Version=4.0.1.2...

TBH, I am reluctant to modify project file manually. These references were created by the Visual Studio NuGet manager view and I prefer not to alter it and instead, use the same view for managing all these packages (e.g. updating them).

I just checked and the sample project that I created and shared with you just a day ago also has the same referencing info. So the NuGet manager does it consistently.

[maettu-this]

Thanks for the .NET Framework Sample.zip and the additional pieces of information. I am skiing this week, next week I will look at it in detail and try to apply it to my host app.