C#

private int counter;
public int Counter {
    get {
        if (some_error_condition) MessageBox.Show("Can't comply, however the counter's value equals "+Counter);
        return counter;
}

return (TResult)result;

public override TResult Calculate<TResult, TInput> (params TInput[] input) // !! public override double Calculate(params int[] input)
		{
			int[] ints = input as int[];
			double result = 0;
			foreach (int item in ints) {
				result += item;
			}

			return (TResult)result; // !! ErrorMessage: Cannot convert type double to TResult
		}

List<TextBox> textboxes=new List<TextBox>();
List<Control> controls=textboxes;

public TResult Calculate<TResult, TInput>(params TInput[] input) // !! public override double Calculate(params int[] input)
        {
            int[] ints = input as int[];

            double result = 0;

            byte test = 4;

            result = test << 2;

            return (TResult)(object)result; // cast to object then generic no errors and this sample code runs and returns the expected value of 16
        }

public class testtype
{
    //private constructor
    private testtype()
    {
    }

    public Type ValueType { get { return _type; } } //readonly type
    public object Value { get { return _value; } } //readonly value

    private Type _type = typeof(int); //initally object is integer
    private object _value = int.MinValue; //set value to failsafe value

    //convert to testtype
    public static implicit operator testtype(int m)
    {
        testtype t = new testtype();
        t._value = m;
        t._type  = typeof(int);
        return t;
    }

    //convert to int
    public static implicit operator int(testtype m)
    {
        if (typeof(int).Equals(m._type))
            return (int)m._value;

        //failsafe value
        return int.MinValue;
    }
}

testtype v = 1;

double b = v;

public override T Calculate<T, P>(params P[] input) where T : IConvertible where P : IConvertible  // !! public override double Calculate(params int[] input)
{
    TypeCode mode = Type.GetTypeCode(typeof(P));

    switch (mode)
    {
        case TypeCode.Double:
            //do your calculations for double[]

                    //change array to usable format - we know T is double so we can cast them
                    double[] args = (double[])Convert.ChangeType(input, typeof(double[])); 

                    //do some math...
                    double r = 0;
                    //obviously you want to verify 
                    r = args[0] + args[1];

                    return (T)Convert.ChangeType(r, typeof(T));
        case TypeCode.Int32:
            //do your calculations for int32[]

        case TypeCode.Decimal:
            //do your calculations for decimal[]

        default:
            break;
    }

    throw new NotSupportedException("Generic type value [" + typeof(T).ToString() + "] is not supported.");
}

double y = Calculate<int, double>(new double[] { 1.5, 2.25 });

               Console.WriteLine(y.ToString());

               try
               {
                   Calculate<string, string>(new string[] { "no", "gonna error!" });
               }
               catch (NotSupportedException ex)
               {
                   System.Diagnostics.Trace.TraceError(ex.Message);
               }

Quote:

UnitTest.vshost.exe Error: 0 : Generic type value [System.String] is not supported.