c#代表重构学习

我有一个代码片段，如下所示。如何重构它以使用委托？是否值得重新引用此代码以使用委托？我认为这是一个可以使用代表的场景，这是错误的吗？我正在努力学习学员，并希望看到他们的使用

public class Program
{
    public static void Main(string[] args)
    {             
        var count = Int32.Parse(Console.ReadLine());
        Console.Write("Logger Type -->");
        var logType = Console.ReadLine();

        if (logType == "A")
        {
            if (count > 10)
            {
                LoggerTypeA.Error(count);
            }
            else
            {
                LoggerTypeA.Warning(count);
            }
        }
        else
        {
            if (count > 10)
            {
                LoggerTypeB.Error(count);
            }
            else
            {
                LoggerTypeB.Warning(count);
            }
        }

        Console.ReadLine();

    }
}

internal static class LoggerTypeA
{
    public static void Error(int count)
    {
        Console.WriteLine("Error {0} from Logger A", count);
    }

    public static void Warning(int counter)
    {
        Console.WriteLine("Warning {0} from Logger A", counter);
    }
}

internal static class LoggerTypeB
{
    public static void Error(int count)
    {
        Console.WriteLine("Error {0} from Logger B", count);
    }

    public static void Warning(int counter)
    {
        Console.WriteLine("Warning {0} from Logger ", counter);
    }
}

---

代表在哪里有用的好例子是和。例如，您可以重新实现LINQ的

选择
和
Where
方法，如下所示：

public static IEnumerable<TResult> MySelect<TSource, TResult>
              (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
{
    foreach (var item in source)
        yield return selector(item);
}
public static IEnumerable<T> MyWhere<T>(this IEnumerable<T> source,
                                        Func<T, bool> selector)
{
    foreach (T item in source)
        if (selector(item))
            yield return item;
}

如果您仍然希望能够将记录器用作
静态
方法，则可以使用将其自身暴露为
ILogger
和
静态
方法：

internal class LoggerTypeA : ILogger
{
    public static void Error(int count)
    {
        Console.WriteLine("Error {0} from Logger A", count);
    }
    void ILogger.Error(int count)
    {
        Error(count);
    }

    public static void Warning(int count)
    {
        Console.WriteLine("Warning {0} from Logger A", count);
    }
    void ILogger.Warning(int count)
    {
        Warning(count);
    }
}

例如，这样，前面的代码仍然有效，但您也可以执行
LoggerTypeA.Error（count）

与学员一起完成此操作的方法如下所示。如您所见，与原始方法相比没有太多改进

{
    var count = Int32.Parse(Console.ReadLine());
    Console.Write("Logger Type -->");
    var logType = Console.ReadLine();
    Action<int> logAction;
    if (logType == "A")
    {
        if (count > 10)
        {
            logAction = LoggerTypeA.Error;
        }
        else
        {
            logAction = LoggerTypeA.Warning;
        }
    }
    else
    {
        if (count > 10)
        {
            logAction = LoggerTypeB.Error;
        }
        else
        {
            logAction = LoggerTypeB.Warning;
        }
    }
    logAction(count);

    Console.ReadLine();
}

{
var count=Int32.Parse（Console.ReadLine（））；
写入（“记录器类型-->”；
var logType=Console.ReadLine（）；
行动日志行动；
如果（日志类型=“A”）
{
如果（计数>10）
{
logAction=LoggerTypeA.错误；
}
其他的
{
logAction=LoggerTypeA.警告；
}
}
其他的
{
如果（计数>10）
{
logAction=LoggerTypeB.错误；
}
其他的
{
logAction=LoggerTypeB.警告；
}
}
对数动作（计数）；
Console.ReadLine（）；
}
接口可能比委托更好。这里没有明显的委托需求。关于委托的文章会有一些例子。你能给我一个可以使用委托的简单例子吗？你能提供一个简单的委托例子，一个必须使用委托的场景吗？@user1108205 LINQ和事件处理程序是委托非常有用的两个很好的例子。我在回答的顶部加了一个例子。有关类似问题，请参见。
{
    var count = Int32.Parse(Console.ReadLine());
    Console.Write("Logger Type -->");
    var logType = Console.ReadLine();
    Action<int> logAction;
    if (logType == "A")
    {
        if (count > 10)
        {
            logAction = LoggerTypeA.Error;
        }
        else
        {
            logAction = LoggerTypeA.Warning;
        }
    }
    else
    {
        if (count > 10)
        {
            logAction = LoggerTypeB.Error;
        }
        else
        {
            logAction = LoggerTypeB.Warning;
        }
    }
    logAction(count);

    Console.ReadLine();
}