C# - Inkrementera variable varje gång .Add() körs på lista

Kan du inte bara modifiera listan via andra funktioner (som dessutom håller reda på summan och liknande)?

Jag är lite av en nybörjare när det gäller c# men har mer erfarenhet i c++ och jag tänkte mig något åt det här hållet:
(Har som sagt inte så bra koll på c# så jag kanske tänkt/skrivit fel)

public class IntList : List<int>
{
    private int sum;

    public IntList()
        : base()
    {
        sum = 0;
    }

    public IntList(IEnumerable<int> collection)
        : base(collection)
    {
        sum = 0;
        foreach (int number in collection)
        {
            sum += number;
        }
    }

    public IntList(int capacity)
        : base(capacity)
    {
        sum = 0;
    }

    public override void Add(int number)
    {
        base.Add(number);
        sum += number;
    }

    public int Sum
    {
        get
        {
            return sum;
        }
    }
}

Någon anledning till att du inte vill använda list.Count ?:P

Tänkte vara med och leka och då bidra med något som inte redan nämns.

public class SumCollection : ObservableCollection<int>
{
            public int Sum { get; private set; }

            protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
            {
                CalculateSum();
                base.OnCollectionChanged(e);
            }

            private void CalculateSum()
            {
                Sum = this.Sum();
            }
}

Lite mer generisk:

public class SumCollection<T> : ObservableCollection<T>
{
            public T Sum { get; private set; }

            protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
            {
                CalculateSum();
                base.OnCollectionChanged(e);
            }

            private void CalculateSum()
            {
                if (this.Count == 0)
                {
                    Sum = default(T);
                    return;
                }

                dynamic dynamicSum = this[0];
                for (int i = 1; i < this.Count; i++)
                {
                    dynamicSum += this[i];
                }

                Sum = dynamicSum;
            }
}

Tack för kommentarer och bättre lösning, som sagt nybörjare än så länge. Så då lärde man sig något nyttigt idag också

Undvik dynamic, den är slö och anses ofta som bad practice, den kan med fördel användas från Enhetstester etc, men undvik i produktionskod. Man kan även använa den istället för reflection där det behövs

edit: Och den tar bort tanken bakom generiska klasser

I min kod skulle dock kunna klassas som ett fall där det behövs. Alternativet hade varit att hantera 10 olika sätt att overloada Sum. Dock hanterar detta inte alla fall.

problemet är att du inte längre är generisk, denna rad kan crashar vid runtime om du valt fel T
dynamicSum += this[i];

Jag skulle iallafall sätta nån form av contranst på genericen så att det inte kan runtime crasha, det hade varit nice om det fanns en contraint för operatorer typ

where T : Operator+

Alla värdetyper inkl iof även guid (som inte går att addera) implementerar IConvertable, den skulle iallafall minimera runtime crasher om du sätter den som constraint

Detta löser ju dock inte problemet, om du har en egen klass som implementerar + operatorn. Sen ser jag inte det som direkt farligt att den carshar runtime, för detta är runtime i utvecklingsmiljön och tester skall se till att detta aldrig sker i produktion.

Närmsta man kan komma är att skapa ett eget interface i still med IAddOperator som är tomt, och sedan kräva att de som använder sig av min kod, implementerar IAddOperator.