gistfile1.cs

public class ReflectionBasedPresenterDiscoveryStrategy : IPresenterDiscoveryStrategy
{
    private readonly ViewPresenterTable _presenterTable;

    public ReflectionBasedPresenterDiscoveryStrategy(params Assembly[] presenterAssemblies)
    {
        _presenterTable = new ViewPresenterTable(presenterAssemblies);
    }

    public IEnumerable<PresenterDiscoveryResult> GetBindings(IEnumerable<object> hosts, IEnumerable<IView> viewInstances)
    {
        return viewInstances.Select(v => GetPresenters(v));
    }

    private PresenterDiscoveryResult GetPresenters(IView view)
    {
        var presenterTypes = _presenterTable[view];
        var bindings = new PresenterBinding[0];
        
        if(presenterTypes.Count() > 0)
            bindings = new[] { new PresenterBinding(presenterTypes, view.GetType(), BindingMode.Default, new[] { view }) };
        
        return new PresenterDiscoveryResult(new [] { view }, string.Empty, bindings);
    }

    private class ViewPresenterTable 
    {
        public IEnumerable<Type> this[IView view]
        {
            get
            {
                var actualViewType = view.GetType();

                if (actualViewType.Namespace == "ASP" && (typeof(Page).IsAssignableFrom(actualViewType) || typeof(Control).IsAssignableFrom(actualViewType)))
                {
                    actualViewType = actualViewType.BaseType;
                }

                return (from viewType in Views.Keys
                        where viewType.IsAssignableFrom(actualViewType)
                        select Views[viewType]).SelectMany(v => v);
            }
        }

        public ViewPresenterTable(IEnumerable<Assembly> presenterAssemblies)
        {
            var presenterTypes = presenterAssemblies.SelectMany(a => GetPresenterTypes(a));

            Views = (from v in presenterTypes.Select(p => p.BaseType.GetGenericArguments()[0]).Distinct()
                     select new
                    {
                        View = v,
                        Presenters = presenterTypes.Where(p => p.BaseType.GetGenericArguments()[0] == v)
                    }).ToDictionary(v => v.View, v => v.Presenters);
        }

        private static IEnumerable<Type> GetPresenterTypes(Assembly presenterAssembly)
        {
            return from t in presenterAssembly.GetTypes()
                   let b = t.BaseType
                   where
                       b != null && b.IsGenericType &&
                       b.GetGenericTypeDefinition() == typeof (Presenter<>)
                   select t;
        }

        private Dictionary<Type, IEnumerable<Type>> Views { get; set; }
    }
}