为什么我不能用T？ 作为 C# 中的泛型参数

Question

I use .NET 5 in .NET Core Console Application. The following code can't be compiled:

public class NullableClass<T?> 
{ 
}

The error is:

Error CS1003 Syntax error, ',' expected.

It doesn't matter whether I use any constraint.

But this code compiles:

[return: MaybeNull]
public static T? Find<T>(IEnumerable<T?> sequence, Func<T?, bool> predicate)
{
    foreach (var element in sequence) {
        if (predicate(element)) return element;
    }
    return default(T?);
}

When I declare Find<T?> I have the same error.
What don't I understand here?

Answer 1

If you want T to be a nullable reference type, you should use a generic constraint for that:

where T : class?
The type argument must be a reference type, either nullable or non-nullable. This constraint applies also to any class, interface, delegate, or array type.

public class NullableClass<T> where T : class?
{ 
    // code here
}

Note the question mark is a part of the constraint - there's also a constraint for class (without the question mark) meaning "reference type", and in c# 8 or higher meaning "non-nullable reference type".

Answer 2

You are confused about where types can be used.

You are not supposed to use/write a type here:

public class NullableClass<   >
                           ^^^

or here:

public static T? Find<   >(IEnumerable<T?> sequence, Func<T?, bool> predicate)
                      ^^^

Syntactically, these places are the type_parameters . You should declare type parameters there, rather than to use an existing type. public class Foo<List<int>> makes no sense, right?

From the language spec, this is the syntax for a class declaration :

class_declaration
    : attributes? class_modifier* 'partial'? 'class' identifier type_parameter_list?
      class_base? type_parameter_constraints_clause* class_body ';'?
    ;

type_parameter_list is:

type_parameter_list
    : '<' type_parameters '>'
    ;

type_parameters
    : attributes? type_parameter
    | type_parameters ',' attributes? type_parameter
    ;

type_parameter
    : identifier
    ;

So really, type parameters are just identifiers, just like variable names in a variable declaration. T? is not an identifier. In a type_parameter_list , you are just declaring what type parameters this class/method will have.

Now let's look at where types are used.

public static T? Find<T>(IEnumerable<T?> sequence, Func<T?, bool> predicate)
              ^^         ^^^^^^^^^^^^^^^           ^^^^^^^^^^^^^^

These are all types, so you can use T? in those places. The method return type is obviously a type, so you can use a type there. The <> I marked above are part of a type, so they are type_argument_list s, not type_parameter_list s. You can use types in type_argument_list s:

type_name
    : namespace_or_type_name
    ;

namespace_or_type_name
    : identifier type_argument_list?
    | namespace_or_type_name '.' identifier type_argument_list?
    | qualified_alias_member
    ;

type_argument_list
    : '<' type_arguments '>'
    ;

type_arguments
    : type_argument (',' type_argument)*
    ;

type_argument
    : type
    ;

---

If you want to allow both nullable and non-nullable reference types to be used as the type argument for the type parameter T , use the class? constraint :

class NullableClass<T> where T: class? { ... }

Answer 3

Upvote Sweeper, if you want to use a nullable type, you don't need to have the ? on the definitions, ie

class Program
{
    static void Main(string[] args)
    {            
        int?[] valueList = new int?[] { 1, null, 3, 4, 5, null };
        int? val = NullableClass<int?>.Find(valueList, new Func<int?, bool>(test));
    }
    public static bool test(int? testMe)
    {
        // Do something productive here
        if (testMe != null && testMe % 2 == 0)
            return true;
        return false;
    }
}

class NullableClass<T> {
    public static T Find<T>(IEnumerable<T> sequence, Func<T, bool> predicate)
    {
        foreach (var element in sequence)
        {
            if (predicate(element)) return element;
        }
        return default(T);
    }
}