Add a concept of 'static interface' for use with generics by Lucas C1

Lucas

thanks for your suggestion. A number of other people have suggested variations of this theme.

We are actively looking at revising this aspect of generic constraints, but it probably won't be in the upcoming release. Sorry.

Santosh

Has there been any movement on supporting static interface members for the exact scenario Lucas posted? Its been almost 4 years since this was posted as a suggestion and then marked as Postponed. This would be extremely useful for certain factory scenarios.

I'm just downloading Visual Studio 2010 CTP to check if something has changed in this subject.
I just want to add another benefits aside from those pointed by Lucas and Ahimoth:
- (at last) testability of static methods: we can create mock types and pass it to generic methods
- with this mechanism we can replace Dependency Injection (with all its advantages) in a much "cleaner" way - of course when there is no need to evaluate the type on runtime

Please Microsoft, add this feature to C#(and CLR) 4.0

Adding the ability for generic constraints to define static methods (and operators) would bring generics up to par with c++ template methods while remaining type safe and easy to understand.

This would also allow for another oft asked for INumeric addition to the framework, which would allow format independent maths. For example if I write a Vector4 class in C++ I can have a Vector4<float> a Vector4<int>, or in a bad case any other class that defines + - * and / even if its not really a number. In C# we have to choose a format (normally float or double) and stick with it, adding INumeric (or SNumeric, see later) and static methods on generic constraints would allow C# to define Vector4<float>, Vector4<int> or any other numeric type.

A solution to this would be to have interfaces stay how they are now. And add a new static interface (Prefixed with S instead of I). Static interfaces could only be inherited from and used on generic constraints. A static interface could only define constructors and static methods/operators.

public static interface SExample
{
    SExample(string value);
    
    static int StaticMethod(int a, int b);
    
    static SExample operator + (SExample left, SExample right);
    
    static implicit operator double(SExample value);
    static explicit operator SExample(double value);
}

When you override the static interfaces all occurrences of the static interface name are overwritten with your type name.

public class Example : SExample
{
    public Example(string value) { ...stuff... }
    
    public static int StaticMethod(int a, int b) { ...stuff... }
    
    public static Example operator + (Example left, Example right) { ...stuff... }
    
    public static implicit operator double(Example value) { ...stuff... }
    public static explicit operator Example(double value) { ...stuff... }
}

You can then use Example with any generic method/type that is constrained to SExample. As its only used as a constraint no virtual lookup needs to be done as the type will be know at compile time.

Is this possible? It would really make generic so much more powerfull.

normal interfaces. Class that inherit from the interface have to define those constructors and methods, replacing the interface type with their type (like my last post). However the constructors and static methods can only be looked up on a generic type constrained to that interface, but not to an instance of the interface (say passed to a method).

So this would be legal as all the methods could be looked up at compile time

T Method<T>(T value) where T : IInterfaceWithStaticMethodsAndConstructors
{
    T otherValue = new T(5.0); //Look up the type T and find its constructor that matches the interface constructor
    return T.StaticMethod(value, otherValue); //Loop up type T and find the static method that matches the interface static method
}

While this would be illegal as it would require a virtual lookup of a static method (not really possible)

IInterfaceWithStaticMethodsAndConstructors Method(IInterfaceWithStaticMethodsAndConstructors value)
{
    IInterfaceWithStaticMethodsAndConstructors otherValue = new IInterfaceWithStaticMethodsAndConstructors(5.0); //What type should be created?
    return IInterfaceWithStaticMethodsAndConstructors.StaticMethod(value, otherValue); //What static method should be called?
}

Can we please get some feedback on this issue?

Whenever you add this feature to .Net Framework. I request interface INumber and attach to all numeric type too.

Also I think you should allow interface constructor and replace it with where T : new().
Or at least. please make new(Can contain user-defined parameter)

It'll make our generic life easier.

What would be even better is if they had number classes like Haskel.
A base interface called INumber, and then derived interfaces IReal(or IFloating) and IIntegral.