Spencer.NET 1.0.0

Spencer.NET

Open Source project of smart IoC Container made by programmer for programmer.

Is made with a view to creating class libraries.

Author

Kacper Faber, Poland

Requires

• NET STANDARD 2.0 or newest

• .NET CORE 2.0 or newest

• .NET FRAMEWORK 4.61 or newest

Versions

• 1.0 (29.04.2020)

Usage

• Installing package
• Adding using statement
• Creating new Container
• Creating new ReadOnlyContainer
• Creating Storage
• Attributes
• Troubleshooting
• Using parametrized constructors
• Factories
• Inject, TryInject, Auto

Installing package

Spencer.NET is avaible on nuget.org.

You can use one of follow commands.

dotnet add package Spencer.NET

Install-Package Spencer.NET

Adding using

Spencer.NET using one statement for every feature.

It is it.

using Spencer.NET;

Create Container

Constructors of both of containers are too long to

writing it by contributor programmer.

You can use tested and safely ContainerFactory class

IContainer container = ContainerFactory.Container();

Create ReadOnlyContainer

Constructors of both of containers are too long to

writing it by contributor programmer.

You can use tested and safely ContainerFactory class

This container cannot be updated in him lifetime

You should provide instance of Storage class

Prefered way is using StorageBuilder

IReadOnlyContainer container = ContainerFactory.ReadOnlyContainer(storage);

Create Storage

ReadOnlyContainer cannot be updated in him lifetime.

To provides static registrations, you have to use instance of Storage class

Prefered way is using StorageBuilder class.

StorageBuilder.Build():IStorage

Returns Storage instance

StorageBuilder.Register<T>():StorageBuilder

Registering generic T as class or interface

StorageBuilder.Register(Type):StorageBuilder

Registering class or interface

StorageBuilder.Register<T>(params object[]):StorageBuilder

Registering generic T as class or interface with

given parameters to constructor

with compatible parameters

StorageBuilder.Register(Type, params object[]):StorageBuilder

Registering class or interface using constructor

with compatible parameters

StorageBuilder.RegisterObject(object):StorageBuilder

Registering class with instance gived in parameter.

Registration type will be taken from unboxed instance.

StorageBuilder.RegisterObject<T>(T):StorageBuilder

Registering class with instance of gived in parameter.

Registration type will be taken from T.

StorageBuilder.RegisterAssembly(Assembly):StorageBuilder

Registering assembly types.

StorageBuilder.RegisterAssembly(AssemblyName):StorageBuilder

Registering assembly types

StorageBuilder.RegisterAssemblies(params Assembly[]):StorageBuilder

Registering assembly types

StorageBuilder.RegisterAssemblies(params AssemblyName[]):StorageBuilder

Registering assembly types

Attributes

• SingleInstance service will using single instance of class

• MultiInstance service will create a new instance for each trying to get

• AutoValue service will be instantiate on registering process

• Exclude (Type) excluding type from registration.

• ServiceConstructor pointing to default constructor for class, if any constructor will be find automatically

• Factory pointing to static method, which will be used to instantiate new instance of class

• FactoryResult (Type) expanding factory method for good type which actually is producing in this method

Troubleshooting

[SingleInstance]
[MultiInstance]
class Test
{
}

// Test will be registered as SingleInstance.

class Test
{
}

// Test will be registered as SingleInstance
// SingleInstance is default

class Test
{
}

// Test will be registered as not AutoValue,
// Class will be instantiate, on first trying to get

[MultiInstance]
class Test
{
}

Test instance = new Test();
IContainer container = ContainerFactory.Container();
container.RegisterObject(instance);

// Test will be registered as MultiInstace
// Given instance will be ever returns using Resolve methods.

class Test
{
    [Factory]
    public static Test FactoryMethod() => new Test();

    [ServiceConstructor]
    public Test()
    {
    }
}

// Factory always be checked first.
// In this situation Test will be instantiate using factory

Parametrized Constructors

Mechanism for finding constructor always will be picking accessible and

with the smallest count of parameters he have, or he could have.

You would use ServiceConstructor attribute?

If you want dynamically choose constructor you would to use,

i'm providing functionality to find constructor by given parameters.

Lets see the sample... :>

class Test
{
    // #1
    public Test(int x) {}
    
    // #2
    public Test(int x, int y) {}

    // #3 
    public Test(string str, bool b) {}
}

// Container.Register<Test>(0);
// Will invoke #1 constructor
// params
// x = 0

// Container.Register<Test>(1, 2);
// Will use #2 constructor
// params
// x = 1,
// y = 2

// Container.Register<Test>(true, "Hello World!");
// Will use #3 constructor
// params 
// str = "Hello World!"
// b = true

Factories

Factories is a static methods generating instance of a class.

They can returns interface, if they will have a FactoryResult(Type) attribute,

which will be pointing to the valid returns type.

They can take dependencies as their parameters

class Test 
{
    Test() {}
        
    [Factory]
    public static Test FactoryMethod() => new Test();
}

interface ITest 
{
}

class Test : ITest
{
    Test() {}
        
    [Factory]
    [FactoryResult(typeof(Test))
    public static ITest FactoryMethod() => new Test();
}

Injections

Spencer.NET want to help you. If you want, you cannot inject everything in constructor.

I am providing attributes Inject, TryInject and Auto.

Inject way is not recommended for good Dependency Injection

• Injections

  • Inject trying to resolve instance from self Container,

  if could not found any matching will throw ResolveException

  • TryInject trying to resolve instance from self Container,

  if could not found any matching set variable to null

• Auto initializing simple types

class OldWay
{
    public IEnumerable<int> Ints { get; set; }
    public IDep Dep { get; set; }
    
    public OldWay(IDep dep)
    {
        Dep = dep;
        Ints = new List<int>();
    }
}

class NewWay
{
    [Auto]
    public IEnumerable<int> Ints { get; set; }

    [Inject]
    public IDep Dep { get; set; } 
}