Ersetzen von C # -Ereignissen durch reaktive Erweiterungen mithilfe der Codegenerierung

Hallo, mein Name ist Ivan und ich bin Entwickler.

Die .NETConf 2020-Konferenz wurde kürzlich zeitgleich mit der Veröffentlichung von .NET 5 abgehalten, bei der einer der Redner über C # -Quellengeneratoren sprach . Nachdem ich auf Youtube gesucht hatte, fand ich ein weiteres gutes Video zu diesem Thema . Ich rate Ihnen, sie zu beobachten. Sie zeigen, wie während der Entwickler den Code schreibt, der Code generiert wird und InteliSense den generierten Code sofort aufnimmt, die generierten Methoden und Eigenschaften anbietet und der Compiler nicht auf ihre Abwesenheit schwört. Meiner Meinung nach ist dies eine gute Gelegenheit, die Fähigkeiten der Sprache zu erweitern, und ich werde versuchen, dies zu demonstrieren.

Idee

Kennt jemand LINQ ? Für Ereignisse gibt es also eine ähnliche Bibliothek Reactive Extensions , mit der Sie Ereignisse auf die gleiche Weise wie LINQ verarbeiten können .

Das Problem ist, dass Sie zur Verwendung von Reactive Extensions Ereignisse in Form von Reactive Extensions anordnen müssen. Da alle Ereignisse in Standardbibliotheken in einer Standardform geschrieben sind, ist es nicht bequem, Reactive Extensions zu verwenden. Es gibt eine Krücke, die Standard-C # -Ereignisse in reaktive Erweiterungen konvertiert. Es sieht aus wie das. Nehmen wir an, es gibt eine Klasse mit einem Ereignis:

public partial class Example
{
    public event Action<int, string, bool> ActionEvent;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Um dieses Ereignis im Stil " Reaktive Erweiterungen" zu verwenden , müssen Sie eine Ansichtserweiterungsmethode schreiben:

public static IObservable<(int, string, bool)> RxActionEvent(this TestConsoleApp.Example obj)
{
    if (obj == null) throw new ArgumentNullException(nameof(obj));
    return Observable.FromEvent<System.Action<int, string, bool>, (int, string, bool)>(
    conversion => (obj0, obj1, obj2) => conversion((obj0, obj1, obj2)),
    h => obj.ActionEvent += h,
    h => obj.ActionEvent -= h);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Danach können Sie beispielsweise alle Vorteile von Reactive Extensions nutzen :

var example = new  Example();
example.RxActionEvent().Where(obj => obj.Item1 > 10).Take(1).Subscribe((obj)=> { /* some action  */});
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Die Idee ist also, dass diese Krücke von selbst generiert wird und die Methoden während der Entwicklung von InteliSense verwendet werden können.

Eine Aufgabe

1)  «.» «Rx», , example.RxActionEvent()



, , , Action ActionEvent, .RxActionEvent()



, :

public static IObservable<(System.Int32 Item1Int32, System.String Item2String, System.Boolean Item3Boolean)> RxActionEvent(this TestConsoleApp.Example obj)
{
    if (obj == null) throw new ArgumentNullException(nameof(obj));
    return Observable.FromEvent<System.Action<System.Int32, System.String, System.Boolean>, (System.Int32 Item1Int32, System.String Item2String, System.Boolean 
Item3Boolean)>(
    conversion => (obj0, obj1, obj2) => conversion((obj0, obj1, obj2)),
    h => obj.ActionEvent += h,
    h => obj.ActionEvent -= h);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

2) InteliSense .

2 .

:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.1">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.8.0" />
  </ItemGroup>
</Project>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, netstandard2.0 2 Microsoft.CodeAnalysis.Analyzers Microsoft.CodeAnalysis.CSharp.Workspaces.

:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
    <LangVersion>preview</LangVersion>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="System.Reactive" Version="5.0.0" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\SourceGenerator\RxSourceGenerator.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
  </ItemGroup>
</Project>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

<ProjectReference Include="..\SourceGenerator\RxSourceGenerator.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

[Generator]



ISourceGenerator:

[Generator]
public class RxGenerator : ISourceGenerator
{
    public void Initialize(GeneratorInitializationContext context)  {  }
    public void Execute(GeneratorExecutionContext context)  {  }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

M Initialize , Execute .

Initialize ISyntaxReceiver.

, :

• ->

  
  
  
  
  

• ISyntaxReceiver->

  
  
  
  
  

• ISyntaxReceiver , ->

  
  
  
  
  

• Execute ISyntaxReceiver, .

  
  
  
  
  

, :

[Generator]
public class RxGenerator : ISourceGenerator
{
    private const string firstText = @"using System; using System.Reactive.Linq; namespace RxGenerator{}";
    public void Initialize(GeneratorInitializationContext context)
    {
        //  ISyntaxReceiver
        context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
    }
    public void Execute(GeneratorExecutionContext context)
    {
        if (context.SyntaxReceiver is not SyntaxReceiver receiver) return;
        //      "RxGenerator.cs"  ,   firstText
        context.AddSource("RxGenerator.cs", firstText);
    }
    class SyntaxReceiver : ISyntaxReceiver
    {
        public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
        {
        //     ,     .
        }
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

VS, using RxGenerator;



VS.

ISyntaxReceiver

OnVisitSyntaxNode MemberAccessExpressionSyntax.

private class SyntaxReceiver : ISyntaxReceiver
{
    public List<MemberAccessExpressionSyntax> GenerateCandidates { get; } =
        new List<MemberAccessExpressionSyntax>();

    public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
    {
        if (!(syntaxNode is MemberAccessExpressionSyntax syntax)) return;
        if (syntax.HasTrailingTrivia || syntax.Name.IsMissing) return;
        if (!syntax.Name.ToString().StartsWith("Rx")) return;
        GenerateCandidates.Add(syntax);

    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

• syntax.Name.IsMissing
  
  
  
  

  
  
  
  
  

• syntax.HasTrailingTrivia
  
  
  
  -

  
  
  
  
  

• !syntax.Name.ToString().StartsWith("Rx")
  
  
  
  "Rx"

  
  
  
  
  

, .

:

•  ,    

  
  
  
  
  

•   . , 

  
  
  
  
  

  System.Action<System.Int32, System.String, System.Boolean,xSouceGeneratorXUnitTests.SomeEventArgs>
  
  
  
  

  
  
  
  
  

•     

  
  
  
  
  

:

private static IEnumerable<(string ClassType, string EventName, string EventType, List<string> ArgumentTypes)>
    GetExtensionMethodInfo(GeneratorExecutionContext context, SyntaxReceiver receiver)
{
    HashSet<(string ClassType, string EventName)>
        hashSet = new HashSet<(string ClassType, string EventName)>();
    foreach (MemberAccessExpressionSyntax syntax in receiver.GenerateCandidates)
    {
        SemanticModel model = context.Compilation.GetSemanticModel(syntax.SyntaxTree);
        ITypeSymbol? typeSymbol = model.GetSymbolInfo(syntax.Expression).Symbol switch
        {
            IMethodSymbol s => s.ReturnType,
            ILocalSymbol s => s.Type,
            IPropertySymbol s => s.Type,
            IFieldSymbol s => s.Type,
            IParameterSymbol s => s.Type,
            _ => null
        };
        if (typeSymbol == null) continue;

...
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

SemanticModel. . ITypeSymbol. ITypeSymbol .

...
        string eventName = syntax.Name.ToString().Substring(2);

        if (!(typeSymbol.GetMembersOfType<IEventSymbol>().FirstOrDefault(m => m.Name == eventName) is { } ev)
        ) continue;

        if (!(ev.Type is INamedTypeSymbol namedTypeSymbol)) continue;
        if (namedTypeSymbol.DelegateInvokeMethod == null) continue;
        if (!hashSet.Add((typeSymbol.ToString(), ev.Name))) continue;

        string fullType = namedTypeSymbol.ToDisplayString(SymbolDisplayFormat);
        List<string> typeArguments = namedTypeSymbol.DelegateInvokeMethod.Parameters
            .Select(m => m.Type.ToDisplayString(SymbolDisplayFormat)).ToList();
        yield return (typeSymbol.ToString(), ev.Name, fullType, typeArguments);
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

string fullType = namedTypeSymbol.ToDisplayString(symbolDisplayFormat);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

SymbolDisplayFormat SymbolDisplayFormat ToDisplayString() . ToDisplayString() :

System.Action<System.Int32, System.String, System.Boolean, RxSouceGeneratorXUnitTests.SomeEventArgs>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Action<int, string, bool, SomeEventArgs>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

.

:

List<string> typeArguments = namedTypeSymbol.DelegateInvokeMethod.Parameters.Select(m => m.Type.ToDisplayString(SymbolDisplayFormat)).ToList();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

.

StringBuilder , , .

Execute:

public void Execute(GeneratorExecutionContext context)
{
    if (!(context.SyntaxReceiver is SyntaxReceiver receiver)) return;

    if (!(receiver.GenerateCandidates.Any()))
    {
        context.AddSource("RxGenerator.cs", startText);
        return;
    }

    StringBuilder sb = new();
    sb.AppendLine("using System;");
    sb.AppendLine("using System.Reactive.Linq;");
    sb.AppendLine("namespace RxMethodGenerator{");
    sb.AppendLine("    public static class RxGeneratedMethods{");

    foreach ((string classType, string eventName, string eventType, List<string> argumentTypes) in
        GetExtensionMethodInfo(context,
            receiver))
    {
        string tupleTypeStr;
        string conversionStr;

        switch (argumentTypes.Count)
        {
            case 0:
                tupleTypeStr = classType;
                conversionStr = "conversion => () => conversion(obj),";
                break;
            case 1:
                tupleTypeStr = argumentTypes.First();
                conversionStr = "conversion => obj1 => conversion(obj1),";
                break;
            default:
                tupleTypeStr =
                    $"({string.Join(", ", argumentTypes.Select((x, i) => $"{x} Item{i + 1}{x.Split('.').Last()}"))})";
                string objStr = string.Join(", ", argumentTypes.Select((x, i) => $"obj{i}"));
                conversionStr = $"conversion => ({objStr}) => conversion(({objStr})),";
                break;
        }

        sb.AppendLine(@$"        public static IObservable<{tupleTypeStr}> Rx{eventName}(this {classType} obj)");
        sb.AppendLine( @"        {");

        sb.AppendLine(  "            if (obj == null) throw new ArgumentNullException(nameof(obj));");
        sb.AppendLine(@$"            return Observable.FromEvent<{eventType}, {tupleTypeStr}>(");
        sb.AppendLine(@$"            {conversionStr}");
        sb.AppendLine(@$"            h => obj.{eventName} += h,");
        sb.AppendLine(@$"            h => obj.{eventName} -= h);");

        sb.AppendLine(  "        }");
    }
    sb.AppendLine(      "    }");
    sb.AppendLine(      "}");

    context.AddSource("RxGenerator.cs", sb.ToString());
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

  InteliSense     

«.» InteliSense . . «.» . , MS . .

CompletionProvider InteliSense «.». NuGet, .

.

CompletionProvider , , CompletionProvider:

public override bool ShouldTriggerCompletion(SourceText text, int caretPosition, CompletionTrigger trigger, OptionSet options)
{
    switch (trigger.Kind)
    {
        case CompletionTriggerKind.Insertion:
            int insertedCharacterPosition = caretPosition - 1;
            if (insertedCharacterPosition <= 0) return false;
            char ch = text[insertedCharacterPosition];
            char previousCh = text[insertedCharacterPosition - 1];
            return ch == '.' && !char.IsWhiteSpace(previousCh) && previousCh != '\t' && previousCh != '\r' && previousCh != '\n';
        default:
            return false;
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

«.» - .

True , InteliSense:

public override async Task ProvideCompletionsAsync(CompletionContext context)
{
    SyntaxNode? syntaxNode = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
    if (!(syntaxNode?.FindNode(context.CompletionListSpan) is ExpressionStatementSyntax
        expressionStatementSyntax)) return;
    if (!(expressionStatementSyntax.Expression is MemberAccessExpressionSyntax syntax)) return;
    if (!(await context.Document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false) is { }
        model)) return;

    ITypeSymbol? typeSymbol = model.GetSymbolInfo(syntax.Expression).Symbol switch
    {
        IMethodSymbol s => s.ReturnType,
        ILocalSymbol s => s.Type,
        IPropertySymbol s => s.Type,
        IFieldSymbol s => s.Type,
        IParameterSymbol s => s.Type,
        _ => null
    };
    if (typeSymbol == null) return;

    foreach (IEventSymbol ev in typeSymbol.GetMembersOfType<IEventSymbol>())
    {
        ...        
        //     InteliSense
        CompletionItem item = CompletionItem.Create($"Rx{ev.Name}");
        context.AddItem(item);
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , .

, InteliSense:

public override Task<CompletionDescription> GetDescriptionAsync(Document document, CompletionItem item, CancellationToken cancellationToken)
{
    return Task.FromResult(CompletionDescription.FromText(" "));
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

InteliSense , , «.» :

public override async Task<CompletionChange> GetChangeAsync(Document document, CompletionItem item,
    char? commitKey, CancellationToken cancellationToken)
{
    string newText = $".{item.DisplayText}()";
    TextSpan newSpan = new TextSpan(item.Span.Start - 1, 1);

    TextChange textChange = new TextChange(newSpan, newText);
    return await Task.FromResult(CompletionChange.Create(textChange));
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

!

Visual Studio №16.8.3. GitHub Visual Studio. Rider ReSharper 2020.3. ReSharper , 2020.3.

, . WPF , GitHub Roslyn.

CompletionProvider Vsix . NuGet . . using , NuGet.

Initialize Debugger.Launch();



VS

public void Initialize(GeneratorInitializationContext context)
{
    #if (DEBUG)
    Debugger.Launch();
    #endif
    context.RegisterForSyntaxNotifications(() => new SyntaxReceiver());
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

. - VS, .

CompletionProvider VS «Analyzer with code Fix». , Vsix. CompletionProvider , .

Der Generatorcode passt in 140 Zeilen. Bei diesen 140 Zeilen stellte sich heraus, dass die Syntax der Sprache geändert und Ereignisse beseitigt wurden, indem sie durch reaktive Erweiterungen ersetzt wurden , die meiner Meinung nach bequemer sind. Ich denke, dass die Technologie der Quellcode-Generatoren den Ansatz zur Entwicklung von Bibliotheken und Erweiterungen stark verändern wird.

Links

NuGet

Github