Question

I have a series of static methods to modify a collection then return the modified collection:

private static IEnumerable<Invoice> ResolveProxies(IEnumerable<Invoice> e) {
    // do something to e
    return e;
}

private static IEnumerable<Person> ResolveProxies(IEnumerable<Person> e) {
    // do something to e
    return e;
}

In another part of the application there is a method to decide if a collection is of a certain type, so that it can be converted to that type and have its corresponding ResolveProxies method called:

public static GridModel<T> ToGridModel<T>(this GridModel gridModel) {
    // gridModel.Data is just IEnumerable
    var collection = gridModel.Data as IEnumerable<T> ?? new List<T>();

    return new GridModel<T> {
        Data = EvaluateDynamicProxies(collection),
        Total = gridModel.Total
    };
}

private static IEnumerable<T> EvaluateProxies<T>(IEnumerable<T> collection) {
    if (collection is IEnumerable<Invoice>) {
        var enumeration = (collection as IEnumerable<Invoice>);
        return ResolveProxies(enumeration) as IEnumerable<T>;
    }
    if (collection is IEnumerable<Person>) {
        var enumeration = (collection as IEnumerable<Person>);
        return ResolveProxies(enumeration) as IEnumerable<T>;
    }

    // proxy resolution isn't needed so return the unchanged collection
    return collection;
}

Having such repetitive conditional logic is bad code smell. I’m struggling to come up with some way to mark particular types so that I know they have a corresponding proxy resolver method. Something like this perhaps:

public interface IProxyResolver<out T> where T:IEnumerable<T> {
    T ResolveProxies();
}

But how would I use this? In effect I need a way to ask the compiler:

1. Does T have a matching ResolveProxies method?
2. What is the name of the class or method that resolves proxies for T so that I can get an instance of it and call it?

Answer 1

You could use an inversion of control (IOC) framework. For example, my team uses Castle Windsor. You can register services (usually interfaces) and types that provide the services. It has some nice generics resolution, so you can do things like this:

interface IProxyResolver<T> { /* whatever */ }
class ProxyResolver<T> : IProxyResolver<T> { /* ... */ }
class PersonProxyResolver : ProxyResolver<Person> { }
class InvoiceProxyResolver : ProxyResolver<Invoice> { }

then, you can summon these types like this:

void SomeMethodThatNeedsAProxyResolver<T>(T obj)
{
    var resolver = ioc.Resolve<IProxyResolver<T>>();
    //...
}

If you’ve regsitered the classes above, when T is Person or Invoice, you get the correct non-generic subclass of ProxyResolver; if it is any other type, you get the default generic superclass. Of course, you can structure things differently; if you need a specific proxy resolver for every type, that’s possible too.