Kolekce nebo kontejner je třída nebo abstraktní datový typ obsahující sadu hodnot jednoho nebo různých typů a umožňující přistupování k těmto hodnotám. Kolekce umožňuje zapisovat do sebe hodnoty a získávat je. Cíl kolekce je sloužit jako úložiště objektů a zajišťovat k nim přístup. Obvykle se kolekce používají pro uchovávání skupin objektů stejného typu podléhajících stereotypnímu zpracování. Pro přistupování ke konkrétnímu elementu kolekce mohou používat různé metody v závislosti na její logické organizaci. Implementace může připouštět provedení jednotlivých operací na celé kolekce. Takové operace na celé kolekce mohou v mnoha případech podstatně usnadnit programování.

Pole s pevnou velikostí se obvykle nepovažuje za kolekci, protože uchovává pevné číslo položek, ačkoliv se pole/tabulky běžně používají při implementaci kolekcí. Pole s proměnnou velikostí se obyčejně považují za kolekci.

Kolekce mohou být zkoumány ze třech hledisek:

1. z hlediska přistupování k prvkům kolekce
2. z hlediska uchovávání prvků kolekce
3. z hlediska procházení prvků kolekce

Obvykle kolekce implementuje a může provádět následující operace:

• oznamovat jaký má počet objektů, které v sobě uchovává
• odstraňovat všechny objekty z kolekce
• přidávat nový objekt do kolekce
• odstraňovat objekt z kolekce
• poskytovat přístup k uchovávanému objektu

Většina programovacích jazyků ukládá pole lineárně v paměti . To znamená, že prvky pole jsou uloženy za sebou jeden po druhém v paměti.
Každý prvek v poli má svůj index , který určuje jeho umístění v paměti. Indexování se může lišit v různých jazycích - některé jazyky začínají indexy od 0 (např. C, C++, Python, C#), zatímco jiné mohou začínat od 1 (např. MATLAB).
Každý prvek pole má určitou velikost, která závisí na jeho datovém typu. Například v jazyce C# int zabírá obvykle 4 byty (32 bitů) paměti, zatímco double zabírá 8 bytů (64 bitů).
V některých jazycích jsou pole statické, což znamená, že jejich velikost je určena při kompilaci a nelze ji měnit za běhu programu. V jiných jazycích jsou pole dynamické a mohou se měnit za běhu programu.

Tato pole jsou pole, která mají dvě úrovně indexace. To znamená, že každý prvek v poli je identifikován dvojicí indexů. Lze si představit 2D pole jako matici, kde máte řádky a sloupce.

    
        int[,] twoDArray = new int[3, 3]; // 2D pole s rozměry 3x3

        int[,] pole = new int[,]
        {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
    
    

Tato pole jsou pole, která mají tři úrovně indexace. Každý prvek v poli je identifikován trojicí indexů. Můžete si představit 3D pole jako například kostku, kde máte vrstvy, řádky a sloupce.

    
        int[,,] threeDArray = new int[3, 3, 3]; // 3D pole s rozměry 3x3x3

        int[,,] pole = new int[3, 3, 3] {
            {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
            },
            {
                {10, 11, 12},
                {13, 14, 15},
                {16, 17, 18}
            },
            {
                {19, 20, 21},
                {22, 23, 24},
                {25, 26, 27}
            }
        };
        
    

představuje dynamickou datovou strukturu , která poskytuje flexibilní a efektivní způsob ukládání a manipulace s daty. List je součástí .NET core a je definován v knihovně System.Collections.Generic .
List je generický typ , což znamená, že může obsahovat prvky pouze jednoho určitého datového typu. To zajišťuje typovou bezpečnost a zabraňuje vložení neplatných dat.

Duležité metody:

• Add - přidá prvek na konec Listu
• Remove - odstraní první výskyt zadaného objektu z Listu
• RemoveAt - odstraní prvek na zadaném indexu
• Clear - odstraní všechny prvky z Listu
• Contains - určuje, zda List obsahuje konkrétní prvek
• IndexOf - vrátí index prvního výskytu zadaného objektu v Listu

        // Vytvoření nového Listu pro ukládání celých čísel
        List<int> cisla = new List<int>();

        // Přidání prvků do Listu
        cisla.Add(10);
        cisla.Add(20);
        cisla.Add(30);

        // Vypsání prvků Listu
        foreach (int cislo in cisla)
        {
            Console.WriteLine(cislo);
        }
    

představuje datovou strukturu, která uchovává data ve formě dvojic klíč-hodnota. Tato datová struktura umožňuje rychlý přístup k hodnotám na základě klíče a je optimalizována pro rychlé vyhledávání.
Podobně jako List, Dictionary je také generický typ, což znamená, že může obsahovat prvky pouze jednoho určitého datového typu. To zajišťuje typovou bezpečnost a zabraňuje vložení neplatných dat.

Duležité metody:

• Add - přidá prvek s určeným klíčem a hodnotou do Dictionary
• Remove - odstraní prvek s určeným klíčem z Dictionary
• Clear - odstraní všechny prvky z Dictionary
• ContainsKey - určuje, zda Dictionary obsahuje určitý klíč
• ContainsValue - určuje, zda Dictionary obsahuje určitou hodnotu

        // Vytvoření nového Dictionary pro ukládání jmen a věků
        Dictionary<string, int> lide = new Dictionary<string, int>();

        // Přidání hodnot do Dictionary
        lide.Add("Alice", 30);
        lide.Add("Bob", 25);
        lide.Add("Charlie", 35);

        // Přístup k hodnotám pomocí klíče
        Console.WriteLine("Věk Alice je: " + lide["Alice"]);

        // Vypsání všech klíč-hodnota párů
        foreach (KeyValuePair<string, int> pár in lide)
        {
            Console.WriteLine("Jméno: " + pár.Key + ", Věk: " + pár.Value);
        }
    

Mnoho kolekcí se chovají, jako kdyby uchovávali data do řady uspořádané nějakým způsobem s přístupem k jednomu nebo obou koncům. Skutečná datová struktura implementující takovou kolekci nemusí být lineární. Například prioritní fronta je často implementována jako halda, což je něco jako strom. Lineární kolekcí je:

• Lineární seznam
• Pole
• Zásobník(FILO, LIFO)
• Fronta (FILO, LIFO)
• Prioritní fronta (často implementována jako Halda)