Zmienne i typy danych w języku C#

Mariusz Jurczenko

Zmienne i typy danych w języku C#

Zmienna (Variable)

Zmienna to symboliczna nazwa, która jest używana do przechowywania danych w pamięci komputera. Zmienna może przechowywać różne rodzaje danych, takie jak liczby, tekst czy wartości logiczne. W języku C#, zmienne są deklarowane za pomocą odpowiedniego typu danych.

Typy danych (Data Types)

W C# istnieje wiele różnych typów danych, które można podzielić na kilka kategorii. Oto najważniejsze typy danych:

  1. Typy liczbowe:
    • int: Przechowuje liczby całkowite. Przykład: int liczba = 42;
    • double: Przechowuje liczby zmiennoprzecinkowe. Przykład: double liczbaZmiennoprzecinkowa = 3.14;
    • float: Przechowuje liczby zmiennoprzecinkowe o mniejszej precyzji niż double. Przykład: float mniejszaPrecyzja = 1.2345f;
    • decimal: Przechowuje liczby zmiennoprzecinkowe o dużej precyzji, często używane w finansach. Przykład: decimal duzaPrecyzja = 123.456m;
  2. Typy logiczne:
    • bool: Przechowuje wartości logiczne true (prawda) lub false (fałsz). Przykład: bool czyPrawda = true;
  3. Typ znakowy:
    • char: Przechowuje pojedynczy znak Unicode. Przykład: char litera = 'A';
  4. Typy tekstowe:
    • string: Przechowuje ciągi znaków (tekst). Przykład: string napis = "Hello, World!";
  5. Typy specjalne:
    • byte: Przechowuje wartości całkowite od 0 do 255. Przykład: byte bajt = 255;
    • short: Przechowuje krótkie liczby całkowite. Przykład: short krotkaLiczba = 1000;
    • long: Przechowuje długie liczby całkowite. Przykład: long dlugaLiczba = 1000000000L;
    • sbyte: Przechowuje wartości całkowite od -128 do 127. Przykład: sbyte znakowyBajt = -50;
    • ushort: Przechowuje krótkie liczby całkowite bez znaku. Przykład: ushort krotkaLiczbaBezZnaku = 5000;
    • ulong: Przechowuje długie liczby całkowite bez znaku. Przykład: ulong dlugaLiczbaBezZnaku = 10000000000UL;
  6. Typy referencyjne:
    • object: Jest bazowym typem dla wszystkich innych typów w C#. Przykład: object obiekt = "Jestem obiektem";

Deklaracja i Inicjalizacja

Deklaracja zmiennej to proces przypisywania nazwy i określenia typu danej zmiennej. Inicjalizacja oznacza przypisanie początkowej wartości do zmiennej.
W C# można zadeklarować i zainicjalizować zmienną w jednym kroku, na przykład:

int wiek = 100;
string imie = "Marcin";
bool czyPrawda = true;

Konwersja Typów (Type Casting)

Czasami może być konieczne przekształcenie jednego typu danych w inny.
Możemy to zrobić za pomocą jawnej (explicit) konwersji lub niejawnej (implicit) konwersji. Na przykład:

int liczbaCalkowita = 150;
double liczbaZmiennoprzecinkowa = (double)liczbaCalkowita; // Jawna konwersja

Stałe (Constants)

Stałe to zmienne, których wartość nie może być zmieniana po zadeklarowaniu. Deklaracja stałej wygląda tak:

const int stala = 500;

Zmienna readonly

Zmienna readonly to zmienna, której wartość można ustawić tylko podczas inicjalizacji lub w konstruktorze. Po inicjalizacji nie można zmieniać jej wartości.

readonly int stalaCzytelnik = 300;

Zakresy wartości typów danych

Każdy typ danych w C# ma określony zakres wartości, co oznacza, że ​​może przechowywać tylko określone wartości. Na przykład, typ byte może przechowywać liczby całkowite od 0 do 255, podczas gdy typ int może przechowywać znacznie większe zakresy wartości. Jest to ważne, aby unikać przepełnienia (overflow) lub niedomiaru (underflow) danych.

byte zakresByte = 255; // OK
byte przepelnienie = 256; // Błąd kompilacji - przekroczenie zakresu byte

Zmienne lokalne vs. pola klasy

Zmienne lokalne są deklarowane i używane tylko wewnątrz określonej funkcji lub metody.
Zmienne te istnieją tylko podczas wykonywania funkcji i nie są dostępne poza nią. Pola klasy to zmienne zdefiniowane wewnątrz klasy i są dostępne dla wszystkich metod i funkcji w tej klasie.

public class Przyklad
{
    private int poleKlasy = 100; // Pole klasy - dostępne dla wszystkich metod tej klasy

    public void Metoda()
    {
        int zmiennaLokalna = 200; // Zmienna lokalna - dostępna tylko wewnątrz tej metody
        // ...
    }
}

Wyjątki związane z typami danych

Podczas pracy z różnymi typami danych, może dojść do sytuacji, gdzie konwersja lub operacje mogą spowodować wyjątki. Na przykład, próba przekonwertowania ciągu znaków na liczbę może spowodować wyjątek FormatException. Dlatego warto stosować obsługę wyjątków, aby uniknąć awarii programu.

string tekst = "to nie jest Liczba";
try
{
    int liczba = int.Parse(tekst); // Może spowodować FormatException
}
catch (FormatException ex)
{
    Console.WriteLine("Błąd konwersji: " + ex.Message);
}

Typy danych niestandardowe

W języku C# można również tworzyć własne typy danych niestandardowe za pomocą deklaracji klas. To daje dużą elastyczność w tworzeniu struktur danych i obiektów odpowiadających specyficznym potrzebom projektu.

public class Osoba
{
    public string Imie { get; set; }
    public string Nazwisko { get; set; }
}

Osoba klient = new Osoba();
klient.Imie = "Marcin";
klient.Nazwisko = "Lewandowski";

Podsumowując, zrozumienie zmiennych i typów danych w C# jest niezbędne do tworzenia programów.
Wybierając odpowiedni typ danych i zachowując spójność typów w swoim kodzie, możesz uniknąć wielu potencjalnych błędów i stworzyć bardziej czytelny i efektywny kod.
Pamiętaj, że typy danych i zmienni są podstawowymi składnikami każdego programu, więc ważne jest, aby dokładnie zrozumieć ich zachowanie i zastosowanie w Twoim kodzie.

Oto kilka bardziej zaawansowanych koncepcji i praktyk związanych z zmiennymi i typami danych w języku C#:

Nullable Types

Typy wartości w C# (takie jak int, double, bool, itp.) nie mogą przyjmować wartości null (brak wartości) z wyjątkiem, gdy użyjemy Nullable<T> lub skróconej notacji T? w celu zadeklarowania zmiennej jako “nullable”. To pozwala na przechowywanie wartości null w zmiennych, co jest przydatne w niektórych sytuacjach.

int? nullableInt = null;
double? nullableDouble = null;

Typy dynamiczne (Dynamic Types)

Typ dynamiczny (dynamic) pozwala na omijanie sprawdzania typów w trakcie kompilacji i dokładne określenie typów w trakcie działania programu. Jest to przydatne w sytuacjach, gdy typ nie jest znany w czasie kompilacji.

dynamic dynamicznaZmienna = 10;
dynamicznaZmienna = "Tekst";

Wyrażenia lambda

Wyrażenia lambda to krótkie funkcje anonimowe, które można używać w miejscu, gdzie wymagana jest funkcja. Są szczególnie przydatne w programowaniu funkcyjnym i LINQ (Language Integrated Query).

Func<int, int> podwojenie = x => x * 2;
int wynik = podwojenie(10); // Wynik to 20

Interpolacja ciągów znaków

Interpolacja ciągów znaków pozwala na łączenie zmiennych i wyrażeń bezpośrednio w ciągu znaków, co ułatwia czytelność kodu.

string imie = "Marcin";
int wiek = 20;
string wiadomosc = $"Witaj, jestem {imie} i mam {wiek} lat.";

Metody rozszerzeń (Extension Methods)

Metody rozszerzeń pozwalają na dodawanie nowych funkcji do istniejących typów bez konieczności ich zmieniania. Jest to przydatne do rozszerzania funkcjonalności istniejących typów.

public static class Rozszerzenia
{
    public static string Odwroc(this string tekst)
    {
        char[] tablica = tekst.ToCharArray();
        Array.Reverse(tablica);
        return new string(tablica);
    }
}

string napis = "Hello";
string odwroconyNapis = napis.Odwroc(); // Wynik: "olleH"

To tylko kilka zaawansowanych koncepcji i praktyk związanych z zmiennymi i typami danych w języku C#. Im bardziej zgłębiasz te zagadnienia, tym bardziej stajesz się zaawansowanym programistą w tym języku. Pamiętaj, że w miarę zdobywania doświadczenia będziesz miał okazję eksperymentować z różnymi technikami i narzędziami dostępnymi w C#.

Ostatnia rzecz, którą chciałbym dodać w kontekście zmiennych i typów danych w języku C#, to:

Nie tylko podstawowe typy

W C# istnieją również bardziej zaawansowane typy danych i biblioteki, które pozwalają na tworzenie bardziej skomplikowanych struktur danych i rozwiązań.
Oto kilka przykładów:

  • Enum: Enumeracje pozwalają zdefiniować zestaw nazwanych stałych. Są używane, gdy chcemy ograniczyć dostępne opcje do stałych wartości.
public enum Kierunek
{

    Poziomo,
    Pionowo
}

Kierunek kierunek = Kierunek.Poziomo;

Struktury (Structs): Struktury są podobne do klas, ale są typami wartości, co oznacza, że ​​są kopiowane, a nie referencjonowane. Są bardziej efektywne w przypadku prostych typów danych.

public struct Punkt
{
    public int X;
    public int Y;
}

Punkt punktA = new Punkt { X = 1, Y = 2 };
Punkt punktB = punktA; // Kopia punktu A

Kolekcje: C# oferuje różne rodzaje kolekcji do przechowywania i zarządzania danymi, takie jak List, Stack, Dictionary, HashSet itp. Te kolekcje ułatwiają manipulowanie danymi w bardziej zaawansowany sposób.

List<string> lista = new List<string>();
lista.Add("Pierwszy");
lista.Add("Drugi");
lista.Add("Trzeci");
string pierwszyElement = lista[0]; // "Pierwszy"

Tuples: Tuples to zestawy wartości o różnych typach, które pozwalają na zwracanie wielu wartości z metody lub funkcji.

(string Imie, int Wiek) DaneOsobowe = ("Jan", 30);
Console.WriteLine($"{DaneOsobowe.Imie} ma {DaneOsobowe.Wiek} lat.");

Rozważanie użycia tych bardziej zaawansowanych typów i struktur danych może pomóc w tworzeniu bardziej elastycznych i efektywnych rozwiązań programistycznych w C#. Pamiętaj, że wybór odpowiedniego typu danych zależy od konkretnej sytuacji i potrzeb projektu.

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *