C#

jrahma wrote:

Why the App.Config is usually copied in the application folder in Program Files? any technical reason?

 

Is it advisable to move it to the AppData folder?

Bastard Programmer from Hell

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.