Welcome to the Lounge

public class MovingAverage
    {
    private List<int> samples = new List<int>();
    private int total = 0;

    public int SampleSize { get; private set; }
    public decimal Value
        {
        get
            {
            return samples.Count == SampleSize? (decimal)total / SampleSize : decimal.MinValue;
            }
        }
    public MovingAverage(int sampleSize = -1)
        {
        SampleSize = sampleSize;
        }
    /// <summary>
    /// Add a new sample to the average
    /// </summary>
    /// <param name="value"></param>
    public void Add(int value)
        {
        if (SampleSize > 0)
            {
            while (samples.Count >= SampleSize)
                {
                int remove = samples[0];
                samples.RemoveAt(0);
                total -= remove;
                }
            }
        samples.Add(value);
        total += value;
        }
    }

static T Add<T>(T a, T b)
{
    if (typeof(T) == typeof(int))
        return (T)(object)((int)(object)a + (int)(object)b);
    else if .. etc
}

OriginalGriff wrote:

I don't fancy doing that in SQL

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);