RealProxy im Dotnet-Kern?

Question

Ich arbeite mit den Namespaces System.Runtime.Remoting.Proxies und System.Runtime.Remoting.Messaging für AOP in C#. Ich versuche, meine Anwendung von .NET Framework 4.6 auf dnxcore/dotnet Core zu portieren.

Intellisense sagt, dass diese beiden Namespaces nicht mit meiner Framework-Version (netcoreapp1.0/dnxcore50) verfügbar sind. Irgendeine Idee, wenn diese zwei Namespaces erscheinen werden? oder irgendeine Idee, wie man den AOP wie mit der RealProxy-Klasse bekommt?

Ich möchte keine 3rd-Party-Libraries verwenden - ich möchte nur verwenden, was .Net mir anbietet.

Answer 1

It looks like RealProxy won't come to .NET Core/Standard. In der Ausgabe schlägt ein Microsoft-Entwickler DispatchProxy als Alternative vor.

Außerdem können einige vorhandene AOP-Frameworks .NET Core bereits oder in der Zukunft unterstützen (wie in den Kommentaren zu der Frage zu sehen). Eine Alternative ist die DispatchProxy, die hier ein wunderbares Beispiel hat: http://www.c-sharpcorner.com/article/aspect-oriented-programming-in-c-sharp-using-dispatchproxy/.

Wenn wir den Code zu vereinfachen, ist es das, was wir bekommen:

public class LoggingDecorator<T> : DispatchProxy 
{ 
    private T _decorated; 

    protected override object Invoke(MethodInfo targetMethod, object[] args) 
    { 
     try 
     { 
      LogBefore(targetMethod, args); 

      var result = targetMethod.Invoke(_decorated, args); 

      LogAfter(targetMethod, args, result); 
      return result; 
     } 
     catch (Exception ex) when (ex is TargetInvocationException) 
     { 
      LogException(ex.InnerException ?? ex, targetMethod); 
      throw ex.InnerException ?? ex; 
     } 
    } 

    public static T Create(T decorated) 
    { 
     object proxy = Create<T, LoggingDecorator<T>>(); 
     ((LoggingDecorator<T>)proxy).SetParameters(decorated); 

     return (T)proxy; 
    } 

    private void SetParameters(T decorated) 
    { 
     if (decorated == null) 
     { 
      throw new ArgumentNullException(nameof(decorated)); 
     } 
     _decorated = decorated; 
    } 

    private void LogException(Exception exception, MethodInfo methodInfo = null) 
    { 
     Console.WriteLine($"Class {_decorated.GetType().FullName}, Method {methodInfo.Name} threw exception:\n{exception}"); 
    } 

    private void LogAfter(MethodInfo methodInfo, object[] args, object result) 
    { 
     Console.WriteLine($"Class {_decorated.GetType().FullName}, Method {methodInfo.Name} executed, Output: {result}"); 
    } 

    private void LogBefore(MethodInfo methodInfo, object[] args) 
    { 
     Console.WriteLine($"Class {_decorated.GetType().FullName}, Method {methodInfo.Name} is executing"); 
    } 
} 

Wenn wir also ein Beispiel Klasse Calculator mit einer entsprechenden Schnittstelle (hier nicht dargestellt):

public class Calculator : ICalculator 
{ 
    public int Add(int a, int b) 
    { 
     return a + b; 
    } 
} 

können wir einfach verwenden Sie es wie dieser

static void Main(string[] args) 
{ 
    var decoratedCalculator = LoggingDecorator<ICalculator>.Create(new Calculator()); 
    decoratedCalculator.Add(3, 5); 
    Console.ReadKey(); 
} 

Answer 2

können Sie entweder System.Reflection.DispatchProxy verwenden oder Ihre eigenen einfachen Decorator-Implementierungen. Überprüfen Sie Decorator pattern Seite auf Wikipedia für Implementierungsbeispiele.

In .NET Core können Sie die Konstruktorinjektion nicht mit DispatchProxy verwenden. Sie müssen DispatchProxy.Create() Factory-Methode und Property-Injection mit expliziten Cast zu Proxy-Typ verwenden, die Sie verwenden möchten. Weitere Informationen finden Sie im .NET Core GitHub-Repository unter DispachProxyTest.cs.

Dies ist ein Beispiel für einen einfachen generischen Dekorateur, die DispatchProxy erbt:

class GenericDecorator : DispatchProxy 
{ 
    public object Wrapped { get; set; } 
    public Action<MethodInfo, object[]> Start { get; set; } 
    public Action<MethodInfo, object[], object> End { get; set; } 
    protected override object Invoke(MethodInfo targetMethod, object[] args) 
    { 
     Start?.Invoke(targetMethod, args); 
     object result = targetMethod.Invoke(Wrapped, args); 
     End?.Invoke(targetMethod, args, result); 
     return result; 
    } 
} 

Und es ist Nutzung:

class Program 
{ 
    static void Main(string[] args) 
    { 
     IEcho toWrap = new EchoImpl(); 
     IEcho decorator = DispatchProxy.Create<IEcho, GenericDecorator>(); 
     ((GenericDecorator)decorator).Wrapped = toWrap; 
     ((GenericDecorator)decorator).Start = (tm, a) => Console.WriteLine($"{tm.Name}({string.Join(',', a)}) is started"); 
     ((GenericDecorator)decorator).End = (tm, a, r) => Console.WriteLine($"{tm.Name}({string.Join(',', a)}) is ended with result {r}"); 
     string result = decorator.Echo("Hello"); 
    } 

    class EchoImpl : IEcho 
    { 
     public string Echo(string message) => message; 
    } 

    interface IEcho 
    { 
     string Echo(string message); 
    } 
} 

Answer 3

Sie können auch eine Kombination von Autofac und Dynamic verwenden. Dieser Artikel hat eine nette Einführung und Beispiele, wie man es erreicht.

AOP in .Net Core