作为通用值的结构数组

Question

I am trying to use an array of structs as a generic parameter as follows:

new Test<S[,]>()

This is easy, except for my class needs to create an instance of T as follows:

T s = new T();

This is giving me various compile-time errors. I have tried a few ways of getting around these errors, but without success.

Here is some sample code to illustrate the errors and what I have tried:

class Program
{
    static void Main(string[] args)
    {
        var t1 = new Test<S[,]>();

        // ERROR: 'Program.S[*,*]' must be a non-abstract type
        // with a public parameterless constructor in order to
        // use it as parameter 'T' in the generic type or method
        // 'Program.Test2<T>'
        var t2 = new Test2<S[,]>();

        // ERROR: 'Program.S[*,*]' must be a non-nullable value
        // type in order to use it as parameter 'T' in the generic
        // type or method 'Program.Test3<T>'
        var t3 = new Test3<S[,]>();

        // ERROR: 'Program.S[*,*]' must be a non-nullable value
        // type in order to use it as parameter 'T' in the generic
        // type or method 'Program.Test3<T>'
        var t4 = new Test4<S[,]>();
    }

    struct S
    {
    }

    class Test<T>
    {
        // ERROR: Cannot create an instance of the variable type 'T'
        // because it does not have the new() constraint
        T s = new T();
    }

    class Test2<T> where T: new()
    {
        T s = new T();
    }

    class Test3<T> where T: struct
    {
        T s = new T();
    }

    // ERROR: The 'new()' constraint cannot be used with the 'struct' constraint
    class Test4<T> where T : struct, new()
    {
        T s = new T();
    }
}

Is there a simple way around this issue?

Answer 1

Your error gives you the answer. new() constraint can not be used for structure(both new() and struct constraint can not be used together). So unless it is imperative to have S as structure, I would change S to class and get rid of problem. But you must have S as structure then workaround I suggest is to create a wraper class.

public class Wraper
{
    Wrapper(){}
    Wrapper(S value){
        this.Value = value;
    }

    public S Value {get; set;}

    public static implicit operator S(Wrapper wrapper){
        return wrapper. Value;
    }

    public static implicit operator Wraper(S s){
        return new Wrapper(S);
    }
}

Now you can define your Test as the following:

class Test<T> where T : Wrapper, new()
{
    T value;

    //as you have provided implicit conversion from S to Wrapper and vice versa
    //something like this should work
    public S Value{
        get{ 
            //implicit conversion from Wrapper to S;
            return this.Value;
        }

        set{
            //implicit conversion from S to Wrapper
            this.value = value;
        }
    }
}