Adding custom Logging to container

[JohnBerg60]

As stated in the documentation, it is a good idea to implement Logging. So I created my own LogFactory and added a custom implementation to get the Logging from the Stylet frame work to:

Stylet.Logging.LogManager.LoggerFactory = name => new StyletLogToMemory(name, Hub.Default);
Stylet.Logging.LogManager.Enabled = true;

Great! Hub.Default is a IPublisher, and publishes LogItems to a View to be displayed.

Next, I set my LogFactory to a LogToMemory:

MyLogManager.LoggerFactory = type => new LogToMemory(type, Hub.Default);

To avoid confusion, and because its short, I Implement ILog in LogToMemory.
Last step is to tell the container, that every time I need a ILog, a instance of LogToMemory has to be created.

The question is, how to do that? For now I've done:

builder.Bind<ILog>().ToFactory<ILog>(c => { return new LogToMemory(typeof(object), Hub.Default); });

but that is obvious not doing the job. To be complete MyLogManager:

public static class LogManager
    {
        static readonly ILog LogToNullInstance = new LogToNull();

        public static Func<Type, ILog> LoggerFactory = type => LogToNullInstance;
    }

[canton7]

I'm a little bit confused as to what your question is I'm afraid.

1. You start off configuring a logger to be used by Stylet, and that appears to be fine?
2. You then configure your own logging infrastructure with ILog and MyLogManager? Fine, I assume your code is using your MyLogManager to get logger instances?
3. Then you start trying to register ILog with the container, and bypass the MyLogManager altogether.

What are you trying to do by registering ILog with the container? Are you trying to inject loggers into other types? If so, why doesn't this registration involve the MyLogManager at all?

I'm also not sure what "but that is obvious not doing the job" means -- why is it obvious that it's not doing a job? What's wrong with it?

Perhaps the problem is that all ILog instances created through the container will have a type parameter of typeof(object)? Stylet's IoC container doesn't let you see what type your instance is being injected into (some other containers support this), so you'll have to create an ILog<T> type, e.g.:

public class SomeViewModel
{
    public SomeViewModel(ILog<SomeViewModel> logger) { ... }
}

You can then bind this to a generic Log<T> class with Bind(typeof(ILog<>)).To(typeof(Log<>)), where Log<T> inherits from Log and passes typeof(T) to its base ctor.

[JohnBerg60]

Thank you so much for your help!
Sorry that my question was unclear.
I forgot to mention that I do not want to take a dependency on Stylet in my domain classes.

As it turns out, I do not need a LogManager at all, and I also ditched the LogToNull.

For future reference, this is how I did it:
Definition:

    public interface ILog
    {      
        public void Info(string format, params object[] args);
        public void Warn(string format, params object[] args);
        public void Error(Exception exception, string message = null);
    }

    public interface ILog<T> : ILog
    {

    }

In the constructor of the implementation:

        public LogToMemory(IPublisher publisher)
        {
            this.publisher = publisher;
            type = typeof(T);
            name = type.FullName;
        }

And finally the binding:

builder.Bind(typeof(ILog<>)).To(typeof(LogToMemory<>));