Hogyan tudom egy létező Arraylist-net egy objectjét átírni? C#

TL;DR

A kérdésedre az indexer property a válasz. Használd úgy a listát, mint egy tömböt:

ArrayList list = new ArrayList();

list.Add(5);

list[0] = 6;

Nagyon kérlek, hogyha nem .NET 1.0, 1.1 vagy .NET Micro Framework-re fejlesztesz, felejtsd el a System.Collections.ArrayList-et és használd helyette a System.Collections.Generic.List<T>-t. A mostani megoldás, amit használsz, nagyon nem hatékony amiatt, hogy az elemeket System.Object referenciákként tárolja. Ezért két ponton is teljesítménycsökkenés lép fel:

1) Amikor beleteszel egy elemet, az implicit cast-olódik System.Object típusú referenciává.

2) Amikor kiveszel belőle egy elemet, explicit cast-olnod kell arra a típusra, amiként használni akarod.

A cast-olás pedig egy igen költséges művelet. Ha szeretnéd, kipróbálhatod egy System.Diagnostics.Stopwatch példánnyal lemérve az időt, amíg a kódod fut. Továbbá, van egy harmadik nagy hibája is. Mégpedig az, hogy kvázi bármilyen adattípust bele tudsz pakolni, mivel a .NET-ben minden osztály a System.Object-ből származik le.

ArrayList list = new ArrayList();

list.Add("Ez egy teszt szöveg");

list.Add(5);

Ha ennek a listának az elemeit akarod feldolgozni naiv módszerrel, feltételezvén, hogy a listád csak int-eket tartalmaz, simán bajba kerülsz:

foreach (object current in list) {

.. int num = (int)current; //erre hibát fogsz kapni

}

Szóval ellenőrizgetned kell a típusát, ami szintén egy költséges művelet:

foreach (object current in list) {

.. if (current is int) {

.. .. int num = (int)current; //"as" operátor value-type esetében nem használható, muszáj explicit cast-ot használni

.. }

}

Ezzel szemben a System.Collections.Generic.List<T> megakadályoz téged ilyen ámokfutásokban, biztonságosabb kódot írhatsz, ami nem mellesleg sokkal hatékonyabb is.

List<int> numbers = new List<int>();

numbers.Add(5);

numbers.Add("Sanyi"); //ez az utasítás le sem fog fordulni, hiába próbálkozol meg vele

Óh igen, a .NET-es doksikban az indexer property mindig egy Item nevű property-ként van feltüntetve, ezért nem találtad:

[link]

Minden adatszerkezetnek megvan a maga szerepe, és hogy milyen helyzetekben melyiket érdemes használni.

A tömböt már ismered. Ez az a jószág, amit így hozol létre:

int[] tomb = new int[3]; //a tömb méretét mondod meg - mindhárom eleme az int típus alapértelmezett értéke, azaz 0 lesz

int[] tomb = new int[] { 1, 2, 3 }; //a tömb elemeit adod meg - ebben az esetben a fordító az alapján állapítja meg a tömb méretét, hogy hány elemet tettél itt bele

A lényege az, hogy a létrehozásakor valamilyen úton-módon rendelkezel arról, hogy hány elemű legyen a tömböd, de innentől kezdve se törölni, se hozzáadni nem tudsz a tömbhöz. Csak módosítani. Vagyis előre tudnod kell, hogy hány elemet akarsz bele pakolni. És egy pro tip: ha kell neked egy nulla elemű tömb, akkor ne csinálj újat, hanem csak kérj egy meglévőt:

int[] ures = new int[0]; //helyett:

int[] ures = Array.Empty<int>();

Szóval olyan esetekben, amikor kellene neked valami bővíthető (mert nem tudod előre, hogy hány elemet akarsz benne tárolni), vagy ha törölni szeretnél belőle, akkor a lista lesz a nyerő:

List<int> lista = new List<int>(); //csinálunk egy üres listát

List<int> lista = new List<int>() { 1, 2, 3 }; //ezt nevezzük Collection Initializer-nek - így tudsz bele tenni néhány elemet gyorsan a létrehozása után

List<int> lista = new List<int>(new int[] {1, 2, 3}); //lehetőséged van arra is, hogy egy meglévő kollekciót, ami ugyanolyan típusú elemeket tartalmaz, átmásold egy listába

lista.Add(3); //így tudsz hozzáadni egy új elemet

lista.Remove(3); //így tudsz kitörölni egy értéket belőle - figyelj arra, hogy ez nem a harmadik elemet törli, hanem a listában található legelső 3-mas értéket

lista.RemoveAt(0); //ezzel pedig ki tudod törölni a 0. indexű elemet.

Előfordulhat az, hogy kell valami, ami hasonlóan működik, mint a lista, de minden értéket csak egyszer tárol. Erre jó a halmaz:

HashSet<int> halmaz = new HashSet<int>();

halmaz.Add(1);

halmaz.Add(1);

halmaz.Add(2);

foreach (int num in halmaz) Console.WriteLine(num); //a kimenet: 1(újsor)2(újsor)

Van még két adatszerkezet, amik érdekesek lehetnek még, ezek közül az egyik a verem (stack) - ez úgy működik, mint egy gödör. Dobálhatod bele a dolgokat, ameddig jól esik, de csak azt tudod kiszedni először, amit legutoljára beletettél (ezt hívják LIFO [last-in, first-out] adatszerkezetnek):

Stack<int> verem = new Stack<int>();

verem.Push(5);

verem.Push(3);

int elem = verem.Pop(); //a verem tetejéről kikerül a hármas szám és tárolódik a változódban

A másik a sor (queue) - ha beraksz valamit, az a sor végére kerül, de kivenni a sor elejéről tudsz (ezt nevezzük FIFO adatszerkezetnek [first-in, first-out]):

Queue<int> sor = new Queue<int>();

sor.Enqueue(5);

sor.Enqueue(3);

int elem = sor.Dequeue(); //a sor elejéről kikerül az 5-ös szám és tárolódik a változódban

Előfordulhat olyan eset, amikor egy általad meghatározott kulcshoz egy általad meghatározott értéket akarsz rendelni - mint egy szótárban. Erre jó a Dictionary:

Dictionary<string, string> En2HuDict= new Dictionary<string, string>() {

.. ["apple"] = "alma",

.. ["horse"] = "ló"

};

Ha kíváncsi vagy az "apple" jelentésére:

Console.WriteLine(En2HuDict["apple"]);

Arra kell odafigyelni, hogy egy kulcshoz csak egy érték tartozhat, nem adhatsz hozzá kétszer ugyanazzal a kulccsal elemet:

En2HuDict.Add("corn", "kukorica");

En2HuDict.Add("corn", "tengeri"); //hibát fogsz kapni, hogy "corn" kulccsal már van érték a Dictionary-ben.

Ezért lesz jó barátod a ContainsKey metódus.

Hasonlóan a Dictionary-t elő lehet venni, ha azt akarod mondjuk tárolni, hogy egy adott nevű ember mikor született, stb.

Vannak még különféle fák, gráfok, ezekbe most nem mennék bele. Így is hosszú lett ez a rövid bemutató.