Dynamic Code Framework Release - CZGL.Roslyn

CZGL.Roslyn

Open Source Project Location: https://github.com/whuanle/CZGL.CodeAnalysis

A C# dynamic code builder and compiler based on Roslyn technology, developers can use this library to dynamically build C# code and compile code conditionally.

• Runtime dynamic code construction;
• Provide new module functionalities at runtime, expanding capabilities;
• Design function platform to execute in code snippet units;
• Syntactic analysis hints, compile-time syntax error warnings, accurate to code lines;
• Comprehensive code standards to avoid syntax errors in dynamic code;
• Simplistic, easy-to-use API, complete test coverage;
• ... ...

Animated Demo

This demo uses Blazor, and the code can be found in the source under examples/BlazorExample.

The Blazor demo showcases compilation by namespace. You can customize the backend to run with just code blocks, without even needing function headers. More features for you to explore!

Rich Documentation and Examples

CZGL.Roslyn has extensive documentation and API interface descriptions to make your usage smooth!

Documentation URL: https://1586052146.gitbook.io/codeanalysis

API URL: https://czgl-roslyn.github.io/czgl-roslyn

Version Update Plan

• [ ] 0.1.0 α version (in development, current version)

  Features: An initial version with complete functionality.

• [ ] 0.2.0 β (beta) version

  Features: Eliminated serious bugs and defects, completed extensive unit tests, greatly improved code reliability; able to go live on Nuget for user trials; gather user requirements to improve the software;

• [ ] 0.3.0 γ version

This version is already quite mature, with updates based on user feedback and requirements after using the β version; it begins to focus on performance, conducting performance tests and implementing measures to enhance performance.

What Can Be Done

The biggest feature is dynamic code construction and dynamic compilation, so we can discuss them in two parts.

Dynamic Code Generation

• Database table restoration entities, automatically generate class model files; (EFCore has this feature)

• Internal company toolset definitions, generate code with one click through fixed templates!

• Quickly generate exported code through predetermined logical functions!

• Write AOP framework to achieve dynamic proxy;

• Code syntax checking;

• Generate scheduled code, manage which parts of the code can be executed;

• Construct workflow programs all at once through code generation, directly writing workflows into the assembly to improve performance!

• Quickly generate code from various data sources like tables;

• Custom UI generator, generating code by dragging and dropping controls;

  ... ...

Dynamic Compilation

• Self-developed cloud function platform, users can directly execute uploaded code;

• Corporate backend scheduled tasks, with assembly as units, custom scheduled execution of assemblies;

• Write AOP framework to dynamically compile assemblies;

• Single file (.cs) compilation, no need for SDK, IDE! Compile without a development environment!

  ... ...

Relationship with Natasha

Natasha is an excellent dynamic code framework led by Dashuai, forming a complete, high-performance ecosystem that is compatible with .NET FX 4.6~.NET Core ↑, having passed extensive performance tests and optimizations.

It can be described as extremely powerful. Repository address: https://github.com/dotnetcore/Natasha

So why write CZGL.Roslyn?

1. To hone technical skills;

2. Natasha does not create a competitive product with CZGL.Roslyn; CZGL.Roslyn aims to be lightweight. Developers can choose between the scale of the task, using Natasha for large scenarios and CZGL.Roslyn for quick setups; Natasha has a steeper learning curve, whereas CZGL.Roslyn is easier to learn;

3. Natasha offers comprehensive functionality but has more dependencies; CZGL.Roslyn aims to offer sufficient features while retaining fewer dependencies and being smaller in size;

4. CZGL.Roslyn is suitable for writing small tools, such as dotnet-tools, database entity restoration, providing rapid code generation for ML.NET, etc., serving as a widget to boost your program's functionalities; Natasha is better suited as a standalone product to build more features around it;

In terms of performance, Natasha excels; in terms of functionality completeness, Natasha provides a whole suite of services... ...

Compared to Natasha, CZGL.Roslyn's only real characteristic might be "lightweight," which is basically overwhelmed...

What Can I Learn from This Framework

The framework's characteristics are simplicity and ease of use; you can learn a lot about reflection, as well as Roslyn knowledge, and even might learn about EMIT (which I will later use to optimize performance).

For example, how to obtain property values from attributes?

[Display(Name = "_Id")]
public int Id {get;set;}

How to determine if a Type is a class, struct, or delegate?

If you look it up, you'll find that Type.IsClass can identify classes and delegates;

Why do the results of the following code differ between JAVA and C#?

public class A
{
    public void Test
    {
        Console.WriteLine("A");
    }
}
public class B:A
{
    // Hides the parent class Test function
    public new void Test
    {
        Console.WriteLine("B");
    }
}
A a = new B();
a.Test();

Currently, CZGL.Roslyn is in its initial version, with the code being rather simple, and the logic is straightforward. Hence, if you are interested in learning about reflection in C#, dynamic code technology, or how to retrieve information through reflection after code generation, or how source code will be compiled, CZGL.Roslyn is your best choice.