{"id":31529,"date":"2021-01-12T07:23:50","date_gmt":"2021-01-12T14:23:50","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/dotnet\/?p=31529"},"modified":"2021-01-12T07:24:41","modified_gmt":"2021-01-12T14:24:41","slug":"migrating-realproxy-usage-to-dispatchproxy","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/migrating-realproxy-usage-to-dispatchproxy\/","title":{"rendered":"Migrating RealProxy Usage to DispatchProxy"},"content":{"rendered":"

As I’ve helped customers port .NET Framework apps to .NET Core 3.1 and .NET 5, one question that has come up several times is the question of what to do about System.Runtime.Remoting.Proxies.RealProxy<\/code><\/a> usage. Customers using the API are concerned because they know that remoting is not supported<\/a> on .NET Core. Fortunately, the new DispatchProxy<\/code><\/a> API works as an easy replacement in many cases. In this blog post, I’m going to briefly discuss how to use DispatchProxy<\/code> (or Castle.Core’s DynamicProxy<\/code>) in place of RealProxy<\/code> for aspect-oriented programming scenarios and what differences exist between the three proxy APIs.<\/p>\n

Despite being in the System.Runtime.Remoting<\/code> namespace, in many cases, users aren’t actually doing any cross-process remoting with RealProxy<\/code>. Instead, many developers use it as an easy way to implement an aspect-oriented programming (AOP)<\/a> paradigm as explained in Aspect-Oriented Programming : Aspect-Oriented Programming with the RealProxy Class<\/a>. The idea is that cross-cutting concerns (like logging or caching) can be handled in a proxy class that wraps other types so that those concerns can be handled centrally without having to modify the original classes.<\/p>\n

Although RealProxy<\/code> isn’t available in .NET Core or .NET 5, a dedicated API was added for exactly this scenario. If you are trying to implement cross-cutting concerns via proxy wrappers (and don’t care about cross-process remoting), System.Reflection.DispatchProxy<\/code><\/a> will probably fit the bill. And if DispatchProxy<\/code> doesn’t meet your needs for some reason, the third-party Castle.DynamicProxy<\/code><\/a> APIs from Castle.Core<\/a> offer another .NET Standard-compatible alternative. The sample code in this post is available on GitHub in the mjrousos\/ProxyExploration<\/a> repository.<\/p>\n

RealProxy example<\/h2>\n

To start, let’s take a look at how RealProxy<\/code> may have been used in a .NET Framework project to add logging.<\/p>\n

RealProxy<\/code> is an abstract class. To use it, you need to derive from it and implement the abstract Invoke<\/code> method. The proxy is able to generate objects that appear to be of a given type but, when the generated objects’ APIs are used, the proxy’s Invoke<\/code> method will be called (instead of using the proxied type’s members). Invoke<\/code> should take whatever action is desired (possibly invoking the indicated member on a wrapped instance of the proxied type) and return a ReturnMessage<\/code> with the result of the operation.<\/p>\n

Here is a simple example of a RealProxy<\/code>-based proxy for adding Serilog<\/a> logging around all method calls. The comments in the code explain the role the different methods play in making the proxy work.<\/p>\n

\/\/ Simple sample RealProxy-based logging proxy\r\n\/\/ Note that the proxied type must derive from MarshalByRefObject\r\npublic class RealProxyLoggingDecorator<T> : RealProxy where T: MarshalByRefObject\r\n{\r\n    \/\/ A field to store an inner 'real' instance of the proxied type.\r\n    \/\/ All API calls will go to this wrapped instance (after the proxy has \r\n    \/\/ done its logging).\r\n    private readonly T _target;\r\n\r\n    \/\/ The Serilog logger to be used for logging.\r\n    private readonly Logger _logger;\r\n\r\n    \/\/ When creating a new instance of this proxy type, invoke RealProxy's\r\n    \/\/ constructor with the type to be wrapped and, optionally, allow\r\n    \/\/ the caller to provide a 'target' object to be wrapped.\r\n    private RealProxyLoggingDecorator(T target = null) : base(typeof(T))\r\n    {\r\n        \/\/ If no target object is supplied, created a new one.\r\n        if (target == null)\r\n        {\r\n            target = Activator.CreateInstance<T>();\r\n        }\r\n\r\n        _target = target;\r\n\r\n        \/\/ Setup the Serilog logger\r\n        _logger = new LoggerConfiguration()\r\n            .WriteTo.Console().CreateLogger();\r\n        _logger.Information(\"New logging decorator created for object of type {TypeName}\", typeof(T).FullName);\r\n    }\r\n\r\n    \/\/ This convenience method creates an instance of RealProxyLoggingDecorator\r\n    \/\/ and calls RealProxy's GetTransparentProxy method to retrieve the proxy\r\n    \/\/ object (which looks like an instance of T but calls our Invoke method\r\n    \/\/ whenever an API is used).\r\n    public static T Decorate(T target = null) =>\r\n        new RealProxyLoggingDecorator<T>(target).GetTransparentProxy() as T;\r\n\r\n    \/\/ The invoke method is the heart of a RealProxy implementation. Here, we\r\n    \/\/ define what should happen when a member on the proxy object is used.\r\n    public override IMessage Invoke(IMessage msg)\r\n    {\r\n        \/\/ The IMessage argument should be an IMethodCallMessage indicating\r\n        \/\/ which method is being invoked. Interestingly, RealProxy even translates \r\n        \/\/ field access into method calls so those will show up here, too.\r\n        if (msg is IMethodCallMessage methodCallMsg)\r\n        {\r\n            try\r\n            {\r\n                \/\/ Perform the logging that this proxy is meant to provide\r\n                _logger.Information(\"Calling method {TypeName}.{MethodName} with arguments {Arguments}\",\r\n                    methodCallMsg.MethodBase.DeclaringType.Name, methodCallMsg.MethodName, methodCallMsg.Args);\r\n\r\n                \/\/ Cache the method's arguments locally so that out and ref args can be updated at invoke time.\r\n                \/\/ (methodCallMsg.Args can't be updated directly since they are returned by a property getter\r\n                \/\/ and don't refer to a consistent object[])\r\n                var args = methodCallMsg.Args;\r\n\r\n                \/\/ For this proxy implementation, we still want to call the original API \r\n                \/\/ (after logging has happened), so use reflection to invoke the desired\r\n                \/\/ API on our wrapped target object.\r\n                var result = methodCallMsg.MethodBase.Invoke(_target, args);\r\n\r\n                \/\/ A little more logging.\r\n                _logger.Information(\"Method {TypeName}.{MethodName} returned {ReturnValue}\", \r\n                    methodCallMsg.MethodBase.DeclaringType.Name, methodCallMsg.MethodName, result);\r\n\r\n                \/\/ Finally, Invoke should return a ReturnMessage object indicating the result of the operation\r\n                return new ReturnMessage(result, args, args.Length, methodCallMsg.LogicalCallContext, methodCallMsg);\r\n            }\r\n            catch (TargetInvocationException exc)\r\n            {\r\n                \/\/ If the MethodBase.Invoke call fails, log a warning and then return\r\n                \/\/ a ReturnMessage containing the exception.\r\n                _logger.Warning(exc.InnerException, \"Method {TypeName}.{MethodName} threw exception: {Exception}\",\r\n                    methodCallMsg.TypeName, methodCallMsg.MethodName, exc.InnerException);\r\n\r\n                return new ReturnMessage(exc.InnerException, methodCallMsg);\r\n            }\r\n        }\r\n        else\r\n        {\r\n            throw new ArgumentException(\"Invalid message; expected IMethodCallMessage\", nameof(msg));\r\n        }\r\n    }\r\n}\r\n<\/code><\/pre>\n
To use the proxy type, a caller just needs to use the Decorate<\/code> helper method to create an instance of the proxy. The returned object will look and act just like the type being proxied except that the proxy’s Invoke<\/code> method will be used whenever a member of the object is used.<\/p>\n
\/\/ Creates an object that acts like an instance of Widget\r\nvar widget = RealProxyLoggingDecorator<Widget>.Decorate(new Widget(\"Widget name\", 9.99));\r\n<\/code><\/pre>\n
Pros and cons of RealProxy<\/h3>\n