Wprowadzenie do C#

C# (wymawiane "C sharp") to nowoczesny język programowania ogólnego przeznaczenia opracowany przez firmę Microsoft. Jest szeroko stosowany do tworzenia różnego rodzaju aplikacji, w tym aplikacji komputerowych, internetowych, mobilnych i gier. W tym przewodniku omówimy podstawy programowania w języku C#, w tym typy danych, zmienne, przepływ sterowania, funkcje, klasy, przestrzenie nazw i nie tylko.

Co więcej, C# oferuje bogaty zestaw funkcji i narzędzi, dzięki czemu jest wszechstronnym i wydajnym językiem programowania dla różnych dziedzin, w tym aplikacji komputerowych, tworzenia stron internetowych, aplikacji mobilnych i tworzenia gier przy użyciu technologii takich jak Unity. W miarę postępów w swojej podróży do C# możesz eksplorować bardziej zaawansowane tematy, takie jak dziedziczenie, polimorfizm, interfejsy, typy generyczne, LINQ (Language Integrated Query) i programowanie asynchroniczne przy użyciu zadań i async/await. Zrozumienie tych koncepcji zwiększy Twoje możliwości projektowania solidnych i skalowalnych aplikacji.

Zacznijmy od podstaw.

Konfigurowanie środowiska programistycznego

Aby rozpocząć kodowanie w języku C#, musisz skonfigurować środowisko programistyczne. Oto kroki, jak rozpocząć:

Zainstaluj program Visual Studio: Pobierz i zainstaluj program Visual Studio z oficjalnej witryny firmy Microsoft. Visual Studio to potężne zintegrowane środowisko programistyczne (IDE), które zapewnia wszystkie narzędzia niezbędne do programowania w języku C#.
Utwórz nowy projekt: Uruchom program Visual Studio i utwórz nowy projekt. Wybierz odpowiedni szablon projektu w oparciu o typ aplikacji, którą chcesz zbudować.
Napisz kod: Po skonfigurowaniu projektu możesz rozpocząć pisanie kodu C# w edytorze kodu udostępnianym przez program Visual Studio.

Teraz, gdy masz już skonfigurowane środowisko programistyczne, przejdźmy do podstaw programowania w języku C#.

Program Witaj Świecie

Tradycyjne „Hello, World!” program jest często pierwszym programem, który piszesz w dowolnym języku programowania. Oto jak możesz to napisać w C#:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

W tym przykładzie kodu najpierw uwzględniamy przestrzeń nazw 'System', która zawiera klasę o nazwie 'Console' do obsługi danych wejściowych i wyjściowych. Następnie definiujemy klasę o nazwie 'Program'. Wewnątrz tej klasy mamy metodę 'Main', która jest punktem wejścia programu C#. Na koniec używamy metody 'Console.WriteLine', aby wydrukować komunikat „Hello, World!” wiadomość do konsoli.

Zmienne i typy danych

W C# musisz zadeklarować variable zanim będziesz mógł z nich skorzystać. Zmienne przechowują wartości różnych typów danych. Oto kilka powszechnie używanych typów danych w języku C#:

'int': Reprezentuje liczby całkowite (np. 10, -5, 0).
'double': Reprezentuje liczby zmiennoprzecinkowe z miejscami dziesiętnymi (np. 3,14, -0,5).
'bool': Reprezentuje wartości logiczne (prawda lub fałsz).
'string': Reprezentuje sekwencję znaków (np. "Hello", "C#").

Oto przykład demonstrujący deklarację zmiennej i podstawowe operacje:

int age = 25;
double pi = 3.14;
bool isStudent = true;
string name = "John";

int sum = age + 5;
double circleArea = pi * 2 * 2;
bool isAdult = age >= 18;

Console.WriteLine("Name: " + name);
Console.WriteLine("Age: " + age);
Console.WriteLine("Sum: " + sum);
Console.WriteLine("Circle Area: " + circleArea);
Console.WriteLine("Is Adult? " + isAdult);

W tym przykładzie deklarujemy zmienne 'age', 'pi', 'isStudent' i 'name' wraz z ich odpowiednimi typy danych. Wykonujemy podstawowe operacje, takie jak dodawanie, mnożenie i porównywanie. Do wyświetlania wartości na konsoli używana jest metoda 'Console.WriteLine'.

Tablice i kolekcje

Tablice i kolekcje to podstawowe struktury danych w języku C#, które umożliwiają wydajne przechowywanie wielu wartości i manipulowanie nimi. Odgrywają kluczową rolę w różnych scenariuszach programowania i są szeroko stosowane w programowaniu w języku C#.

Tablice

Tablica w języku C# to kolekcja elementów tego samego typu o stałym rozmiarze. Oto przykład:

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

W tym przykładzie deklarujemy tablicę liczb całkowitych o nazwie 'numbers' i rozmiarze '5'. Inicjujemy tablicę określonymi wartościami, używając nawiasów klamrowych '{}'. Dostęp do poszczególnych elementów tablicy można uzyskać za pomocą notacji indeksowej, zaczynając od 0. Na przykład 'numbers[0]' daje pierwszy element.

Kolekcje

Kolekcje w języku C# zapewniają większą elastyczność niż tablice, ponieważ mogą dynamicznie rosnąć lub zmniejszać się. C# oferuje różne typy kolekcji, takie jak 'List<T>', 'Dictionary<TKey, TValue>' i 'HashSet<T>'.

Możesz utworzyć kolekcję ogólną, używając jednej z klas z przestrzeni nazw 'System.Collections.Generic'. Kolekcja ogólna jest przydatna, gdy każdy element kolekcji ma ten sam typ danych. Kolekcja ogólna wymusza silne pisanie, umożliwiając dodanie tylko żądanego typu danych.

using System.Collections.Generic;

Oto przykład użycia kolekcji 'List<T>':

List<string> names = new List<string>();
names.Add("Alice");
names.Add("Bob");
names.Add("Charlie");

W tym przykładzie tworzymy listę ciągów o nazwie 'names' przy użyciu klasy inicjatora 'List<T>'. Do dodawania elementów do listy używamy metody 'Add()'.

Wartość 'List<T>' udostępnia wiele przydatnych metod i właściwości do pracy z kolekcjami, takich jak 'Count' w celu uzyskania liczby elementów, 'Remove()' w celu usunięcia element i 'Contains()', aby sprawdzić, czy element istnieje.

Iteracja po tablicach i kolekcjach

Możesz iterować po tablicach i kolekcjach, używając pętli, takich jak 'for' lub 'foreach', aby uzyskać dostęp do ich elementów i manipulować nimi. Oto przykład iteracji po tablicy i liście:

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

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

List<string> names = new List<string>() { "Alice", "Bob", "Charlie" };

foreach (string name in names)
{
    Console.WriteLine(name);
}

W tym przykładzie używamy pętli 'foreach' do iteracji po każdym elemencie tablicy 'numbers' i listy 'names' i wypisujemy je do konsola.

Kontrola przepływu

Przepływ sterowania umożliwia podejmowanie decyzji i wykonywanie różnych bloków kodu w oparciu o warunki. Język C# udostępnia kilka struktur przepływu sterowania, w tym instrukcje 'if', instrukcje 'switch' i pętle.

'If'

Instrukcja 'if' umożliwia wykonanie bloku kodu tylko wtedy, gdy spełniony jest określony warunek. Oto przykład:

int number = 10;

if (number > 0)
{
    Console.WriteLine("The number is positive.");
}
else if (number < 0)
{
    Console.WriteLine("The number is negative.");
}
else
{
    Console.WriteLine("The number is zero.");
}

W tym przykładzie sprawdzamy wartość zmiennej 'number' przy użyciu klauzul 'if', 'else if' i 'else'. W zależności od warunku zostanie wydrukowany odpowiedni komunikat.

'Switch'

Instrukcja 'switch' umożliwia wybranie jednego z wielu bloków kodu do wykonania w oparciu o wartość wyrażenia. Oto przykład:

int dayOfWeek = 2;
string dayName;

switch (dayOfWeek)
{
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    // ...
    default:
        dayName = "Invalid day";
        break;
}

Console.WriteLine("Today is " + dayName + ".");

W tym przykładzie nazwę dnia przypisujemy na podstawie wartości 'dayOfWeek' za pomocą instrukcji 'switch'. Instrukcje 'case' określają możliwe wartości, a przypadek 'default' jest wykonywany, jeśli żaden z przypadków nie pasuje.

Instrukcje pętli

Pętle pozwalają na wielokrotne wykonanie bloku kodu, aż do spełnienia określonego warunku. C# udostępnia pętle 'for', 'while' i 'do-while'.

'For'

Pętla 'for' jest używana, jeśli z góry znana jest liczba iteracji. Oto przykład:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Iteration: " + i);
}

W tym przykładzie pętla wykonuje się pięć razy, za każdym razem wypisując numer iteracji.

'While'

Pętla 'while' jest używana, gdy nie znasz z góry liczby iteracji, ale musisz sprawdzić warunek. Oto przykład:

int count = 0;

while (count < 5)
{
    Console.WriteLine("Count: " + count);
    count++;
}

W tym przykładzie pętla działa, aż zmienna 'count' osiągnie wartość 5.

'Do-While'

Pętla 'do-while' jest podobna do pętli while, ale warunek jest sprawdzany na końcu, więc pętla wykona się co najmniej raz. Oto przykład:

int num = 1;

do
{
    Console.WriteLine("Number: " + num);
    num++;
} while (num <= 5);

W tym przykładzie pętla działa, dopóki zmienna 'num' nie będzie już mniejsza lub równa 5.

Funkcje

Funkcje umożliwiają hermetyzację bloków kodu wielokrotnego użytku. C# obsługuje definiowanie funkcji przy użyciu słowa kluczowego 'void' w przypadku metod, które nie zwracają wartości, oraz innych typów danych w przypadku metod zwracających wartość. Oto przykład:

int Add(int a, int b)
{
    return a + b;
}

void Greet(string name)
{
    Console.WriteLine("Hello, " + name + "!");
}

int result = Add(5, 3);
Greet("Alice");

W tym przykładzie definiujemy dwie funkcje: 'Add' i 'Greet'. Funkcja 'Add' przyjmuje dwa parametry całkowite i zwraca ich sumę. Funkcja 'Greet' pobiera parametr typu string i wyświetla komunikat powitalny. Następnie wywołujemy te funkcje z odpowiednimi argumentami.

Klasy i obiekty

C# jest językiem programowania zorientowanym obiektowo, co oznacza, że obsługuje tworzenie klas i obiektów. Klasy definiują plan tworzenia obiektów, które są instancjami tych klas. Oto przykład:

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + Name + " and I'm " + Age + " years old.");
    }
}

Person person = new Person();
person.Name = "John";
person.Age = 30;
person.SayHello();

W tym przykładzie definiujemy klasę 'Person' z właściwościami 'Name' i 'Age' oraz metodą 'SayHello'. Następnie tworzymy instancję klasy 'Person' przy użyciu słowa kluczowego 'new' i ustawiamy jej właściwości. Na koniec wywołujemy metodę 'SayHello' na obiekcie 'person'.

Koncepcje programowania obiektowego (OOP).

C# to obiektowy język programowania oferujący różne funkcje wspierające koncepcje OOP, takie jak dziedziczenie, enkapsulacja i polimorfizm.

Dziedzictwo

Dziedziczenie umożliwia tworzenie nowych klas w oparciu o istniejące klasy, dziedziczenie ich atrybutów i zachowań. Oto przykład:

class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

W tym przykładzie klasa 'Circle' dziedziczy po klasie 'Shape' przy użyciu symbolu ':'. Klasa 'Circle' zastępuje metodę 'Draw' z klasy bazowej, zapewniając własną implementację.

Kapsułkowanie

Hermetyzacja to praktyka polegająca na łączeniu danych i metod w klasę i kontrolowaniu ich dostępu. Możesz użyć modyfikatorów dostępu ('public', 'private', 'protected' itd.), aby określić widoczność elementów. Oto przykład:

class Person
{
    private string name;

    public string GetName()
    {
        return name;
    }

    public void SetName(string newName)
    {
        name = newName;
    }
}

W tym przykładzie pole 'name' jest hermetyzowane w klasie 'Person' i można uzyskać do niego dostęp wyłącznie poprzez 'GetName' i * metody h81*.

Wielopostaciowość

Polimorfizm pozwala na traktowanie obiektów różnych klas jako obiektów wspólnej klasy bazowej. Umożliwia to napisanie kodu, który w jednolity sposób współpracuje z różnymi typami obiektów. Oto przykład:

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound.");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks.");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Cat meows.");
    }
}

W tym przykładzie klasa 'Animal' ma wirtualną metodę 'MakeSound', która jest zastępowana przez klasy 'Dog' i 'Cat' zajęcia. Polimorfizm pozwala nam traktować instancje 'Dog' i 'Cat' jako instancje 'Animal' i wywoływać 'MakeSound' na nich metoda.

Obsługa wyjątków

Obsługa wyjątków umożliwia płynną obsługę błędów wykonawczych. W języku C# można używać bloków 'try-catch' do przechwytywania i obsługi wyjątków. Oto przykład:

try
{
    int result = 10 / 0;
    Console.WriteLine("Result: " + result);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Divide by zero error: " + ex.Message);
}
finally
{
    Console.WriteLine("Cleanup code goes here.");
}

W tym przykładzie próbujemy wykonać dzielenie przez zero, co wyrzuca 'DivideByZeroException'. Kod znajdujący się w bloku 'try' jest wykonywany i jeśli wystąpi wyjątek, jest przechwytywany przez blok 'catch'.

Blok 'finally' jest wykonywany niezależnie od tego, czy wystąpi wyjątek, czy nie, i zazwyczaj jest używany do operacji czyszczenia.

Obsługa wyjątków pomaga zapobiegać awariom programów i umożliwia kontrolowaną obsługę błędów i ich odzyskiwanie.

Wniosek

Ten obszerny przewodnik zawiera szczegółowe wprowadzenie do programowania w języku C#, obejmujące podstawy i podstawowe koncepcje języka. Zaczynając od skonfigurowania środowiska programistycznego i napisania „Hello, World!” programu, badaliśmy typy danych, zmienne, struktury przepływu sterowania, takie jak instrukcje if i pętle, oraz tworzenie funkcji. Zagłębiliśmy się w bardziej zaawansowane tematy takie jak klasy, obiekty, dziedziczenie, enkapsulacja, polimorfizm, a także obsługa wyjątków. Dodatkowo omówiliśmy wykorzystanie tablic i kolekcji do zarządzania wieloma wartościami. Dzięki tej wiedzy masz teraz solidne podstawy programowania w języku C#, umożliwiające tworzenie szerokiej gamy aplikacji, od aplikacji konsolowych po aplikacje internetowe i mobilne. Pamiętaj, aby kontynuować ćwiczenia i eksplorować rozległy ekosystem C#, aby udoskonalić swoje umiejętności i odblokować nieskończone możliwości.

programowanie csharp oop rozwój zmienne przepływ sterowania klasy obiekty dziedziczenie enkapsulacja obsługa wyjątków tablice kolekcje funkcje