Question

I don’t know if this is too specific a question, if that is possible, but I’m having to port an app that uses Castle Windsor to Unity so that there isn’t a reliance on non-microsoft approved libraries. I know I know but what are you going to do.

Anyway I’ve managed it but I’m not happy with what I’ve got. In Windsor I had this:

Register(             AllTypes.Of(typeof(AbstractPresenter<>)).FromAssemblyNamed('Links.Mvp'),             AllTypes.Of(typeof(IView)).FromAssemblyNamed('Links.WinForms').WithService.FromInterface()); 

which I’ve converted to this in unity

RegisterType<IMainView, MainView>();         RegisterType<IConfigureLinkView, ConfigureLinkView>();         RegisterType<IConfigureSourceView, ConfigureSourceView>();         RegisterType<IConfigureSinkView, ConfigureSinkView>();         RegisterType<MainPresenter, MainPresenter>();         RegisterType<ConfigureLinkPresenter, ConfigureLinkPresenter>();         RegisterType<ConfigureSourcePresenter, ConfigureSourcePresenter>();         RegisterType<ConfigureSinkPresenter, ConfigureSinkPresenter>(); 

As you can see I’m having to register every single thing rather than be able to use some sort of auto-configuration. So my question is: is there a better way of doing this in unity?

Thanks,

Adam.

Answer 1

Cool. This feature is not in unity yet but if you felt a bit ambitious you could setup your own convention based registration. Found below is a snipped that works for the executing assembly and interfaces. Good luck.

P.S. This feels like a big hack, I would probably continue just registering all types by hand.

using System; using System.Collections.Generic; using System.Linq; using System.Text;  using System.Reflection;  namespace Forum {     class Program     {         static void Main(string[] args)         {             // get your assemblies and types you can register             Assembly a = Assembly.GetExecutingAssembly();             var types = a.GetTypes();                         var bindTo = from t in types                          where t.IsAbstract || t.IsInterface                          select t;              // apply your conventions to filter our types to be registered             var interfacePairs = from t in bindTo.Where(x => x.IsInterface)                                  let match = types.FirstOrDefault(x => x.Name ==     t.Name.Substring(1))                                  where match != null                                  select new Pair { To = t, From = match };             var abstractPairs = new Pair[] {};               // setup the generic form of the method to register the types             var thisType = typeof(Program);             var bindings = BindingFlags.Static | BindingFlags.Public;             MethodInfo genericMethod = thisType.GetMethod('RegisterType', bindings);                          // register all your types by executing the              // specialized generic form of the method             foreach (var t in interfacePairs.Concat(abstractPairs))             {                 Type[] genericArguments = new Type[] { t.To, t.From };                 MethodInfo method = genericMethod.MakeGenericMethod(genericArguments);                 method.Invoke(null, new object [] {});             }              Console.ReadKey();         }          public static void RegisterType<To, From>()         {             Console.WriteLine('Register { To: {0} From: {1} }', typeof(To), typeof(From));         }          // Test classes that should be picked up         interface ITest { }         class Test : ITest { }          class Pair         {             public Type To { get; set; }             public Type From { get; set; }         }             } }