search

microservicecqrstddbddframework

InversionOfControl

Library used to manage the reversal of the dependencies between the interfaces and implemenation of service it the project. It allows you to build a modular and scalable application.

v1.0.1

↙ 2.3K / total

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.

v0.7.0

↙ 4.8K / total

messagingservicebusservicebusnano

NanoMessageBus.Autofac

Additional wireup provider for NanoMessageBus using Autofac.

v2.0.51

↙ 88.9K / total

NET.efilnukefesin.Implementations.DependencyInjection

Implementation of Inversion of Control.

v1.6.4

↙ 17.9K / total

diiocdependencyinjectioninversion

MicroSliver

MicroSliver is a micro, non-bloat, non-intimidating and speedy .NET (ASP.NET, Silverlight, RIA Services, WPF, Forms and Metro!) dependency injection container which has just the essentials. Contains dependency injection support for Metro .NET (WinRT) and extensions for Silverlight & Metro MVVM, RIA Services Domain Services and ASP.NET MVC Controllers. Tired of large dependency injection frameworks that require a significant amount of knowledge in order to understand or build on top of? Look no further...

v2.1.6

↙ 81.0K / total

MugenInjection

A lightweight and very fast managed IoC (Inversion of Control) and DI (Dependency Injection) with support for constructor, property and method call injection. Supports Silverlight 4-5, WinRT, Windows Phone 7.1-8, NET 2-4.5.

v3.5.1

↙ 57.5K / total

MugenInjectioniocdiWinRT

ModuleInject

IoC Framework that provides modules and compiler support

↙ 45.0K / total

HCI.IoC

Inversion of Control symplify using Simple Injector

IoCSimpleInjectorDIdependency

↙ 22.6K / total

InversionOfControl.Core

Simple Reflection-driven Inversion of Control container.

v1.0.1

↙ 694 / total

HaveBox

Among the fastest of IoC containers. Light weight, effective and easy to use. Features: 1 interface to many implementations Auto IEnumerable Auto registration Auto-wiring Config Injection Container configuring through sub-configs Custom lifetime Eager/Lazy Singletons Injection with in-memory assemblies Interception Open generics Supported Frameworks: .Net 3.5 .Net 4.0 .Net 4.5 .Net 4.5 .1 Silverlight 4 Silverlight 5 Windows Phone 7 Windows Phone 8

DependencyInjectionIoCSilverlightWindows

↙ 30.6K / total

Appeaser.Microsoft.DependencyInjection

Appeaser .NET Core DI extension

v1.3.0

↙ 20.9K / total

AppeaserMicrosoft.Extensions.DependencyInjectionDependencyinjectionInversion

Jens.InversionOfControl

Simple inversion of control container with simple instance activation mechanic. Always tries to activate the largest constructor possible.

↙ 747 / total

InversionOfControl_LJ

Library used to manage the inversion of dependences in an application.

v1.2.1.1

↙ 693 / total

LambdaContainer

Lambda Container is a lightweight Inversion of Control (IoC) container suitable for small to medium size .Net solutions.

.NetIOCDependencyInjectionInversion

↙ 12.6K / total

Dynamo.Ioc.Extensions

Dynamo Ioc Extensions provide features like Lambda Registrations and Scoped resolving. It also adds LazyResolve and GetFactory extensions for resolving.

v3.0.1.1

↙ 26.3K / total

IoCContainerInversionOfControl

iocinversionofcontroldependency

Griffin.Container.Mvc3

ASP.NET integration package for Griffin.Container

v1.0.1

↙ 14.9K / total

ModuleInject.Interfaces

All interfaces used by ModuleInject.

↙ 19.1K / total

ModuleInject.Common

Common functionality required by ModuleInject.

↙ 17.2K / total

DIIoCDependencyInjectionInversion

Rayson.DependencyInjection

Useful Types: Container, DefaultContainer, IContainer

v1.0.8

↙ 14.9K / total

IoCSharp

You need to implement the technique of invesion of control in a streamlined and efficient? IoCSharp is what you are looking for! http://www.codeproject.com/Articles/844756/IoCSharp-example-project