Marcin Wojas
514 lines
19 KiB
C#
514 lines
19 KiB
C#
#r "nuget: Microsoft.CodeAnalysis.CSharp, 4.11.0"
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Text.Encodings.Web;
|
|
using System.Text.Unicode;
|
|
using Microsoft.CodeAnalysis;
|
|
using Microsoft.CodeAnalysis.CSharp;
|
|
|
|
// Argumenty pozycyjne + flagi (np. --related).
|
|
var positional = Args.Where(a => !a.StartsWith("--", StringComparison.Ordinal)).ToList();
|
|
var includeRelated = Args.Any(a => a == "--related");
|
|
|
|
if (positional.Count < 1)
|
|
{
|
|
Console.Error.WriteLine("Użycie: dotnet script scan-workers.csx -- <KatalogDll> [<NazwaTypuDanych>] [--related]");
|
|
Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0");
|
|
Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0 DokumentHandlowy");
|
|
Console.Error.WriteLine("Przykład: dotnet script scan-workers.csx -- ./bin/Debug/net8.0 Pracownik --related");
|
|
return 1;
|
|
}
|
|
|
|
var dllDir = Path.GetFullPath(positional[0]);
|
|
var typeFilter = positional.Count >= 2 ? positional[1] : null;
|
|
if (!Directory.Exists(dllDir))
|
|
{
|
|
Console.Error.WriteLine($"Katalog nie istnieje: {dllDir}");
|
|
return 1;
|
|
}
|
|
|
|
var dllPaths = Directory.EnumerateFiles(dllDir, "*.dll", SearchOption.TopDirectoryOnly).ToList();
|
|
if (dllPaths.Count == 0)
|
|
{
|
|
Console.Error.WriteLine($"Brak plików *.dll w katalogu: {dllDir}");
|
|
return 1;
|
|
}
|
|
|
|
var refs = new List<MetadataReference>();
|
|
var addedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var p in dllPaths)
|
|
{
|
|
try
|
|
{
|
|
refs.Add(MetadataReference.CreateFromFile(p));
|
|
addedPaths.Add(Path.GetFileName(p));
|
|
}
|
|
catch (Exception ex) { Console.Error.WriteLine($"# Pominięto {Path.GetFileName(p)}: {ex.Message}"); }
|
|
}
|
|
|
|
var tpa = (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string ?? "")
|
|
.Split(Path.PathSeparator, StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (var path in tpa)
|
|
{
|
|
var name = Path.GetFileName(path);
|
|
if (addedPaths.Contains(name)) continue;
|
|
try { refs.Add(MetadataReference.CreateFromFile(path)); addedPaths.Add(name); }
|
|
catch { /* pomiń */ }
|
|
}
|
|
|
|
var compilation = CSharpCompilation.Create("ScanWorkers")
|
|
.WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
|
|
.AddReferences(refs);
|
|
|
|
// Rekord opisujący pojedynczą rejestrację Worker/Extender (jednej klasie może
|
|
// odpowiadać wiele rejestracji — np. ten sam worker przypięty do różnych typów danych).
|
|
var registrations = new List<WorkerRegistration>();
|
|
|
|
foreach (var asmRef in compilation.References)
|
|
{
|
|
if (compilation.GetAssemblyOrModuleSymbol(asmRef) is not IAssemblySymbol asm) continue;
|
|
foreach (var a in asm.GetAttributes())
|
|
{
|
|
var ac = a.AttributeClass;
|
|
if (ac == null) continue;
|
|
if (!IsWorkerAttribute(ac)) continue;
|
|
|
|
INamedTypeSymbol workerType = null;
|
|
INamedTypeSymbol dataType = null;
|
|
string alias = null;
|
|
|
|
// Wariant generyczny: [Worker<TWorker>] lub [Worker<TWorker, TData>]
|
|
if (ac.IsGenericType && ac.TypeArguments.Length >= 1)
|
|
{
|
|
workerType = ac.TypeArguments[0] as INamedTypeSymbol;
|
|
if (ac.TypeArguments.Length >= 2)
|
|
dataType = ac.TypeArguments[1] as INamedTypeSymbol;
|
|
|
|
// Opcjonalny string z konstruktora = alias (Name)
|
|
foreach (var arg in a.ConstructorArguments)
|
|
{
|
|
if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s)
|
|
{
|
|
alias = s;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Wariant z parametrami: [Worker(typeof(TWorker))] / [Worker(typeof(TWorker), typeof(TData))]
|
|
// ewentualnie z dodatkowym name jako string.
|
|
else
|
|
{
|
|
var ca = a.ConstructorArguments;
|
|
int typeIdx = 0;
|
|
foreach (var arg in ca)
|
|
{
|
|
if (arg.Kind == TypedConstantKind.Type && arg.Value is INamedTypeSymbol nt)
|
|
{
|
|
if (typeIdx == 0) workerType = nt;
|
|
else if (typeIdx == 1) dataType = nt;
|
|
typeIdx++;
|
|
}
|
|
else if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s && alias == null)
|
|
{
|
|
alias = s;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NamedArgument "Name" ma priorytet, gdy jest jawnie podany.
|
|
foreach (var na in a.NamedArguments)
|
|
{
|
|
if (na.Key == "Name" && na.Value.Value is string s) alias = s;
|
|
}
|
|
|
|
if (workerType == null) continue;
|
|
registrations.Add(new WorkerRegistration(workerType, dataType, alias, asm.Name));
|
|
}
|
|
}
|
|
|
|
// Filtr po nazwie typu danych — gdy podany drugi argument, ograniczamy do workerów
|
|
// przypiętych do tego typu (po prostej nazwie lub po pełnej nazwie z namespace).
|
|
// Z flagą --related dorzucamy typy powiązane: Row→Table (przez property `Table`),
|
|
// Table→Row (przez indekser this[int]), oraz history-row (gdy DataType implementuje
|
|
// IRowWithHistory — przez indekser this[Date]).
|
|
// Extendery (rejestracje bez DataType) są w trybie filtra pomijane.
|
|
|
|
var allowedDataTypes = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
|
|
INamedTypeSymbol primaryFilterType = null;
|
|
if (typeFilter != null && includeRelated)
|
|
{
|
|
primaryFilterType = FindTypeByName(compilation, typeFilter);
|
|
if (primaryFilterType != null)
|
|
{
|
|
allowedDataTypes.Add(primaryFilterType);
|
|
var related = ResolveRelatedTypes(primaryFilterType).ToList();
|
|
foreach (var r in related) allowedDataTypes.Add(r);
|
|
|
|
Console.Error.WriteLine($"# Typ podstawowy: {primaryFilterType.ToDisplayString()}");
|
|
foreach (var r in related)
|
|
Console.Error.WriteLine($"# Typ powiązany: {r.ToDisplayString()}");
|
|
}
|
|
else
|
|
{
|
|
Console.Error.WriteLine($"# Nie znaleziono typu `{typeFilter}` w referencjach — --related wyłączony.");
|
|
}
|
|
}
|
|
|
|
bool MatchesTypeFilter(INamedTypeSymbol dt)
|
|
{
|
|
if (typeFilter == null || dt == null) return typeFilter == null;
|
|
if (allowedDataTypes.Count > 0) return allowedDataTypes.Contains(dt);
|
|
return string.Equals(dt.Name, typeFilter, StringComparison.Ordinal)
|
|
|| string.Equals(dt.ToDisplayString(), typeFilter, StringComparison.Ordinal);
|
|
}
|
|
|
|
var filtered = typeFilter != null
|
|
? registrations.Where(r => r.DataType != null && MatchesTypeFilter(r.DataType)).ToList()
|
|
: registrations;
|
|
|
|
// Sortowanie: najpierw workery z dataType (po nazwie dataType), potem extendery (bez dataType).
|
|
var byData = filtered
|
|
.Where(r => r.DataType != null)
|
|
.GroupBy(r => r.DataType, SymbolEqualityComparer.Default)
|
|
.OrderBy(g => ((INamedTypeSymbol)g.Key).ToDisplayString(), StringComparer.Ordinal)
|
|
.ToList();
|
|
|
|
var extenders = typeFilter == null
|
|
? registrations.Where(r => r.DataType == null)
|
|
.OrderBy(r => r.WorkerType.ToDisplayString(), StringComparer.Ordinal)
|
|
.ToList()
|
|
: new List<WorkerRegistration>();
|
|
|
|
WriteJson(byData, extenders, typeFilter);
|
|
return 0;
|
|
|
|
static bool IsWorkerAttribute(INamedTypeSymbol attrClass)
|
|
{
|
|
// Nazwa klasy atrybutu w metadanych może mieć backtick dla wariantu generycznego
|
|
// (WorkerAttribute, WorkerAttribute`1, WorkerAttribute`2). Symbol.Name zwraca "WorkerAttribute"
|
|
// bez backticka, więc wystarczy porównać po nazwie i — dla bezpieczeństwa — sprawdzić namespace.
|
|
if (attrClass.Name != "WorkerAttribute") return false;
|
|
var ns = attrClass.ContainingNamespace?.ToDisplayString() ?? "";
|
|
return ns.StartsWith("Soneta", StringComparison.Ordinal);
|
|
}
|
|
|
|
static bool HasAttribute(ISymbol s, string attributeTypeName)
|
|
{
|
|
var shortName = attributeTypeName.EndsWith("Attribute")
|
|
? attributeTypeName.Substring(0, attributeTypeName.Length - "Attribute".Length)
|
|
: attributeTypeName;
|
|
foreach (var a in s.GetAttributes())
|
|
{
|
|
var n = a.AttributeClass?.Name;
|
|
if (n == attributeTypeName || n == shortName) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static string GetActionTitle(IMethodSymbol m)
|
|
{
|
|
foreach (var a in m.GetAttributes())
|
|
{
|
|
var n = a.AttributeClass?.Name;
|
|
if (n != "ActionAttribute" && n != "Action") continue;
|
|
foreach (var arg in a.ConstructorArguments)
|
|
{
|
|
if (arg.Kind == TypedConstantKind.Primitive && arg.Value is string s)
|
|
return s;
|
|
}
|
|
return ""; // [Action] bez tytułu — i tak licz jako akcja
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static string StripSuffix(string name, string suffix)
|
|
{
|
|
return name.EndsWith(suffix, StringComparison.Ordinal)
|
|
? name.Substring(0, name.Length - suffix.Length)
|
|
: name;
|
|
}
|
|
|
|
static void WriteJson(
|
|
List<IGrouping<ISymbol, WorkerRegistration>> byData,
|
|
List<WorkerRegistration> extenders,
|
|
string typeFilter)
|
|
{
|
|
// Dictionary z zachowaną kolejnością wstawiania — opis na początku, potem klucze typów.
|
|
var root = new Dictionary<string, object>();
|
|
root["description"] = typeFilter != null
|
|
? $"Workery przypięte do typu `{typeFilter}` (Soneta)"
|
|
: "Workery i extendery (Soneta)";
|
|
|
|
foreach (var g in byData)
|
|
{
|
|
var dt = (INamedTypeSymbol)g.Key;
|
|
root[dt.ToDisplayString()] = g
|
|
.OrderBy(r => r.WorkerType.Name, StringComparer.Ordinal)
|
|
.Select(BuildWorkerJson)
|
|
.ToList();
|
|
}
|
|
if (typeFilter == null && extenders.Count > 0)
|
|
{
|
|
root["__extenders__"] = extenders.Select(BuildWorkerJson).ToList();
|
|
}
|
|
|
|
var opts = new JsonSerializerOptions
|
|
{
|
|
WriteIndented = true,
|
|
Encoder = JavaScriptEncoder.Create(UnicodeRanges.All),
|
|
};
|
|
Console.WriteLine(JsonSerializer.Serialize(root, opts));
|
|
}
|
|
|
|
static Dictionary<string, object> BuildWorkerJson(WorkerRegistration reg)
|
|
{
|
|
var w = reg.WorkerType;
|
|
var hasWorkerSuffix = w.Name.EndsWith("Worker", StringComparison.Ordinal);
|
|
var defaultAlias = hasWorkerSuffix
|
|
? StripSuffix(w.Name, "Worker")
|
|
: w.Name;
|
|
var aliasShown = !string.IsNullOrEmpty(reg.Alias) ? reg.Alias : defaultAlias;
|
|
|
|
var paramsList = new List<Dictionary<string, object>>();
|
|
|
|
// Parametry konstruktora (kind=ctor) — wybieramy pierwszy publiczny konstruktor z parametrami.
|
|
var ctor = w.InstanceConstructors
|
|
.FirstOrDefault(c => c.DeclaredAccessibility == Accessibility.Public && c.Parameters.Length > 0);
|
|
if (ctor != null)
|
|
{
|
|
foreach (var p in ctor.Parameters)
|
|
{
|
|
var entry = new Dictionary<string, object>
|
|
{
|
|
["name"] = p.Name,
|
|
["type"] = p.Type.ToDisplayString(),
|
|
["kind"] = "ctor",
|
|
};
|
|
AttachContextBaseProps(entry, p.Type);
|
|
paramsList.Add(entry);
|
|
}
|
|
}
|
|
|
|
// Property z [Context] — inicjowane z Context.
|
|
foreach (var p in w.GetMembers().OfType<IPropertySymbol>()
|
|
.Where(p => p.DeclaredAccessibility == Accessibility.Public && !p.IsStatic && !p.IsIndexer)
|
|
.Where(p => HasAttribute(p, "ContextAttribute"))
|
|
.OrderBy(p => p.Name, StringComparer.Ordinal))
|
|
{
|
|
var entry = new Dictionary<string, object>
|
|
{
|
|
["name"] = p.Name,
|
|
["type"] = p.Type.ToDisplayString(),
|
|
};
|
|
AttachContextBaseProps(entry, p.Type);
|
|
paramsList.Add(entry);
|
|
}
|
|
|
|
// Akcje [Action] — metoda + tytuł + typ wyniku.
|
|
var actions = new List<Dictionary<string, object>>();
|
|
foreach (var m in w.GetMembers().OfType<IMethodSymbol>()
|
|
.Where(m => m.MethodKind == MethodKind.Ordinary
|
|
&& m.DeclaredAccessibility == Accessibility.Public
|
|
&& !m.IsStatic)
|
|
.OrderBy(m => m.Name, StringComparer.Ordinal))
|
|
{
|
|
var title = GetActionTitle(m);
|
|
if (title == null) continue;
|
|
actions.Add(new Dictionary<string, object>
|
|
{
|
|
["name"] = title,
|
|
["method"] = m.Name,
|
|
["result"] = m.ReturnsVoid ? "void" : m.ReturnType.ToDisplayString(),
|
|
});
|
|
}
|
|
|
|
// Pozostałe public property z getterem (bez [Context]) — do bindowania / odczytu.
|
|
var props = new List<Dictionary<string, object>>();
|
|
foreach (var p in w.GetMembers().OfType<IPropertySymbol>()
|
|
.Where(p => p.DeclaredAccessibility == Accessibility.Public && !p.IsStatic && !p.IsIndexer)
|
|
.Where(p => p.GetMethod != null)
|
|
.Where(p => !HasAttribute(p, "ContextAttribute"))
|
|
.OrderBy(p => p.Name, StringComparer.Ordinal))
|
|
{
|
|
props.Add(new Dictionary<string, object>
|
|
{
|
|
["name"] = p.Name,
|
|
["type"] = p.Type.ToDisplayString(),
|
|
});
|
|
}
|
|
|
|
var obj = new Dictionary<string, object>
|
|
{
|
|
["workerAssembly"] = reg.AssemblyName,
|
|
["workerType"] = w.ToDisplayString(),
|
|
["name"] = aliasShown,
|
|
};
|
|
if (paramsList.Count > 0) obj["params"] = paramsList;
|
|
if (actions.Count > 0) obj["actions"] = actions;
|
|
if (props.Count > 0) obj["props"] = props;
|
|
return obj;
|
|
}
|
|
|
|
// Dla typu parametru workera dziedziczącego z ContextBase doczepia listę publicznych
|
|
// instancyjnych property — to są pod-parametry, które użytkownik widzi w oknie parametrów workera.
|
|
static void AttachContextBaseProps(Dictionary<string, object> entry, ITypeSymbol type)
|
|
{
|
|
if (type is not INamedTypeSymbol nt) return;
|
|
if (!InheritsFromContextBase(nt)) return;
|
|
|
|
var props = new List<Dictionary<string, object>>();
|
|
var seen = new HashSet<string>(StringComparer.Ordinal);
|
|
for (var t = nt; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
|
|
{
|
|
if (t.Name == "ContextBase") break; // property bazowe ContextBase pomijamy (Context itp.)
|
|
foreach (var p in t.GetMembers().OfType<IPropertySymbol>())
|
|
{
|
|
if (p.DeclaredAccessibility != Accessibility.Public || p.IsStatic || p.IsIndexer) continue;
|
|
if (p.GetMethod == null) continue;
|
|
if (!seen.Add(p.Name)) continue;
|
|
props.Add(new Dictionary<string, object>
|
|
{
|
|
["name"] = p.Name,
|
|
["type"] = p.Type.ToDisplayString(),
|
|
});
|
|
}
|
|
}
|
|
if (props.Count > 0)
|
|
{
|
|
props = props.OrderBy(d => (string)d["name"], StringComparer.Ordinal).ToList();
|
|
entry["props"] = props;
|
|
}
|
|
}
|
|
|
|
static bool InheritsFromContextBase(INamedTypeSymbol type)
|
|
{
|
|
for (var t = type.BaseType; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
|
|
{
|
|
if (t.Name == "ContextBase"
|
|
&& (t.ContainingNamespace?.ToDisplayString() ?? "").StartsWith("Soneta", StringComparison.Ordinal))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Szuka typu po prostej nazwie ("DokumentHandlowy") lub pełnej z namespace
|
|
// ("Soneta.Handel.DokumentHandlowy"). Zwraca pierwsze trafienie.
|
|
static INamedTypeSymbol FindTypeByName(CSharpCompilation compilation, string nameOrFullName)
|
|
{
|
|
foreach (var asmRef in compilation.References)
|
|
{
|
|
if (compilation.GetAssemblyOrModuleSymbol(asmRef) is not IAssemblySymbol asm) continue;
|
|
foreach (var t in EnumerateAllTypes(asm.GlobalNamespace))
|
|
{
|
|
if (t.DeclaredAccessibility != Accessibility.Public) continue;
|
|
if (string.Equals(t.Name, nameOrFullName, StringComparison.Ordinal)
|
|
|| string.Equals(t.ToDisplayString(), nameOrFullName, StringComparison.Ordinal))
|
|
return t;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static IEnumerable<INamedTypeSymbol> EnumerateAllTypes(INamespaceSymbol ns)
|
|
{
|
|
foreach (var t in ns.GetTypeMembers()) yield return t;
|
|
foreach (var sub in ns.GetNamespaceMembers())
|
|
foreach (var t in EnumerateAllTypes(sub)) yield return t;
|
|
}
|
|
|
|
// Zbiór typów powiązanych z `primary` (przechodnio):
|
|
// - jeśli typ dziedziczy z `Soneta.Business.Row` → typ z property `Table` (klasa tabeli);
|
|
// - jeśli typ dziedziczy z `Soneta.Business.Table` → typ zwracany przez indekser `this[int]`
|
|
// (klasa rekordu);
|
|
// - jeśli typ implementuje interfejs `IRowWithHistory` → typ zwracany przez indekser
|
|
// przyjmujący `Soneta.Types.Date` (historyczny rekord).
|
|
// Reguły aplikowane są w pętli — np. dla `Pracownik` (Row + IRowWithHistory) najpierw
|
|
// dostajemy `Pracownicy` i `PracHistoria`, a `PracHistoria` (kolejny Row) dorzuca własną
|
|
// tabelę `PracHistorie`. Pętle są zabezpieczone zbiorem już odwiedzonych typów.
|
|
static IEnumerable<INamedTypeSymbol> ResolveRelatedTypes(INamedTypeSymbol primary)
|
|
{
|
|
var result = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default);
|
|
var queue = new Queue<INamedTypeSymbol>();
|
|
queue.Enqueue(primary);
|
|
var visited = new HashSet<INamedTypeSymbol>(SymbolEqualityComparer.Default) { primary };
|
|
|
|
while (queue.Count > 0)
|
|
{
|
|
var t = queue.Dequeue();
|
|
foreach (var related in DirectRelatedTypes(t))
|
|
{
|
|
if (visited.Add(related))
|
|
{
|
|
result.Add(related);
|
|
queue.Enqueue(related);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static IEnumerable<INamedTypeSymbol> DirectRelatedTypes(INamedTypeSymbol t)
|
|
{
|
|
if (InheritsFromNamed(t, "Row", "Soneta.Business"))
|
|
{
|
|
if (FindMemberInherited(t, m => m is IPropertySymbol p && !p.IsIndexer && p.Name == "Table")
|
|
is IPropertySymbol tableProp
|
|
&& tableProp.Type is INamedTypeSymbol tableType)
|
|
yield return tableType;
|
|
}
|
|
|
|
if (InheritsFromNamed(t, "Table", "Soneta.Business"))
|
|
{
|
|
if (FindMemberInherited(t, m => m is IPropertySymbol p
|
|
&& p.IsIndexer && p.Parameters.Length == 1
|
|
&& p.Parameters[0].Type.SpecialType == SpecialType.System_Int32)
|
|
is IPropertySymbol rowIndexer
|
|
&& rowIndexer.Type is INamedTypeSymbol rowType)
|
|
yield return rowType;
|
|
}
|
|
|
|
if (ImplementsInterface(t, "IRowWithHistory"))
|
|
{
|
|
if (FindMemberInherited(t, m => m is IPropertySymbol p
|
|
&& p.IsIndexer && p.Parameters.Length == 1
|
|
&& p.Parameters[0].Type is INamedTypeSymbol pt
|
|
&& pt.Name == "Date"
|
|
&& (pt.ContainingNamespace?.ToDisplayString() ?? "").StartsWith("Soneta", StringComparison.Ordinal))
|
|
is IPropertySymbol dateIndexer
|
|
&& dateIndexer.Type is INamedTypeSymbol histType)
|
|
yield return histType;
|
|
}
|
|
}
|
|
|
|
static bool InheritsFromNamed(INamedTypeSymbol type, string name, string nsPrefix)
|
|
{
|
|
for (var t = type.BaseType; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
|
|
{
|
|
if (t.Name == name
|
|
&& (t.ContainingNamespace?.ToDisplayString() ?? "").StartsWith(nsPrefix, StringComparison.Ordinal))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool ImplementsInterface(INamedTypeSymbol type, string ifaceName)
|
|
{
|
|
return type.AllInterfaces.Any(i => i.Name == ifaceName);
|
|
}
|
|
|
|
static ISymbol FindMemberInherited(INamedTypeSymbol type, Func<ISymbol, bool> predicate)
|
|
{
|
|
for (var t = type; t != null && t.SpecialType != SpecialType.System_Object; t = t.BaseType)
|
|
{
|
|
var m = t.GetMembers().FirstOrDefault(predicate);
|
|
if (m != null) return m;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
record WorkerRegistration(INamedTypeSymbol WorkerType, INamedTypeSymbol DataType, string Alias, string AssemblyName);
|