Question

我需要在两个静态类之间共享一些常用功能：

public static class Class
{
    public static void ClassMethod()
    {
       SharedMethod<object>();
    }


    //ideally a private method
    internal static void SharedMethod<T>()
    {

    }
}

public static class GenericClass<T>
{
    public static void GenericClassMethod()
    {
       SharedMethod<T>();
    }
}

这里有更好的设计吗？ internal是我的最后选择，但实际上方法SharedMethod在这两个类之外没有任何意义。

要求：

我无法将它们合并到一个类中，我需要单独使用它们，一个是通用的而另一个不是。
这些类不一定是严格的静态，但它们不应该是可实例化的或可继承的。
SharedMethod可以属于任何一个类，无所谓。

Answer 1

这种解决方法不符合所有3个要求（这是不可能的imo），但它弥补了我想要的相同功能。

我最终使用了一个单独的课程，正如Marc在评论中所建议的那样。但后来我将通用类嵌套在非泛型类中，以实现通用功能。

public static class Class
{
    public static void ClassMethod()
    {
        SharedMethod<object>();
    }



    static void SharedMethod<T>()
    {
        //----
    }



    public static void GenericClassMethod<T>()
    {
        return GenericClass<T>.SharedMethod();
    }

    static class GenericClass<T> 
    {
        static void SharedMethod()
        {
            //available here since private members of outer class is visible to nested class
            SharedMethod<T>();
        }
    }
}

所以现在，尽管调用必须与我原来在问题中的方式完全不同，但在功能上两者都是相同的。

Answer 2

首先我认为你不能满足3条规则，但后来我想到了反思，我想出了一些有用的东西，但除非你真的没有任何其他东西，否则不应该使用实现你需要的方式

我不推荐使用，但为了好玩，我会发布代码：

public static class ClassA
{
    private static void sharedMethod<T>() { }

    public static void ClassMethod()
    {
        sharedMethod<object>();
    }
}

public static class GenericClass<T>
{
    static MethodInfo sharedMethodInfo;

    static GenericClass()
    {
        MethodInfo mi = typeof(ClassA).GetMethod("sharedMethod", BindingFlags.NonPublic | BindingFlags.Static);
        sharedMethodInfo = mi.MakeGenericMethod(new Type[] { typeof(T) });
    }

    public static void GenericClassMethod()
    {
        sharedMethodInfo.Invoke(null, null);
    }
}

Answer 3

将类声明为密封 - 这样它们就不会被继承。

如果您将权限从私有更改为受保护，那么应用程序中的任何内容都可以看到该方法，但对于尝试使用您的方法的其他应用程序将不可见。

希望这有帮助！

Answer 4

如果可以使用单例模式，则可以有2个类，泛型类继承自标准类。你也可以保留静态方法，它的外观如下：

internal class ClassA
{
    private static ClassA _instance;
    private static ClassA Instance
    {
        get
        {
            if (_instance == null) _instance = new ClassA();
            return _instance;
        }
    }

    protected void sharedMethod<T>() { }

    public static void ClassMethod()
    {
        Instance.sharedMethod<object>();
    }
}

public sealed class GenericClass<T> : ClassA
{
    private static GenericClass<T> _instance;
    private static GenericClass<T> Instance
    {
        get
        {
            if (_instance == null) _instance = new GenericClass<T>();
            return _instance;
        }
    }

    public static void GenericClassMethod()
    {
        Instance.sharedMethod<T>();
    }
}

在两个静态类之间共享通用功能

4 个答案: