C# keeles on massiivid ja tuple-id (enamikud) olulised andmestruktuurid, mida kasutatakse andmete grupeerimiseks, kuid neil on erinevad eesmärgid ja omadused.

Siin on ülevaade tuginedes allikatele:

1. Massiivid (Arrays)

Massiiv on fikseeritud suurusega kogum elementidest, mis on kõik samast tüübist.

• Viitetüüp: Massiivid on viitetüübid ja pärinevad ühisest baasklassist System.Array.
• Indekseerimine: Massiivid on null-indeksipõhised, mis tähendab, et esimene element on positsioonil 0 ja viimane positsioonil pikkus - 1.
• Staatilisus: Massiivi suurus määratakse selle loomise hetkel ja seda ei saa hiljem muuta. See teeb massiivid mälukasutuse poolest väga tõhusaks ja kiireks.
• Tüübid:
  • Ühemõõtmelised: Tavaline elementide jada.
  • Mitmemõõtmelised: Ristkülikukujuline maatriks-struktuur, kus igal dimensioonil on fikseeritud suurus.
  • Siksak-massiivid (jagged arrays): Massiivide massiiv, kus iga “sisemine” massiiv võib olla erineva pikkusega.
• Millal kasutada: Massiivid on parim valik jõudluskriitilistes rakendustes ja olukordades, kus andmete hulk on ette teada ega muutu.

2. Tuple-id (Tuples)

Tuple on strukturaalne tüüp, mida kasutatakse seotud andmete lühiajaliseks hoidmiseks ilma unikaalset nime loomata.

• Lihtsus: Tuple on üks lihtsamaid tüüpe, mida saab luua seotud andmete rühmitamiseks. See on määratletud liikmete nimede, tüüpide ja järjekorra järgi.
• Piiratud käitumine: Tuple-id on eelkõige väärtuste konteinerid ja neil on väga vähe sisseehitatud käitumist või meetodeid.
• Paindlikkus: Kui rakenduse arenedes selgub, et andmed vajavad keerukamat loogikat (meetodeid), saab tuple-i hõlpsasti teisendada struct-iks või class-iks.
• Millal kasutada: Tuple-id on mugavad siis, kui on vaja meetodist tagastada mitu väärtust või grupeerida andmeid ajutiselt, soovimata luua täiemahulist klassi.

Peamine erinevus: Kui massiiv on loodud hoidma suurt hulka sama tüüpi elemente ja on optimeeritud indekseerimiseks, siis tuple on mõeldud väikese hulga erineva tüübiga seotud andmete koos hoidmiseks.

Näited:

        public static void Run()
        {
            int[] arvud = { 2, 4, 6, 8, 10, 12 };
            Console.WriteLine("Ruudud (for):");
            for (int i = 0; i < arvud.Length; i++)
            {
                Console.WriteLine(arvud[i] + " -> " + (arvud[i] * arvud[i]));
            }
            Console.WriteLine("\nKahekordsed (foreach):");
            foreach (int a in arvud)
            {
                Console.WriteLine(a + " -> " + (a * 2));
            }
            Console.WriteLine("\nJagub 3-ga (while loendus):");
            int nr = 0;
            int loendur = 0;

            while (nr < arvud.Length)
            {
                if (arvud[nr] % 3 == 0)
                {
                    loendur = loendur + 1;
                }
                nr = nr + 1;
            }

            Console.WriteLine("Kogus: " + loendur);
        }

---

public class Juhuslike_arvude_ruudud
    {
       public static int[] JuhuslikeArvudeRuudud(int min, int max)
        {
            Random rnd = new Random();
            int n = rnd.Next(min, max + 1);
            int m = rnd.Next(min, max + 1);
            int alg = Math.Min(n, m);
            int lopp = Math.Max(n, m);
            int[] tulemused = new int[lopp - alg + 1];

            for (int i = 0; i < tulemused.Length; i++)
            {
                  tulemused[i] = (alg + i) * (alg + i);
            }
            Console.WriteLine($"Vahemik: {alg} kuni {lopp}");
            return tulemused;
        }

        public static void Run()
        {
            var results = JuhuslikeArvudeRuudud(1, 10);
            Console.WriteLine("Ruudud:");
            foreach (var r in results)
                Console.WriteLine(r);
        }

public class InimesteTootlus
{
    public Tuple<int, double, Inimene, Inimene> Statistika(List<Inimene> inimesed)
    {
        int sum = 0;
        Inimene vanim = inimesed[0], noorem = inimesed[0];
        foreach (Inimene isik in inimesed)
        {
            sum += isik.Vanus;
            if (isik.Vanus > vanim.Vanus) vanim = isik;
            if (isik.Vanus < noorem.Vanus) noorem = isik;
        }
        return Tuple.Create(sum, (double)sum / inimesed.Count, vanim, noorem);
    }

    public static void Run()
    {
        var inimesed = new List<Inimene>() { new Inimene("Mari", 25), new Inimene("Jaan", 40), new Inimene("Anna", 30) };
        var stat = new InimesteTootlus().Statistika(inimesed);
        Console.WriteLine($"Summa vanustest: {stat.Item1}, Keskmine: {stat.Item2}");
        Console.WriteLine($"Vanim: {stat.Item3.Nimi} ({stat.Item3.Vanus}), Noorem: {stat.Item4.Nimi} ({stat.Item4.Vanus})");
    }

7. Tuple vs Massiiv vs List

kriteerium	Massiiv	List	Tuple
Suurus	fikseeritud	dünaamiline	fikseeritud
Tüübid	üks tüüp	üks tüüp	erinevad tüübid ✅
Nimetatud väljad	❌	❌	✅
Kasuta kui	fikseeritud kogum	muutuv kogum	mitut tüüpi andmed koos