Fabrik zum Erstellen von Objekten Nach ein Generischer Typ C#

Ich denke, es ist am besten halten Sie es einfach, vielleicht so etwas wie dieses:

public static class LoggerFactory
{
    static readonly Dictionary<Type, Type> loggers = new Dictionary<Type, Type>();

    public static void AddLoggerProvider<T, TLogger>() where TLogger : ILogger<T>, new()
    {
        loggers.Add(typeof(T), typeof(TLogger));
    }

    public static ILogger<T> CreateLogger<T>()
    {
        //implement some error checking here
        Type tLogger = loggers[typeof(T)];

        ILogger<T> logger = (ILogger<T>) Activator.CreateInstance(tLogger);

        return logger;
    }
}

Rufen Sie einfach die AddLoggerProvider für jeden Typ, den Sie unterstützen möchten, können verlängert werden, zur Laufzeit, sorgt Sie für Sie auf jeden Fall fügen Sie eine Implementierung der Schnittstelle in die Bibliothek, und nicht ein Objekt, ist nicht sehr schnell, weil der Activator, aber einen logger nicht wahrscheinlich ein Engpass sowieso. Hoffe, es sieht okay aus.

Verwendung:

//initialize somewhere
LoggerFactory.AddLoggerProvider<String, StringLogger>();
LoggerFactory.AddLoggerProvider<Exception, ExceptionLogger>();
//etc..

ILogger<string> stringLogger = LoggerFactory.CreateLogger<string>();

Hinweis: jeder ILogger<T> benötigt einen parameterlosen Konstruktor für die Activator, sondern dass auch gewährleistet ist, mit der new() generische Einschränkung in der add-Methode.

Obwohl ich in der Regel empfehlen die Verwendung eines dependency injection-framework, die Sie implementieren können, etwas mit Reflexion, suchen würde, die verfügbaren Typen für das eine, führt die entsprechende ILogger-Schnittstelle.

Ich würde empfehlen, dass Sie sorgfältig überlegen, welche Baugruppen enthalten, die diese logger-Implementierungen, und wie erweiterbar und Kugel-Beweis-Sie wollen die Lösung zu sein. Durchführung Laufzeit Recherchen über die verfügbaren Baugruppen und-Arten ist nicht Billig. Es ist jedoch eine einfache Möglichkeit, um zu ermöglichen, Erweiterbarkeit in dieser Art von design. Sie vermeiden auch das Problem von up-front-Konfiguration erfordert jedoch, dass nur eine einzige konkrete Art implementieren, die eine bestimmte version der ILogger<> interface - ansonsten gibt es eine zweideutige situation, die Sie lösen müssen.

Können Sie ausführen möchten, einige interne caching zu vermeiden, die die Kosten der Durchführung Reflexion bei jedem Aufruf von Create().

Ist hier einige Beispiel-code, den Sie könnte beginnen mit.

using System;
using System.Linq;
using System.Reflection;

public interface ILogger<T> { /*... */}

public class IntLogger : ILogger<int> { }

public class StringLogger : ILogger<string> { }

public class DateTimeLogger : ILogger<DateTime> { }

public class LoggerFactory
{
    public static ILogger<T> Create<T>()
    {
        //look within the current assembly for matching implementation
        //this could be extended to search across all loaded assemblies
        //relatively easily - at the expense of performance
        //also, you probably want to cache these results...
        var loggerType = Assembly.GetExecutingAssembly()
                     .GetTypes()
                     //find implementations of ILogger<T> that match on T
                     .Where(t => typeof(ILogger<T>).IsAssignableFrom(t))
                     //throw an exception if more than one handler found,
                     //could be revised to be more friendly, or make a choice
                     //amongst multiple available options...
                     .Single(); 

        /* if you don't have LINQ, and need C# 2.0 compatibility, you can use this:
        Type loggerType;
        Type[] allTypes = Assembly.GetExecutingAssembly().GetTypes();
        foreach( var type in allTypes )
        {
            if( typeof(ILogger<T>).IsAssignableFrom(type) && loggerType == null )
                loggerType = type;
            else
                throw new ApplicationException( "Multiple types handle ILogger<" + typeof(T).Name + ">" );                   
        }

        */

        MethodInfo ctor = loggerType.GetConstructor( Type.EmptyTypes );
        if (ctor != null)
            return ctor.Invoke( null ) as ILogger<T>;

        //couldn't find an implementation
        throw new ArgumentException(
          "No mplementation of ILogger<{0}>" + typeof( T ) );
    }
}

//some very basic tests to validate the approach...
public static class TypeDispatch
{
    public static void Main( string[] args )
    {
        var intLogger      = LoggerFactory.Create<int>();
        var stringLogger   = LoggerFactory.Create<string>();
        var dateTimeLogger = LoggerFactory.Create<DateTime>();
        //no logger for this type; throws exception...
        var notFoundLogger = LoggerFactory.Create<double>(); 
    }
}

switch-Anweisung vs Wörterbuch - spielt keine Rolle für die perfomance, wie ein Schalter kompiliert in ein Wörterbuch. So wirklich ist es eine Frage der readabilty und Flexibilität. Der Schalter ist einfacher zu Lesen, auf der anderen Seite ein Wörterbuch kann erweitert werden zur Laufzeit.

1) ich bin immer erstaunt über die Komplexität der Menschen in der Protokollierung. Immer scheint wie overkill zu mir. Wenn log4net ist opensource, ich empfehlen, dass Sie gehen sehen, infact, Sie könnte genauso gut verwenden Sie es ...

2) ich Persönlich versuchen zu vermeiden, Typüberprüfung Wann immer möglich - es Niederlagen der Punkt, der Generika. Verwenden Sie einfach die .ToString () - Methode und mit ihm getan werden.