Hand.Generators.EasySyntax 0.2.0.4

.NET 8.0 This package targets .NET 8.0. The package is compatible with this framework or higher. .NET Standard 2.0 This package targets .NET Standard 2.0. The package is compatible with this framework or higher. .NET Framework 4.6.2 This package targets .NET Framework 4.6.2. The package is compatible with this framework or higher.
There is a newer version of this package available.
See the version list below for details. 
dotnet add package Hand.Generators.EasySyntax --version 0.2.0.4
                    


                    

                
NuGet\Install-Package Hand.Generators.EasySyntax -Version 0.2.0.4
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="Hand.Generators.EasySyntax" Version="0.2.0.4" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="Hand.Generators.EasySyntax" Version="0.2.0.4" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="Hand.Generators.EasySyntax" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add Hand.Generators.EasySyntax --version 0.2.0.4
                    


                    

                
#r "nuget: Hand.Generators.EasySyntax, 0.2.0.4"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package Hand.Generators.EasySyntax@0.2.0.4
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=Hand.Generators.EasySyntax&version=0.2.0.4
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=Hand.Generators.EasySyntax&version=0.2.0.4
                    


                            Install as a Cake Tool

对SyntaxTree简化

一、 声明命名空间

1. 默认方式

var ns = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName("Models"));
var fns = SyntaxFactory.FileScopedNamespaceDeclaration(SyntaxFactory.IdentifierName("Services"));

2. 简化方式

var ns = SyntaxGenerator.NamespaceDeclaration("Models");
var fns = SyntaxGenerator.FileScopedNamespaceDeclaration("Services");

3. 生成的代码

namespace Models
{
}

namespace Services;

二、 预定义类型

1. 默认方式

  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ByteKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.SByteKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UIntKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ShortKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UShortKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.LongKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ULongKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.FloatKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DecimalKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.CharKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword))
  • SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword))

2. 简化方式

  • SyntaxGenerator.BoolType
  • SyntaxGenerator.ByteType
  • SyntaxGenerator.SByteType
  • SyntaxGenerator.IntType
  • SyntaxGenerator.UIntType
  • SyntaxGenerator.ShortType
  • SyntaxGenerator.UShortType
  • SyntaxGenerator.LongType
  • SyntaxGenerator.ULongType
  • SyntaxGenerator.FloatType
  • SyntaxGenerator.DoubleType
  • SyntaxGenerator.DecimalType
  • SyntaxGenerator.StringType
  • SyntaxGenerator.CharType
  • SyntaxGenerator.ObjectType
  • SyntaxGenerator.VoidType

3. 生成的代码

  • bool
  • byte
  • sbyte
  • int
  • uint
  • short
  • ushort
  • long
  • ulong
  • float
  • double
  • decimal
  • string
  • char
  • object
  • void

三、 常量表达式

1. 默认方式

  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1U))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1L))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1UL))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1F))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1D))
  • SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1M))
  • SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("abc"))
  • SyntaxFactory.LiteralExpression(SyntaxKind.CharacterLiteralExpression, SyntaxFactory.Literal('a'))
  • SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)
  • SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)
  • SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)
  • SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)
  • SyntaxFactory.ImplicitObjectCreationExpression()
  • SyntaxFactory.CollectionExpression()

2. 简化方式

  • SyntaxGenerator.Literal(1)
  • SyntaxGenerator.Literal(1U)
  • SyntaxGenerator.Literal(1L)
  • SyntaxGenerator.Literal(1UL)
  • SyntaxGenerator.Literal(1F)
  • SyntaxGenerator.Literal(1D)
  • SyntaxGenerator.Literal(1M)
  • SyntaxGenerator.Literal("abc")
  • SyntaxGenerator.Literal('a')
  • SyntaxGenerator.TrueLiteral
  • SyntaxGenerator.FalseLiteral
  • SyntaxGenerator.NullLiteral
  • SyntaxGenerator.DefaultLiteral

3. 生成的代码

  • 1
  • 1U
  • 1L
  • 1UL
  • 1F
  • 1D
  • ushort
  • 1M
  • "abc"
  • 'a'
  • true
  • null
  • default
  • new()
  • []

四、 插值表达式

1. 普通插值

1.1 默认方式
InterpolatedStringContentSyntax[] contents = [
    SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
        SyntaxTriviaList.Empty,
        SyntaxKind.InterpolatedStringTextToken,
        SymbolDisplay.FormatLiteral("Hello ", false),
        "Hello ",
        SyntaxTriviaList.Empty)),
    SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("name")),
    SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
        SyntaxTriviaList.Empty,
        SyntaxKind.InterpolatedStringTextToken,
        SymbolDisplay.FormatLiteral("!", false),
        "!",
        SyntaxTriviaList.Empty))
    ];
var interpolation = SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), SyntaxGenerator.List(contents));
1.2 简化方式
var interpolation = SyntaxGenerator.Interpolation()
    .Add("Hello ")
    .Add(SyntaxFactory.IdentifierName("name"))
    .Add("!")
    .Build();
1.3 生成的代码
$"Hello {name}!"

2. 格式化插值

1.1 默认方式
InterpolatedStringContentSyntax[] contents = [
    SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(
                SyntaxTriviaList.Empty,
                SyntaxKind.InterpolatedStringTextToken,
                "Today is: ",
                "Today is: ",
                SyntaxTriviaList.Empty)),
    SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("now"), default,  SyntaxFactory.InterpolationFormatClause(
        SyntaxFactory.Token(SyntaxKind.ColonToken),
        SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.InterpolatedStringTextToken, "yyyy-MM-dd", "yyyy-MM-dd", SyntaxTriviaList.Empty)))
];
var interpolation = SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), SyntaxGenerator.List(contents));
1.2 简化方式
var interpolation = SyntaxGenerator.Interpolation()
    .Add("Today is: ")
    .Add(SyntaxFactory.IdentifierName("now"), "yyyy-MM-dd")
    .Build();
1.3 生成的代码
$"Today is: {now:yyyy-MM-dd}"

五、 运算

1. 默认方式

  • SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.MultiplyExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.ModuloExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.LeftShiftExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.RightShiftExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseAndExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseOrExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.ExclusiveOrExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.LogicalAndExpression, left, right)
  • SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, left, right)
  • SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, variable)
  • SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreDecrementExpression, variable)
  • SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, variable)
  • SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostDecrementExpression, variable)
  • SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, variable)
  • SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, variable)
  • SyntaxFactory.QualifiedName(prefix, name)
  • SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, owner, member)
  • SyntaxFactory.ConditionalAccessExpression(owner, SyntaxFactory.MemberBindingExpression(SyntaxFactory.IdentifierName(member)))

2. 简化方式(扩展方法)

  • left.Add(right)
  • left.Subtract(right)
  • left.Multiply(right)
  • left.Divide(right)
  • left.Modulo(right)
  • left.LeftShift(right)
  • left.RightShift(right)
  • left.And(right)
  • left.Or(right)
  • left.XOr(right)
  • left.LogicalAnd(right)
  • left.LogicalOr(right)
  • variable.PreIncrement()
  • variable.PreDecrement()
  • variable.PostIncrement()
  • variable.PostDecrement()
  • variable.Not()
  • variable.LogicalNot()
  • name.Qualified(prefix)
  • owner.Access(member)
  • owner.ConditionalAccess(member)

3. 生成的代码

  • left + right
  • left - right
  • left * right
  • left / right
  • left % right
  • left << right
  • left >> right
  • left & right
  • left | right
  • left ^ right
  • left && right
  • left || right
  • ++variable
  • --variable
  • variable++
  • variable--
  • ~variable
  • !variable
  • prefix.name
  • owner.member
  • owner?.member

六、定义变量

1. 默认方式

var x = SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
    .AddVariables(SyntaxFactory.VariableDeclarator("x"));
var y = SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
    .AddVariables(SyntaxFactory.VariableDeclarator("y")
        .WithInitializer(SyntaxFactory.EqualsValueClause(
            SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))));
var z = SyntaxFactory.VariableDeclaration(SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.VarKeyword)))
    .AddVariables(SyntaxFactory.VariableDeclarator("z")
        .WithInitializer(SyntaxFactory.EqualsValueClause(
            SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))));

2. 简化方式

var x = SyntaxGenerator.IntType.Variable("x");
var y = SyntaxGenerator.IntType.Variable("y", SyntaxGenerator.Literal(1));
var z = SyntaxGenerator.IntType.Variable("z", SyntaxGenerator.Literal(1));

3. 生成的代码

int x;
int y = 1;
var z = 1;

七、定义字段

1. 默认方式

var _x = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))
    .AddDeclarationVariables(
        SyntaxFactory.VariableDeclarator("_x")
    );
var _y = SyntaxFactory.FieldDeclaration(SyntaxFactory.VariableDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))
    .AddDeclarationVariables(
        SyntaxFactory.VariableDeclarator("_y")
        .WithInitializer(SyntaxFactory.EqualsValueClause(
            SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))
        )
    );

2. 简化方式

var _x = SyntaxGenerator.IntType.Field("_x");
var _y = SyntaxGenerator.IntType.Field("_y", SyntaxGenerator.Literal(1));

3. 生成的代码

int _x;
int _y = 1;

八、定义参数

1. 默认方式

var a = SyntaxFactory.Parameter(SyntaxFactory.Identifier("a"))
    .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
var b = SyntaxFactory.Parameter(SyntaxFactory.Identifier("b"))
    .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
    .WithDefault(SyntaxFactory.EqualsValueClause(
        SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1))));

2. 简化方式

var a = SyntaxGenerator.IntType.Parameter("a");
var b = SyntaxGenerator.IntType.Parameter("b", SyntaxGenerator.Literal(1));

3. 生成的代码

int a

int b = 1

九、定义函数

1. 默认方式

var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)), "Increment")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("num"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))),
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("value"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
            .WithDefault(SyntaxFactory.EqualsValueClause(
                SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1))))
    )
    .WithBody(SyntaxFactory.Block(
        SyntaxFactory.ReturnStatement(
            SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression,
                SyntaxFactory.IdentifierName("num"),
                SyntaxFactory.IdentifierName("value"))
        )
    ));

2. 简化方式

var num = SyntaxFactory.IdentifierName("num");
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxGenerator.IntType.Method("Increment", 
        SyntaxGenerator.IntType.Parameter(num.Identifier), 
        SyntaxGenerator.IntType.Parameter(value.Identifier, SyntaxGenerator.Literal(1)))
    .ToBuilder()
    .Return(num.Add(value));

3. 生成的代码

int Increment(int num, int value = 1)
{
    return num + value;
}

十、 定义构造函数

1. 默认方式

var constructor = SyntaxFactory.ConstructorDeclaration("UserId")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("original"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))

2. 简化方式

var constructor = type.Constructor(SyntaxGenerator.IntType.Parameter(original.Identifier));

3. 生成的代码

UserId(int original)

十一、声明类和结构体

1. 默认方式

var userClass = SyntaxFactory.ClassDeclaration("UserClass");
var userStruct = SyntaxFactory.StructDeclaration("UserStruct");

2. 简化方式无

3. 生成的代码

class UserClass
{
}
struct UserStruct
{
}

十二、声明记录类

1. 默认方式

var record = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "Person")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("Name"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)))
    )
    .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

2. 简化方式

var record = SyntaxGenerator.RecordDeclaration("Person")
    .AddParameterListParameters(
        SyntaxGenerator.StringType.Parameter("Name")
    )
    .WithSemicolonToken();

3. 生成的代码

record Person(string Name);

十三、声明记录结构体

1. 默认方式

var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxKind.RecordStructDeclaration, SyntaxFactory.Token(SyntaxKind.RecordKeyword), SyntaxFactory.Identifier("UserId"))
    .WithClassOrStructKeyword(SyntaxFactory.Token(SyntaxKind.StructKeyword))
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("Id"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
    )            
    .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

2. 简化方式

var type = SyntaxGenerator.RecordStructDeclaration("UserId")
    .AddParameterListParameters(
        SyntaxGenerator.IntType.Parameter("Id")
    )
    .WithSemicolonToken();

3. 生成的代码

record struct UserId(int Id);

十四、继承基类

1. 默认方式

var vipType = SyntaxFactory.ClassDeclaration("Vip")
    .AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("Customer")));

2. 简化方式

var vipType = SyntaxFactory.ClassDeclaration("Vip")
    .AddBaseTypes("Customer");

3. 生成的代码

class Vip : Customer
{
}

十五、构造函数调用自身构造函数

1. 默认方式

var constructor = SyntaxFactory.ConstructorDeclaration("Discounter")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("percent"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.DoubleKeyword))))
    .WithBody(SyntaxFactory.Block());
var constructor2 = SyntaxFactory.ConstructorDeclaration("Discounter")
    .WithInitializer(SyntaxFactory.ConstructorInitializer(
        SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(
            SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0.9)))))))
    .WithBody(SyntaxFactory.Block());
var discounterType = SyntaxFactory.ClassDeclaration("Discounter")
    .AddMembers(constructor, constructor2);

2. 简化方式

var discounterType = SyntaxFactory.ClassDeclaration("Discounter");
var constructor = discounterType.Constructor(SyntaxGenerator.DoubleType.Parameter("percent"))            
    .WithBody(SyntaxFactory.Block());
var constructor2 = discounterType.Constructor()
    .WithInitializer(SyntaxGenerator.Literal(0.9))
    .WithBody(SyntaxFactory.Block());

3. 生成的代码

class Discounter
{
    Discounter(double percent)
    {
    }

    Discounter() : this(0.9)
    {
    }
}

十六、构造函数调用父类构造函数

1. 默认方式

var constructor = SyntaxFactory.ConstructorDeclaration("Vip")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("name"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))),
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("level"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))
    .WithInitializer(SyntaxFactory.ConstructorInitializer(
        SyntaxKind.BaseConstructorInitializer, SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
            SyntaxFactory.Argument(SyntaxFactory.IdentifierName("name"))))))
    .WithBody(SyntaxFactory.Block());
var vipType = SyntaxFactory.ClassDeclaration("Vip")
    .AddBaseListTypes(SyntaxFactory.SimpleBaseType(SyntaxFactory.IdentifierName("Customer")))
    .AddMembers(constructor);

2. 简化方式

var vipType = SyntaxFactory.ClassDeclaration("Vip")
    .AddBaseTypes("Customer");
var constructor = vipType.Constructor(SyntaxGenerator.StringType.Parameter("name"), SyntaxGenerator.IntType.Parameter("level"))
    .WithBaseInitializer(SyntaxFactory.IdentifierName("name"))
    .WithBody(SyntaxFactory.Block());
vipType = vipType.AddMembers(constructor);

3. 生成的代码

class Vip : Customer
{
    Vip(string name, int level) : base(name)
    {
    }
}

十七、主构造函数调用父类构造函数

1. 默认方式

var baseType = SyntaxFactory.PrimaryConstructorBaseType(
    SyntaxFactory.IdentifierName("Customer"), 
    SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
        SyntaxFactory.Argument(SyntaxFactory.IdentifierName("Name")))));
var recordDeclaration = SyntaxFactory.RecordDeclaration(SyntaxFactory.Token(SyntaxKind.RecordKeyword), "Vip")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("Name"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))),
        SyntaxFactory.Parameter(SyntaxFactory.Identifier("Level"))
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))
    .AddBaseListTypes(baseType)
    .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

2. 简化方式

var recordDeclaration = SyntaxGenerator.RecordDeclaration("Vip")            
    .AddParameterListParameters(SyntaxGenerator.StringType.Parameter("Name"), SyntaxGenerator.IntType.Parameter("Level"))
    .AddPrimaryConstructorBaseType("Customer", SyntaxFactory.IdentifierName("Name"))
    .WithSemicolonToken();

3. 生成的代码

record Vip(string Name, int Level) : Customer(Name);

十八、修饰符

  • abstract
  • virtual
  • override
  • sealed
  • partial
  • static
  • readonly
  • const
  • params
  • in
  • ref
  • out

1. 访问修饰符

  • private
  • protected
  • internal
  • public
1.1 默认方式
var field = SyntaxFactory.FieldDeclaration(
    SyntaxFactory.VariableDeclaration(
        SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
        SyntaxFactory.SingletonSeparatedList(
            SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("_id"))
        )
    ))
    .AddModifiers(SyntaxFactory.Token(SyntaxKind.PrivateKeyword));
var property = SyntaxFactory.PropertyDeclaration(
    SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
    SyntaxFactory.Identifier("Id"))
    .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
    .AddAccessorListAccessors(
        SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
            .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
        SyntaxFactory.AccessorDeclaration(SyntaxKind.InitAccessorDeclaration)
            .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
    );
1.2 简化方式
var field = SyntaxGenerator.IntType.Field("_id")
    .Private();
var property = SyntaxGenerator.IntType.Property("Id", 
        SyntaxKind.GetAccessorDeclaration, 
        SyntaxKind.InitAccessorDeclaration)
    .Public();
1.3 生成的代码
private int _id;
public int Id { get; init; }

2. 字段修饰符

  • readonly
  • const
  • volatile‌
2.1 默认方式
var field = SyntaxFactory.FieldDeclaration(
    SyntaxFactory.VariableDeclaration(
        SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
        SyntaxFactory.SingletonSeparatedList(
            SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("_id"))
        )
    ))
    .AddModifiers(
        SyntaxFactory.Token(SyntaxKind.PrivateKeyword), 
        SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
2.2 简化方式
var field = SyntaxGenerator.IntType.Field("_id")
     .Private()
     .ReadOnly();
2.3 生成的代码
private readonly int _id;

3. 参数修饰符

  • params
  • in
  • ref
  • out
3.1 默认方式
var parameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier("name"))
    .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)))
    .AddModifiers(SyntaxFactory.Token(SyntaxKind.RefKeyword));
3.2 简化方式
var parameter = SyntaxGenerator.StringType.Parameter("name")
    .Ref();
3.3 生成的代码
ref string name

4. 方法修饰符

  • virtual‌
  • override
  • extern‌
  • async
4.1 默认方式
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), "CreateId")
    .AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword))
    .WithBody(
        SyntaxFactory.Block(SyntaxFactory.ReturnStatement(
            SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, SyntaxFactory.IdentifierName("_seed"))))
    );
4.2 简化方式
var method = SyntaxGenerator.IntType.Method("CreateId")
    .Virtual()
    .ToBuilder()
    .Return(SyntaxFactory.IdentifierName("_seed").PostIncrement());
4.3 生成的代码
virtual int CreateId()
{
    return _seed++;
}

5. 其他修饰符

  • abstract
  • sealed
  • new
  • static‌
  • partial
5.1 默认方式
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), "CreateId")
    .AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword))
    .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
5.2 简化方式
var method = SyntaxGenerator.IntType.Method("CreateId")
    .Partial()
    .WithSemicolonToken();
5.3 生成的代码
partial int CreateId();

十九、方法体定义

1. 方法体构造器

  • 调用ToBuilder简化方法体定义
1.1 支持构造函数、方法和属性
var type = SyntaxFactory.ClassDeclaration("UserId");
var original = SyntaxFactory.IdentifierName("original");
var constructor = type.Constructor(SyntaxGenerator.IntType.Parameter(original.Identifier))
    .ToBuilder()
    .Add(SyntaxFactory.IdentifierName("_original").Assign(original))
    .End();

var num = SyntaxFactory.IdentifierName("num");
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxGenerator.IntType.Method("Increment", 
        SyntaxGenerator.IntType.Parameter(num.Identifier), 
        SyntaxGenerator.IntType.Parameter(value.Identifier, SyntaxGenerator.Literal(1)))
    .ToBuilder()
    .Return(num.Add(value));

var getAge = SyntaxGenerator.PropertyGetDeclaration()
    .ToBuilder()
    .Return(SyntaxFactory.IdentifierName("_age"));
var setAge = SyntaxGenerator.PropertySetDeclaration()
    .ToBuilder()
    .Add(SyntaxFactory.IdentifierName("_age").AssignValue())
    .End();
var property = SyntaxGenerator.IntType.Property(SyntaxFactory.Identifier("Age"), getAge, setAge);
1.2 生成的代码
UserId(int original)
{
    _original = original;
}

int Increment(int num, int value = 1)
{
    return num + value;
}


int Age
{
    get
    {
        return _age;
    }

    set
    {
        _age = value;
    }
}

2. if/else分支逻辑

2.1 默认方式
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), "BoolToString")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(value.Identifier)
            .WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)))))
    .AddBodyStatements(
        SyntaxFactory.IfStatement(
            SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, value, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)),
            SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("false"))),
            SyntaxFactory.ElseClause(
                SyntaxFactory.IfStatement(
                value,
                SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("true"))),
                SyntaxFactory.ElseClause(SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("false")))))))
    );
2.2 简化方式
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxGenerator.StringType.Method("BoolToString", SyntaxGenerator.BoolType.Nullable().Parameter(value.Identifier))
    .ToBuilder()
    .If(value.IsNull())
        .Add(SyntaxGenerator.Literal("false").Return())
    .ElseIf(value)
        .Return(SyntaxGenerator.Literal("true"))
    .Return(SyntaxGenerator.Literal("false"));
2.3 生成的代码
string BoolToString(bool? value)
{
    if (value == null)
        return "false";
    else if (value)
        return "true";
    return "false";
}

3. switch/case分支逻辑

3.1 默认方式
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)), "IntToBool")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(value.Identifier)
            .WithType(SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))))
    .AddBodyStatements(
        SyntaxFactory.SwitchStatement(value)
            .AddSections(
                SyntaxFactory.SwitchSection(
                    SyntaxFactory.SingletonList<SwitchLabelSyntax>(SyntaxFactory.CaseSwitchLabel(
                        SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)))),
                    SyntaxFactory.SingletonList<StatementSyntax>(SyntaxFactory.ReturnStatement(
                        SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)))),
                SyntaxFactory.SwitchSection(
                    SyntaxFactory.SingletonList<SwitchLabelSyntax>(SyntaxFactory.CaseSwitchLabel(
                        SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))),
                    SyntaxFactory.SingletonList<StatementSyntax>(SyntaxFactory.ReturnStatement(
                        SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)))),
                SyntaxFactory.SwitchSection(
                    SyntaxFactory.SingletonList<SwitchLabelSyntax>(SyntaxFactory.DefaultSwitchLabel()),
                    SyntaxFactory.SingletonList<StatementSyntax>(SyntaxFactory.ReturnStatement(
                        SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)))))
    );
3.2 简化方式
var value = SyntaxFactory.IdentifierName("value");
var method = SyntaxGenerator.BoolType.Method("IntToBool", SyntaxGenerator.IntType.Parameter(value.Identifier))
    .ToBuilder()
    .Switch(value)
        .Case(SyntaxGenerator.Literal(0))
            .Add(SyntaxGenerator.FalseLiteral.Return())
        .Case(SyntaxGenerator.Literal(1))
            .Add(SyntaxGenerator.TrueLiteral.Return())
        .Default()
            .Return(SyntaxGenerator.TrueLiteral)
    .End();
3.3 生成的代码
bool IntToBool(int value)
{
    switch (value)
    {
        case 0:
            return false;
        case 1:
            return true;
        default:
            return true;
    }
}

4. foreach循环

4.1 默认方式
var list = SyntaxFactory.IdentifierName("list");
var item = SyntaxFactory.IdentifierName("item");
var count = SyntaxFactory.IdentifierName("count");
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)), "Count")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(list.Identifier)
            .WithType(SyntaxFactory.ArrayType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))))
    .AddBodyStatements(
        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
            SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList(
                SyntaxFactory.VariableDeclarator(count.Identifier)
                    .WithInitializer(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, 
                        SyntaxFactory.Literal(0)))))),
        SyntaxFactory.ForEachStatement(
            SyntaxFactory.IdentifierName("var"), 
            item.Identifier, 
            list, 
            SyntaxFactory.ExpressionStatement(
                SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, count, item))),
        SyntaxFactory.ReturnStatement(count)
    );
4.2 简化方式
var list = SyntaxFactory.IdentifierName("list");
var item = SyntaxFactory.IdentifierName("item");
var count = SyntaxFactory.IdentifierName("count");
var method = SyntaxGenerator.IntType.Method("Count", SyntaxGenerator.IntType.Array().Parameter(list.Identifier))
    .ToBuilder()
    .Declare(SyntaxGenerator.VarType.Variable(count.Identifier, SyntaxGenerator.Literal(0)))
    .ForEach(SyntaxGenerator.VarType, item.Identifier, list)
        .Add(count.AddAssign(item))
    .End()
    .Return(count);
4.3 生成的代码
int Count(int[] list)
{
    var count = 0;
    foreach (var item in list)
        count += item;
    return count;
}

5. for循环

5.1 默认方式
var i = SyntaxFactory.IdentifierName("i");
var num = SyntaxFactory.IdentifierName("num");
var count = SyntaxFactory.IdentifierName("count");
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)), "Total")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(num.Identifier)
            .WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))))
    .AddBodyStatements(
        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
            SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList(
                SyntaxFactory.VariableDeclarator(count.Identifier)
                    .WithInitializer(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,
                        SyntaxFactory.Literal(0)))))),
        SyntaxFactory.ForStatement(
            SyntaxFactory.VariableDeclaration(
                SyntaxFactory.IdentifierName("var")).AddVariables(
                    SyntaxFactory.VariableDeclarator(i.Identifier)
                        .WithInitializer(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,
                            SyntaxFactory.Literal(0)))),
            default,
            SyntaxFactory.BinaryExpression(SyntaxKind.LessThanExpression, i, num),
            SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, i)),
            SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, count, i))),
        SyntaxFactory.ReturnStatement(count)
    );
5.2 简化方式
var i = SyntaxFactory.IdentifierName("i");
var num = SyntaxFactory.IdentifierName("num");
var count = SyntaxFactory.IdentifierName("count");
var method = SyntaxGenerator.IntType.Method("Total", SyntaxGenerator.IntType.Parameter(num.Identifier))
    .ToBuilder()
    .Declare(SyntaxGenerator.IntType.Variable(count.Identifier, SyntaxGenerator.Literal(0)))
    .For(i, num)
        .Add(count.AddAssign(i))
    .End()
    .Return(count);
5.3 生成的代码
int Total(int num)
{
    int count = 0;
    for (var i = 0; i < num; i++)
        count += i;
    return count;
}

6. while循环

6.1 默认方式
var readerType = SyntaxFactory.IdentifierName("DbDataReader");
var reader = SyntaxFactory.IdentifierName("reader");
var listType = SyntaxFactory.GenericName("List")
    .AddTypeArgumentListArguments(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
var list = SyntaxFactory.IdentifierName("list");
var getFieldValue = SyntaxFactory.QualifiedName(
    reader, 
    SyntaxFactory.GenericName("GetFieldValue")
        .AddTypeArgumentListArguments(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))));
var method = SyntaxFactory.MethodDeclaration(listType, "GetIds")
    .AddParameterListParameters(
        SyntaxFactory.Parameter(reader.Identifier)
            .WithType(readerType)
    )
    .AddBodyStatements(
        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
            listType, SyntaxFactory.SingletonSeparatedList(
                SyntaxFactory.VariableDeclarator(list.Identifier)
                    .WithInitializer(SyntaxFactory.CollectionExpression())))),
        SyntaxFactory.WhileStatement(
            SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, reader, SyntaxFactory.IdentifierName("Read"))),
            SyntaxFactory.ExpressionStatement(
                SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, list, SyntaxFactory.IdentifierName("Add")))
                    .AddArgumentListArguments(SyntaxFactory.Argument(
                        SyntaxFactory.InvocationExpression(getFieldValue)
                        .AddArgumentListArguments(SyntaxFactory.Argument(
                            SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))
                        ))
                    ))
            )
        ),
        SyntaxFactory.ReturnStatement(list)
    );
6.2 简化方式
 var readerType = SyntaxFactory.IdentifierName("DbDataReader");        
 var reader = SyntaxFactory.IdentifierName("reader");
 var listType = SyntaxGenerator.Generic("List", SyntaxGenerator.IntType);
 var list = SyntaxFactory.IdentifierName("list");
 var getFieldValue = SyntaxGenerator.Generic("GetFieldValue", SyntaxGenerator.IntType).Qualified(reader);
 var method = listType.Method("GetIds", readerType.Parameter(reader.Identifier))
     .ToBuilder()
     .Declare(listType.Variable(list.Identifier, SyntaxFactory.CollectionExpression()))
     .While(reader.Access("Read").Invocation())
         .Add(list.Access("Add").Invocation([getFieldValue.Invocation([SyntaxGenerator.Literal(0)])]))
     .End()
     .Return(list);
6.3 生成的代码
List<int> GetIds(DbDataReader reader)
{
    List<int> list = [];
    while (reader.Read())
        list.Add(reader.GetFieldValue<int>(0));
    return list;
}

6. do/while循环

6.1 默认方式
var console = SyntaxFactory.IdentifierName("Console");
var writeLine = console.Access("WriteLine");
var thing = SyntaxFactory.IdentifierName("thing");
var method = SyntaxFactory.MethodDeclaration(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)), "DoSTh")
    .AddBodyStatements(
        SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
            SyntaxFactory.NullableType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))), SyntaxFactory.SingletonSeparatedList(
                SyntaxFactory.VariableDeclarator(thing.Identifier)))),
        SyntaxFactory.ExpressionStatement(
            SyntaxFactory.InvocationExpression(writeLine)
               .AddArgumentListArguments(SyntaxFactory.Argument(
                   SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Enter some things:"))
               ))
        ),
        SyntaxFactory.DoStatement(
            SyntaxFactory.Block(
                SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                    thing,
                    SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, console, SyntaxFactory.IdentifierName("ReadLine"))))),
                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, console, SyntaxFactory.IdentifierName("Write")))
                        .AddArgumentListArguments(SyntaxFactory.Argument(
                            SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Do "))
                        ))
                ),
                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(writeLine)
                        .AddArgumentListArguments(SyntaxFactory.Argument(thing))
                )
            ),
            thing.NotEqual(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("exit"))))
    );
6.2 简化方式
var console = SyntaxFactory.IdentifierName("Console");
var writeLine = console.Access("WriteLine");
var thing = SyntaxFactory.IdentifierName("thing");
var method = SyntaxGenerator.VoidType.Method("DoSTh")
    .ToBuilder()
    .Declare(SyntaxGenerator.StringType.Nullable().Variable(thing.Identifier))
    .Add(writeLine.Invocation([SyntaxGenerator.Literal("Enter some things:")]))
    .Do(thing.NotEqual(SyntaxGenerator.Literal("exit")))
        .Add(thing.Assign(console.Access("ReadLine").Invocation()))
        .Add(console.Access("Write").Invocation([SyntaxGenerator.Literal("Do ")]))
        .Add(writeLine.Invocation([thing]))
        .End()
    .End();
6.3 生成的代码
void DoSTh()
{
    string? thing;
    Console.WriteLine("Enter some things:");
    do
    {
        thing = Console.ReadLine();
        Console.Write("Do ");
        Console.WriteLine(thing);
    }
    while (thing != "exit");
}

7. 逻辑支持多层嵌套

  • 分支逻辑可以嵌套
  • 循环逻辑也可以嵌套
7.1 for循环嵌套的Case
 var parameter = SyntaxGenerator.IntType.Array(2).Parameter("list");
 var list = parameter.ToIdentifierName();
 var i = SyntaxFactory.IdentifierName("i");
 var j = SyntaxFactory.IdentifierName("j");
 var getLength = list.Access("GetLength");
 var count = SyntaxGenerator.IntType.Variable("count", SyntaxGenerator.Literal(0));
 var method = SyntaxGenerator.IntType.Method("Count", parameter)
     .ToBuilder()
     // int count=0
     .Declare(count)
     // for(var i = 0;i<list.GetLength(0);i++)
     .For(i, getLength.Invocation([SyntaxGenerator.Literal(0)]))
         // for(var j = 0;j<list.GetLength(1);j++)
         .For(j, getLength.Invocation([SyntaxGenerator.Literal(1)]))
             // count+=list[i,j]
             .Add(count.ToIdentifierName().AddAssign(list.Element([i, j])))
         .End()
     .End()
     // return count
     .Return(count.ToIdentifierName());
7.2 for循环嵌套的生成的代码
int Count(int[, ] list)
{
    int count = 0;
    for (var i = 0; i < list.GetLength(0); i++)
        for (var j = 0; j < list.GetLength(1); j++)
            count += list[i, j];
    return count;
}
Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 is compatible.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 is compatible.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
.NET Core netcoreapp2.0 was computed.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 is compatible. 
.NET Framework net461 was computed.  net462 is compatible.  net463 was computed.  net47 is compatible.  net471 was computed.  net472 was computed.  net48 is compatible.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages (5)

Showing the top 5 NuGet packages that depend on Hand.Generators.EasySyntax:

Package Downloads
Hand.GenerateCore

Package Description
Hand.GenerateCachedProperty

Package Description
Hand.GenerateProperty

Package Description
Hand.GeneratePoco

Package Description
Hand.Generators.SyntaxScripting

Package Description

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
0.2.0.5 177 5/1/2026
0.2.0.4 122 5/1/2026
0.2.0.3 135 4/28/2026
0.2.0.2 264 4/26/2026
0.2.0.1 137 3/27/2026
0.2.0 219 3/26/2026
0.1.0.2-alpha 178 3/18/2026
0.1.0.1-alpha 96 3/9/2026
0.1.0-alpha 93 3/8/2026