//version1
interface eer
{    
    public abstract void S1<T>(T? t) where T : struct;
    public abstract void S1<T>(T? t) ;   //ok
}

//version2
interface eer
{    
    public abstract void S1<T>(T t) where T : struct;  
    public abstract void S1<T>(T t) ; //error
}

As you can see when I use nullable it is okay to have the 2 methods but when I do not use nullable, it will not compile.

Could you please tell me exactly why this is so with an example?

CodePudding user response：

In version 1 of the interface, you are declaring two methods with the same name, "S1", but with different generic type parameters. The first method, "S1(T? t)" has a generic type parameter T and a nullable type constraint, meaning that T must be a struct and can be assigned a null value. The second method, "S1(T? t)", also has a generic type parameter T but no type constraint, so it can accept any type as an argument, including nullable types.

In version 2 of the interface, you are also declaring two methods with the same name, "S1", but with different generic type parameters. However, in this case, the first method "S1(T t)" has a generic type parameter T and a struct type constraint, which means T must be a struct and cannot be assigned a null value. The second method "S1(T t)" also has a generic type parameter T, but no type constraint. Since the first method is already defining a struct constraint, the second method with the same name and parameter cannot be defined, resulting in a compile-time error.

In general, the reason for this is that the C# compiler does not allow for methods with the same name and the same parameter list to be defined within the same scope if they have different return types or different constraints. This is to avoid confusion and ambiguity when calling the method.

CodePudding user response：

It is because of nullable reference types and how signatures of methods are generated in C#:

1. T?

   • is a value type with where T : struct and
   • a reference type without the where.

2. In C# method signatures

   • include type of the parameter (value, reference, or output)
   • don't include type parameter constraints.

This means that both T versions (S1<T>(T t)) generate the same method signature because the constraint is not part of it.

In C# 7.0 draft specification in 7.6 Signatures and overloading¹ we can read:

7.6 Signatures and overloading

• The signature of a method consists of the name of the method, the number of type parameters, and the type and parameter-passing mode (value, reference, or output) of each of its formal parameters, considered in the order left to right. For these purposes, any type parameter of the method that occurs in the type of a formal parameter is identified not by its name, but by its ordinal position in the type parameter list of the method. The signature of a method specifically does not include the return type, parameter names, type parameter names, type parameter constraints, the params or this parameter modifiers, nor whether parameters are required or optional.
  [emphasis mine]

BTW. A related problem (not just for overloading, but also for overriding) is described in where (generic type constraint) (C# Reference) in the section about overriding:

The addition of nullable reference types introduces a potential ambiguity in the meaning of T? in generic methods. If T is a struct, T? is the same as System.Nullable. However, if T is a reference type, T? means that null is a valid value. The ambiguity arises because overriding methods can't include constraints. The new default constraint resolves this ambiguity. You'll add it when a base class or interface declares two overloads of a method, one that specifies the struct constraint, and one that doesn't have either the struct or class constraint applied:

public abstract class B
{
    public void M<T>(T? item) where T : struct { }
    public abstract void M<T>(T? item);

}

You use the default constraint to specify that your derived class overrides the method without the constraint in your derived class, or explicit interface implementation. It's only valid on methods that override base methods, or explicit interface implementations:

public class D : B
{
    // Without the "default" constraint, the compiler tries to override the first method in B
    public override void M<T>(T? item) where T : default { }
}

¹ - Available also here from https://github.com/dotnet/csharpstandard