如何从一个 class 到另一个 c# 获取泛型类型

Question

Is it possible to pass the generic type from one class to other class generic property.

For example:

Assembly Logger

  namespace Logger
    {
        public class GenericLoger<T>
        {
            T _genericLog;
            LogManager _logManager;
            public GenericLoger(string logName)
            {
                _logManager = new LogManager(logName);

                //Assigning the generic type to Log.GenerciLog, this is how I am 
                  expecting or by some other possible way?.
                Log.GenerciLog = _genericLog;
            }
            public static Write(string description)
            {
                _logManager.write(description);
            }
        }

        public static class Log
        {
            LogManager _logManager;
            static Log()
            {
                _logManager = new LogManager();
            }
            public static Write(string description)
            {
                _logManager.write(description);
            }
            //The generic type supplied in GenericLoger need to pass here,
            //like this or by some other possible way?
            public static T GenerciLog { get; internal set; } 
//T is unrecognized here as type is available in GenericLoger 
//I want to pass here from GenericLoger
        }
   }

Assembly Main Caller of Logger

    using Logger;
    namespace DataProcessor
{
    internal class SpecialLogger
    {
        private static Lazy<GenericLog<SpecialLogger>> _passed;
        public static GenericLog<SpecialLogger> Passed
        {
            get
            {
                if (_passed == null)
                {
                    _passed = new Lazy<GenericLog<SpecialLogger>>(() => new GenericLog<SpecialLogger>("Passed"), true);
                }
                return _passed.Value;
            }
        }

        private static Lazy<GenericLog<SpecialLogger>> _failed;
        public static GenericLog<SpecialLogger> Failed
        {
            get
            {
                if (_failed == null)
                {
                    _failed = new Lazy<GenericLog<SpecialLogger>>(() => new GenericLog<SpecialLogger>("Failed"), true);
                }
                return _failed.Value;
            }
        }

    }

    internal class Processor
    {
        public void ProcessRate()
        {
            var trans = dataManager.GetData();
            //Will write the log in "Log.txt" file
            Log.write(trans.Count + " transaction found");
            foreach (var item in trans)
            {
                try
                {
                    //transaction process code here

                    //This will write the text in "Passed.txt" file. 'Passed' property I want to access like this
                    Log.GenerciLog.Passed.Write(item);
                }
                catch (Exception ex)
                {
                     //This will write the text in "Failed.txt" file. 'Failed' property I want to access like this
                    Log.GenerciLog.Failed.Write(item);
                }
            }

        }

    }

}

Answer 1

NOTE : In .NET you don't have a way for automatic type inference for use case like yours, also there is no automatic type substitution.

Not sure if this is what you are looking for

Your method definition should look like this

public static T GenerciLog<T> { get; internal set; }

and this is how to call it

try
{
    //transaction process code here

    //This will write the text in "Passed.txt" file. 'Passed' method I want to access like this
    Log.GenerciLog<SpecialLogger>.Passed.Write(item);
}
catch (Exception ex)
{
     //This will write the text in "Failed.txt" file. 'Failed' method I want to access like this
    Log.GenerciLog<SpecialLogger>.Failed.Write(item);
}

Answer 2

This is a very simple log class. There is a lot more you could do with this sort of thing. Its all provided by log4net which I'd recommend using rather than trying to write your own logger. But the below is a start of how I'd implement a simple logger. It allows you to log to several different things at once. I appreciate the below doesn't answer exactly what you want but its an indication of how to start and you can adapt it to suit your needs.

public static class Logger
{
    private static List<ILogger> _loggers = new List<ILogger>();
    public static void Log(string message)
    {
        foreach (var logger in _loggers)
            logger.Write(message);
    }
    public static void AddLogger(ILogger logger)
    {
        _loggers.Add(logger);
    }
}

public interface ILogger
{
    void Write(string message);
}

public class SpecialLogger : ILogger
{
    public void Write(string message)
    {
        //special log code here eg
        Console.WriteLine(message);

    }
}

then somewhere do this

Logger.AddLogger(new SpecialLogger());
Logger.Log("A log message");