jasonbock/dynamicproxies

This is an assembly that creates proxy classes on-the-fly using the Reflection.Emit API. Generics are supported.

DynamicProxies

This is an assembly that creates proxy classes on-the-fly using the Reflection.Emit API. Generics are supported.

Note that no more work is going into this project. Consider using System.Reflection.DispatchProxy:

• https://docs.microsoft.com/en-us/dotnet/api/system.reflection.dispatchproxy?view=netcore-3.1
• https://www.strathweb.com/2019/09/implementing-a-non-public-interface-in-net-core-with-dispatchproxy/

dynamicproxies's Issues

Ensure IDisposable-based Objects Can Be Proxied

Based on this article:

http://michaelbraude.com/2008/12/overriding-dispose-with-reflectionemit.html

This might be an issue. Ensure there's tests there for this case, and if it's an issue, address it.

Ensure All Locals Have Meaningful Names

Self-explanatory :)

Check Opcodes for Short Form Usage

I don't think I'm being as aggressive as I can be with using "short form" opcodes. I need to review the emitting code to see if there's any places for this kind of optimization.

Support a Group of Interfaces

Change Proxy.Create() to take a List<> (or array) of interfaces. Create a proxy that implements all interface members (and handle collisions among the interfaces gracefully).

Consider Overriding Finalizers

Since finalizers can be overriden, consider having the proxy override them if it sees them.

I think I do this by default anyway, but I should investigate if this should continue to work this way, and if this should be added to the ProxyContext object as a configurable flag.

Add Better XML Documentation

Especially for IInvocationHandler - it's not at all clear what the bool return values should be.

Add .NET Core 3.0 Support

Self-explanatory

Support Abstract Types

Self-explanatory. If Proxy.Create() gets an abstract type, create a proxy for it. Add before/after calls for abstract methods, but no-op the implementation in the proxy subclass (return the default value if the method has a return value).

Address Serializable Types

I.e. I'm giving a Serializable type, how do I effectively implement that in the dynamic type? And if that's serialized, how (if it can) does it get deserialized into the base class type? Need to (probably) mark the wrapped object and handler fields as [NotSerializable].

Use the Compiler API to Generate Proxies

It would be interesting to see if using the Compiler API to generate the proxy objects would be an overall "better" experience. Basically do what Rocks does: generate the proxy class via C# (as a string) and then compile/emit. That would probably be slower than doing direct IL generation, but it would make the overall process cleaner and easier (and it would also make it far easier to debug).