C# od początkującego do ekperta #002

Wstęp:

Cześć! Ostatnio razem uczyliśmy się podstaw C#, tym razem przejdziemy do rzeczy trochę trudniejszych (ale nie za bardzo) i jednocześnie dużo bardziej praktycznych.

Uwaga! W poniższych przykładach będę pomijał importowanie przestrzeni nazw na początku naszego programu. Nie znaczy to jednak, że ich tam nie ma :D.

Komentarze:

Pisanie programu nie jest rzeczą prostą, a co za tym idzie wymaga poświęcenia czasu (duże projekty mogą ciągnąć się przez kilka miesięcy). Programista piszący taki program niejednokrotnie musi wracać do kodu napisanego na samym początku trwania projektu. Niestety człowiek nie jest w stanie zapamiętać wszystkiego. Tutaj z pomocą programiście przychodzą komentarze.

Komentarze są to krótkie notatki robione przez programistów podczas pisania programu, które mają za zadanie powiedzieć osobie czytającej kod jakie jest jego działanie bez zbędnego zagłębiania się w wszystkie działania wewnątrz tego kodu. Komentarze są pomijane podczas kompilacji (zmiany kodu naszego programu w aplikację, którą nasz komputer może uruchomić), co oznacza, że nie wpływają na wielkość lub prędkość działania gotowego produktu. Możemy również używać komentarzy aby „wyrzucić” część kodu bez usuwania go, abyśmy mogli do niego wrócić.

W C# mamy kilka różnych możliwości tworzenia komentarzy.

Pierwszą, najbardziej podstawową jest wpisanie //. Wszystko co zostanie wpisane po tym ciągu znaków staje się komentarzem, o ile znajduje się w tej samej linii.

Przykład:

//to jest komentarz, nie wpływa on na działanie programu

Znacznik ten możemy bez problemu wstawić w dowolnym miejscu naszego kodu np.:

Console.WriteLine(„Hello World!”); // wypisywanie Hello World na ekran konsoli

Innym sposobem na wstawienie komentarza jest umieszczenie /* … */ w naszym kodzie.

Podstawowa różnica jest taka, że // to komentarz obejmujący wszystko co się po nim znajduje w jednej linii, natomiast tutaj komentarz rozpoczyna się po ciągu znaków /* i kończy wraz z */ (może obejmować więcej niż jedną linię). Pozwala to pisać dłuższe opisy do naszego kodu lub komentować całe jego wycinki.

namespace ProgramName
{
    class Program
    {   
	 /*
	   Tutaj możemy wstawić dowolny opis naszej klasy
	   Może znajdować się w kilku różnych liniach
	 */
        static void Main(string[] args) // funkcja main, to tutaj zaczyna pracę nasz program
       {
           //Console.WriteLine("Text");  <- ten tekst nie wyświetli się na ekranie
           //konsoli ponieważ jest napisany wewnątrz komentarza
           Console.WriteLine("Hello World!");
           Console.ReadLine();
       }
   }
}

Jak można zauważyć, możliwość używania komentarzy znacznie ułatwia pracę oraz pozwala szybciej zrozumieć działanie naszego programu lub jego poszczególnych części.

Zmienne:

Najpierw zaczniemy od teorii. Zmienna jest odpowiedzialna za przechowywanie informacji w naszym programie. Aby móc jej użyć musimy ją wcześniej utworzyć. Możemy to zrobić w dowolnym miejscu w naszej klasie (pomiędzy { } ). My utworzymy dwie zmienne. Jedną wewnątrz klasy Program, natomiast drugą wewnątrz metody Main:

namespace ProgramName
{
    class Program
   {
       int zmienna1;  // <- zmienna wewnątrz klasy Program
       
        static void Main(string[] args)
       {
           int zmienna2;  // <- zmienna wewnątrz metody Main
           Console.WriteLine("Hello World!");
           Console.ReadLine();
       }
   }

Jak widzimy definicja naszej zmiennej składa się z dwóch rzeczy:

int – jest to określenie typu zmiennej (o typach będziemy mówić w dalszej części tego poradnika)

oraz:

zmienna1 / zmienna2 – są to nazwy naszych zmiennych, których będziemy używać aby odwołać się do ich wartości w dalszej części programu.

Do czego będziemy używać zmiennych?

To proste! Zmiennych będziemy używać aby kontrolować nasz program, oraz wszystkie przechowywane w nim dane. Ale przejdźmy do praktyki:

namespace ProgramName
{
    class Program
    {
        int zmienna1;  // <- zmienna wewnątrz klasy Program
        static void Main(string[] args)
        {
            int zmienna2 = 12;  // <- zmienna wewnątrz metody Main

            Console.WriteLine(zmienna2);
            //Console.WriteLine("Hello World!");
            Console.ReadLine();
        }
    }
}

Jak możemy zauważyć użyliśmy przypisania liczby do zmiennej. Mogliśmy to zrobić ponieważ typ int odpowiada liczbą całkowitym (z zakresu od -2147483648 do 2147483647).

Do naszej dyspozycji jest jeszcze kilka typów, odpowiedzialnych za różne dane:

-float – odpowiedzialny za liczby zmiennoprzecinkowe (np.: 2.763),

-double – odpowiednik zmiennej float o zwiększonym zakresie i dokładności,

-char – typ danych odpowiedzialny za przechowywanie pojedynczych znaków (np.: ‘z’),

-string – ciąg znaków (możemy w nim przechowywać dłuższe teksty, np.: „To jest jabłko”).

-bool – zmienna logiczna, odpowiada wartością true oraz false.

Więcej typów danych oraz ich zakresy możemy znaleźć tutaj. 

Ale samo przypisanie wartości do zmiennej niewiele nam daje. Najważniejsze jest to że na takich zmiennych możemy wykonywać różne operacje. Poniżej przedstawię kilka podstawowych operacji matematycznych

Zmieńmy trochę nasz kod:

class Program
{
    static void Main(string[] args)
    {
        int z1 = 10;
        int z2 = 3;
        Console.WriteLine( (z1 + z2) );
        Console.WriteLine( (z1 - z2) );
        Console.WriteLine( (z1 * z2) );
        Console.WriteLine( (z1 / z2) );

        Console.ReadLine();
    }
}

Co zrobiliśmy? Wewnątrz metody Main utworzyliśmy dwie zmienne typu int. W następnych czterech linijkach wykonaliśmy na naszych zmiennych podstawowe operacje matematyczne. Jak widać nie jest to nic trudnego. W zależności od typu danych możemy wykonywać na nich różne operacje (nie tylko matematyczne :D). Tak więc o ile zmienne typu int, float lub double przydadzą się nam do różnych obliczeń, to zmienne typu char i string, które będą używane by pracować z tekstem.

Ta część kursu również dobiegła końca. Teraz potraficie już stworzyć zmienne (przynajmniej te podstawowe) oraz dodać do waszego projektu komentarze które znacznie ułatwią późniejszą analizę kodu.

Na koniec chciałbym jeszcze przeprosić za dłuższą przerwę po pierwszej części tej serii poradników. Następna część nie ukaże się jednak szybko a będzie ona dotyczyć programowania na nieco wyższym poziomie, zajmiemy się bowiem zagadnieniem sieci neuronowych (część z pisaniem kodu prawdopodobnie poprzedzona będzie częścią teoretyczną, w której postaram się wyjaśnić działanie takiej sieci). Ogólna lista tematów które chciałbym poruszyć jest znacznie dłuższa: REST Api (aktualnie jestem w trakcie nauki), Unity (C#) oraz biblioteka Processing (Java).

Mam nadzieję, że będę mógł przejść wraz z Wami przez wszystkie te zagadnienia i razem zgłębimy swoją wiedzę dotyczącą programowania (i nie tylko :D).