डॉटनेट कोर में रियलप्रोक्सी?

Question

मैं सी # में एओपी के लिए नामस्थान System.Runtime.Remoting.Proxies और System.Runtime.Remoting.Messaging के साथ काम कर रहा हूं। मैं अपने आवेदन को नेट फ्रेमवर्क 4.6 से dnxcore/dotnet कोर से पोर्ट करने का प्रयास कर रहा हूं।

इंटेलिसेंस कहता है कि ये दो नामस्थान मेरे ढांचे-vesion (netcoreapp1.0/dnxcore50) के साथ उपलब्ध नहीं हैं। कोई विचार अगर इन दो नामस्थान दिखाई देंगे? या किसी भी विचार को RealProxy -class के साथ एओपी कैसे प्राप्त करें?

मैं तीसरे पक्ष-पुस्तकालयों का उपयोग नहीं करना चाहता - मैं केवल इतना उपयोग करना चाहता हूं कि नेट मुझे क्या प्रदान करता है।

Answer 1

It looks like RealProxy won't come to .NET Core/Standard। इस मुद्दे में, एक माइक्रोसॉफ्ट डेवलपर एक विकल्प के रूप में DispatchProxy सुझाता है।

इसके अलावा, कुछ मौजूदा एओपी ढांचे पहले से या भविष्य में .NET कोर का समर्थन कर सकते हैं (जैसा कि प्रश्न पर टिप्पणियों में देखा गया है)।

एक विकल्प DispatchProxy है, जिसमें यहां एक शानदार उदाहरण है: http://www.c-sharpcorner.com/article/aspect-oriented-programming-in-c-sharp-using-dispatchproxy/।

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"); 
    } 
} 

तो अगर हम एक इसी इंटरफेस (यहाँ नहीं दिखाया गया है) के साथ एक उदाहरण वर्ग Calculator है:

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

हम कर सकते हैं

हम कोड को आसान बनाने में है, तो यह है कि हम क्या मिलता है बस इस

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

Answer 2

की तरह उपयोग आप उपयोग कर सकते हैं या तो System.Reflection.DispatchProxy या अपने स्वयं के साधारण सजावटी कार्यान्वयन। कार्यान्वयन उदाहरणों के लिए विकिपीडिया पर Decorator pattern पृष्ठ देखें।

वर्तमान में .NET कोर में आप DispatchProxy के साथ कन्स्ट्रक्टर इंजेक्शन का उपयोग नहीं कर सकते हैं। आपको DispatchProxy.Create() फ़ैक्टरी विधि और प्रॉपर्टी इंजेक्शन का उपयोग स्पष्ट रूप से प्रॉक्सी प्रकार के साथ करना है जिसे आप उपयोग करना चाहते हैं। अधिक जानकारी के लिए .NET कोर गिटहब भंडार में DispachProxyTest.cs देखें।

यह एक सरल सामान्य डेकोरेटर कि DispatchProxy विरासत का एक उदाहरण है:

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; 
    } 
} 

और यह उपयोग है:

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

तुम भी Autofac और DynamicProxy के संयोजन का उपयोग कर सकते हैं। इस आलेख में इसे पूरा करने के तरीके पर एक अच्छा परिचय और नमूने हैं।

AOP in .Net Core