Saját osztályhoz saját operátor

Legyen a következő a feladat: készítsünk egy olyan osztályt mely rendelkezik két int típusú változóval, melyeket property-ken keresztül érhetünk el. Legyen értelmezhető ehhez az osztályhoz az összeadás művelet, melynek eredményeképpen az egyik osztály két int változóját hozzáadjuk a másik osztály két int változójához.

Az új osztályunk neve Class1 lesz és a Class1.cs állományba kerül.

Osztályon belül tehát deklarálunk két változót a és b névvel.

    private int a;
    private int b;

Meghagyjuk az alapértelmezett konstruktort, mely nem tesz semmit.

    public Class1()
    {
    }

Majd létrehozunk egy új konstruktort, mely rendelkezik két paraméterrel, amivel állítható egy kezdeti érték a két változónk számára.

    public Class1(int aValue, int bValue)
    {
      a=aValue;
      b=bValue;
    }

Létrehozunk két property-t A és B névvel az a és b változónk eléréséhez.

    public int A
    {
      get { return a; }
      set { a = value; }
    }
    public int B
    {
      get { return b;}
      set { b = value; }
    }

Végezetül már csak egy teendőnk marad: létrehozni az összeadás operátort. Egy ilyen operátorra úgy tekinthetünk, mint egy speciális függvényre: ugyanúgy deklaráljuk, paraméterezzük és a kódjában is hasonlóan járunk el, mint egy rendes függvény esetén. Apró különbség, hogy most nem egy függvény nevet kell megadnunk, hanem az operátor kulcsszót, majd ezután a végzendő művelet jelét, mely jelen esetben a + lesz. Mivel egy összeadás során két értékre van szükségünk, melyeket összeadunk, így két paramétere kell hogy legyen. Mivel az a feladat, hogy két osztályt szeretnénk összeadni, nyilvánvaló, hogy e két paraméter típusa, valamint az operátorunk visszatérési értékének típusa egyezzen az osztály típusával.

A kódban egyszerű a helyzetünk: létrehozunk egy új Class1 osztályt, melynél azt a konstruktort használjuk fel, ahol rögtön kezdő értéket is adhatunk a két változónak. Ez a két érték pedig a paraméterként kapott egyik és másik osztály változóinak összege lesz.

    public static Class1 operator +(Class1 arg1, Class1 arg2)
    {
      return (new Class1(arg1.a+arg2.a, arg1.b+arg2.b));
    }  

Térjünk most át a Form1.cs-re és nézzük a felhasználási lehetőségét ennek az osztálynak.

Létrehozunk belőle egy példányt x névvel.

    private void button1_Click(object sender, System.EventArgs e)
    {
      Class1 x = new Class1();
      x.A = 10;
      x.B = 20;

Majd egyet y névvel.

      Class1 y = new Class1(100, 200);

Ezek után egy harmadik, z nevű példánynak úgy adunk értéket, hogy összeadjuk az x és az y osztályt. Ennek eredménye szintén egy Class1 osztály lesz, így z-ben tárolható.

      Class1 z = x + y;

Végül teszt céljából kiírjuk z-nek A és B property-jét, aminek eddig nem adtunk értéket, viszont kapott az összeadás művelet során. Így, ha mindent jól tettünk, akkor z.A egyenlő lesz 110-el, míg z.B 220-al.

      label1.Text = z.A.ToString()+" - "+z.B.ToString();
    }