dependency-injection - dependency - inversion of control security



Warum brauche ich einen IoC-Container im Gegensatz zu einem einfachen DI-Code? (20)

Bei der Verwendung eines Containers geht es hauptsächlich darum, von einem imperativen / skriptbasierten Initialisierungs- und Konfigurationsstil zu einem deklarativen zu wechseln. Dies kann einige verschiedene positive Auswirkungen haben:

  • Reduzierung der Startup-Routinen für das Hauptprogramm des Hairballs.
  • Ermöglichung ziemlich neuer Bereitstellungszeit-Rekonfigurationsfähigkeiten.
  • Abhängiger injizierbarer Stil ist der Weg des geringsten Widerstands für neue Arbeit.

Natürlich kann es Schwierigkeiten geben:

  • Code, der ein komplexes Start- / Herunterfahren / Lifecycle-Management erfordert, kann möglicherweise nicht einfach an einen Container angepasst werden.
  • Sie werden wahrscheinlich alle persönlichen, Prozess- und Teamkulturprobleme durchgehen müssen - aber dann haben Sie gefragt ...
  • Einige der Toolkits werden selbst zu einem Schwergewicht, was die tiefe Abhängigkeit, die viele DI-Container auslösten, als Gegenreaktion gegen sie förderte.

https://src-bin.com

Ich verwende Dependency Injection (DI) für eine Weile und injiziere entweder in einem Konstruktor, einer Eigenschaft oder einer Methode. Ich hatte nie das Bedürfnis, einen Inversion of Control (IoC) -Container zu verwenden. Je mehr ich jedoch lese, desto mehr Druck fühle ich von der Gemeinschaft, einen IoC-Container zu benutzen.

Ich habe mit .NET-Containern wie StructureMap , NInject , Unity und Funq gespielt . Ich sehe immer noch nicht, wie ein IoC-Container meinen Code verbessern / verbessern wird.

Ich habe auch Angst, einen Container bei der Arbeit zu benutzen, weil viele meiner Mitarbeiter Code sehen werden, den sie nicht verstehen. Viele von ihnen zögern vielleicht, neue Technologien zu erlernen.

Bitte überzeugen Sie mich, dass ich einen IoC-Container verwenden muss. Ich werde diese Argumente verwenden, wenn ich mit meinen Kollegen bei der Arbeit spreche.


Answer #1

Der größte Vorteil der Verwendung von IoC-Containern für mich (persönlich benutze ich Ninject) war die Beseitigung der Weitergabe von Einstellungen und anderen Arten von globalen Zustandsobjekten.

Ich programmiere nicht für das Web, meins ist eine Konsolenanwendung und an vielen Stellen tief im Objektbaum muss ich Zugriff auf die vom Benutzer angegebenen Einstellungen oder Metadaten haben, die in einem völlig separaten Zweig des Objektbaums erstellt werden. Mit IoC sage ich Ninject einfach, die Einstellungen als Singleton zu behandeln (weil es immer nur eine Instanz von ihnen gibt), die Einstellungen oder das Wörterbuch im Konstruktor anzufordern und presto ... sie erscheinen magisch, wenn ich sie brauche!

Ohne Verwendung eines IoC-Containers müsste ich die Einstellungen und / oder Metadaten durch 2, 3, ..., n Objekte weiterleiten, bevor sie tatsächlich von dem Objekt verwendet wurden, das sie benötigt.

Es gibt viele andere Vorteile für DI / IoC-Container, wie andere Leute hier ausführlich beschrieben haben, und die Idee, Objekte zu erstellen, kann verwirrend sein, aber die Verwendung von DI war sehr hilfreich für mich und mein Team zu deinem Arsenal!


Answer #2

Ich bin bei dir, Vadim. IoC-Container haben ein einfaches, elegantes und nützliches Konzept und machen es zu etwas, das Sie für zwei Tage mit einem 200-seitigen Handbuch lernen müssen.

Ich persönlich bin perplex darüber, wie die IoC-Gemeinschaft einen schönen, eleganten Artikel von Martin Fowler aufgenommen und in einen Haufen komplexer Frameworks verwandelt hat, typischerweise mit Handbüchern mit 200-300 Seiten.

Ich versuche, nicht wertend zu sein (HAHA!), Aber ich denke, dass Leute, die IoC-Container benutzen, (A) sehr intelligent sind und (B) keine Empathie für Menschen haben, die nicht so schlau sind wie sie sind. Alles macht für sie Sinn, daher haben sie Probleme zu verstehen, dass viele gewöhnliche Programmierer die Konzepte verwirrend finden. Es ist der Fluch des Wissens . Die Leute, die IoC-Container verstehen, haben Schwierigkeiten zu glauben, dass es Leute gibt, die es nicht verstehen.

Der größte Vorteil eines IoC-Containers besteht darin, dass Sie an einer Stelle einen Konfigurationsschalter haben, mit dem Sie beispielsweise zwischen dem Testmodus und dem Produktionsmodus wechseln können. Angenommen, Sie haben zwei Versionen Ihrer Datenbankzugriffsklassen ... eine Version, die aggressiv protokollierte und viele Validierungen durchführte, die Sie während der Entwicklung verwendet haben, und eine andere Version ohne Protokollierung oder Validierung, die für die Produktion schreiend schnell war. Es ist schön, zwischen ihnen an einem Ort wechseln zu können. Auf der anderen Seite ist dies ein ziemlich triviales Problem, das auf einfache Weise ohne die Komplexität von IoC-Containern einfach gehandhabt werden kann.

Ich glaube, wenn Sie IoC-Container verwenden, wird Ihr Code, ehrlich gesagt, viel schwerer zu lesen. Die Anzahl der Orte, an denen Sie nachsehen müssen, um herauszufinden, was der Code zu tun versucht, steigt um mindestens eins. Und irgendwo im Himmel schreit ein Engel.


Answer #3

Ich bin ein Fan der deklarativen Programmierung (schau dir an, wie viele SQL-Fragen ich beantworte), aber die IoC-Container, die ich mir angeschaut habe, erscheinen zu geheimnisvoll für ihr eigenes Wohl.

... oder vielleicht sind die Entwickler von IoC-Containern nicht in der Lage, eine klare Dokumentation zu schreiben.

... oder sonst sind beide zu dem einen oder anderen Grad wahr.

Ich glaube nicht, dass das Konzept eines IoC-Containers schlecht ist. Aber die Implementierung muss sowohl leistungsfähig (dh flexibel) sein, um in einer Vielzahl von Anwendungen nützlich zu sein, und dennoch einfach und leicht verständlich zu sein.

Es ist wahrscheinlich sechs von ein und ein halbes Dutzend der anderen. Eine echte Anwendung (kein Spielzeug oder eine Demo) muss komplex sein und viele Eckfälle und Ausnahmen von den Regeln berücksichtigen. Entweder kapseln Sie diese Komplexität in imperativem Code oder in deklarativem Code. Aber du musst es irgendwo darstellen.


Answer #4

Ich denke, der größte Wert eines IoC wird durch die Verwendung von DI erzielt. Da Sie dies bereits tun, ist der weitere Nutzen inkrementell.

Der Wert, den Sie erhalten, hängt von der Art der Anwendung ab, an der Sie arbeiten:

  • Bei mehreren Mandanten kann der IoC-Container einen Teil des Infrastrukturcodes zum Laden verschiedener Client-Ressourcen übernehmen. Wenn Sie eine Komponente benötigen, die clientspezifisch ist, verwenden Sie einen benutzerdefinierten Selektor, um die Logik zu verarbeiten, und machen Sie sich keine Gedanken über Ihren Clientcode. Sie können das natürlich selbst bauen, aber hier ist ein Beispiel, wie ein IoC helfen kann.

  • Mit vielen Punkten der Erweiterbarkeit kann der IoC zum Laden von Komponenten aus der Konfiguration verwendet werden. Dies ist eine gewöhnliche Sache zu bauen, aber Werkzeuge werden vom Behälter zur Verfügung gestellt.

  • Wenn Sie AOP für einige bereichsübergreifende Probleme verwenden möchten, bietet der IoC Hooks zum Abfangen von Methodenaufrufen. Dies wird weniger häufig ad-hoc bei Projekten gemacht, aber der IoC macht es einfacher.

Ich habe bereits Funktionen wie diese geschrieben, aber wenn ich eines dieser Features benötige, würde ich lieber ein vorgefertigtes und getestetes Tool verwenden, wenn es zu meiner Architektur passt.

Wie von anderen erwähnt, können Sie auch zentral konfigurieren, welche Klassen Sie verwenden möchten. Obwohl dies eine gute Sache sein kann, kostet es Irreführung und Komplikationen. Die Kernkomponenten für die meisten Anwendungen werden nicht viel ersetzt, so dass der Kompromiss etwas schwieriger ist.

Ich benutze einen IoC-Container und schätze die Funktionalität, muss aber zugeben, dass mir der Trade-off aufgefallen ist: Mein Code wird auf Klassenebene klarer und auf Anwendungsebene weniger klar (dh Visualisierung des Kontrollflusses).


Answer #5

IoC-Container eignen sich auch zum Laden tief verschachtelter Klassenabhängigkeiten. Zum Beispiel, wenn Sie den folgenden Code mit Dependency Injection hatten.

public void GetPresenter()
{
    var presenter = new CustomerPresenter(new CustomerService(new CustomerRepository(new DB())));
}

class CustomerPresenter
{
    private readonly ICustomerService service;
    public CustomerPresenter(ICustomerService service)
    {
        this.service = service;
    }
}

class CustomerService
{
    private readonly IRespository<Customer> repository;
    public CustomerService(IRespository<Customer> repository)
    {
        this.repository = repository;
    }
}

class CustomerRepository : IRespository<Customer>
{
    private readonly DB db;
    public CustomerRepository(DB db)
    {
        this.db = db;
    }
}

class DB { }

Wenn Sie alle diese Abhängigkeiten in den IoC-Container geladen haben, können Sie den CustomerService auflösen, und alle untergeordneten Abhängigkeiten werden automatisch aufgelöst.

Beispielsweise:

public static IoC
{
   private IUnityContainer _container;
   static IoC()
   {
       InitializeIoC();
   }

   static void InitializeIoC()
   {
      _container = new UnityContainer();
      _container.RegisterType<ICustomerService, CustomerService>();
      _container.RegisterType<IRepository<Customer>, CustomerRepository>();
   }

   static T Resolve<T>()
   {
      return _container.Resolve<T>();
   }
}

public void GetPresenter()
{
   var presenter = IoC.Resolve<CustomerPresenter>();
   // presenter is loaded and all of its nested child dependencies 
   // are automatically injected
   // -
   // Also, note that only the Interfaces need to be registered
   // the concrete types like DB and CustomerPresenter will automatically 
   // resolve.
}

Answer #6

Meiner Meinung nach ist der größte Vorteil eines IoC die Möglichkeit, die Konfiguration Ihrer Abhängigkeiten zu zentralisieren.

Wenn Sie derzeit Dependency-Injektion verwenden, sieht Ihr Code möglicherweise so aus

public class CustomerPresenter
{
  public CustomerPresenter() : this(new CustomerView(), new CustomerService())
  {}

  public CustomerPresenter(ICustomerView view, ICustomerService service)
  {
    // init view/service fields
  }
  // readonly view/service fields
}

Wenn Sie eine statische IoC-Klasse verwenden, im Gegensatz zu den IMHO-Dateien, die verwirrender sind, könnten Sie Folgendes haben:

public class CustomerPresenter
{
  public CustomerPresenter() : this(IoC.Resolve<ICustomerView>(), IoC.Resolve<ICustomerService>())
  {}

  public CustomerPresenter(ICustomerView view, ICustomerService service)
  {
    // init view/service fields
  }
  // readonly view/service fields
}

Dann würde Ihre statische IoC-Klasse wie folgt aussehen: Ich verwende Unity hier.

public static IoC
{
   private static readonly IUnityContainer _container;
   static IoC()
   {
     InitializeIoC();
   }

   static void InitializeIoC()
   {
      _container = new UnityContainer();
      _container.RegisterType<ICustomerView, CustomerView>();
      _container.RegisterType<ICustomerService, CustomerService>();
      // all other RegisterTypes and RegisterInstances can go here in one file.
      // one place to change dependencies is good.
   }
}

Answer #7

Vermutlich zwingt Sie niemand, ein DI-Containerframework zu verwenden. Sie verwenden bereits DI, um Ihre Klassen zu entkoppeln und die Testbarkeit zu verbessern, sodass Sie viele Vorteile erhalten. Kurz gesagt, Sie bevorzugen Einfachheit, was im Allgemeinen eine gute Sache ist.

Wenn Ihr System einen Komplexitätsgrad erreicht, bei dem manuelle DI zu einer lästigen Aufgabe wird (dh die Wartung erhöht), vergleichen Sie dies mit der Team-Lernkurve eines DI-Container-Frameworks.

Wenn Sie mehr Kontrolle über das Management der Abhängigkeitsdauer benötigen (dh wenn Sie das Singleton-Muster implementieren möchten), sehen Sie sich die DI-Container an.

Wenn Sie einen DI-Container verwenden, verwenden Sie nur die Funktionen, die Sie benötigen. Überspringen Sie die XML-Konfigurationsdatei und konfigurieren Sie sie im Code, wenn dies ausreichend ist. Bleiben Sie bei der Konstruktorinjektion. Die Grundlagen von Unity oder StructureMap können auf wenige Seiten reduziert werden.

Es gibt einen tollen Blogbeitrag von Mark Seemann zu diesem Thema: Wann man einen DI-Container benutzt


Answer #8

Here is why. The project is called IOC-with-Ninject. You can download and run it with Visual Studio. This example uses Ninject but ALL the 'new' statements are in one location and you can completely change how your application runs by changing which bind module to use. The example is set up so you can bind to a mocked version of the services or the real version. In small projects that may not matter, but in big projects it's a big deal.

Just to be clear, advantages as I see them: 1) ALL new statements in one location at root of code. 2) Totally re-factor code with one change. 3) Extra points for 'cool factor' 'cause it's... well: cool. :p


Answer #9

As you continue to decouple your classes and invert your dependencies, the classes continue to stay small and the "dependency graph" continues to grow in size. (This isn't bad.) Using basic features of an IoC container makes wiring up all these objects trivial, but doing it manually can get very burdensome. For example, what if I want to create a new instance of "Foo" but it needs a "Bar". And a "Bar" needs an "A", "B", and "C". And each of those need 3 other things, etc etc. (yes, I can't come up with good fake names :) ).

Using an IoC container to build your object graph for you reduces complexity a ton and pushes it out into one-time configuration. I simply say "create me a 'Foo'" and it figures out what's needed to build one.

Some people use the IoC containers for much more infrastructure, which is fine for advanced scenarios but in those cases I agree it can obfuscate and make code hard to read and debug for new devs.


Answer #10

Dittos about Unity. Get too big, and you can hear the creaking in the rafters.

It never surprises me when folks start to spout off about how clean IoC code looks are the same sorts of folks who at one time spoke about how templates in C++ were the elegant way to go back in the 90's, yet nowadays will decry them as arcane. Bah !


Answer #11

Honestly I don't find there to be many cases where IoC containers are needed, and most of the time, they just add unneeded complexity.

If you are using it just for making construction of an object simpler, I'd have to ask, are you instantiating this object in more than one location? Would a singleton not suit your needs? Are you changing the configuration at runtime? (Switching data source types, etc).

If yes, then you might need an IoC container. If not, then you're just moving the initialization away from where the developer can easily see it.

Who said that an interface is better than inheritance anyway? Say you're testing a Service. Why not use constructor DI, and create mocks of the dependencies using inheritance? Most services I use only have a few dependencies. Doing unit testing this way prevents maintaining a ton of useless interfaces and means you don't have to use Resharper to quickly find the declaration of a method.

I believe that for most implementations, saying that IoC Containers remove unneeded code is a myth.

First, there's setting up the container in the first place. Then you still have to define each object that needs to be initialized. So you don't save code in initialization, you move it (unless your object is used more than once. Is it better as a Singleton?). Then, for each object you've initialized in this way, you have to create and maintain an interface.

Anyone have any thoughts on this?


Answer #12

I realize this is a rather old post, but it seems to still be reasonably active, and I thought I'd contribute a couple of points that have not yet been mentioned in other answers.

I will say that I agree with the benefits of dependency injection, but I do prefer to construct and manage the objects myself, using a pattern not unlike that outlined by Maxm007 in his answer. I have found two main problems with using 3rd party containers:

1) Having a 3rd party library manage the lifetime of your objects "automagically" can lend itself to unexpected results. We have found that especially in large projects, you can have vastly more copies of an object than you expect, and more than you would if you were manually managing the lifecycles. I'm sure this varies depending on the framework used, but the problem exists nonetheless. This can also be problematic if your object holds resources, data connections, etc., since the object can sometimes live longer than you expect. So inevitably, IoC containers tend to increase the resource utilization and memory footprint of an application.

2) IoC containers, in my opinion, are a form of "black box programming". I have found that in particular, our less experienced developers tend to abuse them. It allows the programmer to not have to think about how objects should relate to each other or how to decouple them, because it provides them with a mechanism in which they can simply grab any object they want out of thin air. Eg, there may be a good design reason that ObjectA should never know about ObjectB directly, but rather than creating a factory or bridge or service locator, an inexperienced programmer will simply say "no problem, I'll just grab ObjectB from the IoC container". This can actually lead to increased object coupling, which is what IoC is supposed to help prevent.


Answer #13

I will try to find why IOC might not be good for from my perspective.

As with everything else, IOC container (or as Einstein would put it I=OC^2) is a concept you have to decide for yourself if you need it or not in your code. Recent fashion outcry about IOC is only that, fashion. Don't fall for fashion, that is first. There are myriads of concepts out there you could implement in your code. First of all, I am using dependency injection since I have started programming, and learned the term itself when it was popularized under that name. Dependency control is a very old subject and it was addressed so far in trillions of ways, depending on what was decoupling from what. Decoupling everything from everything is a nonsense. The problem with IOC container is that it tries to be as useful as Entity Framework or NHibernate. While writing an object-relational mapper is simply a must as soon as you have to couple any database with your system, IOC container is not always necessary. So when IOC container is useful:

  1. When you have a situation with many dependencies you want to organize
  2. When you do not care about coupling your code with third-party product
  3. When your developers want to learn how to work with a new tool

1: It is not that often that you have so many dependencies in your code, or that you are aware of them early in design. Abstract thinking is useful when abstract thinking is due.

2: Coupling your code with third-party code is a HuGe problem. I was working with code that is 10+ years old and that was following at that time fancy and advanced concepts ATL, COM, COM+ and so on. There is nothing you can do with that code now. What I am saying is that an advanced concept gives an apparent advantage, yet this is cancelled on long run with the outdated advantage itself. It just had made all of it more expensive.

3: Software development is hard enough. You can extend it to unrecognizable levels if you allow some advanced concept to crop into your code. There is a problem with IOC2. Although it is decoupling dependencies, it is decoupling the logic flow as well. Imagine you have found a bug and you need to set a break to examine the situation. IOC2, as any other advanced concept, is making that more difficult. Fixing a bug within a concept is more difficult than fixing a bug in a plainer code, because when you fix a bug a concept must be obeyed again. (Just to give you an example, C++ .NET is constantly changing the syntax so much that you need to think hard before you refactor some older version of .NET.) So what is the problem with IOC? The problem is in resolving dependencies. The logic for resolving is commonly hidden in the IOC2 itself, written maybe in uncommon way that you need to learn and maintain. Will your third-party product be there in 5 years? Microsoft's was not.

"We know how" syndrome is written all over the place regarding IOC2. This is similar to automation testing. Fancy term and perfect solution at first glance, you simply put all your tests to execute over night and see the results in the morning. It is really painful to explain company after company what automated testing really means. Automated testing is definitely not a quick way of reducing the number of bugs which you can introduce overnight to increase the quality of your product. But, fashion is making that notion annoyingly dominant. IOC2 suffers the same syndrome. It is believed that you need to implement it in order your software to be good. EvErY recent interview I was asked if I am implementing IOC2 and automation. That is a sign of fashion: the company had some part of code written in MFC they will not abandon.

You need to learn IOC2 as any other concept in software. The decision if IOC2 needs to be used is within the team and the company. However, at least ALL above arguments must be mentioned before the decision is made. Only if you see that plus side outweighs negative side, you can make a positive decision.

There is nothing wrong with IOC2 except that it does solve only the problems it solves and introduces the problems it introduces. Nothing else. However, going against the fashion is very difficult, they have sweat mouth, the followers of anything. It is strange how none of them is there when the problem with their fanciness becomes apparent. Many concepts in software industry have been defended because they create profit, books are written, conferences held, new products made. That is fashion, usually short lived. As soon as people find something else they abandon it completely. IOC2 is useful but it shows the same signs as many other vanished concepts I have seen. I do not know if it will survive. There is no rule for that. You think if it is useful, it will survive. No, it does not go that way. One big rich company is enough and the concept can die within few weeks. We'll see. NHibernate survived, EF came second. Maybe IOC2 will survive too. Do not forget that most concepts in software development are about nothing special, they are very logical, simple and obvious, and sometimes it is more difficult to remember the current naming convention than to understand the concept itself. Does the knowledge of IOC2 make a developer a better developer? No, because if a developer was not able to come up with a concept similar in nature to IOC2 then it will be difficult for him or her to understand which problem IOC2 is solving, using it will look artificial and he or she may start using it for sake of being some sort of politically correct.



Answer #15

In the .NET world AOP isn't too popular, so for DI a framework is your only real option, whether you write one yourself or use another framework.

If you used AOP you can inject when you compile your application, which is more common in Java.

There are many benefits to DI, such as reduced coupling so unit testing is easier, but how will you implement it? Do you want to use reflection to do it yourself?


Answer #16

So, it's been almost 3 years, eh?

  1. 50% of those who commented in favor of IoC frameworks don't understand the difference between IoC and IoC Frameworks. I doubt they know that you can write code without being deployed to an app server

  2. If we take most popular Java Spring framework, it is IoC configuration moved from XMl into the code and now look like this

`@Configuration public class AppConfig {

public @Bean TransferService transferService() {
    return new TransferServiceImpl(accountRepository());
}

public @Bean AccountRepository accountRepository() {
    return new InMemoryAccountRepository();
}

} ` And we need a framework to do this why exactly?


Answer #17

Whenever you use the "new" keyword, you are creating a concrete class dependency and a little alarm bell should go off in your head. It becomes harder to test this object in isolation. The solution is to program to interfaces and inject the dependency so that the object can be unit tested with anything that implements that interface (eg. mocks).

The trouble is you have to construct objects somewhere. A Factory pattern is one way to shift the coupling out of your POXOs (Plain Old "insert your OO language here" Objects). If you and your co-workers are all writing code like this then an IoC container is the next "Incremental Improvement" you can make to your codebase. It'll shift all that nasty Factory boilerplate code out of your clean objects and business logic. They'll get it and love it. Heck, give a company talk on why you love it and get everyone enthused.

If your co-workers aren't doing DI yet, then I'd suggest you focus on that first. Spread the word on how to write clean code that is easily testable. Clean DI code is the hard part, once you're there, shifting the object wiring logic from Factory classes to an IoC container should be relatively trivial.


Answer #18

You would need an IoC container if you needed to centralize the configuration of your dependencies so that they may be easily swapped out en mass. This makes the most sense in TDD, where many dependencies are swapped out, but where there is little interdependence between the dependencies. This is done at the cost of obfuscating the flow of control of object construction to some degree, so having a well organized and reasonably documented configuration is important. It is also good to have a reason to do this, otherwise, it is mere abstraction gold-plating . I have seen it done so poorly that it was dragged down to being the equivalent to a goto statement for constructors.






ioc-container