Dependency injection with a static logger, static helper class

Question

I have a static class which calls a static Logger class,

e.g

static class DoesStuffStatic
{
  public static void DoStuff()
  {
    try
    {
      //something
    }
    catch(Exception e)
    {
      //do stuff; 
      Logger.Log(e);
    }
  }
}

static class Logger
{
  public static void Log(Exception e)
  {
     //do stuff here
  }
}

How do I inject the Logger into my static class?

Note: I've read Dependency Injection in .NET with examples?, but this seems to use an instance logger.

score 42 · Answer 1 · answered Aug 20 '12 at 20:47

This is not necessarily so. As long as your static logger exposes a method for:

Injection of the classes you WANT injected, or
Injection of the DI Container in an appropriate method call prior to running it (say in something like the asp.net global.asax Application_Start method), then you should be fine.

Here's an example. Take the following class for DI:

 public class Logger : ILogger
    {
        public void Log(string stringToLog)
        {
           Console.WriteLine(stringToLog);
        }
    }

    public interface ILogger
    {
        void Log(string stringToLog);
    }

And here's our static class which needs a logger:

public static class SomeStaticClass
    {
        private static IKernel _diContainer;
        private static ILogger _logger;

        public static void Init(IKernel dIcontainer)
        {
            _diContainer = dIcontainer;
            _logger = _diContainer.Get<ILogger>();
        }


        public static void Log(string stringToLog)
        {
            _logger.Log(stringToLog);
        }


    }

Now, in a global startup for your app (in this case, in my global.asax.cs), you can instantiate your DI Container, then hand that off to your static class.

public class Global : Ninject.Web.NinjectHttpApplication
    {

        protected override IKernel CreateKernel()
        {
            return Container;
        }


        static IKernel Container
        {
            get
            {
                var standardKernel = new StandardKernel();
                standardKernel.Bind<ILogger>().To<Logger>();
                return standardKernel;
            }

        }

        void Application_Start(object sender, EventArgs e)
        {
            SomeStaticClass.Init(Container);
            SomeStaticClass.Log("Dependency Injection with Statics is totally possible");

        }

And presto! You are now up and running with DI in your static classes.

Hope that helps someone. I am re-working an application which uses a LOT of static classes, and we've been using this successfully for a while now.

Looks to me more like dependency resolution than dependency injection. The static class now have knowledge of the dependency framework. But it would not be hard to adapt it to avoid it. (Resolve in application_start and initialize with resolved dependencies, rather than supplying the resolver in initialization.) — Frédéric, Sep 02 '14 at 15:52
The question is about injecting a static class into a static class. This deals with how to inject a non-static instance into a static class. This looks like a response to the following statement in the previous answer: " Also it is fairly hard to inject anything to a static class " — Andy Thomas, May 11 '15 at 15:25
This seems overly complex for something as simple as a logger. — rollsch, Apr 30 '17 at 03:34

score 38 · Accepted Answer · answered Aug 18 '09 at 12:23

38

You can't inject a static logger. You have to either change it to an instance logger (if you can), or wrap it in an instance logger (that will call the static). Also it is fairly hard to inject anything to a static class (because you don't control the static constructor in any way) - that's why I tend to pass all the objects I want to inject as parameters.

answered Aug 18 '09 at 12:23

Grzenio

35,875
47
158
240

For what it's worth, I just want to say that you can use the static constructor, you just don't have the ability to pass it any constructor parameters as this is strictly prohibited. – dyslexicanaboko Sep 06 '19 at 03:02

score 1 · Answer 3 · answered Apr 30 '17 at 03:38

This is a very simple way to "inject" the functionality of a static logger.

public static class Logger
{
    private static Action<string, Exception> _logError;
    public static bool Initialised;

    public static void InitLogger(Action<string, Exception, bool> logError)
    {
        if(logError == null) return;
        _logError = logError
        Initialised = true;
    }

    public static void LogError(string msg, Exception e = null)
    {
        if (_logError != null)
        {
            try
            {
                _logError.Invoke(msg, e);
            }
            catch (Exception){}
        }
        else
        {
            Debug.WriteLine($"LogError() Msg: {msg} Exception: {e}");
        }
    }
}

public class MainViewModel
{
    public MainViewModel()
    {
        //Inject the logger so we can call it globally from anywhere in the project
        Logger.InitLogger(LogError);
    }
    public void LogError(string msg, Exception e = null)
    {
        //Implementation of logger
    }
}

score 0 · Answer 4 · answered Dec 08 '16 at 13:35

I'm not sure how Logger works, but generally you can use RequestService to get your instance. For example in abstract class:

this.HttpContext.RequestServices.GetService(typeof(YOUR_SERVICE));

It is possible for controller, where you can access to HttpContext.

The second way is use it for example in Startup, where you can do this:

serviceCollection.AddScoped(typeof(ICmsDataContext), typeof(TDbContext));

where serviceCollection is IServiceCollection in dotnet Core.

Hope it helped.

Dependency injection with a static logger, static helper class

4 Answers4

Linked

Related