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

Question

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

Answer 1

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

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

可以调用

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

顺便说一句，您也可以对泛型方法进行非泛型重载。

Answer 2

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

然后从您的非通用版本中调用通用版本。

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 3

在类的定义中不能这样做：

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 4

那么...为什么不使用简单继承呢？喜欢：

class MyGenericClass<T>
{
}

class MyGenericClass : MyGenericClass<int>
{
}

这样你可以写两种方式：

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

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 !