Welcome to the Lounge

public interface IArithmetic<T>
{
    T Add(T augend, T addend);
}

public class GenericAdd<T, U> where T : IArithmetic<U>, new()
{
    T adder = new T();

    public U AddGenericTypes(U augend, U addend)
    {
        return adder.Add(augend, addend);
    }
}

public class AddInt : IArithmetic<int>
{
    public AddInt()
    {
    }

    #region IArithmetic<int> Members

    public int Add(int augend, int addend)
    {
        return augend + addend;
    }

    #endregion
}

GenericAdd<AddInt, int> intAdder = new GenericAdd<AddInt, int>();
int result = intAdder.AddGenericTypes(1, 2);

public class MyNumber {
    private object _value;
    public object Value {
        get { return _value; }
        set {
            if ((value is int) || (value is double) || (value is decimal))
                _value = value;
            else throw new InvalidCastException();
        }
    }

    public MyNumber(object val) {
        Value = val;
    }

    public static implicit operator MyNumber(int val) { return new MyNumber(val); }

    public static implicit operator int(MyNumber val) { return (int)val._value; }

    public static implicit operator MyNumber(double val) { return new MyNumber(val); }

    public static implicit operator double(MyNumber val) { return (double)val._value; }

    public static implicit operator MyNumber(decimal val) { return new MyNumber(val); }

    public static implicit operator decimal(MyNumber val) { return (decimal)val._value; }
}

public class MovingAverage {
    private LinkedList<MyNumber> _samples = new LinkedList<MyNumber>();
    private decimal total = 0;
    public int SampleSize { get; private set; }
    public decimal Value {
        get {
            if (SampleSize < 0) return (_samples.Count > 0) ? total / _samples.Count : 0;
            return (_samples.Count >= SampleSize) ? total / (decimal)SampleSize : 0;
        }
    }

    public MovingAverage(int sampleSize = -1) {
        SampleSize = sampleSize;
    }

    public void Add(MyNumber value)
    {
        _samples.AddLast(value);
        total += value;
        if (SampleSize > 0) {
            while (_samples.Count > SampleSize) {
                total -= _samples.First;
                _samples.RemoveFirst();
            }
        }
    }
}

Gary Wheeler wrote:

Everyone has their own workflow that's best for them.

OriginalGriff wrote:

SVN/GIT

public static class GenericOperator<T>
{
    private static Func<T, T, TResult> CreateCore<TResult>(Func<Expression, Expression, BinaryExpression> body)
    {
        try
        {
            Type typeT = typeof(T);
            var left = Expression.Parameter(typeT, "left");
            var right = Expression.Parameter(typeT, "right");
 
            if (typeT.IsEnum)
            {
                Type enumType = Enum.GetUnderlyingType(typeT);
                var x = Expression.Convert(left, enumType);
                var y = Expression.Convert(right, enumType);
 
                Expression op = body(x, y);
                if (op.Type == enumType) op = Expression.Convert(op, typeT);
 
                return Expression.Lambda<Func<T, T, TResult>>(op, left, right).Compile();
            }
 
            return Expression.Lambda<Func<T, T, TResult>>(body(left, right), left, right).Compile();
        }
        catch (InvalidOperationException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
        catch (ArgumentException ex)
        {
            string message = ex.Message;
            return delegate { throw new InvalidOperationException(message); };
        }
    }
 
    private static Lazy<Func<T, T, TResult>> Create<TResult>(Func<Expression, Expression, BinaryExpression> body)
    {
        return new Lazy<Func<T, T, TResult>>(() => CreateCore<TResult>(body), true);
    }
 
    private static readonly Lazy<Func<T, T, T>> _add = Create<T>(Expression.Add);
 
    public static Func<T, T, T> Add
    {
        get { return _add.Value; }
    }
 
    ...
}