如何为泛型提供默认类型？

Question

我有一个类，当前有几个采用整数参数的方法。 这些整数映射到应用程序可以执行的操作。 我想让该类变得通用，以便该类的使用者可以提供他们拥有的枚举类型以及其中的所有操作，然后这些方法将采用该枚举类型的参数。 但是，我希望他们能够根本不指定泛型类型，并将其默认返回整数，而当前方式的语法没有变化。 这可能吗？

Answer 1

那么...为什么不使用简单继承呢？ 就像：

class MyGenericClass<T>
{
}

class MyGenericClass : MyGenericClass<int>
{
}

这样你就可以两种方式写：

var X = new MyGenericClass<string>();
var Y = new MyGenericClass(); // Is now MyGenericClass<int>

Answer 2

你不能在类的定义中做到这一点：

var foo = new MyGenericClass(); // defaults to integer... this doesn't work
var bar = new MyGenericClass<MyEnum>(); // T is a MyEnum

如果真的重视默认类型 int 的隐式性，你将不得不使用静态工厂方法来做到这一点，尽管我没有看到它的价值。

public class MyGenericClass<T>
{
    public static MyGenericClass<T> Create()
    {
        return new MyGenericClass<T>();
    }
    public static MyGenericClass<int> CreateDefault()
    {
        return new MyGenericClass<int>();
    }
}

请参阅下文，了解您如何真正没有从上述内容中受益。

var foo = MyGenericClass<MyEnum>.Create();
var bar1 = MyGenericClass.CreateDefault(); // doesn't work
var bar2 = MyGenericClass<int>.CreateDefault(); // works, but what's the point

如果你想更进一步，你可以创建一个静态工厂类来解决这个问题，但如果你这样做只是为了提供默认类型，那么这是一个更荒谬的解决方案：

public static class MyGenericClassFactory
{
    public static MyGenericClass<T> Create<T>()
    {
        return new MyGenericClass<T>();
    }
    public static MyGenericClass<int> Create()
    {
        return new MyGenericClass<int>();
    }
}

var foo = MyGenericClassFactory.Create(); // now we have an int definition
var bar = MyGenericClassFactory.Create<MyEnum>();

Answer 3

保留您的原始版本（非通用版本）并创建它的通用版本。

然后从非通用版本调用通用版本。

void Main()
{
    DoSomething(2);
    DoSomething(EnumValue);
}
    
public void DoSomething(int test) {
    DoSomething<int>(test);
}
    
// Define other methods and classes here
public void DoSomething<T>(T test) {
    Console.WriteLine(test);
}

Answer 4

大多数时候，编译器可以根据传递的参数类型来推断方法上的参数类型：

public void DoSomething<T>(T test) {
}

可以使用 调用

DoSomething(4);                   // = DoSomething<int>(4);
DoSomething(MyEnum.SomeValue);    // = DoSomething<MyEnum>(MyEnum.SomeValue);

顺便说一句，您也可以拥有泛型方法的非泛型重载。

Answer 5

我确信您已经离开了这个，但是我正在解决类似的问题，并发现这个解决方案使用了我不熟悉的“使用”上下文。 他们需要将其放在自己的命名空间中，因此它并不完全完美。

namespace mygeneric
{
    public class SecurityContext<T>
    {

    }
}

namespace mytest
{
    using SecurityContext = mygeneric.SecurityContext<int>;
    using mygeneric;

    enum MyContexts
    {
        User,
        Admin
    }
    class MyTest
    {
        SecurityContext myDefaultContext;
        SecurityContext<MyContexts> mySpecialContext;
    }
}

Answer 6

编译器大多数时候可以根据传递的参数类型推断字段上的类型参数：

import lombok.Data;

@Data
public class MyClass<T> {

    private T myField;
}

可以用作，

MyClass myClass = new MyClass();
String abc = "hello world !";
myClass.setMyField(abc);
System.out.println("test generic class with generic field = " + myGenericClass.getMyField());

并且应该导致，

test generic class with generic field = hello world !