Mi az index a C#-ban? Milyen típusú indexek léteznek, és használtad őket gyakorlatban?

A C#-ban az indexelők lehetővé teszik, hogy egy osztály vagy szerkezet példányát tömbként kezeljük a [] szintaxis használatával. Nem statikusak és túlterhelik a [] operátort.

Indexelők

Az indexelők lehetővé teszik, hogy logikát határozzunk meg a kollekció vagy adatszerkezet elemeihez való hozzáféréshez egy osztályon belül.

public class MyCollection
{
    private string[] data = new string[10];

    // Indexelő, amely lehetővé teszi az elem elérését vagy beállítását index szerint
    public string this[int index]
    {
        get
        {
            // Határellenőrzés
            if (index >= 0 && index < data.Length)
            {
                return data[index];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
        set
        {
            // Határellenőrzés
            if (index >= 0 && index < data.Length)
            {
                data[index] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}

Indexelő paraméter típusai

Az indexelők bármennyi paramétert fogadhatnak tetszőleges típusból, nem csak egész szám típusból.

public class DictionaryLike
{
    private Dictionary<string, string> _dictionary = new Dictionary<string, string>();

    // String típusú paraméterrel rendelkező indexelő
    public string this[string key]
    {
        get
        {
            if (_dictionary.ContainsKey(key))
            {
                return _dictionary[key];
            }
            else
            {
                return null; // Vagy kivétel dobása
            }
        }
        set
        {
            _dictionary[key] = value;
        }
    }
}

Indexelők túlterhelése

Különböző szignatúrákkal (paraméterkészletekkel és típusokkal) túlterhelt indexelők hozhatók létre.

public class Matrix
{
    private int[,] data;

    public Matrix(int rows, int cols)
    {
        data = new int[rows, cols];
    }

    // Két egész paraméteres indexelő
    public int this[int row, int col]
    {
        get
        {
            // Határellenőrzés
            if (row >= 0 && row < data.GetLength(0) && col >= 0 && col < data.GetLength(1))
            {
                return data[row, col];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
        set
        {
            // Határellenőrzés
            if (row >= 0 && row < data.GetLength(0) && col >= 0 && col < data.GetLength(1))
            {
                data[row, col] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}

Tartomány indexek (Ranges & Indices)

A C# 8.0-ban bevezették az System.Index és System.Range típusokat, amelyek lehetővé teszik a szintaxis használatát a kollekciók végéről való hozzáféréshez (^) és részkollekciók lekéréséhez (..). Ezeket a fogalmakat gyakran "indexeknek" nevezik, de eltérnek a klasszikus indexelőtől.

using System;

public class ArrayExample
{
    public static void Main(string[] args)
    {
        string[] words = { "the", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog" };

        // System.Index használata a végéről való hozzáféréshez
        Index last = ^1; // az utolsó elem indexe
        Console.WriteLine(words[last]); // dog

        // System.Range használata részkollekció lekéréséhez
        Range middle = 1..4; // az 1-től a 4-ig tartó elemek (4 nem tartozik bele)
        string[] subset = words[middle]; // {"quick", "brown", "fox"}

        // Range System.Index használatával
        Range fromEnd = ^3..; // a harmadik utolsó elemtől a végéig
        string[] suffix = words[fromEnd]; // {"the", "lazy", "dog"}
    }
}

Gyakorlati alkalmazás

Aktívan használtam indexelőket saját kollekciós osztályok vagy meglévő kollekciók feletti burkolatok készítésekor, hogy intuitívabb hozzáférést biztosítsak az adatokhoz. Például:

• Mátrixokat vagy többdimenziós adatokat reprezentáló osztályok fejlesztése, ahol a koordináták szerinti hozzáférés (matrix[row, col]) logikus volt.
• Burkolatok készítése a Dictionary<> vagy más kollekciók felett, ahol a kulcs szerinti hozzáférés az indexelőn keresztül olvashatóbbá tette a kódot.
• Egyszerű kollekciókban, ahol szintaktikus kényelmet jelentett a tömbhöz hasonló hozzáférés.

A tartomány indexeket (System.Index és System.Range) a tömbök vagy listák részeinek rövidebb elérésére használtam, ami különösen hasznos szubrészletek vagy részadatok kezelésénél a kollekcióból.