Überladungsdifferenz für C # -Postfix und Präfix-Inkrement / -Dekrement

Laut den meisten Quellen führt das Überladen von ++ und - Operatoren in c # dazu, dass sowohl Postfix als auch Präfix gleichzeitig überladen werden. Aber es sieht so aus, als ob ihr Verhalten immer noch anders ist.

class Counter
{
    public Counter(int v = 0)
    {
        this.v = v;
    }
    public Counter(Counter c)
    {
        v = c.v;
    }
    public int GetValue() { return v; }
    public static Counter operator ++(Counter c)
    {
        c.v++;
        return new Counter(c);
    }
    private int v;
}


class Program
{
    public static void Main()
    {
        Counter c1 = new Counter(1);

        Counter c2 = c1++;

        Counter c3 = ++c1;

        c3++;

        System.Console.WriteLine("c1 = {0}", c1.GetValue());
        System.Console.WriteLine("c2 = {0}", c2.GetValue());
        System.Console.WriteLine("c3 = {0}", c3.GetValue());
    }
}

Wunderbar, obwohl überladenoperator ++ Gibt in diesem Beispiel eine Kopie der ursprünglichen Klasse zurückc1 undc3 wird zu Referenzen auf dasselbe Objekt, währendc2 verweist auf einen anderen (c1=4, c2=2, c3=4 Hier). ÄndernCounter c3 = ++c1; zuCounter c3 = c1++; Ausgängec1=3, c2=2, c3=4.

Worin besteht also der genaue Unterschied zwischen Postfix- und Präfix-Inkrement / -Dekrement und wie wirkt sich dies auf das Überladen aus? Handelt es sich bei diesen Operatoren um Klassen und primitive Typen?