search
Found 153 packages
System.InversionOfControl.Abstractions.Ninject
This is an implementation of the IoC Abstractions for Ninject. The IoC Abstractions represent an abstraction layer for multiple IoC containers. Using the abstractions, applications can use an inversion of control container for dependency injection, without directly seeing the underlying API. This makes it very easy to switch between different IoC implementations.
v0.1.2
↙ 8.4K / total
IoCAbstractionInversionofControl
Endjin.Core.Composition
Whatever the framework, component composition works the same way: you have interfaces and concrete implementations and you need to map one against the other. The Endjin Composition Framework helps you work smarter, not harder by making component composition simple. This framework supports .NET 4.0, .NET 4.5, WinRT and WP8.
v2.2.0.45
↙ 331.4K / total
endjinDependencyInjectionDIInversionOfControlIoC
System.InversionOfControl.Abstractions.SimpleIoc
This is an implementation of the IoC Abstractions for Simple IoC. The IoC Abstractions represent an abstraction layer for multiple IoC containers. Using the abstractions, applications can use an inversion of control container for dependency injection, without directly seeing the underlying API. This makes it very easy to switch between different IoC implementations.
v0.1.2
↙ 6.4K / total
IoCAbstractionInversionofControl
Castle.EventWiringFacility✓
Castle Windsor event wiring facility provides ability to wire up classes exposing events to classes consuming them.
v4.1.1
↙ 206.6K / total
castlewindsorinversionOfControlDependencyInjectionevent
Endjin.Core.Composition.Web
Whatever the framework, component composition works the same way: you have interfaces and concrete implementations and you need to map one against the other. The Endjin Composition Framework helps you work smarter, not harder by making component composition simple. This framework supports .NET 4.0, .NET 4.5, WinRT and WP8. This package integrates the framework with ASP.NET MVC 4
v2.2.0.45
↙ 200.4K / total
endjinDependencyInjectionDIInversionOfControlIoC
Castle.Windsor.Extensions.Hosting✓
Allows to use Castle Windsor as a container using IServiceProvider
v6.0.0
↙ 172.3K / total
castlewindsorinversionOfControlDependencyInjectionaspnet
RapidField.SolidInstruments.InversionOfControl.Autofac
This library exposes the Autofac implementation of Solid Instrument's inversion of control abstraction.
v1.0.26
↙ 7.2K / total
solid-instrumentsinversion-of-controliocdependency-injectiondi
Applinate.Microservice.InversionOfControl.Microsoft
Want to build software right the first time to boost your teams productivity, avoid code rot, and produce highly scalable products? Applinate is a lightweight framework with conventions for building distributed, maintainable, and scalable software products. https://github.com/TruthShield/Applinate.Microservice.Foundation/ --------------------------------------------------------------------- Building any digital product is expensive, risky, and hard to get right. - Complexity balloons exponentially like a runaway freight train, so the longer your code base is around, the slower you go. Many companies had to rebuild products from scratch (e.g., Apple, Facebook, Twitter, Ebay, and more). - Quality degrades rapidly because your solution is only as good as your weakest link, which means a single change can break your system and put you out of business. - Team efficiency is low, creating a lot of stress and wasting your time and money. Large companies can (sometimes) survive a rebuild, but for most, it's a death march. Want to avoid these typical software product problems? With a well-designed foundation, you can. Applinate is a framework for building top-quality software that's easy to scale, maintain, and change, so you won’t have to scrap everything and rebuild from scratch. Doesn’t it make sense to isolate what you know will change, so you can change parts of your system without throwing out the baby with the bathwater? Applinate guides your team to build sustainable, scalable, and high-quality distributed microservices. You can use Applinate today to extend your project or quickly build something new. - Establish guardrails for building agile software. Everyone knows technology and business move at different rates. Applinate helps you isolate changes between things that change independently so your product can evolve, which significantly extends the life of your code base (and may save your company). - Construct your system on a bedrock of proven architectural patterns. Applinate leverages decades of knowledge, experience, and best practices from seasoned software architects. This way, your teams bypass unnecessary learning curves and mistakes, helping you avoid severe headaches (or worse) down the road. - Boost your teams’ productivity. Applinate gives you tools for encryption, compression, distributed messaging (CQRS/PubSub), caching, logging, and more, so you don’t waste time reinventing the wheel. - Prevent tech, vendor, and implementation lock-in. Applinate gives you a plugin convention to make it easy to build alternative implementations for any aspect of your system, so you don’t get locked into anything that doesn’t work for you. - Stop software rot. Applinate helps you separate your implementation from your interfaces. Your implementation can be (and should be) internal (only accessed through an interface), so you prevent unnecessary coupling, significantly extending the life of your products. With Applinate, you build on top of scalable, flexible, and proven microservice conventions designed to make your life easier. Testing, maintenance, and product evolution are simplified using Applinate. Try building with Applinate today. You'll extend your product's life, prevent expensive rebuilds, and add rocket fuel to your teams productivity.
RapidField.SolidInstruments.InversionOfControl.DotNetNative
This library exposes the native .NET implementation of Solid Instrument's inversion of control abstraction.
v1.0.26
↙ 6.8K / total
solid-instrumentsinversion-of-controliocdependency-injectiondi
pkg
sogeti.pattern.inversionofcontrol.autofac
Allows you to use Autofac together with the inversion of control features in Sogeti.Pattern.
v0.0.3
↙ 6.5K / total
autofacsogeti.patterninversionofcontrol
EyeSoft.ServiceLocator
An inversion control abstraction system.
v3.0.7760.34875
↙ 87.8K / total
CommonServiceLocatorinversionofcontroldependency
Castle.Facilities.AspNet.WebApi✓
Castle Windsor WebApi facility lets you easily add windsor to aspnet webapi apps.
v6.0.0
↙ 113.5K / total
castlewindsorinversionOfControlDependencyInjectionaspnet
pkg
InversionOfControl.Core
Simple Reflection-driven Inversion of Control container.
v1.0.1
↙ 694 / total
BoC
BoC needs some documentation, but contains lots of usefull stuff like -EventAggregator pattern implementation -Inversion of Control wrapper (see other BoC packages like BoC.InversionOfControl.Unity for implementations) -DataContext pattern implementation (see other BoC packages like BoC.Persistence.NHibernate for implementations) -Bootstrapper and Background task pattern implementation -Logging wrapper (see BoC.Logging.log4net for implementation) -Persistence repository and service pattern implementation (see other BoC packages like BoC.Persistence.NHibernate for implementations)
v4.0.7
↙ 96.4K / total
EventAggregatorinversionofcontrollibrary
N17Solutions.Microphobia.ServiceResolution
Long Running Process Execution in Dotnet. Runs long running processes in the background of your application allowing you to fire and forget any long running processes you may need to execute. Helper elements to get Service Resolution and Dependency Injection available.
v4.0.3
↙ 249.6K / total
n17solutionsmicrophobiamicrophobialong
pkg
Jens.InversionOfControl
Simple inversion of control container with simple instance activation mechanic. Always tries to activate the largest constructor possible.
v1.0.0
↙ 747 / total
pkg
InversionOfControl_LJ
Library used to manage the inversion of dependences in an application.
v1.2.1.1
↙ 693 / total
IoC
This is a IoC container based on Dependency Injection. As dependencies are controlled with attributes, you do not need any code to register, lookup, or wire object instances. It is self contained by defining attributes in your classes. Configuration can also be externalized with a declarative XML configuration. On top, there is a continuously growing "Enterprise Features Layer" which offers functionality like asynchronous task scheduling or validation api. See the project web page for an introduction and examples.
v2.2.0.2
↙ 81.0K / total
DIDependencyInjectionIoCInversion
Dynamo.Ioc
Dynamo IoC is a super fast and lightweight IoC Container.
v3.0.2
↙ 64.6K / total
IoCInversionOfControlDependency
Endjin.Core.Composition.WebApi
Whatever the framework, component composition works the same way: you have interfaces and concrete implementations and you need to map one against the other. The Endjin Composition Framework helps you work smarter, not harder by making component composition simple. This framework supports .NET 4.0, .NET 4.5, WinRT and WP8. This package integrates the framework with ASP.NET MVC 4
v2.2.0.45
↙ 43.3K / total
endjinDependencyInjectionDIInversionOfControlIoC