如何调用运行时选择的几个静态类之一的方法？

问题描述

我正在使用几个类来提供服务，例如有一个用于FTP的类，另一个用于HTTP的类，它们都实现相同的方法，但是针对协议进行了定制：

public static class FtpProvider { public static string GetString () { return "1"; } }
public static class HttpProvider { public static string GetString () { return "2"; } }

我需要一个简单的服务选择器，以切换提供服务的静态类。我使用Type变量来保存当前提供程序，例如

Type _type = (condition) ? typeof (FtpProvider) : typeof (HttpProvider);

然后使用反射调用所选类的方法。整个代码：

class Program {
    static void Main () {
        Type _type = (new Random ().NextDouble () > .5) ? typeof (FtpProvider) : typeof (HttpProvider);
        string _methodName = nameof (FtpProvider.GetString);
        MethodInfo _method = _type.getmethod (
            _methodName,BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
        object _result = _method.Invoke (null,null);
        Console.WriteLine (_result.ToString ()); Console.ReadKey ();
    }
}
public static class FtpProvider { public static string GetString () { return "1"; } }
public static class HttpProvider { public static string GetString () { return "2"; } }

这确实有效，但是考虑到仅替换currentProvider.GetString ()之类的调用，这确实是在运行时切换静态类型的丑陋代码。所以我想知道：

如果有更好的设计来切换静态类提供程序。
如果可以接受，可以简化代码吗？

更新：

我尝试了带接口的单例模式，但是静态方法无法实现该接口，并且实例创建对我来说似乎太多了，因为服务是无状态的。我也尝试了抽象基类，但是构造函数必须在每个派生类中。
如果静态方法有问题，请说明原因（我知道它确实不是面向对象的。）

解决方法

静态类型不支持继承或Liskov替换。他们不是故意的。这就是为什么您的代码如此混乱的原因-您正在做的事情很奇怪。如果您想使其变得简单，则应该将这些提供程序实现为具有公共接口的常规实例类。

话虽这么说，如果您绝对不能使用静态类，那么简化此操作的一种方法是使用提供程序映射。

var map = new Dictionary<string,Func<string>>
{
    { "HTTP",HttpProvider.GetString },{ "FTP",FtpProvider.GetString }
};

有了地图，剩下的就很容易了：

var protocol = (new Random().NextDouble() > .5) ? "FTP" : "HTTP";
var result = map[protocol]();
Console.WriteLine(result); 
Console.ReadKey();

这是一个使用Singleton模式而不是static类的示例，以及一个实现所需内容的接口。无需反射。您可以从静态CurrentProvider属性访问“提供者”（也可以根据自己的喜好更改访问权限）。

希望您的提供程序类重叠得足够多，以至于您想要使用它们的通用接口。然后，您的应用程序的其余部分不必知道提供程序的实际类型是什么；它们只是与界面交互。

注意，我已经为单例private设置了默认构造函数，因此，获取此类的实例的唯一方法是调用静态Instance属性。因此，它们的行为类似于静态类。（如果您确实不希望人们在静态Instance属性之外构造它们，则可以考虑标记这些sealed。）

您仍然可以通过切换Condition变量来切换提供程序。我建议不要将其设置为bool，但最好将其设置为enum，尽管您可以稍后修改条件的工作方式。

using System;

namespace SomeNamespace
{
    public class Program
    {
        static void Main()
        {
            Condition = new Random().NextDouble() > .5;
            Console.WriteLine(CurrentProvider.GetString()); Console.ReadKey();
        }

        static bool Condition;
        static IProvider CurrentProvider => Condition ? FtpProvider.Instance as IProvider : HttpProvider.Instance as IProvider;
    }

    // interface allows for multiple provider types
    public interface IProvider
    {
        string GetString();
    }
    public class FtpProvider : IProvider
    {
        // use Lazy<T> to implement Singleton pattern
        private static readonly Lazy<FtpProvider> lazy = new Lazy<FtpProvider>(() => new FtpProvider());
        public static FtpProvider Instance
        {
            get
            {
                return lazy.Value;
            }
        }
        // don't allow normal construction of this class
        // force everyone to use Instance
        private FtpProvider() { }

        public string GetString() => "1"; 
    }
    public class HttpProvider : IProvider
    {
        // use Lazy<T> to implement Singleton pattern
        private static readonly Lazy<HttpProvider> lazy = new Lazy<HttpProvider>(() => new HttpProvider());
        public static HttpProvider Instance
        {
            get
            {
                return lazy.Value;
            }
        }
        // don't allow normal construction of this class
        // force everyone to use Instance
        private HttpProvider() { }

        public string GetString() => "2";
    }
}

c#c#reflection static-methods