gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-03-22 10:34:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(logging): 重构日志生成器代码结构

Browse Source 
- 添加AttributeData扩展方法用于获取命名参数和构造函数参数
- 引入GenericInfo记录结构体处理泛型信息
- 将INamedTypeSymbol扩展方法转换为扩展方法语法
- 添加ResolveGenerics方法解析泛型参数和约束条件
- 简化LoggerGenerator中的参数解析逻辑
- 移除不再需要的GetNamedArg私有方法
- 优化代码可读性和维护性
This commit is contained in:
GeWuYou 2026-01-14 13:36:32 +08:00
parent 7876647871
commit 14894814a5
4 changed files with 167 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
GFramework.SourceGenerators.Common/extensions/AttributeDataExtensions.cs Normal file
View File

@ -0,0 +1,47 @@
using System;
using Microsoft.CodeAnalysis;
namespace GFramework.SourceGenerators.Common.extensions;
/// <summary>
/// 提供AttributeData的扩展方法
/// </summary>
public static class AttributeDataExtensions
{
/// <param name="attr">特性数据对象</param>
extension(AttributeData attr)
{
/// <summary>
/// 从特性数据中获取指定名称的命名参数值
/// </summary>
/// <typeparam name="T">期望返回的参数类型</typeparam>
/// <param name="name">要查找的命名参数名称</param>
/// <param name="defaultValue">当找不到指定参数时返回的默认值</param>
/// <returns>找到的参数值，如果未找到或类型不匹配则返回默认值</returns>
public T? GetNamedArgument<T>(string name,
T? defaultValue = default)
{
// 遍历所有命名参数以查找匹配的键值对
foreach (var kv in attr.NamedArguments)
{
if (string.Equals(kv.Key, name, StringComparison.Ordinal) && kv.Value.Value is T t)
return t;
}
return defaultValue;
}
/// <summary>
/// 获取特性构造函数的第一个参数作为字符串值
/// </summary>
/// <param name="defaultValue">当没有构造函数参数或第一个参数不是字符串时返回的默认值</param>
/// <returns>构造函数第一个参数的字符串值，如果不存在则返回默认值</returns>
public string GetFirstCtorString(string defaultValue)
{
if (attr.ConstructorArguments.Length == 0)
return defaultValue;
return attr.ConstructorArguments[0].Value as string ?? defaultValue;
}
}
}

115
GFramework.SourceGenerators.Common/extensions/INamedTypeSymbolExtensions.cs
View File

@ -1,4 +1,6 @@
using System.Collections.Generic;
using System.Linq;
using GFramework.SourceGenerators.Common.info;
using Microsoft.CodeAnalysis;
namespace GFramework.SourceGenerators.Common.extensions;
@ -8,45 +10,12 @@ namespace GFramework.SourceGenerators.Common.extensions;
/// </summary>
public static class INamedTypeSymbolExtensions
{
/// <summary>
/// 获取命名类型符号的完整类名（包括嵌套类型名称）
/// </summary>
/// <param name="symbol">要获取完整类名的命名类型符号</param>
/// <returns>完整的类名，格式为"外层类名.内层类名.当前类名"</returns>
public static string GetFullClassName(this INamedTypeSymbol symbol)
{
var names = new Stack<string>();
var current = symbol;
// 遍历包含类型链，将所有类型名称压入栈中
while (current != null)
{
names.Push(current.Name);
current = current.ContainingType;
}
// 将栈中的名称用点号连接，形成完整的类名
return string.Join(".", names);
}
/// <summary>
/// 获取命名类型符号的命名空间名称
/// </summary>
/// <param name="symbol">要获取命名空间的命名类型符号</param>
/// <returns>命名空间名称，如果是全局命名空间则返回null</returns>
private static string? GetNamespace(this INamedTypeSymbol symbol)
{
return symbol.ContainingNamespace.IsGlobalNamespace
? null
: symbol.ContainingNamespace.ToDisplayString();
}
/// <summary>
/// 根据类型种类解析对应的类型关键字
/// </summary>
/// <param name="symbol">要解析类型的命名类型符号</param>
/// <returns>对应类型的字符串表示，如"class"、"struct"或"record"</returns>
private static string ResolveTypeKind(this INamedTypeSymbol symbol)
public static string ResolveTypeKind(this INamedTypeSymbol symbol)
{
return symbol.TypeKind switch
{
@ -58,4 +27,82 @@ public static class INamedTypeSymbolExtensions
_ => "class",
};
}
/// <summary>
/// 解析泛型信息，包括泛型参数和约束条件
/// </summary>
/// <param name="symbol">要解析泛型信息的命名类型符号</param>
/// <returns>包含泛型参数和约束条件的GenericInfo对象</returns>
public static GenericInfo ResolveGenerics(this INamedTypeSymbol symbol)
{
if (symbol.TypeParameters.Length == 0)
return new GenericInfo(string.Empty, []);
// 构建泛型参数列表
var parameters =
"<" + string.Join(", ", symbol.TypeParameters.Select(tp => tp.Name)) + ">";
// 构建泛型约束条件列表
var constraints = symbol.TypeParameters
.Select(BuildConstraint)
.Where(c => c != null)
.Cast<string>()
.ToList();
return new GenericInfo(parameters, constraints);
}
/// <summary>
/// 构建单个类型参数的约束条件字符串
/// </summary>
/// <param name="tp">类型参数符号</param>
/// <returns>约束条件的字符串表示，如果没有约束则返回null</returns>
private static string? BuildConstraint(ITypeParameterSymbol tp)
{
var parts = new List<string>();
if (tp.HasReferenceTypeConstraint) parts.Add("class");
if (tp.HasValueTypeConstraint) parts.Add("struct");
parts.AddRange(tp.ConstraintTypes.Select(t => t.ToDisplayString()));
if (tp.HasConstructorConstraint) parts.Add("new()");
return parts.Count == 0
? null
: $"where {tp.Name} : {string.Join(", ", parts)}";
}
/// <param name="symbol">要获取完整类名的命名类型符号</param>
extension(INamedTypeSymbol symbol)
{
/// <summary>
/// 获取命名类型符号的完整类名（包括嵌套类型名称）
/// </summary>
/// <returns>完整的类名，格式为"外层类名.内层类名.当前类名"</returns>
public string GetFullClassName()
{
var names = new Stack<string>();
var current = symbol;
// 遍历包含类型链，将所有类型名称压入栈中
while (current != null)
{
names.Push(current.Name);
current = current.ContainingType;
}
// 将栈中的名称用点号连接，形成完整的类名
return string.Join(".", names);
}
/// <summary>
/// 获取命名类型符号的命名空间名称
/// </summary>
/// <returns>命名空间名称，如果是全局命名空间则返回null</returns>
public string? GetNamespace()
{
return symbol.ContainingNamespace.IsGlobalNamespace
? null
: symbol.ContainingNamespace.ToDisplayString();
}
}
}

13
GFramework.SourceGenerators.Common/info/GenericInfo.cs Normal file
View File

@ -0,0 +1,13 @@
using System.Collections.Generic;
namespace GFramework.SourceGenerators.Common.info;
/// <summary>
/// 表示泛型信息的数据结构
/// </summary>
/// <param name="Parameters">泛型参数字符串</param>
/// <param name="Constraints">泛型约束列表</param>
public record struct GenericInfo(
string Parameters,
IReadOnlyList<string> Constraints
);

101
GFramework.SourceGenerators/logging/LoggerGenerator.cs
View File

@ -1,6 +1,4 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GFramework.SourceGenerators.Abstractions.logging;
using GFramework.SourceGenerators.Common.constants;
@ -56,84 +54,42 @@ public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase
INamedTypeSymbol symbol,
AttributeData attr)
{
var ns = symbol.ContainingNamespace.IsGlobalNamespace
? null
: symbol.ContainingNamespace.ToDisplayString();
// 类名和嵌套类完整路径
var ns = symbol.GetNamespace();
var className = symbol.GetFullClassName();
var typeKind = symbol.ResolveTypeKind();
var generics = symbol.ResolveGenerics();
// 构造函数参数解析
var logName = className;
if (attr.ConstructorArguments.Length > 0)
{
var argValue = attr.ConstructorArguments[0].Value;
logName = argValue is string s && !string.IsNullOrWhiteSpace(s)
? s
: className;
}
// 命名参数解析
var fieldName = GetNamedArg(attr, "FieldName")?.ToString() ?? "_log";
var access = GetNamedArg(attr, "AccessModifier")?.ToString() ?? "private";
var isStaticObj = GetNamedArg(attr, "IsStatic");
var isStatic = isStaticObj is not bool b || b; // 默认 true
var logName = attr.GetFirstCtorString(className);
var fieldName = attr.GetNamedArgument("FieldName", "_log");
var access = attr.GetNamedArgument("AccessModifier", "private");
var isStatic = attr.GetNamedArgument("IsStatic", true);
var staticKeyword = isStatic ? "static " : "";
// 泛型参数
var typeParams = symbol.TypeParameters.Length > 0
? "<" + string.Join(", ", symbol.TypeParameters.Select(tp => tp.Name)) + ">"
: "";
// 泛型约束
var constraints = symbol.TypeParameters
.Where(tp => tp.ConstraintTypes.Length > 0 || tp.HasReferenceTypeConstraint || tp.HasValueTypeConstraint ||
tp.HasConstructorConstraint)
.Select(tp =>
{
var parts = new List<string>();
if (tp.HasReferenceTypeConstraint) parts.Add("class");
if (tp.HasValueTypeConstraint) parts.Add("struct");
parts.AddRange(tp.ConstraintTypes.Select(t => t.ToDisplayString()));
if (tp.HasConstructorConstraint) parts.Add("new()");
return $"where {tp.Name} : {string.Join(", ", parts)}";
});
// 判断类型
var typeKind = symbol.TypeKind switch
{
TypeKind.Class => "class",
TypeKind.Struct => "struct",
#if NET5_0_OR_GREATER || ROSLYN_3_7_OR_GREATER
TypeKind.Record => "record",
#endif
_ => "class"
};
var sb = new StringBuilder();
sb.AppendLine("// <auto-generated />");
sb.AppendLine($"using {PathContests.CoreAbstractionsNamespace}.logging;");
sb.AppendLine($"using {PathContests.CoreNamespace}.logging;");
var sb = new StringBuilder()
.AppendLine("// <auto-generated />")
.AppendLine($"using {PathContests.CoreAbstractionsNamespace}.logging;")
.AppendLine($"using {PathContests.CoreNamespace}.logging;");
if (ns is not null)
{
sb.AppendLine($"namespace {ns};");
sb.AppendLine();
sb.AppendLine()
.AppendLine($"namespace {ns};");
}
// 生成 partial 类
sb.AppendLine($"partial {typeKind} {className}{typeParams}");
foreach (var c in constraints)
sb.AppendLine($" {c}");
sb.AppendLine("{");
sb.AppendLine($" /// <summary>Auto-generated logger</summary>");
sb.AppendLine(
$" {access} {staticKeyword}readonly ILogger {fieldName} = LoggerFactoryResolver.Provider.CreateLogger(\"{logName}\");");
sb.AppendLine("}");
sb.AppendLine()
.AppendLine($"partial {typeKind} {className}{generics.Parameters}");
return sb.ToString().TrimEnd();
foreach (var c in generics.Constraints)
sb.AppendLine($" {c}");
sb.AppendLine("{")
.AppendLine(" /// <summary>Auto-generated logger</summary>")
.AppendLine(
$" {access} {staticKeyword}readonly ILogger {fieldName} = " +
$"LoggerFactoryResolver.Provider.CreateLogger(\"{logName}\");")
.AppendLine("}");
return sb.ToString();
}
@ -144,9 +100,4 @@ public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase
{
return $"{symbol.Name}.Logger.g.cs";
}
private static object? GetNamedArg(AttributeData attr, string name)
{
return attr.NamedArguments.FirstOrDefault(kv => kv.Key == name).Value.Value;
}
}