Dependency.Shelf 2.2.1

Dependency Shelf

Simple static dependency injection, NOT a framework!

Methods

ShelveInstance<T>(T instance)

Attempts to put the instance passed on the shelf, if there is an instance of the same interface already shelved then the new instance is NOT shelved and the existing shelved instance persists. If T is not an interface or abstract; OnlyInterfaceOrAbstractExpectedException will be thrown. If the instance passed is null then; CanNotShelveNullException will be thrown.

IsShelved<T>()

Returns a bool, true if an instance of interface T is shelved, false if there is not.

RetrieveInstance<T>()

Returns the shelved instance of T, if there is not a shelved instance null is returned.

ClearInstance<T>()

Returns a bool, true if there was no instance to remove or the instance was cleared successfully, false if there is an instance but removal failed.

Clear()

Clears all instances, of any type, on the shelf.

ClearExceptions()

Clears all exceptions from the Exceptions Log.

IEnumerable<Exception> ExceptionLog()

Returns all caught exceptions held in the exceptions log.

Example

The following is an example of an injected internal class being used by another class library. The "Shelf" is global within the application domain.

ExampleGateway (Library containing common Interface)

IInjectedDependency.cs

namespace ExampleGateway
{
    public interface IInjectedDependency
    {
        void DoSomething();
    }
}

ExampleUsage (Library with a call to dependency)

ExampleUsingShelf.cs

using ExampleGateway;
using static Dependency.Shelf;
namespace ExampleUsage
{
    public class ExampleUsingShelf
    {
        private static IInjectedDependency InjectedDependency => RetrieveInstance<IInjectedDependency>();
        public static void RunSomeDependentCode()
        {
            InjectedDependency.DoSomething();
        }
    }
}

ShelfExample (Console App)

Program.cs

using ExampleUsage;
using static Dependency.Shelf;
namespace ShelfExample
{
    class Program
    {
        static void Main(string[] args)
        {
            ShelveInstance<IInjectedDependency>(new RuntimeDependency());
            ExampleUsingShelf.RunSomeDependentCode();
        }
    }
}

RuntimeDependency.cs

using System;
namespace ShelfExample
{
    internal class RuntimeDependency : IInjectedDependency
    {
        public void DoSomething() => Console.WriteLine("Done Something!");
    }
}

You can find a better example of usage here on github.

Usage is also featured in this Narcolepsy Pumpkin video (https://youtu.be/Sas78ILNyfU)