Inject - .NET dependency injection.

Still under development, first version will be available soon in NuGet. In the mean time, if you would like to try it, feel free to clone the solution and compile it and submit any suggestions you may have. All features mentioned in the README.md are ready to go. Track pending stories here https://trello.com/b/RwsNDyao/inject

Spring-Like dependency injection for .NET Core

.NET library that emulates the Java Spring Frameworks dependency injection behavior using Beans and Component annotations.

Unlike Java Spring, Inject does not require an ApplicationContext or container to initialize the dependency injection, but rather an entry point for the injection to occur.

Creating beans

Inject supports creating beans using Configuration classes like Spring Framework. XML configuration files for beans are not supported at this time.

Configuration classes

Just like in Spring Framework for Java, a configuration class can be created by simply creating a class and adding the Configuration attribute. This will indicate to the Scan process that the class should be loaded to read beans.

E.g.

using System;
using Jucardi.Inject.Attributes;

namespace Company.Product.Configuration
{
    [Configuration]
    public class ServiceConfiguration
    {
        [Bean] // if no name given, the method name will be used for the bean name
        public ISomeService ServiceImpl1()
        {
            return new SomeServiceImpl1();
        }

        [Bean(Name = "ServiceImpl2")]
        public ISomeService SomeMethodName()
        {
            return new SomeServiceImpl2();
        }
    }
}

In the example above, two beans for the ISomeService interface are created, the first one is named after the method name (ServiceImpl1) since no name was specified to the Bean attribute. The second bean however, will be named by the value specified in the Bean annotation (ServiceImpl2)

When injecting the dependencies into another class, to specify which bean to use, simply by adding the Qualifier attribute on the field or parameter, Inject will know which bean to use.

Keep in mind that if multiple beans are available for one type, the Qualifier attribute will be necessary for inject to know which dependency to inject, unless the bean has also the Primary attribute.

E.g.

using System;
using Jucardi.Inject.Attributes;

namespace Company.Product.Configuration
{
    [Configuration]
    public class ServiceConfiguration
    {
        [Bean]
        [Primary] // Indicates this bean will be used if no Qualifier is specified
        public ISomeService ServiceImpl1()
        {
            return new SomeServiceImpl1();
        }

        [Bean(Name = "ServiceImpl2")]
        public ISomeService SomeMethodName()
        {
            return new SomeServiceImpl2();
        }
    }
}

If only one bean exists for a specific type, the Primary attribute is not necessary in the bean definition, nor the Qualifier attribute in the dependency.

Injecting dependencies into bean definitions

Just like in Spring Framework for Java, by creating a method in the configuration class, you may add as parameters as many dependencies as you need, assuming there are beans defined for these dependencies, and Inject will resolve them. You may use the Qualifier annotation for the bean parameters in the bean method if multiple beans of your dependencies.

using System;
using Jucardi.Inject.Attributes;

namespace Company.Product.Configuration
{
    [Configuration]
    public class ServiceConfiguration
    {
        [Bean]
        public ISomeService ServiceImpl1(
                ISomeRepository repository,
                [Qualifier("BeanName")] SomeDependency dependency)
        {
            return new SomeServiceImpl1(repository, dependency);
        }
    }
}

Creating components

Components are simply dependencies that have a single implementation. By adding any of the component stereotype attributes to the target component class (Component, Repository, Service), inject will know how to create a single bean for that class so it becomes available as a dependency for injection

E.g.

using System;
using Jucardi.Inject.Stereotype;

namespace Company.Product.Services
{
    [Service]
    public class MyService
    {
    }
}

This will allow MyService to be injected as a dependency into any class.

Injecting dependencies

Constructor based injection

When injecting components as a dependency, if the component has a Constructor with multiple parameters, inject will try to resolve these dependencies before creating the component instance to be injected. You may use the Qualifier attribute to indicate which bean to inject if multiple beans are available

E.g.

using System;
using Jucardi.Inject.Stereotype;

namespace Company.Product.Services
{
    [Service]
    public class MyService
    {
        private readonly ISomeRepository repository;
        private readonly SomeDependency dependency;

        public MyService(
                ISomeRepository repository,
                [Qualifier("BeanName")]SomeDependency dependency)
        {
            this.repository = repository;
            this.dependency = dependency;
        }
    }
}

If multiple constructors are available for the component, exactly one of them must have the Autowire attribute to indicate to that is the constructor to be used when creating the component instance.

E.g.

using System;
using Jucardi.Inject.Stereotype;

namespace Company.Product.Services
{
    [Service]
    public class MyService
    {
        private ISomeRepository repository;
        private SomeDependency dependency;

        [Autowire]
        public MyService(ISomeRepository repository, SomeDependency dependency)
        {
            this.repository = repository;
            this.dependency = dependency;
        }

        public MyService()
        {

        }
    }
}

If multiple constructors are available and none or multiple constructors are attributed the Autowire attribute, a ComponentLoadException will occur.

Field and Property based injection

A Field or Property injection will happen after the instance of the dependency has been created, inject will do a field assignment or a property setter invoke directly into the bean instance before injecting it as a dependency.

The fields or properties to be injected must be attributed with Autowire. The Qualifier attribute may also be used to specify which bean to use.

using System;
using Jucardi.Inject.Stereotype;

namespace Company.Product.Services
{
    [Service]
    public class MyService
    {
        // Field injection.
        [Autowire]
        private ISomeRepository repository;

        [Autowire]
        [Qualifier(Name = "BeanName")]
        protected SomeDependency Dependency { get; private set; };
    }
}

Constructor injection vs field injection

In most cases it is considered a better practice to do a Constructor injection because it allows the use of the readonly keyword, making the dependency immutable once it has been instantiated.

Loading beans and components into Inject

Scanning specific assemblies

In the start point of the application, by invoking the Scan method of ApplicationContext specifying the assembly start pattern to scan, Inject will filter all loaded assemblies into the current domain by the given pattern and scan for dependencies any assembly that matches the given pattern.

class Program
{
    static void Main(string[] args)
    {
        ApplicationContext.Default.Scan("Company.Product");
    }
}

In this example, all assemblies that start with Company.Product will be scanned for dependencies.

E.g. The following assemblies will be scanned if loaded into the domain.

• Company.Product.Common
• Company.Product.SomeFeature
• Company.Product.SomeOtherFeature

But other assemblies will be ignored.

Scanning all loaded assemblies.

Although it is not recommended due to performance and security, Inject also supports scanning all assemblies loaded into the current domain by not passing the assembly name pattern into the Scan method.

class Program
{
    static void Main(string[] args)
    {
        ApplicationContext.Default.Scan();
    }
}