Jak porównywane są główne frameworki C # DI / IoC? [Zamknięte]

Ryzykując wkroczenie na terytorium świętej wojny, jakie są mocne i słabe strony tych popularnych platform DI / IoC i czy można je łatwo uznać za najlepsze? ..:

• Ninject
• Jedność
• Castle.Windsor
• Autofac
• StrukturaMapa

Czy istnieją inne frameworki DI / IoC dla C #, których tutaj nie wymieniłem?

W kontekście mojego przypadku użycia buduję aplikację kliencką WPF i infrastrukturę usług WCF / SQL, łatwość użycia (szczególnie pod względem przejrzystej i zwięzłej składni), spójną dokumentację, dobre wsparcie społeczności i wydajność - wszystko to są ważne czynniki według mojego wyboru.

Aktualizacja:

Przytoczone zasoby i zduplikowane pytania wydają się nieaktualne. Czy ktoś ze znajomością wszystkich tych ram może się zgłosić i zapewnić prawdziwy wgląd?

Zdaję sobie sprawę, że większość opinii na ten temat może być stronnicza, ale mam nadzieję, że ktoś poświęcił czas na przestudiowanie wszystkich tych ram i co najmniej ogólnie obiektywne porównanie.

Jestem skłonny przeprowadzić własne dochodzenie, jeśli nie zostało to zrobione wcześniej, ale założyłem, że było to coś, co zrobiło już kilka osób.

Druga aktualizacja:

Jeśli masz doświadczenie z więcej niż jednym kontem DI / IoC, proszę uszeregować i podsumować zalety i wady tych kontenerów, dziękuję. Nie jest to ćwiczenie polegające na odkrywaniu wszystkich niejasnych małych kontenerów, które ludzie stworzyli, szukam porównań między popularnymi (i aktywnymi) frameworkami.

Chociaż wyczerpująca odpowiedź na to pytanie zajmuje setki stron mojej książki , oto krótka tabela porównawcza, nad którą wciąż pracuję:

Natknąłem się na inne porównanie wydajności (najnowsza aktualizacja 10 kwietnia 2014 r.). Porównuje następujące:

• AutoFac
• LightCore (strona jest niemiecka)
• LinFu
• Ninject
• Mały
• Simple Injector (najszybszy ze wszystkich zawodników)
• Spring.NET
• StrukturaMapa
• Jedność
• Windsor
• Hiro

Oto krótkie podsumowanie postu:

Wniosek

Ninject jest zdecydowanie najwolniejszym pojemnikiem.

MEF, LinFu i Spring.NET są szybsze niż Ninject, ale wciąż dość powolne. Następne są AutoFac, Catel i Windsor, a następnie StructureMap, Unity i LightCore. Wadą Spring.NET jest to, że można go skonfigurować tylko za pomocą XML.

SimpleInjector, Hiro, Funq, Munq i Dynamo oferują najlepszą wydajność, są niezwykle szybkie. Wypróbuj je!

Szczególnie prosty wtryskiwacz wydaje się dobrym wyborem. Jest bardzo szybki, ma dobrą dokumentację, a także obsługuje zaawansowane scenariusze, takie jak przechwytywanie i ogólne dekoratory.

Możesz także spróbować skorzystać z biblioteki Common Service Selector Library i, mam nadzieję, wypróbować wiele opcji i sprawdzić, co będzie dla Ciebie najlepsze.

Niektóre informacje o Common Selector Library z witryny:

Biblioteka zapewnia abstrakcję kontenerów IoC i lokalizatorów usług. Korzystanie z biblioteki pozwala aplikacji na pośredni dostęp do możliwości bez konieczności korzystania z twardych referencji. Mamy nadzieję, że dzięki tej bibliotece aplikacje i frameworki innych firm mogą zacząć wykorzystywać IoC / Service Location bez ograniczania się do konkretnej implementacji.

Aktualizacja

13.09.2011: Funq i Munq zostali dodani do listy uczestników. Wykresy również zostały zaktualizowane, a Spring.NET został usunięty z powodu niskiej wydajności.

04.11.2011: „dodano Simple Injector , wydajność jest najlepsza ze wszystkich zawodników”.

Wystarczy przeczytać ten wspaniały blog z porównaniem kontenerów .Net DI autorstwa Philipa Mat.

Przeprowadza dokładne testy porównawcze wydajności;

• Autofac
• StrukturaMapa
• Ninject
• Jedność
• Castle.Windsor
• Spring.Net

Poleca Autofac, ponieważ jest mały, szybki i łatwy w użyciu ... Zgadzam się. Wygląda na to, że Unity i Ninject są najwolniejsze w jego testach.

Oświadczenie: Na początku 2015 r. Istnieje świetne porównanie funkcji kontenera IoC od Jimmy'ego Bogarda , oto podsumowanie:

Porównywane pojemniki:

• Autofac
• Ninject
• Prosty wtryskiwacz
• StrukturaMapa
• Jedność
• Windsor

Scenariusz jest następujący: mam interfejs IMediator, w którym mogę wysłać pojedyncze żądanie / odpowiedź lub powiadomienie do wielu odbiorców:

public interface IMediator 
{ 
    TResponse Send<TResponse>(IRequest<TResponse> request);

    Task<TResponse> SendAsync<TResponse>(IAsyncRequest<TResponse> request);

    void Publish<TNotification>(TNotification notification)
        where TNotification : INotification;

    Task PublishAsync<TNotification>(TNotification notification)
        where TNotification : IAsyncNotification; 
}

Następnie utworzyłem podstawowy zestaw żądań / odpowiedzi / powiadomień:

public class Ping : IRequest<Pong>
{
    public string Message { get; set; }
}
public class Pong
{
    public string Message { get; set; }
}
public class PingAsync : IAsyncRequest<Pong>
{
    public string Message { get; set; }
}
public class Pinged : INotification { }
public class PingedAsync : IAsyncNotification { }

Chciałem przyjrzeć się kilku kwestiom związanym z obsługą kontenerów dla leków generycznych:

• Konfiguracja dla otwartych generics (łatwa rejestracja IRequestHandler <,>)
• Konfiguracja wielu rejestracji otwartych generycznych (dwóch lub więcej INotificationHandler)

Konfiguracja wariancji ogólnej (rejestrowanie procedur obsługi dla podstawowego INotification / tworzenie potoków żądań) Moje procedury obsługi są dość proste, po prostu wysyłają dane do konsoli:

public class PingHandler : IRequestHandler<Ping, Pong> { /* Impl */ }
public class PingAsyncHandler : IAsyncRequestHandler<PingAsync, Pong> { /* Impl */ }

public class PingedHandler : INotificationHandler<Pinged> { /* Impl */ }
public class PingedAlsoHandler : INotificationHandler<Pinged> { /* Impl */ }
public class GenericHandler : INotificationHandler<INotification> { /* Impl */ }

public class PingedAsyncHandler : IAsyncNotificationHandler<PingedAsync> { /* Impl */ }
public class PingedAlsoAsyncHandler : IAsyncNotificationHandler<PingedAsync> { /* Impl */ }

Autofac

var builder = new ContainerBuilder();
builder.RegisterSource(new ContravariantRegistrationSource());
builder.RegisterAssemblyTypes(typeof (IMediator).Assembly).AsImplementedInterfaces();
builder.RegisterAssemblyTypes(typeof (Ping).Assembly).AsImplementedInterfaces();

• Otwarte leki generyczne: tak, domyślnie
• Wiele otwartych rodzajów ogólnych: tak, domyślnie
• Kontrawariancja ogólna: tak, wyraźnie

Ninject

var kernel = new StandardKernel();
kernel.Components.Add<IBindingResolver, ContravariantBindingResolver>();
kernel.Bind(scan => scan.FromAssemblyContaining<IMediator>()
    .SelectAllClasses()
    .BindDefaultInterface());
kernel.Bind(scan => scan.FromAssemblyContaining<Ping>()
    .SelectAllClasses()
    .BindAllInterfaces());
kernel.Bind<TextWriter>().ToConstant(Console.Out);

• Otwarte leki generyczne: tak, domyślnie
• Wiele otwartych rodzajów ogólnych: tak, domyślnie
• Kontrawariancja ogólna: tak, z rozszerzeniami zbudowanymi przez użytkownika

Prosty wtryskiwacz

var container = new Container();
var assemblies = GetAssemblies().ToArray();
container.Register<IMediator, Mediator>();
container.Register(typeof(IRequestHandler<,>), assemblies);
container.Register(typeof(IAsyncRequestHandler<,>), assemblies);
container.RegisterCollection(typeof(INotificationHandler<>), assemblies);
container.RegisterCollection(typeof(IAsyncNotificationHandler<>), assemblies);

• Otwarte generyczne: tak, wyraźnie
• Wiele otwartych rodzajów ogólnych: tak, wyraźnie
• Kontrawariancja ogólna: tak, niejawnie (z aktualizacją 3.0)

StrukturaMapa

var container = new Container(cfg =>
{
    cfg.Scan(scanner =>
    {
        scanner.AssemblyContainingType<Ping>();
        scanner.AssemblyContainingType<IMediator>();
        scanner.WithDefaultConventions();
        scanner.AddAllTypesOf(typeof(IRequestHandler<,>));
        scanner.AddAllTypesOf(typeof(IAsyncRequestHandler<,>));
        scanner.AddAllTypesOf(typeof(INotificationHandler<>));
        scanner.AddAllTypesOf(typeof(IAsyncNotificationHandler<>));
    });
});

• Otwarte generyczne: tak, wyraźnie
• Wiele otwartych rodzajów ogólnych: tak, wyraźnie
• Kontrawariancja ogólna: tak, domyślnie

Jedność

container.RegisterTypes(AllClasses.FromAssemblies(typeof(Ping).Assembly),
   WithMappings.FromAllInterfaces,
   GetName,
   GetLifetimeManager);

/* later down */

static bool IsNotificationHandler(Type type)
{
    return type.GetInterfaces().Any(x => x.IsGenericType && (x.GetGenericTypeDefinition() == typeof(INotificationHandler<>) || x.GetGenericTypeDefinition() == typeof(IAsyncNotificationHandler<>)));
}

static LifetimeManager GetLifetimeManager(Type type)
{
    return IsNotificationHandler(type) ? new ContainerControlledLifetimeManager() : null;
}

static string GetName(Type type)
{
    return IsNotificationHandler(type) ? string.Format("HandlerFor" + type.Name) : string.Empty;
}

• Otwarte leki generyczne: tak, domyślnie
• Wiele otwartych ogólnych: tak, z wbudowanym rozszerzeniem
• Kontrawariancja ogólna: derp

Windsor

var container = new WindsorContainer();
container.Register(Classes.FromAssemblyContaining<IMediator>().Pick().WithServiceAllInterfaces());
container.Register(Classes.FromAssemblyContaining<Ping>().Pick().WithServiceAllInterfaces());
container.Kernel.AddHandlersFilter(new ContravariantFilter());

• Otwarte leki generyczne: tak, domyślnie
• Wiele otwartych rodzajów ogólnych: tak, domyślnie
• Kontrawariancja ogólna: tak, z wbudowanym rozszerzeniem

W rzeczywistości istnieje mnóstwo frameworków IoC. Wygląda na to, że każdy programista próbuje napisać jeden w pewnym momencie swojej kariery. Może nie po to, by je opublikować, ale po to, aby nauczyć się wewnętrznych mechanizmów.

Osobiście wolę autofac, ponieważ jest dość elastyczny i ma odpowiednią składnię (chociaż naprawdę nie znoszę, że wszystkie metody rejestrowania są metodami rozszerzenia).

Niektóre inne frameworki:

• https://simpleinjector.org/
• http://microioc.codeplex.com/
• http://munq.codeplex.com/
• http://funq.codeplex.com/

Po sprawdzeniu najlepszego porównania, jakie do tej pory znalazłem, jest:

• http://www.sturmnet.org/blog/2010/03/04/poll-ioc-containers-for-net

• http://www.sturmnet.org/blog/2010/03/04/poll-results-ioc-containers-for-net

To była ankieta przeprowadzona w marcu 2010 r.

Jednym z punktów zainteresowania mnie jest to, że ludzie, którzy korzystali ze środowiska DI / IoC i polubili go / nie lubili, wydaje się, że StructureMap wychodzi na wierzch.

Także z ankiety wynika, że Castle.Windsor i StructureMap wydają się być najbardziej uprzywilejowane.

Co ciekawe, Unity i Spring.Net wydają się być popularnymi opcjami, które w większości nie są lubiane. (Rozważałem Unity z lenistwa (i odznaki / wsparcia Microsoft), ale teraz przyjrzę się bliżej Castle Windsor i StructureMap.)

Oczywiście to prawdopodobnie (?) Nie dotyczy Unity 2.0, który został wydany w maju 2010 roku.

Mam nadzieję, że ktoś inny zapewni porównanie oparte na bezpośrednim doświadczeniu.

Zobacz porównanie frameworków net-ioc w kodzie Google, w tym linfu i spring.net, których nie ma na liście podczas pisania tego tekstu.

Pracowałem z spring.net: ma wiele funkcji (aop, biblioteki, docu, ...) i jest z nim wiele doświadczenia w dotnet i java-world. Funkcje są modułowe, więc nie musisz brać wszystkich funkcji. Funkcje te są abstrakcjami typowych problemów, takich jak analiza bazy danych, rejestrowanie analizy. jednak trudno jest wykonać i debugować konfigurację IoC.

Z tego, co przeczytałem do tej pory: Gdybym musiał wybierać dla małego lub średniego projektu, użyłbym ninject, ponieważ konfiguracja ioc jest wykonywana i debuggowana w języku c #. Ale jeszcze z tym nie pracowałem. dla dużego systemu modułowego zostałbym z spring.net z powodu bibliotek abstrakcji.