C# Generic Constraint Improve Way?

C++ template use constraint by signature,It's very flexible to programmer but complex for complier, and at most time programmer can not get clear error message from complier if error occur. C# generic use constraint by type,complier is relaxed, but it is very limited and even sometime tedious to programmer. Is there a way to get merits of both

(NOTE: I think the all-important purpose of develope tools is to let programmer relax, not the complier !!! Anders Hejlsberg spend so many time add some useless feathers(Except LING) to C# 3.0 to some extent,but he do not spend enough time to improve C#' most basical and important feathers: generic[Constraint, dynamic Constraint, Specilization and so on ] and AOP[G# ], let programmers still in hell...[write and maintance similar code again and again, and sometime, think out many complex architect that is unnecessary in order to use c#'s bad designed generic])
(BUT I'm not Anders Hejlsberg, Even i do not know how to contract with him. BUT hope him can read this thread. and rescue programmers like me.)

Maybe the following way can achieve this purpose :

//First add a keyword "constrant" to define constrant, so the meta data can be treat same as common class.

//For all types
constrant TAll : ISomeInterface,ISomeInterface2,...
{
    //Constructors
    public TClass();
    public TClass(int i);

    //Methods
    public static bool operator ==(TClass t1, TClass t2);
    public static bool operator +(TClass t1, TClass t2);
    public void Method1();
    public void Method2(TClass t, int i);

    //Properties
    public int Property1{get;set;}
    public int this[int i]{get;}
}

//For class
class constrant TClass : ISomeInterface,ISomeInterface2,...
{
    //Constructors
    public TClass();
    public TClass(int i);

    //Methods
    public static bool operator ==(TClass t1, TClass t2);
    public static bool operator +(TClass t1, TClass t2);
    public void Method1();
    public void Method2(TClass t, int i);

    //Properties
    public int Property1{get;set;}
    public int this[int i]{get;}
}

//For struct
struct constrant TStruct: ISomeInterface,ISomeInterface2,...
{
    //Constructors
    public TStruct();
    public TStruct(int i);

    //Static Methods
    public static bool operator ==(TStruct t1, TStruct t2);
    public static bool operator +(TStruct t1, TStruct t2);
    public void Method1();
    public void Method2(TStruct t, int i);

    //Properties
    public int Property1{get;set;}
    public int this[int i]{get;}
}

//GenericClass use TClass,TStruct as normal class,compiler can give clear error message
public class GenericClass<TAll,TClass,TStruct>
    //Note here use constrant class or struct directly
    //"where" statement is not needed now
{
    public void sample()
    {
        //here just treat TAll, TClass,TStruct as normal type, it's simple for compiler.
        TAll all=new TAll(10);

        TClass refObj = new TClass();
        TClass refObj2 = new TClass(1);

TClass refObj3 = refObj + refObj2;

TStruct valueObj = new TStruct(100);
TStruct valueObj2 = new TStruct(10);

        if (valueObj == valueObj2)
        {
            valueObj.Method1();
            valueObj2.Method2();
        }

        int i=refObj3.Property1;
        int j=valueObj2[0];

        //if can support dynamic constrant,that's better, runtime can produce correct il for each type
        #if(typeof(TAll)==typeof(int))
        {
           //do something for int ....
        }
        #else if(typeof(TAll)==typeof(decimal))
        {
           //do something for decimal ....
        }
        #else
        {

        }

    }
}

public class UseGenericClass
{
    public void Test()
    {
        //Compiler will check:
        //RealType includes all signatures of TAll, but do not force RealType inherited from TAll;
        //RealClass is class, includes all signatures of TClass, but do not force RealClass inherited from TClass;
        //RealStruct is Struct, includes all signatures of TStruct
        GenericClass<RealType, RealClass,RealStruct> obj=new GenericClass<RealClass,RealValue>();
    }
}

Answer this question