C#-ban hogyan tudok egy új szálat indítani, ha a függvényem paramétert vár?

[ClassInterfaceAttribute(ClassInterfaceType.None)]

[ComVisibleAttribute(true)]

public sealed class Thread : CriticalFinalizerObject, _Thread

Remélem, egyikőtöket sem zavar az, hogy a Thread osztály sealed.

"Ha jol ertem akkor az object, az minden tipusu valtozo."

Nem jól érted.

Komolyan 3 év C# programozás után nem sikerült eljutni odáig, hogy konstruktor???

Ezen ne múljon, elmagyarázom neked, hogy miről van szó. De tuti, hogy le leszek pontozva.

Nos, az öröklődéssel két osztály viszonyát írhatod le. Ha egy életszerű példát akarnék venni, akkor ott vannak a vonatok. Van tehervonat és személyvonat. A kétféle vonatnak legalább két közös tulajdonságát csípőből el tudod mondani:

- tud menni valamerre

- és ezt síneken teszi

Mi lenne, ha nem írnánk le ezt a két tulajdonságot a két osztályunkba, hanem bevezetnénk a "vonat" osztályt, kiemelve abba ezeket a közös jellemzőket?

class Vonat {

.. public UtTipus MinKozlekedik {

.. .. get {

.. .. .. return UtTipus.Sin;

.. .. }

.. }

.. public void Megy(int Sebesseg) {}

}

class SzemelyVonat : Vonat {}

class TeherVonat : Vonat {}

Így a személyvonatunk és a tehervonatunk is örökli azokat a nem private tulajdonságokat és viselkedéseket, amit a vonat tud. (Plusz információ: egy assemblyben vagyunk, így internal és protected internal láthatósági módosítókkal is öröklődni fognak.) De ennél még fontosabb, hogy most a személyvonat és a vonat, valamint a tehervonat és a vonat osztályok közt most már felírható egy viszony:

- minden személyvonat vonat is egyben

- minden tehervonat vonat is egyben

(A személyvonat és a tehervonat közt nincs ilyen viszony). És ez a kódban is szépen megjelenik:

Vonat a = new SzemelyVonat();

Vonat b = new TeherVonat();

Magyarul, minden olyan helyen, ahol Vonat típusú kifejezésnek kell állnia, állhat SzemelyVonat vagy TeherVonat típusú kifejezés is, hiszen "egy SzemelyVonat tud minden olyan dolgot, amit egy Vonatnak tudnia kell" - pontosabban azért, mert a SzemelyVonat osztály a Vonat osztály leszármazottja.

Ehhez tartozik még két nagyon fontos definíció, a statikus típus illetve a dinamikus típus. Nagyon egyszerűen fogalmazva, a statikus típus azt jelenti, hogy "milyen típusú a kifejezésed". A dinamikus típus pedig azt, hogy "milyen típusú az az objektum valójában". Ebben a példában:

Vonat a = new SzemelyVonat();

az "a" változó statikus típusa a Vonat, míg dinamikus típusa a SzemelyVonat. Dinamikus típusra mindig "vissza tudsz állni" típuskényszerítéssel vagy az "as" operátorral:

SzemelyVonat x = (SzemelyVonat)a;

SzemelyVonat y = a as SzemelyVonat;

Hogy mi a különbség a típuskényszerítés (cast-olás) és az "as" operátor között, kérded?

Vonat a = new SzemelyVonat();

TeherVonat x = (TeherVonat)a;

TeherVonat y = a as TeherVonat;

Ha megfigyeled, az "a" változó dinamikus típusa SzemelyVonat és nem TeherVonat, így ez a művelet nekünk nem fog sikerülni. A nagy különbség az, hogy

1) a típuskényszerítés során kivétel keletkezik, míg az "as" operátorral az "y" változó értéke "null" lesz, illetve

2) "as" operátort csak reference-type kifejezések esetében használhatsz, value-type értékek esetében nem (mivel null értéke csak reference-type kifejezéseknek lehet).

És akkor eljutottunk a nagy kérdéshez, hogy mégis mi az az Object. C#-ban, Java-ban és sok más objektum-orientált nyelvekben minden egyes osztály az Object osztály leszármazottja, még ha nem is írod oda. Például, ha csinálsz egy Sajt osztályt:

class Sajt {}

Rögtön láthatod, hogy ez egy Object is egyben:

object o = new Sajt();

Ez olyannyira része a nyelvnek, hogy még a struct-ok is, amik value-type-ok (pl. az int, long, bool, ...), azok is az object-ből származnak:

class System.Object -> abstract class System.ValueType -> struct System.Int32

Ebből kifolyólag ilyet is lehet csinálni:

object a = 5;

A ParameterizedThreadStart delegate éppen ezért választotta az object-et, mert így tetszőleges típusú paramétert adhatsz át:

[ComVisibleAttribute(false)]

public delegate void ParameterizedThreadStart(object obj)

Ennek nagy hátránya, hogy valójában sosem lehetsz biztos, hogy azt kapod-e, amit kapnod kellene. Éppen ezért kell ellenőrizni, hogy megfelelő dinamikus típusú értéket kapsz-e.