• C# - ogólnie o języku
• C# - środowisko programistyczne
• C# - struktura programu
• C# - podstawowa składnia
• C# - typy danych
• C# - konwersja typów
• C# - zmienne
• C# - stałe i literały
• C# - operatory
• C# - instrukcje warunkowe
• C# - pętle
• C# - hermetyzacja
• C# - metody
• C# - typy puste
• C# - tablice
• C# - typy łańcuchowe
• C# - struktury
• C# - typy wyliczeniowe
• C# - klasy
• C# - dziedziczenie
• C# - polimorfizm
• C# - interfejsy
• C# - przestrzenie nazw
• C# - dyrektywy preprocesora
• C# - wyrażenia regularne
• C# - obsługa wyjątków
• C# - odczyt i zapis plików
• C# - następne kroki

Tablice przechowują określoną z góry ilość danych tego samego typu. Wspomniane kolekcje danych, znajdują się w sąsiadujących komórkach pamięci.

Zamiast deklarować kolejne zmienne, tj. zmienna_0, zmienna_1, zmienna_2, …, zmienna_99 deklarujemy zmienną tablicową, np. liczby a następnie używamy liczby[0], liczby[1], …, liczby[99] do reprezentacji kolejnych, indywidualnych wartości. Wskazany element tablicy dostępny jest przez prefiks, jakim jest index.

Wszystkie tablice składają się z sąsiadujących komórek pamięci. Najniższy adres odpowiada pierwszemu elementowi, podczas gdy najwyższy adres to element ostatni.

Deklaracja tablic

typ_danych[] nazwa_tablicy;

gdzie:

• typ_danych jest używany do określenia typu elementów przechowywanych w tablicy;
• [] definiuje rozmiar tablicy;
• nazwa_tablicy definiuje nazwę naszej tablicy.

Przykład:

double[] podatek;

Inicjowanie tablic

Deklarowanie tablicy nie wpływa na zapisanie jej w pamięci. Gdy zmienna tablicowa jest inicjowana, możesz przypisać do niej wartości.

Tablica jest typem referencyjnym, dlatego trzeba używać słowa kluczowego new aby utworzyć nową instancję tablicy.
Przykład:

double[] podatek = new double[10];

Przypisywanie wartości do tablic

Wartość może zostać przypisana do indywidualnego element tablicy poprzez użycie jej indeksu:

double[] podatek = new double[10];
podatek[0] = 3750.24;

Wartości można przypisać do tablicy w momencie deklaracji:

double[] podatek = {2340.32, 456.56, 345.12};

Można również utworzyć oraz zainicjować tablicę:

int[] oceny = new int[5] {1, 2, 3, 4, 5};

Można pominać rozmiar tablicy podczas deklaracji:

int[] oceny = new int[] {1, 2, 3, 4, 5};

Można również dokonać kopii tablicy do innej tablicy. W takim przypadku, obie tablice wskazują do tego samego miejsca w pamięci:

int[] oceny = new int[] {1, 2, 3, 4, 5};
int[] punkty = oceny;

Podczas tworzenia tablic, kompilator języka C# niejawnie inicjuje każdy element tablicy do wartości domyślnej zależnej od typu tablicy. Dla przykładu, dla tablicy liczb całkowitych wszystkie elementy są inicjowane na 0.

Dostęp do elementów tablicy

Element jest dostępny za pomocą indeksu, który jednoznacznie identyfikuje konkretny wpis. Odbywa się to poprzez umieszczenie indeksu w nawiasie kwadratowym po nazwie tablicy:

double pensja=pracownik[8];

Z kolei poniższy przykład przedstawia wszystkie powyższe punkty, tj. deklaracje, przypisanie wartości oraz dostęp do poszczególnych elementów tablicy:

class Koncepcja
{
    public Koncepcja()
    {
        int[] n = new int[10]; // tablica 10-cio elementowa
        int i, j;
        // wypełnienie kolejnych elementów listy
        for (i = 0; i < 10; i++)
        {
            n[i] = i + 50; // zwiększamy każdy element o 50
        }
        // W tym miejscu wykorzystamy inny rodzaj pętli, pętlę foreach
        // Jest to pętla, która przejdzie po wszystkich elementach tablicy
        // Nie definiujemy żadnych warunków, jak w pętli for czy while
        // Poniżej prosty przykład takiej pętli
        // int item - element jaki otrzymamy przechodząc pomiędzy kolejnami elementami
        // in n - element po jakim dokonujemy iteracji
        i = 0;
        foreach (int item in n)
        {
            Console.WriteLine("Element [{0}] wynosi: {1}", i, item);
            i++;
        }
        Console.ReadLine();
        // Wynik działania programu
        //Element [0] wynosi: 50
        //Element [1] wynosi: 51
        //Element [2] wynosi: 52
        //Element [3] wynosi: 53
        //Element [4] wynosi: 54
        //Element [5] wynosi: 55
        //Element [6] wynosi: 56
        //Element [7] wynosi: 57
        //Element [8] wynosi: 58
        //Element [9] wynosi: 59
    }
}

Tablice w języku C#

W języku C# możemy spotkać się z kilkoma koncepcjami pracy z tablicami. Wszystkie one powinny być jasnę dla programisty, dlatego zostaną szczegółowo omówione:

• tablice wielowymiarowe - najprostą formą takiej tablicy jest tablica dwuwymiarowa;
• tablice postrzępione - to tablice w tablicach;
• przekazywanie tablic do metody - możemy przekazać do metody wskaźnik do naszej tablicy bez wskazywania na konkretny index;
• tablice parametryczne - pozwalają na przekazanie nieznanej liczby parametrów do metody;
• klasa Array - zdefiniowana w przestrzeni nazw System, jest klasą bazową dla wszystkich tablic oraz zapewnia różne właściowości i metody pracy z tablicami.

Tablice wielowymiarowe

C# powzwala na definiowanie wielowymiarowych tablic. Tablice te nazywane są również tablicami prostokątnymi. Tablicę 2-u wymiarową możemy zadeklarowować w poniższy spososób:

string[,] nazwy;

Z kolei tablicę 3-uj wymiarową definiujemy w poniższy sposób:

int[, , ] liczby;

Najprostszą formą tablicy wielowymiarowej jest tablica 2-u wymiarowa. 2-u wymiarowa tablica to lista tablic jednowymiarowych.

Tablica dwuwymiarowa może być traktowa jak tabela, która ma określoną liczbę wierszy okraz kolumn.
Inicjowanie tablicy 2-u wymiarowej:

int[,] a = new int[3, 4] {
    {0,1,2,3 }, // wiersz o indeksie 0
    {4,5,6,6 }, // wiersz o indeksie 1
    {8,9,10,11 } // wiersz o indeksie 2
};

Poszczególne elementy takiej tablicy dostępne są za pomocą indeksów. Pierwszy indeks oznacza wiersz, do którego chcemy się odwołać, drugi indeks to kolumna naszej tablicy.
Przykład:

int wartość=a[2,3];

Powyższa konkstrukcja pozwala nam na pobranie 4-tej wartości z 3-ciego wiersza. Pamiętajcie, że w programowaniu liczymy od 0.

Poniżej przykład wypisania wszystkich wartości z naszej tablicy 2-u wymiarowej:

class DwaWymiary
{
    public DwaWymiary()
    {
        // Definicja tabeli o 3 wierszach i 4 kolumnach
        int[,] a = new int[3, 4] {
            {0,1,2,3 }, // wiersz o indeksie 0
            {4,5,6,6 }, // wiersz o indeksie 1
            {8,9,10,11 } // wiersz o indeksie 2
        };
        // Wypisanie elementów w konsoli
        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                Console.WriteLine("a[{0}, {1}] = {2}", i,j,a[i,j]);
            }
        }
        Console.ReadLine();
        // Wynik działania programu
        //a[0, 0] = 0
        //a[0, 1] = 1
        //a[0, 2] = 2
        //a[0, 3] = 3
        //a[1, 0] = 4
        //a[1, 1] = 5
        //a[1, 2] = 6
        //a[1, 3] = 6
        //a[2, 0] = 8
        //a[2, 1] = 9
        //a[2, 2] = 10
        //a[2, 3] = 11
    }
}

Tablice postrzępione

Jagged Array (tj. tablica postrzępiona) to tablica w tablicy. Tablica taka może zostać zainicjowana w poniższy sposób:

int [][] scores = new int [ 2 ][]{ new int []{ 71 , 72 , 73 }, new int []{ 32 , 33 , 34 , 35 }};

Tablica scores zawiera w sobie dwie tablice liczb całkowitych. Pierwszy element scores[0] jest tablicą 3 liczb całkowitych, element drugi scores[1] jest tablicą 4 liczb całkowitych.
Przykład:

class TablicaPostrzepiona
{
    public TablicaPostrzepiona()
    {
        // Deklaracja tablicy w tablicy
        // Tablica postrzępiona z 4 tablicami liczb całkowitych
        int[][] a = new int[][] {
        new int[] {0,0},
        new int[] {1,2},
        new int[] {2,4},
        new int[] {3,6}
        };
        // Wypisanie wszystkich elementów w konsoli
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 2; j++)
            {
                Console.WriteLine("a[{0}, {1}] = {2}", i, j, a[i][j]);
            }
        }
        Console.ReadLine();
        // Wynik działania programu
        //a[0, 0] = 0
        //a[0, 1] = 0
        //a[1, 0] = 1
        //a[1, 1] = 2
        //a[2, 0] = 2
        //a[2, 1] = 4
        //a[3, 0] = 3
        //a[3, 1] = 6
    }
}

Przekazywanie tablic do metody

W języku C# możesz przekazać tablicę jako parametr metody. Poniższy przykład pokazuje jak to można zrobić:

	
using System;
using System.Linq;
namespace Tablice
{
    class Program
    {
        static void Main(string[] args)
        {
            TablicaJakoParametr tb = new TablicaJakoParametr();
            int[] liczby = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            double srednia;
            srednia = tb.PoliczSrednia(liczby);
            Console.WriteLine("Średnia liczb to: {0}", srednia);
            Console.ReadLine();
        }
    }
    class TablicaJakoParametr
    {
        public double PoliczSrednia(int[] liczby)
        {
            int i;
            int suma=0;
            double srednia;
            foreach (var item in liczby)
            {
                suma += item;
            }
            // Wbudowana metoda Count() zwraca nam liczbę parametrów 
            // w naszej tablicy;
            i = liczby.Count();
            srednia = (suma) / i;
            return srednia;
        }
    }
}

Tablice parametryczne

Jeżeli w momencie deklaracji metody, nie jesteśmy pewni ile parametrów będziemy chcieli przekzać do jej wnętrza możemy skorzystać z tzw. tablic parametrycznych. Użycie takiej tablicy możliwe jest po zastoswaniu słowa kluczowego params.

	
using System;
using System.Linq;
namespace Tablice
{
    class Program
    {
        static void Main(string[] args)
        {	
            TabliceParametryczne tp = new TabliceParametryczne();
            // W tym momencie do wnętrza naszej metody możemy przekazać różną
            // liczbę parametrów. Nie określamy na sztywno ile może ich być.
            int suma = tp.DodajElementy(1, 2, 3, 4, 6);
            Console.WriteLine("Wynik dodawania to: {0}", suma);
            Console.ReadLine();
        }
    }
    class TabliceParametryczne
    {
        public int DodajElementy(params int[] tablica)
        {
            int suma = 0;
            foreach (var item in tablica)
            {
                suma += item;
            }
            return suma;
        }
    }
}

Klasa Array

Klasa Array jest klasą bazową dla wszystkich tablic w C#. Jest ona zdefiniowana w przestrzeni nazw System. Klasa Array dostarcza różne właściowości oraz metody do pracy z tablicami.

Właściwości klasy Array


Metody klasy Array

W celu uzyskania kompletnej listy właściowości i metod klasy Array proszę skorzystać z oficjalnej dokumentacji Microsoft.
Przykład wykorzystania niektórych metod:

class TabliceKompletnyPrzyklad
{
    public TabliceKompletnyPrzyklad()
    {
        int[] lista = new int[] { 23, 45, 43, 12, 34, 76, 192, -232 };
        int[] temp = lista;
        Console.Write("Oryginalna lista: ");
        foreach (int i in lista)
        {
            Console.Write(i + " ");
        }
        Console.WriteLine();
        // odwrócenie kolejności
        Array.Reverse(temp);
        Console.Write("Odwrócona kolejność: ");
        foreach (int i in temp)
        {
            Console.Write(i + " ");
        }
        Console.WriteLine();
        // sortowanie kolejności
        Array.Sort(lista);
        Console.Write("Posortowana tablica: ");
        foreach (int i in lista)
        {
            Console.Write(i + " ");
        }
        Console.WriteLine();
        Console.ReadKey();
        // Wynik działania programu
        //Oryginalna lista: 23 45 43 12 34 76 192 - 232
        //Odwrócona kolejnosc: -232 192 76 34 12 43 45 23
        //Posortowana tablica: -232 12 23 34 43 45 76 192
    }
}