689 lines
28 KiB
C#
689 lines
28 KiB
C#
using JiShe.CollectBus.Analyzers.Shared;
|
||
using Microsoft.CodeAnalysis;
|
||
using Microsoft.CodeAnalysis.CSharp.Syntax;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Collections.Immutable;
|
||
using System.Diagnostics;
|
||
using System.Linq;
|
||
using System.Text;
|
||
|
||
namespace JiShe.CollectBus.IncrementalGenerator
|
||
{
|
||
/// <summary>
|
||
/// 复杂类型增量源生成器
|
||
/// </summary>
|
||
[Generator(LanguageNames.CSharp)]
|
||
public class ComplexTypeSourceAnalyzers : IIncrementalGenerator
|
||
{
|
||
private const string AttributeFullName = "JiShe.CollectBus.Analyzers.Shared.SourceAnalyzersAttribute";
|
||
|
||
public void Initialize(IncrementalGeneratorInitializationContext context)
|
||
{
|
||
//Debugger.Launch();
|
||
|
||
// 步骤1：筛选带有 [SourceAnalyzers] 的类
|
||
var classDeclarations = context.SyntaxProvider
|
||
.CreateSyntaxProvider(
|
||
predicate: static (s, _) => IsClassWithAttribute(s),
|
||
transform: static (ctx, _) => GetClassDeclaration(ctx))
|
||
.Where(static c => c is not null);
|
||
|
||
// 步骤2：合并编译信息
|
||
var compilationAndClasses = context.CompilationProvider.Combine(classDeclarations.Collect());
|
||
|
||
context.RegisterSourceOutput(compilationAndClasses, (spc, source) =>
|
||
GenerateCode(source.Left, source.Right!, spc));
|
||
}
|
||
|
||
private static bool IsClassWithAttribute(SyntaxNode node) => node is ClassDeclarationSyntax cds && cds.AttributeLists.Count > 0;
|
||
|
||
private static ClassDeclarationSyntax GetClassDeclaration(GeneratorSyntaxContext context)
|
||
{
|
||
var classDecl = (ClassDeclarationSyntax)context.Node;
|
||
var semanticModel = context.SemanticModel;
|
||
|
||
// 获取类符号
|
||
var classSymbol = semanticModel.GetDeclaredSymbol(classDecl) as INamedTypeSymbol;
|
||
if (classSymbol == null) return null;
|
||
|
||
// 检查是否包含 SourceAnalyzers 特性
|
||
var sourceAnalyzerAttr = classSymbol.GetAttributes().FirstOrDefault(attr => attr.AttributeClass?.ToDisplayString() == AttributeFullName);
|
||
|
||
// 必须包含 EntityType 参数
|
||
if (sourceAnalyzerAttr == null ||
|
||
sourceAnalyzerAttr.ConstructorArguments.Length == 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
return classDecl;
|
||
|
||
//var classDecl = (ClassDeclarationSyntax)context.Node;
|
||
//var attributeType = context.SemanticModel.Compilation.GetTypeByMetadataName(AttributeFullName);
|
||
|
||
//foreach (var attribute in classDecl.AttributeLists.SelectMany(al => al.Attributes))
|
||
//{
|
||
// var symbol = context.SemanticModel.GetSymbolInfo(attribute).Symbol;
|
||
// if (symbol is IMethodSymbol ctor &&
|
||
// SymbolEqualityComparer.Default.Equals(ctor.ContainingType, attributeType))
|
||
// {
|
||
// return classDecl;
|
||
// }
|
||
//}
|
||
//return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 递归获取所有层级的属性
|
||
/// </summary>
|
||
/// <param name="classSymbol"></param>
|
||
/// <returns></returns>
|
||
private static IEnumerable<IPropertySymbol> GetAllPropertiesInHierarchy(INamedTypeSymbol classSymbol)
|
||
{
|
||
var currentSymbol = classSymbol;
|
||
while (currentSymbol != null)
|
||
{
|
||
foreach (var prop in currentSymbol.GetMembers().OfType<IPropertySymbol>())
|
||
{
|
||
yield return prop;
|
||
}
|
||
currentSymbol = currentSymbol.BaseType; // 向上遍历基类
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成代码
|
||
/// </summary>
|
||
/// <param name="compilation"></param>
|
||
/// <param name="classes"></param>
|
||
/// <param name="context"></param>
|
||
private static void GenerateCode(
|
||
Compilation compilation,
|
||
IEnumerable<ClassDeclarationSyntax> classes,
|
||
SourceProductionContext context)
|
||
{
|
||
var processedTypes = new HashSet<ITypeSymbol>(SymbolEqualityComparer.Default);
|
||
|
||
if (!classes.Any())
|
||
{
|
||
context.ReportDiagnostic(Diagnostic.Create(
|
||
new DiagnosticDescriptor("GEN002", "没有目标类",
|
||
"没有找到SourceAnalyzers标记的类", "Debug", DiagnosticSeverity.Warning, true),
|
||
Location.None));
|
||
}
|
||
|
||
foreach (var classDecl in classes.Distinct())
|
||
{
|
||
var model = compilation.GetSemanticModel(classDecl.SyntaxTree);
|
||
var classSymbol = model.GetDeclaredSymbol(classDecl) as INamedTypeSymbol;
|
||
|
||
if (classSymbol == null || !processedTypes.Add(classSymbol))
|
||
{
|
||
context.ReportDiagnostic(Diagnostic.Create(
|
||
new DiagnosticDescriptor("GEN003", "无效符号",
|
||
$"类名称为{classDecl.Identifier.Text} 符号为空", "Error", DiagnosticSeverity.Error, true),
|
||
Location.None));
|
||
continue;
|
||
}
|
||
|
||
var code3 = BuildAccessorsForSourceEntity(classSymbol, compilation, processedTypes);
|
||
context.AddSource($"{classSymbol.Name}Accessor.g.cs", code3);
|
||
}
|
||
|
||
// 生成工厂注册代码
|
||
context.AddSource("SourceEntityAccessorFactory.g.cs", BuildFactoryCode());
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取泛型参数
|
||
/// </summary>
|
||
/// <param name="symbol"></param>
|
||
/// <returns></returns>
|
||
public static string GetGenericParams(INamedTypeSymbol symbol)
|
||
{
|
||
if (!symbol.IsGenericType) return "";
|
||
var parameters = symbol.TypeParameters.Select(t => t.Name);
|
||
return $"<{string.Join(", ", parameters)}>";
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 生成标准属性的访问器
|
||
/// </summary>
|
||
/// <param name="prop"></param>
|
||
/// <param name="propType"></param>
|
||
/// <param name="code"></param>
|
||
private static void GenerateStandardAccessors(IPropertySymbol prop, INamedTypeSymbol propType, StringBuilder code)
|
||
{
|
||
var parentType = prop.ContainingType.ToDisplayString();
|
||
code.AppendLine($" public static {propType.ToDisplayString()} Get{prop.Name}({parentType} obj) => obj.{prop.Name};");
|
||
|
||
if (prop.SetMethod != null)
|
||
{
|
||
code.AppendLine($" public static void Set{prop.Name}({parentType} obj, {propType.ToDisplayString()} value) => obj.{prop.Name} = value;");
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 构建实体访问器代码（支持泛型）
|
||
/// </summary>
|
||
private static string BuildAccessorsForSourceEntity(
|
||
INamedTypeSymbol classSymbol,
|
||
Compilation compilation,
|
||
HashSet<ITypeSymbol> processedTypes)
|
||
{
|
||
// 获取 SourceAnalyzers 特性的 EntityType 参数
|
||
var sourceAnalyzerAttr = classSymbol.GetAttributes()
|
||
.FirstOrDefault(attr =>
|
||
attr.AttributeClass?.ToDisplayString() == AttributeFullName);
|
||
|
||
// 解析 EntityType 枚举值
|
||
string entityTypeValue = "EntityTypeEnum.Other"; // 默认值
|
||
if (sourceAnalyzerAttr != null &&
|
||
sourceAnalyzerAttr.ConstructorArguments.Length > 0)
|
||
{
|
||
var arg = sourceAnalyzerAttr.ConstructorArguments[0];
|
||
if (arg.Kind == TypedConstantKind.Enum &&
|
||
arg.Type is INamedTypeSymbol enumType)
|
||
{
|
||
int enumValue = (int)arg.Value!;
|
||
entityTypeValue = GetEnumMemberName(enumType, enumValue);
|
||
}
|
||
}
|
||
|
||
var code = new StringBuilder();
|
||
code.AppendLine("// <auto-generated/>");
|
||
code.AppendLine("#nullable enable");
|
||
code.AppendLine("using System;");
|
||
code.AppendLine("using System.Reflection;");
|
||
code.AppendLine("using System.Collections.Generic;");
|
||
code.AppendLine("using JiShe.CollectBus.Analyzers.Shared;");
|
||
code.AppendLine($"namespace {classSymbol.ContainingNamespace.ToDisplayString()};");
|
||
code.AppendLine();
|
||
|
||
// 处理泛型类型名称
|
||
var accessibility = classSymbol.DeclaredAccessibility switch
|
||
{
|
||
Accessibility.Public => "public",
|
||
_ => "internal"
|
||
};
|
||
|
||
var genericParams = classSymbol.IsGenericType
|
||
? $"<{string.Join(", ", classSymbol.TypeParameters.Select(t => t.Name))}>"
|
||
: "";
|
||
|
||
code.AppendLine(
|
||
$"{accessibility} sealed class {classSymbol.Name}Accessor{genericParams} " + // 保留泛型参数
|
||
$": ISourceEntityAccessor<{classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)}>");
|
||
|
||
code.AppendLine("{");
|
||
|
||
var propList = GetAllPropertiesInHierarchy(classSymbol);
|
||
|
||
//类名称
|
||
code.AppendLine($" public string EntityName {{get;}} = \"{classSymbol.Name}\";");
|
||
// 添加 EntityType 属性
|
||
code.AppendLine($" public EntityTypeEnum? EntityType {{ get; }} = {entityTypeValue};");
|
||
|
||
foreach (var prop in propList)
|
||
{
|
||
// 安全类型转换
|
||
if (prop.Type is not ITypeSymbol propType) continue;
|
||
|
||
if (propType is INamedTypeSymbol namedType)
|
||
{
|
||
GenerateStandardAccessors(prop, namedType, code);
|
||
}
|
||
|
||
if (propType is INamedTypeSymbol { IsTupleType: true } tupleType)
|
||
{
|
||
GenerateTupleAccessors(prop, tupleType, code);
|
||
}
|
||
}
|
||
|
||
//生成当前类属性名称集合
|
||
GeneratePropertyListForSourceEntity(propList, code, compilation, classSymbol);
|
||
|
||
//生成当前类属性信息集合
|
||
GenerateEntityMemberInfoList(propList, code, compilation, classSymbol);
|
||
|
||
|
||
//生成当前类属性访问
|
||
GetGeneratePropertyValueForSourceEntity(propList, code, compilation, classSymbol);
|
||
|
||
//生成当前类属性设置
|
||
SetGeneratePropertyValueForSourceEntity(propList, code, compilation, classSymbol);
|
||
|
||
code.AppendLine("}");
|
||
return code.ToString();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 生成ValueTuple元组属性访问器
|
||
/// </summary>
|
||
/// <param name="prop"></param>
|
||
/// <param name="tupleType"></param>
|
||
/// <param name="code"></param>
|
||
private static void GenerateTupleAccessors(
|
||
IPropertySymbol prop,
|
||
INamedTypeSymbol tupleType,
|
||
StringBuilder code)
|
||
{
|
||
var parentType = prop.ContainingType.ToDisplayString();
|
||
var tupleElements = tupleType.TupleElements;
|
||
|
||
for (int i = 0; i < tupleElements.Length; i++)
|
||
{
|
||
var element = tupleElements[i];
|
||
var elementType = element.Type.ToDisplayString();
|
||
var elementName = element.Name;
|
||
|
||
// Getter
|
||
code.AppendLine($"public static {elementType} Get{prop.Name}_{elementName}({parentType} obj) => obj.{prop.Name}.{elementName};");
|
||
|
||
// Setter
|
||
if (prop.SetMethod != null)
|
||
{
|
||
code.AppendLine($"public static void Set{prop.Name}_{elementName}({parentType} obj, {elementType} value) => obj.{prop.Name} = ({string.Join(", ", GetTupleElements(prop.Name, tupleElements, i))});");
|
||
}
|
||
}
|
||
}
|
||
|
||
private static IEnumerable<string> GetTupleElements(
|
||
string propName,
|
||
ImmutableArray<IFieldSymbol> elements,
|
||
int targetIndex)
|
||
{
|
||
for (int i = 0; i < elements.Length; i++)
|
||
{
|
||
yield return i == targetIndex
|
||
? "value"
|
||
: $"obj.{propName}.{elements[i].Name}";
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理System.Tuple类型的访问器生成
|
||
/// </summary>
|
||
private static void GenerateSystemTupleAccessors(
|
||
IPropertySymbol prop,
|
||
INamedTypeSymbol tupleType,
|
||
StringBuilder code,
|
||
INamedTypeSymbol classSymbol)
|
||
{
|
||
var parentType = classSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
var elementTypes = tupleType.TypeArguments;
|
||
var tupleTypeName = tupleType.ToDisplayString();
|
||
|
||
for (int i = 0; i < elementTypes.Length; i++)
|
||
{
|
||
var elementType = elementTypes[i].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
var elementName = $"Item{i + 1}";
|
||
|
||
// Getter
|
||
code.AppendLine(
|
||
$" public static {elementType} Get{prop.Name}_{elementName}" +
|
||
$"({parentType} obj) => obj.{prop.Name}.{elementName};");
|
||
|
||
// Setter
|
||
if (prop.SetMethod != null)
|
||
{
|
||
var assignments = elementTypes.Select((_, idx) =>
|
||
idx == i ? "value" : $"obj.{prop.Name}.Item{idx + 1}"
|
||
).ToList();
|
||
|
||
code.AppendLine(
|
||
$" public static void Set{prop.Name}_{elementName}" +
|
||
$"({parentType} obj, {elementType} value) => " +
|
||
$"obj.{prop.Name} = new {tupleTypeName}({string.Join(", ", assignments)});");
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 增强的工厂类实现
|
||
/// </summary>
|
||
private static string BuildFactoryCode()
|
||
{
|
||
return """
|
||
using System;
|
||
using System.Collections.Concurrent;
|
||
using System.Reflection;
|
||
|
||
namespace JiShe.CollectBus.Analyzers.Shared;
|
||
|
||
public static class SourceEntityAccessorFactory
|
||
{
|
||
private static readonly ConcurrentDictionary<Type, object> _accessors = new();
|
||
|
||
public static ISourceEntityAccessor<T> GetAccessor<T>()
|
||
{
|
||
return (ISourceEntityAccessor<T>)_accessors.GetOrAdd(typeof(T), t =>
|
||
{
|
||
// 获取泛型类型定义信息（如果是泛型类型）
|
||
var isGeneric = t.IsGenericType;
|
||
var genericTypeDef = isGeneric ? t.GetGenericTypeDefinition() : null;
|
||
var arity = isGeneric ? genericTypeDef!.GetGenericArguments().Length : 0;
|
||
|
||
// 构建访问器类名
|
||
var typeName = isGeneric
|
||
? $"{t.Namespace}.{genericTypeDef!.Name.Split('`')[0]}Accessor`{arity}"
|
||
: $"{t.Namespace}.{t.Name}Accessor";
|
||
|
||
// 尝试从当前程序集加载
|
||
var accessorType = Assembly.GetAssembly(t)!.GetType(typeName)
|
||
?? throw new InvalidOperationException($"Accessor type {typeName} not found");
|
||
|
||
// 处理泛型参数
|
||
if (isGeneric && accessorType.IsGenericTypeDefinition)
|
||
{
|
||
accessorType = accessorType.MakeGenericType(t.GetGenericArguments());
|
||
}
|
||
|
||
return Activator.CreateInstance(accessorType)!;
|
||
});
|
||
}
|
||
}
|
||
""";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 属性访问生成逻辑
|
||
/// </summary>
|
||
/// <param name="propList">属性集合</param>
|
||
/// <param name="code"></param>
|
||
/// <param name="compilation"></param>
|
||
/// <param name="classSymbol"></param>
|
||
private static void GetGeneratePropertyValueForSourceEntity(
|
||
IEnumerable<IPropertySymbol> propList,
|
||
StringBuilder code,
|
||
Compilation compilation,
|
||
INamedTypeSymbol classSymbol)
|
||
{
|
||
code.AppendLine($" public object GetPropertyValue({classSymbol} targetEntity, string propertyName)");
|
||
code.AppendLine(" {");
|
||
code.AppendLine(" return propertyName switch");
|
||
code.AppendLine(" {");
|
||
|
||
foreach (var prop in propList)
|
||
{
|
||
code.AppendLine(
|
||
$" \"{prop.Name}\" => " +
|
||
$"Get{prop.Name}(targetEntity),");
|
||
|
||
if (prop.Type is INamedTypeSymbol { IsTupleType: true } tupleType)
|
||
{
|
||
foreach (var element in tupleType.TupleElements)
|
||
{
|
||
code.AppendLine(
|
||
$" \"{prop.Name}.{element.Name}\" => " +
|
||
$"Get{prop.Name}_{element.Name}(targetEntity),");
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
code.AppendLine(" _ => throw new ArgumentException($\"Unknown property: {propertyName}\")");
|
||
code.AppendLine(" };");
|
||
code.AppendLine(" }");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 属性设置生成逻辑
|
||
/// </summary>
|
||
/// <param name="propList">属性集合</param>
|
||
/// <param name="code"></param>
|
||
/// <param name="compilation"></param>
|
||
/// <param name="classSymbol"></param>
|
||
private static void SetGeneratePropertyValueForSourceEntity(
|
||
IEnumerable<IPropertySymbol> propList,
|
||
StringBuilder code,
|
||
Compilation compilation,
|
||
INamedTypeSymbol classSymbol)
|
||
{
|
||
code.AppendLine($" public void SetPropertyValue({classSymbol} targetEntity, string propertyName, object value)");
|
||
code.AppendLine(" {");
|
||
code.AppendLine(" switch (propertyName)");
|
||
code.AppendLine(" {");
|
||
|
||
foreach (var prop in propList)
|
||
{
|
||
var propType = prop.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
code.AppendLine($" case \"{prop.Name}\":");
|
||
code.AppendLine($" Set{prop.Name}(");
|
||
code.AppendLine($" targetEntity, ({propType})value);");
|
||
code.AppendLine(" break;");
|
||
|
||
if (prop.Type is INamedTypeSymbol { IsTupleType: true } tupleType)
|
||
{
|
||
foreach (var element in tupleType.TupleElements)
|
||
{
|
||
var elementType = element.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
code.AppendLine($" case \"{prop.Name}.{element.Name}\":");
|
||
code.AppendLine($" Set{prop.Name}_{element.Name}(");
|
||
code.AppendLine($" targetEntity, ({elementType})value);");
|
||
code.AppendLine(" break;");
|
||
}
|
||
}
|
||
}
|
||
|
||
code.AppendLine(" default:");
|
||
code.AppendLine(" throw new ArgumentException($\"Unknown property: {propertyName}\");");
|
||
code.AppendLine(" }");
|
||
code.AppendLine(" }");
|
||
}
|
||
|
||
/// <summary>
|
||
/// 属性名称集合
|
||
/// </summary>
|
||
/// <param name="propList">属性集合</param>
|
||
/// <param name="code"></param>
|
||
/// <param name="compilation"></param>
|
||
/// <param name="classSymbol"></param>
|
||
private static void GeneratePropertyListForSourceEntity(
|
||
IEnumerable<IPropertySymbol> propList,
|
||
StringBuilder code,
|
||
Compilation compilation,
|
||
INamedTypeSymbol classSymbol)
|
||
{
|
||
code.AppendLine(" public List<string> PropertyNameList {get;} = new List<string>()");
|
||
code.AppendLine(" {");
|
||
List<string> tempPropList = new List<string>();
|
||
foreach (var prop in propList)
|
||
{
|
||
if (prop.Type is INamedTypeSymbol { IsTupleType: true } tupleType)
|
||
{
|
||
foreach (var element in tupleType.TupleElements)
|
||
{
|
||
tempPropList.Add($"\"{prop.Name}.{element.Name}\"");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
tempPropList.Add($"\"{prop.Name}\"");
|
||
}
|
||
}
|
||
|
||
code.Append(string.Join(",", tempPropList));
|
||
|
||
code.AppendLine(" };");
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 生成当前类属性信息集合
|
||
/// </summary>
|
||
private static void GenerateEntityMemberInfoList(
|
||
IEnumerable<IPropertySymbol> propList,
|
||
StringBuilder code,
|
||
Compilation compilation,
|
||
INamedTypeSymbol classSymbol)
|
||
{
|
||
code.AppendLine(" public List<EntityMemberInfo> MemberList { get; } = new()");
|
||
code.AppendLine(" {");
|
||
|
||
var initializerLines = new List<string>();
|
||
|
||
foreach (var prop in propList)
|
||
{
|
||
var entityType = prop.ContainingType.ToDisplayString();//entity 实体类型名称
|
||
var propType = prop.Type;//实体属性的类型
|
||
var propTypeName = propType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
var declaredTypeName = propType.Name; // 直接获取类型名称（如 "Int32"）
|
||
|
||
// 处理主属性
|
||
var propAttributes = prop.GetAttributes()
|
||
.Where(a => !IsCompilerGeneratedAttribute(a))
|
||
.ToList();
|
||
|
||
var attributeInitializers = propAttributes
|
||
.Select(GenerateAttributeInitializer)
|
||
.Where(s => !string.IsNullOrEmpty(s));
|
||
|
||
var mainMember = new StringBuilder();
|
||
mainMember.Append(
|
||
$"new EntityMemberInfo(" +
|
||
$"\"{prop.Name}\", " +
|
||
$"typeof({propTypeName}), " +
|
||
$"\"{declaredTypeName}\", " +
|
||
$"(e) => Get{prop.Name}(({entityType})e), " +
|
||
$"(e, v) => Set{prop.Name}(({entityType})e, ({propTypeName})v))");
|
||
|
||
if (attributeInitializers.Any())
|
||
{
|
||
mainMember.AppendLine();
|
||
mainMember.Append(" { CustomAttributes = new List<Attribute>");
|
||
mainMember.Append($" {{ {string.Join(", ", attributeInitializers)} }} }}");
|
||
}
|
||
|
||
initializerLines.Add(mainMember.ToString());
|
||
|
||
// 处理元组元素,（暂不需要处理元组元素的特性）
|
||
if (prop.Type is INamedTypeSymbol { IsTupleType: true } tupleType)
|
||
{
|
||
foreach (var element in tupleType.TupleElements)
|
||
{
|
||
var elementType = element.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);//元组元素的类型
|
||
var elementName = element.Name;//元组元素名称
|
||
var elementDeclaredName = element.Type.Name;//元组元素类型名称
|
||
|
||
initializerLines.Add(
|
||
$"new EntityMemberInfo(" +
|
||
$"\"{prop.Name}.{elementName}\", " +
|
||
$"typeof({elementType}), " +
|
||
$"\"{elementDeclaredName}\", " +
|
||
$"(e) => Get{prop.Name}_{elementName}(({entityType})e), " +
|
||
$"(e, v) => Set{prop.Name}_{elementName}(({entityType})e, ({elementType})v))");
|
||
}
|
||
}
|
||
}
|
||
|
||
code.AppendLine(string.Join(",\n", initializerLines));
|
||
code.AppendLine(" };");
|
||
}
|
||
|
||
|
||
private static string GenerateAttributeInitializer(AttributeData attribute)
|
||
{
|
||
if (attribute.AttributeClass == null)
|
||
return string.Empty;
|
||
|
||
var attributeClass = attribute.AttributeClass.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
var args = attribute.ConstructorArguments;
|
||
var namedArgs = attribute.NamedArguments;
|
||
|
||
var parameters = new List<string>();
|
||
foreach (var arg in args)
|
||
{
|
||
parameters.Add(ConvertTypedConstantToCode(arg));
|
||
}
|
||
|
||
var constructorArgs = string.Join(", ", parameters);
|
||
|
||
var initializer = new StringBuilder();
|
||
initializer.Append($"new {attributeClass}({constructorArgs})");
|
||
|
||
if (namedArgs.Any())
|
||
{
|
||
initializer.Append(" { ");
|
||
var namedArgsList = namedArgs.Select(n => $"{n.Key} = {ConvertTypedConstantToCode(n.Value)}");
|
||
initializer.Append(string.Join(", ", namedArgsList));
|
||
initializer.Append(" }");
|
||
}
|
||
|
||
return initializer.ToString();
|
||
}
|
||
|
||
private static string ConvertTypedConstantToCode(TypedConstant constant)
|
||
{
|
||
if (constant.IsNull)
|
||
return "null";
|
||
|
||
switch (constant.Kind)
|
||
{
|
||
case TypedConstantKind.Array:
|
||
var elements = constant.Values.Select(ConvertTypedConstantToCode);
|
||
return $"new[] {{ {string.Join(", ", elements)} }}";
|
||
case TypedConstantKind.Type:
|
||
var typeSymbol = (ITypeSymbol)constant.Value!;
|
||
return $"typeof({typeSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)})";
|
||
case TypedConstantKind.Enum:
|
||
return ConvertEnumTypedConstant(constant);
|
||
default:
|
||
return ConvertPrimitiveConstant(constant);
|
||
}
|
||
}
|
||
|
||
private static string ConvertEnumTypedConstant(TypedConstant constant)
|
||
{
|
||
var enumType = constant.Type!;
|
||
var enumValue = constant.Value!;
|
||
var enumTypeName = enumType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
|
||
|
||
foreach (var member in enumType.GetMembers().OfType<IFieldSymbol>())
|
||
{
|
||
if (member.ConstantValue != null && member.ConstantValue.Equals(enumValue))
|
||
return $"{enumTypeName}.{member.Name}";
|
||
}
|
||
|
||
return $"({enumTypeName})({enumValue})";
|
||
}
|
||
|
||
private static string ConvertPrimitiveConstant(TypedConstant constant)
|
||
{
|
||
var value = constant.Value!;
|
||
return value switch
|
||
{
|
||
string s => $"\"{s}\"",
|
||
char c => $"'{c}'",
|
||
bool b => b ? "true" : "false",
|
||
_ => value.ToString()
|
||
};
|
||
}
|
||
|
||
private static bool IsCompilerGeneratedAttribute(AttributeData attribute)
|
||
{
|
||
return attribute.AttributeClass?.ToDisplayString() == "System.Runtime.CompilerServices.CompilerGeneratedAttribute";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取枚举的参数
|
||
/// </summary>
|
||
/// <param name="enumType"></param>
|
||
/// <param name="value"></param>
|
||
/// <returns></returns>
|
||
private static string GetEnumMemberName(INamedTypeSymbol enumType, int value)
|
||
{
|
||
foreach (var member in enumType.GetMembers().OfType<IFieldSymbol>())
|
||
{
|
||
if (member.ConstantValue is int intValue && intValue == value)
|
||
{
|
||
return $"{enumType.ToDisplayString()}.{member.Name}";
|
||
}
|
||
}
|
||
return $"{enumType.ToDisplayString()}.Other";
|
||
}
|
||
}
|
||
} |