Forem: Victor Sanchez

Understanding .NET Compilation: .NET Standard vs .NET Core, Roslyn vs csc.exe, and Dynamic Compilation

Victor Sanchez — Fri, 09 May 2025 23:42:55 +0000

When working with .NET, it's crucial to understand how code is compiled and what tools are responsible for transforming your C# into executable binaries. This blog explores the differences between compilers used in .NET Standard and .NET Core and explains the role of Roslyn, csc.exe, and dynamic compilation in modern .NET development.

🔍 .NET Standard vs .NET Core Compilation

.NET Standard
What it is: A formal specification of .NET APIs that all .NET implementations (like .NET Framework, .NET Core, Xamarin) must implement.
Usage: Used to build libraries that are portable across all .NET platforms.
Compilation: Uses netstandard.dll as a reference library. The actual runtime compilation is handled by the consuming runtime (.NET Core, Mono, etc.).
.NET Core
What it is: A cross-platform runtime implementation of .NET.
Usage: Can build and run both applications and libraries.
Compilation: Uses Roslyn compiler directly or via dotnet build. Relies on System.Private.CoreLib, System.Console, and other runtime assemblies.

⚙️ Roslyn and csc.exe Explained

csc.exe – The Classic Compiler
What it is: Command-line compiler executable for C#.
Usage: Used in traditional build pipelines or directly via CLI.
Limitations: Not embeddable, harder to use programmatically.
Implementation: Originally implemented in C++ as part of the .NET Framework SDK.

Roslyn – Compiler as a Service
What it is: .NET compiler platform as a set of APIs (Microsoft.CodeAnalysis).
Usage: Used by modern tools like Visual Studio, OmniSharp, analyzers.
Benefits: Fully programmable, supports syntax trees, diagnostics, in-memory emit.
Implementation: Written in C#, and bootstrapped using Roslyn itself.
📝 Note: csc.exe is built on top of Roslyn. It's essentially a thin command-line wrapper around the Roslyn API.

🔄 Dynamic Compilation

Dynamic compilation refers to compiling code at runtime, allowing for runtime behaviors such as scripting, code evaluation, or plugin execution.

In Roslyn, dynamic compilation is achieved by using the Roslyn APIs to compile and execute code in memory, without writing to disk. This is useful for scenarios like:

Online code editors
Plugin systems
Educational tools
Runtime extensibility in applications

Example: Dynamic Compilation in Action

Here's a simple example using the Roslyn API for dynamic compilation:

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using System;
using System.IO;
using System.Reflection;

class Program
{
    static void Main()
    {
        var code = @"
            using System;
            public static class Example
            {
                public static void Main()
                {
                    var tuple = (Part1: \"hello\", Part2: \"world\");
                    Console.WriteLine($\"{tuple.Part1} {tuple.Part2}\");
                }
            }
";

        // Resolve paths to needed assemblies
        string coreDir = Path.GetDirectoryName(typeof(object).Assembly.Location)!;

        var references = new[]
        {
            MetadataReference.CreateFromFile(typeof(object).Assembly.Location),                     // System.Private.CoreLib.dll
            MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),                   // System.Console.dll
            MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location),            // System.Runtime.dll
            MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),               // netstandard.dll
            MetadataReference.CreateFromFile(Assembly.Load("System.Console").Location),            // System.Console.dll again, to be sure
        };

        var syntaxTree = CSharpSyntaxTree.ParseText(code);
        Console.WriteLine(syntaxTree.ToString());

        var compilation = CSharpCompilation.Create(
            "HelloWorld",
            new[] { syntaxTree },
            references,
            new CSharpCompilationOptions(OutputKind.ConsoleApplication)
        );

        using var ms = new MemoryStream();
        var result = compilation.Emit(ms);

        if (!result.Success)
        {
            Console.WriteLine("Compilation failed:");
            foreach (var diag in result.Diagnostics)
                Console.WriteLine(diag.ToString());
            return;
        }

        ms.Seek(0, SeekOrigin.Begin);
        var assembly = Assembly.Load(ms.ToArray());

        var type = assembly.GetType("Example");
        var method = type?.GetMethod("Main", BindingFlags.Public | BindingFlags.Static);
        method?.Invoke(null, null); // Output: hello world
    }
}

✅ Conclusion

Understanding the .NET compilation process is key to mastering modern .NET development. Whether you're writing cross-platform libraries with .NET Standard or building apps with .NET Core, knowing how your code turns into binaries helps you troubleshoot, optimize, and innovate with confidence.
Roslyn has redefined what a compiler can do—turning it from a black box into a programmable service. It powers not only Visual Studio and analyzers but also enables powerful scenarios like dynamic compilation, custom tooling, and interactive scripting.
Whether you're using csc.exe for straightforward builds or Roslyn APIs for advanced scenarios, understanding these tools gives you the flexibility and insight to choose the right approach for your project.

Reinstalling Required Software Using Winget

Victor Sanchez — Wed, 21 Aug 2024 15:57:56 +0000

Overview

Winget (Windows Package Manager) simplifies the management of software installations. This guide will walk you through exporting a list of installed applications to a JSON file and using that file to install the same applications on another machine or after a clean installation.

Prerequisites

Windows Package Manager (winget): Ensure winget is installed on your Windows machine. It comes with Windows 10 and Windows 11 as part of the App Installer package. Verify its installation by running winget --version in Command Prompt or PowerShell.
Administrative Rights: Some operations may require administrative privileges. Ensure you have the necessary permissions to run these commands.

Exporting Installed Applications

To create a JSON file containing a list of your installed applications, follow these steps:

Open Command Prompt or PowerShell: Press Win + X and select either Windows Terminal, Command Prompt, or PowerShell.
Run the Export Command: Use the following command to export your installed applications to a JSON file:

winget export -o 'C:\Users\YourUsername\Desktop\apps.json' --ignore-warnings

This command generates a file named apps.json on your Desktop with a list of all installed applications.

Replace YourUsername with your actual Windows username.
The -o flag specifies the output file path.
The --ignore-warnings flag is optional and suppresses warnings during export.

Importing Applications

To install applications on a new machine or after a fresh installation using the previously exported JSON file, follow these steps:

Open Command Prompt or PowerShell: Open Windows Terminal, Command Prompt, or PowerShell as before.
Run the Import Command: Use the following command to import the list of applications from your JSON file:

winget import -i 'C:\Users\YourUsername\Desktop\apps.json'

This command reads the apps.json file and installs all the applications listed in it.

Again, replace YourUsername with your actual Windows username.
The -i flag specifies the input file path.

Tips

Backup: Ensure the JSON file is up-to-date and includes all the applications you want to install before importing.
Compatibility: Applications listed in the JSON file must be available in the winget repository. If an application is not found, the import process will skip it.

Troubleshooting

File Not Found: Verify that the file paths are correct and that the apps.json file exists at the specified location.
Permission Issues: Run Command Prompt or PowerShell as an administrator if you encounter permission errors.
Application Not Found: Some applications might not be available in the winget repository. Check the application's availability or update the JSON file accordingly.

By following these steps, you can efficiently manage and replicate your application setup across different machines or after a system reset.

Exploring .NET Math Libraries: An Introduction to the NMLs Research Project

Victor Sanchez — Mon, 19 Aug 2024 23:45:43 +0000

Welcome to our exploration of .NET math libraries! In this blog post, we’ll dive into the NMLs (Math Libraries) research project—a solution built using .NET Core 8.0.X designed to evaluate and benchmark various math libraries.

Whether you're a developer interested in mathematical computations or a performance enthusiast, this project offers valuable insights into the capabilities and performance of different libraries.

You could find the code in this repository

Overview

The NMLs solution aims to provide a robust environment for exploring and benchmarking various .NET math libraries. Built on .NET Core 8.0.X, it facilitates the execution and evaluation of mathematical expressions while offering tools to compare performance across different libraries. Here’s a look at what the project entails:

Solution Structure

The Visual Studio solution for NMLs is organized into three main projects, each serving a specific purpose:

MathLibsLogic
Purpose: This project contains implementations for various math libraries.
- Each library is encapsulated in a class named My[LibraryName], allowing for easy extension and customization.
- Manages all NuGet package dependencies necessary for the math libraries, ensuring that all components are up-to-date and properly configured.
NMLs
Purpose: A console application that allows users to test mathematical expressions and library implementations.
- Users can input mathematical expressions and select different library implementations to test.
- Utilizes a loop with a property flag to keep the application running, accepting input until the user decides to exit.
Benchmarking
Purpose: To compare the performance of different math libraries.
- Uses the BenchmarkDotNet package to provide detailed performance metrics.
- Allows for updating and running benchmark tests with various mathematical expressions to evaluate and compare library performance.

External Projects

Our research includes evaluating the following external projects:

ExpressionEvaluator 1.4.40
A versatile library for evaluating expressions. Explore it here.

ExpresiveParser 3.0.1
A powerful parser for evaluating expressions. Check out the project here.

Microsoft.ClearScript 7.4.5
A library for integrating and executing scripts in .NET applications. Learn more here.

How to Run

Using Visual Studio

Open the NMLs solution in Visual Studio.
In the Solution Explorer, right-click on either the Benchmarking or NMLs project.
Select "Set as Startup Project".
Press F5 *or click the *"Start" button to run the project.

Using Terminal

Navigate to the root directory of the cloned repository.
Build the projects with:

dotnet build ./NMLs/NMLs.csproj
dotnet build ./Benchmarking/Benchmarking.csproj

Run the desired project with:

dotnet run --project ./NMLs/NMLs.csproj

dotnet build --configuration Release
dotnet run --project ./Benchmarking/Benchmarking.csproj --configuration Release

Keep in mind that BenckmarkingDotNet needs to us the build project using Release configuration.

Contribution

We welcome contributions to this project! If you have suggestions, improvements, or find any issues, feel free to submit issues or pull requests. Your contributions help enhance the project and benefit the community.