C#-ში ინდექსები რა არის? რა ტიპის ინდექსები არსებობს და იყენებდით მათ პრაქტიკაში?

ინდექსატორები C#-ში საშუალებას აძლევენ კლასის ან სტრუქტურის მაგალითს მიმართოს მასივის მსგავსად, სინტაქსის [] გამოყენებით. ისინი არ არიან სტატიკური და გადახედავენ [] ოპერატორს.

ინდექსატორები

ინდექსატორები საშუალებას აძლევენ განსაზღვროთ წვდომის ლოგიკა კოლექციის ან მონაცემთა სტრუქტურის ელემენტებზე კლასის შიგნით.

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

    // ინდექსატორი, რომელიც საშუალებას აძლევს მიიღოს ან დაყენოს ელემენტი ინდექსის მიხედვით
    public string this[int index]
    {
        get
        {
            // საზღვრების შემოწმება
            if (index >= 0 && index < data.Length)
            {
                return data[index];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
        set
        {
            // საზღვრების შემოწმება
            if (index >= 0 && index < data.Length)
            {
                data[index] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}

ინდექსატორების პარამეტრების ტიპები

ინდექსატორები შეიძლება მიიღონ ნებისმიერი რაოდენობის პარამეტრები ნებისმიერი ტიპის, არა მხოლოდ მთელი რიცხვების.

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

    // ინდექსატორი string ტიპის პარამეტრით
    public string this[string key]
    {
        get
        {
            if (_dictionary.ContainsKey(key))
            {
                return _dictionary[key];
            }
            else
            {
                return null; // ან გამონაკლისის გამოტანა
            }
        }
        set
        {
            _dictionary[key] = value;
        }
    }
}

ინდექსატორების გადატვირთვა

შეგვიძლია შევქმნათ გადატვირთული ინდექსატორები სხვადასხვა სიგნატურით (პარამეტრების ნაკრებით და ტიპებით).

public class Matrix
{
    private int[,] data;

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

    // ორი მთელი რიცხვის პარამეტრით ინდექსატორი
    public int this[int row, int col]
    {
        get
        {
            // საზღვრების შემოწმება
            if (row >= 0 && row < data.GetLength(0) && col >= 0 && col < data.GetLength(1))
            {
                return data[row, col];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
        set
        {
            // საზღვრების შემოწმება
            if (row >= 0 && row < data.GetLength(0) && col >= 0 && col < data.GetLength(1))
            {
                data[row, col] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}

Range-ები და ინდექსები (Ranges & Indices)

C# 8.0-ში შემოვიდა ახალი ტიპები System.Index და System.Range, რომლებიც საშუალებას აძლევენ გამოიყენოთ სინტაქსი კოლექციის ბოლო ელემენტებზე მიმართვისთვის (^) და სუბ-დიაპაზონის მიღებისთვის (..). ამ გაგებით ისინი ხშირად უწოდებენ "ინდექსებს", მაგრამ განსხვავდებიან კლასიკური ინდექსატორებისგან.

using System;

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

        // System.Index-ის გამოყენება ბოლო ელემენტზე წვდომისთვის
        Index last = ^1; // ბოლო ელემენტის ინდექსი
        Console.WriteLine(words[last]); // dog

        // System.Range-ის გამოყენება სუბ-დიაპაზონის მისაღებად
        Range middle = 1..4; // ელემენტები ინდექსებიდან 1-დან 4-მდე (არ მოიცავს 4-ს)
        string[] subset = words[middle]; // {"quick", "brown", "fox"}

        // Range-ის გამოყენება System.Index-თან ერთად
        Range fromEnd = ^3..; // მესამე ბოლოიდან დაწყებული ბოლომდე
        string[] suffix = words[fromEnd]; // {"the", "lazy", "dog"}
    }
}

პრაქტიკული გამოყენება

მე აქტიურად ვიყენებდი ინდექსატორებს საკუთარი კოლექციის კლასების ან ობგურზების შექმნისას, რათა მონაცემებზე უფრო ინტუიტიური წვდომა უზრუნველყო. მაგალითად:

• მატრიცების ან მრავალმეტრიან მონაცემთა კლასების შექმნა, სადაც წვდომა კოორდინატებით matrix[row, col] ლოგიკურია.
• ობგურზების შექმნა Dictionary<> ან სხვა კოლექციებზე, სადაც გასაღებით წვდომა ინდექსატორით კოდის წაკითხვას ამარტივებს.
• სადაც სჭირდება სინტაქსის სიმარტივე, როგორც მასივში.

Range-ები (System.Index და System.Range) გამოიყენება უფრო მოკლე წვდომისთვის მასივების ან სია-ლისტების ნაწილებზე, რაც განსაკუთრებით სასარგებლოა სუბსტრინგების ან ნაწილობრივი მონაცემების მუშაობისას.