कैसल विंडसर एकता - क्या आप एकता में स्वयं को कॉन्फ़िगर कर सकते हैं वैसे ही आप सीडब्ल्यू में कर सकते हैं?

Question

मुझे नहीं पता कि यह एक प्रश्न है, यदि यह संभव है, लेकिन मुझे एक ऐप पोर्ट करना है जो कैसल विंडसर को एकता में उपयोग करता है ताकि गैर-माइक्रोसॉफ्ट अनुमोदित पुस्तकालयों पर निर्भर न हो। मुझे पता है मुझे पता है लेकिन आप क्या करने जा रहे हैं।

वैसे भी मैंने इसे प्रबंधित किया है लेकिन मुझे जो मिला है उससे मैं खुश नहीं हूं। विंडसर में मैं इस किया था:

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

जो मैं एकता

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

में यह करने के लिए परिवर्तित कर दिया है आप मैं हर एक बात रजिस्टर करने के लिए आ रही हैं देख सकते हैं के बजाय किसी प्रकार का उपयोग कर सकेंगे ऑटो कॉन्फ़िगरेशन का। तो मेरा सवाल है: क्या यह एकता में ऐसा करने का एक बेहतर तरीका है?

धन्यवाद,

एडम।

Answer 1

कूल। यह सुविधा अभी तक एकता में नहीं है, लेकिन यदि आप थोड़ा महत्वाकांक्षी महसूस करते हैं तो आप अपना खुद का सम्मेलन आधारित पंजीकरण स्थापित कर सकते हैं। नीचे पाया गया एक स्निप किया गया है जो निष्पादन असेंबली और इंटरफेस के लिए काम करता है। सौभाग्य।

पीएस यह एक बड़े हैक की तरह लगता है, मैं शायद हाथ से सभी प्रकार के पंजीकरण जारी रखता हूं।

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; } 
     }   
    } 
} 

Answer 2

AFAIK यूनिटी में ऐसा करने का कोई तरीका नहीं है। एकता बस विंडसर की तुलना में बहुत कम परिपक्व और खराब आर्किटेक्टेड कंटेनर है, और इसके परिणामस्वरूप कई चीजें इसके साथ कठिन/असंभव हैं।

Answer 3

चेक this आउट:

 var container = new UnityContainer(); 

     container 
      .ConfigureAutoRegistration() 
      .LoadAssemblyFrom("Plugin.dll") 
      .IncludeAllLoadedAssemblies() 
      .ExcludeSystemAssemblies() 
      .ExcludeAssemblies(a => a.GetName().FullName.Contains("Test")) 
      .Include(If.Implements<ILogger>, Then.Register().UsingPerCallMode()) 
      .Include(If.ImplementsITypeName, Then.Register().WithTypeName()) 
      .Include(If.Implements<ICustomerRepository>, Then.Register().WithName("Sample")) 
      .Include(If.Implements<IOrderRepository>, 
        Then.Register().AsSingleInterfaceOfType().UsingPerCallMode()) 
      .Include(If.DecoratedWith<LoggerAttribute>, 
        Then.Register() 
          .AsInterface<IDisposable>() 
          .WithTypeName() 
          .UsingLifetime<MyLifetimeManager>()) 
      .Exclude(t => t.Name.Contains("Trace")) 
      .ApplyAutoRegistration(); 

Answer 4

मैं सिर्फ इस सवाल का विंडसर के लिए सम्मेलन आधारित पंजीकरण के बारे में जानकारी के लिए देख भर में ठोकर खाई और जब तक यह एक काफी पुराने सवाल मैंने सोचा है मैं दूसरों के लिए एक जवाब छोड़ जाने वाले व्यक्ति को एकता में इस तरह की क्षमताओं की तलाश हो सकती है।

पिछले साल मैंने एकता के लिए एक सम्मेलन-आधारित पंजीकरण विस्तार लिखा था जिसे आप here के बारे में पढ़ सकते हैं। वास्तविक डाउनलोड Google कोड here पर उपलब्ध है। मूल उपयोग है:

_container 
       .Using<IConventionExtension>() 
       .Configure(x => 
        { 
         x.Conventions.Add(new ClosingTypeConvention(typeof (IRepository<>))); 
         x.Assemblies.Add(Assembly.GetExecutingAssembly()); 
        }) 
       .Register(); 

Answer 5

एकता 3 अब बॉक्स से बाहर प्रथा के अनुसार पंजीकरण का समर्थन करता:

_container 
     .Using<IConventionExtension>() 
     .Configure(x => 
      { 
       x.Conventions.Add<InterfaceImplementionNameMatchConvention>(); 
       x.Assemblies.Add(Assembly.GetExecutingAssembly()); 
      }) 
     .Register(); 

वहाँ भी स्वत: पंजीकरण के खुले सामान्य प्रकारों के लिए एक ClosingTypeConvention है।

रजिस्टर और एक अंतरफलक है कि सम्मेलन इस प्रकार के लिए अपने सभी ठोस कार्यान्वयन के नक्शे हैं निम्नलिखित: IFoo -> फू

var container = new UnityContainer(); 
container.RegisterTypes(
    AllClasses.FromLoadedAssemblies(), 
    WithMappings.MatchingInterface, 
    WithName.Default); 

वैसे, आप ठोस प्रकार कक्षाएं रजिस्टर करने के लिए (के रूप में है की जरूरत नहीं है आपके XXXPresenter कक्षाओं के मामले में) यदि वे किसी भिन्न प्रकार के लिए मानचित्र नहीं करते हैं ... यदि कोई वर्ग ठोस प्रकार पर निर्भर करता है तो एकता स्वचालित रूप से इसे बनाएगी।

सम्मेलनों के साथ आप बहुत कुछ कर सकते हैं, जैसे कि असेंबली या प्रकार का उपयोग करने के लिए फ़िल्टर करना, या मैपिंग कैसे किया जाता है, लेकिन मैं सुझाव दूंगा कि आप एमएसडीएन में उदाहरण देखें, क्योंकि इनमें से कई को कवर किया गया है:

http://msdn.microsoft.com/en-us/library/dn178463(v=pandp.30).aspx#sec23