在运行时动态扩展类型？

Question

I have the need to extend instances of various types at runtime. Most of the time, I need to work with instances of the original type, however in a few circumstances, I need to create kind of an extension-wrapper around those types that add a couple pieces of contextual information. Something along the lines of the following (which is not actually valid .NET/C# code...but it illustrates the point):

public abstract class BaseClass
{
  // ...
}

public class Concrete1: BaseClass
{
  // ...
}

public class Concrete2: BaseClass
{
  // ...
}

public class WrapperExtender<T>: T // Extending from T here is actually invalid!
  where T: BaseClass
{
    public WrapperExtender(T extensionTarget)
    {
        m_extensionTarget = extensionTarget;
    }

    private readonly T m_extensionTarget;

    public object ContextualReference { get; }
    public int ContextualValue { get; }

    // DERP: Would need to implement overrides of T here...buuut...can't...
}

// In use, special case:
var instance = new Concrete1();
var extendedInstance = new WrapperExtender(instance);

var processor = new SomeProcessorRequiringExtendedInstance();
processor.DoProcessing(extendedInstance);

Another example of this would probably be Microsoft Entity Framework v4.0, or nHibernate. Both of these frameworks provide dynamically extended instances of your entity types, wrapping them internally to provide, at runtime, the hooks required to keep a data/object/session context up to date with changes made to your entity instances. My needs are not nearly as complex, and the generics scenario above would work beautifully, if only there was a way to blend generics and dynamic typing somehow.

Anyway, I'm hoping someone knows how to achieve the above scenario. Or, perhaps even better, someone knows a better solution. I don't care much for the idea of dynamically extending a type like that at runtime (it doesn't make as much sense as it does in the EF/nHibernate scenario.) At the moment, its the only thing I can really think of that will provide me with the information I need in the processor for each type passed in to DoProcessing.

Answer 1

The problems that EF etc are solving is different, and relates to tihngs like lazy loading, etc. I'm simply not sure that the level of complexity that dynamic subclassing requires is worth it for this scenario. A few thoughts, though:

• have a property bag in your object for flexible additional properties; if necessary the property-bag can be exposed to data-binding APIs via ICustomTypeDescriptor
• simply wrap your object in an implementation-specific tuple that contains the existing object and the additional properties (no subclassing)

It is a shame that C# doesn't support "mixins", which would also be a nice way of implementing this type of thing with interfaces.

Answer 2

I know that this can be accomplished using dynamicproxy (which is what NHibernate uses to accomplish this task) which you can find out more about here:

DynamicProxy Page

DynamicProxy tutorial

Answer 3

If all you need is some additional properties, why not just create a context property in BaseClass?

something like this, where ContextBag is either a generic collection class or specially defined context collection:

Public ContextBag Context
{
   get;
   set;
}

When setting/accessing the context, you will be using syntax like this:

SubClass.Context.GetInt(ContextDefinition, ContextName);

SubClass.Context.Add(ContextDefinition, ContextName, ContextValue);

Answer 4

Found a better solution than temporarily extending. I created an actual context object that contained the state I needed available. Whenever that context exists, I initialize the context and set a static property that can be used to retrieve the context object from anywhere, alleviating the need to update all the dependencies of my larger process to take the context in as a parameter (which isn't always possible, as sometimes the calls are made in other contexts.)

public class SomeContext
{
    public SomeContext(object stateData1, object stateData2)
    {
        StateData1 = stateData1;
        StateData2 = stateData2;
    }

    public virtual object StateData1 { get; private set; }
    public virtual object StateData2 { get; private set; }

    [ThreadStatic]
    private static SomeContext m_threadInstance;    

    public static SomeContext Current
    {
        get
        {
            return m_threadInstance;
        }
        set
        {
            if (value != null && m_threadInstance != null) 
                throw new InvalidOperationException("This context has already been initialized for the current thread.");
            m_threadInstance = value;
        }
    }
}

public class SomeContextScope: IDisposable
{
    public SomeContextScope(object stateData1, object stateData2)
    {
        if (SomeContext.Current == null)
        {
            SomeContext context = new SomeContext(stateData1, stateData2);
            SomeContext.Current = context;
            m_contextCreated = true;
        }
    }

    private bool m_contextCreated;

    public void Dispose()
    {
        if (m_contextCreated)
        {
            SomeContext.Current = null;
        }
    }
}

public class ComplexProcessor
{
    public ComplexProcessor(...) // Lots of dependencies injected

    public void DoProcessing(BaseClass instance)
    {
        // do some work with instance

        if (SomeContext.Current != null)
        {
            // do contextually sensitive stuff for SomeContext with instance
            // call a dependency that does contextually sensitive stuff
        }

        // do some more work with instance
        // call a dependency that does contextually sensitive stuff

        if (SomeOtherContext.Current != null)
        {
            // do contextually sensitive stuff for SomeOtherContext with instance
            // call a dependency that does contextually sensitive stuff
        }

        // call a dependency that does contextually sensitive stuff
    }
}

// The original setup of the context and initiation of processing

public void SomeOperation(...)
{
    using (SomeContextScope scope = new SomeContextScope(stateData1, stateData2))
    {    
        // ... do some work

        var processor = complexProcessorFactory.CreateInstance();
        processor.DoProcesing(data);

        // ... do more work
    }
}

I like the way this works. Context is the state within which behavior executes. It has always felt clunky to me to have to pass contextual data around with other objects, and have dozens of methods or method overloads that take in and pass along various forms of contextual data. By setting up a context object that is globally available for the duration of that context, my code is a lot cleaner, and my dependencies are more concise. It should be mockable too, since the Current property is read/write, I can create a mock context in a BDD specification or TDD unit test whenever one is required without a lot of hassle.