where scope inside generic class body to define methods/properties only relevant for certain types

[thomhurst]

Currently, if we declare a generic type without a hierarchy constraint, such as a MyList<T>, it can hold anything.

But what if we wanted to create a method only when T is a certain type?

We can't declare two MyList<T> with different constraints, as that'll create a type conflict.

Currently, we have to use extensions methods for this.

What about a where scoped block where we can define instance level methods/properties that are only accessible when that generic constraint is met?

public class MyList<T>
{
    where T : INumber<T>
    {        
        public T GetMedianNumber()
        {
            // Some logic
        }
    }

    where T : string
    {
        public bool IsInAlphabeticalOrder => true; // Some logic
    }
}

And example usage:

var myList = new MyList<string>();

// Valid because T is a string
var isSorted = myList.IsInAlphabeticalOrder;

// Compiler error because T isn't an INumber
var median = myList.GetMedianNumber(); 

[ufcpp]

#662

[FaustVX]

You can use extension methods to achieve that :

public static class Ext
{
  public T GetMedianNumber<T>(this MyList<T> list)
  where T : INumber<T>
  { ... }
  public bool IsInAlphabeticalOrder<T>(this MyList<string> list)
  { ... }
}

Personally, I would like having where block, but only inside code-blocks, not at the type level.

[thomhurst]

Yes however extension methods have an issue where they cannot always infer the generics automatically which makes the code verbose/difficult/confusing.

See here: #8205

If the type itself already has the generic information at the type level, then I wouldn't need to declare any at the method level.

[yaakov-h]

From the notes I've followed I believe you should be able to do this with Extensions as well, e.g.:

public implicit extension Medians<T> for MyList<T> where T : INumber<T>
{
    public T GetMedianNumber() { ... };
}

however if you're hitting type inference barriers I suspect you may continue to hit them no matter what.

[FaustVX]

I think it's preferable to improve on generic inference #6930 than having where block at the type level.
But inside code-block, I'd be really happy to have them :)

[HaloFour]

Generic types in .NET can't conditionally have different members based on the generic type argument.

However, the concept of where within a method could be covered by this: #6308