6

これがあまりにも具体的な質問であるかどうかはわかりませんが、可能であれば、Microsoftが承認していないライブラリに依存しないように、CastleWindsorを使用するアプリをUnityに移植する必要があります。私は知っていますが、あなたは何をするつもりですか。

とにかく私はそれを管理しましたが、私は私が持っているものに満足していません。ウィンザーで私はこれを持っていました：

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>();

ご覧のとおり、ある種の自動構成を使用するのではなく、すべてのものを登録する必要があります。だから私の質問は：これを団結して行うためのより良い方法はありますか？

ありがとう、

アダム。

4

5 に答える 5

5

これをチェックしてください：

        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();
于 2009-10-08T09:55:52.853 に答える
2

Unity 3 は、標準で規約による登録をサポートするようになりました。

以下は、すべての具体的な実装を登録し、規則に従うインターフェースにマップします: IFoo -> Foo

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

ちなみに、具象型クラスが別の型にマップされていない場合は (XXXPresenter クラスの場合のように)、具象型クラスを登録する必要はありません...クラスが具象型に依存している場合、Unity は自動的にそれを構築します。

使用するアセンブリや型のフィルタリング、マッピングの実行方法など、規則でできることは他にもたくさんありますが、MSDN の例を参照することをお勧めします。

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

于 2013-06-05T20:37:53.383 に答える
0

Windsor の規約ベースの登録に関する情報を探しているときに、この質問に出くわしました。これはかなり古い質問ですが、Unity でこの種の機能を探している可能性のある他の人に答えを残したいと思いました。

昨年、私は Unity の規約に基づく登録拡張機能を作成しました。これについては、こちらを参照してください。実際のダウンロードは、こちらの Google コードから入手できます。基本的な使い方は次のとおりです。

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

オープン ジェネリック型を自動登録するための ClosingTypeConvention もあります。

  _container
                .Using<IConventionExtension>()
                .Configure(x =>
                    {
                        x.Conventions.Add(new ClosingTypeConvention(typeof (IRepository<>)));
                        x.Assemblies.Add(Assembly.GetExecutingAssembly());
                    })
                .Register();
于 2010-03-02T22:42:52.687 に答える
0

涼しい。この機能はまだ統一されていませんが、少し野心的であると感じた場合は、独自のコンベンションベースの登録をセットアップできます. 以下は、実行中のアセンブリとインターフェイスで機能する抜粋です。幸運を。

PSこれは大きなハックのように感じます。おそらく、すべてのタイプを手動で登録し続けるでしょう。

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; }
        }        
    }
}
于 2008-12-25T05:46:06.593 に答える
-1

私の知る限り、Unityでそれを行う方法はありません。Unity は Windsor よりもはるかに成熟度が低く、アーキテクチャが悪いコンテナであり、その結果、Unity では多くのことが難しく/不可能になります。

于 2008-12-30T09:09:54.667 に答える