Hello World w C# z Git: Prosty Start

Mariusz Jurczenko Mariusz Jurczenko

Hello World w C# z Git: Prosty Start

Celem tego przewodnika jest przeprowadzenie Cię przez proces tworzenia prostego projektu „Hello World” w języku C# oraz nauczenie podstaw zarządzania wersjami kodu za pomocą Git. Ten przewodnik jest przeznaczony zarówno dla początkujących, którzy dopiero zaczynają swoją przygodę z programowaniem, jak i dla tych, którzy chcą odświeżyć swoją wiedzę na temat .NET i Git.

Co to jest „Hello World”?

„Hello World” to klasyczny pierwszy program, który tradycyjnie służy do wprowadzenia nowych programistów do nowego języka programowania lub platformy. Jego zadaniem jest wyświetlenie na ekranie prostego komunikatu, najczęściej „Hello World!”. Ten program pomaga zrozumieć podstawowe zasady języka i jego składnię.

Dlaczego C#?

C# jest nowoczesnym, wszechstronnym językiem programowania stworzonym przez Microsoft. Jest szczególnie popularny w rozwijaniu aplikacji desktopowych, webowych oraz gier przy użyciu silnika Unity. C# działa na platformie .NET, która dostarcza bogaty zestaw bibliotek i narzędzi, co znacznie ułatwia tworzenie zaawansowanych aplikacji.

Co to jest Git?

Git to rozproszony system kontroli wersji, który pozwala śledzić zmiany w kodzie, współpracować z innymi programistami i zarządzać historią projektu. Git jest niezwykle popularny w branży programistycznej i jest podstawowym narzędziem używanym do zarządzania kodem w projektach o dowolnej wielkości.

Dlaczego używać Git?

  • Śledzenie zmian:
    Każda zmiana w kodzie jest rejestrowana, co umożliwia przeglądanie historii zmian i powrót do wcześniejszych wersji kodu.
  • Współpraca:
    Git umożliwia wielu programistom pracę nad tym samym projektem jednocześnie, minimalizując konflikty i umożliwiając łatwe scalanie zmian.
  • Bezpieczeństwo:
    Przechowywanie kodu w repozytorium Git zapewnia jego kopię zapasową, co chroni przed utratą danych.
  • Integracja:
    Git integruje się z wieloma narzędziami do ciągłej integracji (CI) i ciągłego wdrażania (CD), co automatyzuje procesy testowania i wdrażania aplikacji.

Zakres Przewodnika

Ten przewodnik krok po kroku pokaże Ci, jak:

  1. Zainstalować wymagane oprogramowanie:
    Dowiesz się, jak zainstalować .NET SDK oraz Git, które są niezbędne do tworzenia i zarządzania projektem.
  2. Utworzyć nowy projekt C#:
    Nauczysz się, jak utworzyć nową aplikację konsolową w języku C#, która wyświetla komunikat „Hello World!”.
  3. Zainicjalizować repozytorium Git:
    Dowiesz się, jak zainicjalizować repozytorium Git w lokalnym katalogu projektu.
  4. Dodać pliki do repozytorium i zatwierdzić zmiany:
    Poznasz podstawowe komendy Git do dodawania plików i zatwierdzania zmian.
  5. Utworzyć repozytorium zdalne na GitHubie:
    Nauczysz się, jak utworzyć repozytorium zdalne na GitHubie i synchronizować je z lokalnym repozytorium.
  6. Testować projekt:
    Nauczysz się, jak uruchamiać i testować swoją aplikację.
  7. Wprowadzać zmiany i aktualizować repozytorium:
    Zrozumiesz, jak wprowadzać zmiany w projekcie, zatwierdzać je i synchronizować z repozytorium zdalnym.
  8. Tworzyć osobne gałęzie dla nowych funkcjonalności:
    Nauczysz się, jak tworzyć i zarządzać gałęziami w Git, co pozwala na równoległe rozwijanie różnych funkcjonalności.

Ten przewodnik jest zaprojektowany tak, aby każdy krok był jasny i zrozumiały, z dokładnymi instrukcjami i przykładami, które możesz od razu zastosować w praktyce.

Krok 1: Instalacja Wymaganego Oprogramowania

Pierwszym krokiem w tworzeniu projektu „Hello World” w języku C# i zarządzaniu nim za pomocą Git jest instalacja odpowiedniego oprogramowania. Ten krok jest niezbędny, aby upewnić się, że masz na swoim komputerze wszystkie narzędzia potrzebne do tworzenia, kompilacji i zarządzania kodem w C#.

Dlaczego jest to ważne?

  • Tworzenie i Kompilacja Kodów:
    .NET SDK (Software Development Kit) zawiera wszystkie narzędzia i biblioteki potrzebne do tworzenia, kompilowania i uruchamiania aplikacji napisanych w C#. Bez zainstalowanego SDK nie będziesz w stanie rozpocząć pracy nad projektem.
  • Zarządzanie Wersjami:
    Git to narzędzie do kontroli wersji, które umożliwia śledzenie zmian w kodzie, zarządzanie historią projektu i współpracę z innymi programistami. Bez Git nie będziesz w stanie zarządzać wersjami kodu ani synchronizować projektu z repozytorium zdalnym (np. na GitHubie).
  • Kompatybilność:
    Instalacja odpowiednich wersji oprogramowania zapewnia, że wszystkie narzędzia będą ze sobą kompatybilne i będą działać poprawnie na Twoim systemie operacyjnym.

Kroki:

  1. Zainstaluj .NET SDK
    • Pobierz i zainstaluj .NET SDK z oficjalnej strony Microsoftu.
    • .NET SDK zawiera kompilator C#, narzędzia do zarządzania pakietami i inne narzędzia potrzebne do tworzenia aplikacji w C#.
  2. Zainstaluj Git
    • Pobierz i zainstaluj Git z oficjalnej strony Git.
    • Git jest narzędziem do kontroli wersji, które umożliwia śledzenie zmian w kodzie, tworzenie gałęzi i współpracę z innymi programistami.
  3. Sprawdź instalację
    • Upewnij się, że .NET SDK i Git zostały poprawnie zainstalowane, sprawdzając ich wersje w terminalu:
dotnet --version
git --version

Instalacja wymaganego oprogramowania jest kluczowym pierwszym krokiem w tworzeniu projektu w C# i zarządzaniu nim za pomocą Git. Dzięki zainstalowaniu .NET SDK będziesz mógł tworzyć i kompilować aplikacje w C#, a dzięki Git będziesz mógł efektywnie zarządzać wersjami kodu, współpracować z innymi i utrzymywać porządek w projekcie.

Krok 2: Utworzenie Nowego Projektu C#

Utworzenie nowego projektu C# to kluczowy krok w rozpoczęciu pracy nad aplikacją. Ten proces obejmuje stworzenie struktury projektu oraz niezbędnych plików, które pozwalają na rozwijanie i kompilowanie aplikacji.

Dlaczego jest to ważne?

  • Struktura projektu:
    Tworzenie projektu C# przy użyciu narzędzia dotnet zapewnia standardową strukturę katalogów i plików, co ułatwia organizację kodu i zarządzanie projektem.
  • Konfiguracja:
    Automatycznie generowane pliki konfiguracyjne, takie jak .csproj, zawierają ustawienia kompilacji i zależności projektu, co pozwala na łatwą konfigurację i rozbudowę aplikacji.
  • Podstawowy kod:
    Generowanie pliku Program.cs zawierającego szablon podstawowego kodu aplikacji pozwala na natychmiastowe rozpoczęcie pracy i testowanie podstawowej funkcjonalności.
  • Kompatybilność:
    Tworzenie projektu za pomocą narzędzi .NET SDK zapewnia, że projekt będzie kompatybilny z innymi narzędziami i bibliotekami w ekosystemie .NET.

Kroki:

1. Utwórz nowy katalog na projekt i przejdź do niego
W terminalu, utwórz katalog dla nowego projektu i przejdź do niego:

mkdir HelloWorld
cd HelloWorld

2. Utwórz nowy projekt C#
Utwórz nową aplikację konsolową w C# za pomocą polecenia:

dotnet new console

To polecenie utworzy strukturę projektu oraz wygeneruje pliki takie jak Program.cs i HelloWorld.csproj.

3. Edytuj plik Program.cs
Otwórz plik Program.cs w ulubionym edytorze tekstu i zmień zawartość na poniższą, aby wyświetlać wiadomość “Hello, World!”:

using System;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

Alternatywnie, dla C# 9.0 i nowszych, możesz użyć uproszczonej wersji:

Console.WriteLine("Hello, World!");

Utworzenie nowego projektu C# za pomocą narzędzi .NET SDK jest fundamentalnym krokiem, który zapewnia odpowiednią strukturę projektu, niezbędne pliki konfiguracyjne oraz podstawowy kod aplikacji. Dzięki temu procesowi możesz szybko rozpocząć rozwijanie i testowanie swojej aplikacji, mając pewność, że projekt jest dobrze zorganizowany i zgodny ze standardami ekosystemu .NET.

Krok 3: Inicjalizacja Repozytorium Git

Inicjalizacja repozytorium Git w lokalnym katalogu jest kluczowym krokiem w zarządzaniu wersjami kodu źródłowego. Polega ona na tworzeniu nowego repozytorium Git, które będzie śledzić wszystkie zmiany w projekcie. Dzięki temu projekt staje się bardziej zorganizowany, bezpieczny i łatwiejszy do zarządzania.

Kroki:

1 Zainicjalizuj repozytorium Git
Przejdź do katalogu projektu (HelloWorld), a następnie zainicjalizuj repozytorium za pomocą polecenia:

git init

To polecenie tworzy ukryty katalog .git, w którym Git przechowuje wszystkie informacje potrzebne do śledzenia zmian w projekcie.

Krok 4: Dodawanie plików do repozytorium

Zaczynamy od dodanie pliku .gitignore do repozytorium Git. Plik .gitignore służy do określenia, które pliki i katalogi mają być ignorowane przez Git, co oznacza, że nie będą dodawane do repozytorium ani śledzone.

Jest to ważne z kilku powodów:

  1. Czystość Repozytorium:
    Pomaga utrzymać repozytorium czyste, ignorując pliki i katalogi, które nie są potrzebne w repozytorium, takie jak pliki wynikowe kompilacji, pliki tymczasowe i pliki specyficzne dla użytkownika.
  2. Oszczędność Miejsca:
    Zapobiega dodawaniu dużych, niepotrzebnych plików do repozytorium, co pomaga zaoszczędzić miejsce i sprawia, że repozytorium jest lżejsze.
  3. Bezpieczeństwo:
    Chroni prywatne dane i konfiguracje użytkownika przed przypadkowym dodaniem do repozytorium.
  4. Kompatybilność:
    Ułatwia współpracę z innymi programistami, eliminując potencjalne konflikty spowodowane przez pliki specyficzne dla środowiska lokalnego.

Kroki:

1. Utwórz plik .gitignore
W katalogu głównym projektu (tam, gdzie znajduje się plik .csproj), utwórz plik o nazwie .gitignore. Możesz to zrobić ręcznie lub użyć polecenia:

touch .gitignore

2. Dodaj wzorce do pliku .gitignore
Otwórz plik .gitignore w edytorze tekstu i dodaj poniższe wzorce, aby ignorować pliki i katalogi związane z kompilacją oraz inne pliki, które nie są potrzebne w repozytorium:

# Ignoruj pliki kompilacji
bin/
obj/

# Ignoruj pliki tymczasowe
*.log
*.tmp

# Ignoruj pliki użytkownika
*.user
*.userosx
*.suo
*.userprefs

# Ignoruj pliki konfiguracyjne IDE
.vscode/
.idea/

# Ignoruj katalogi systemowe
.DS_Store
Thumbs.db

Opis wzorców:

  • bin/ i obj/: Katalogi generowane podczas kompilacji aplikacji .NET. Zawierają pliki wynikowe i nie są potrzebne w repozytorium.
  • *.log, *.tmp: Pliki tymczasowe i logi, które mogą być generowane podczas działania aplikacji.
  • *.user, *.userosx, *.suo, *.userprefs: Pliki konfiguracyjne użytkownika i środowiska IDE, które są specyficzne dla poszczególnych programistów.
  • .vscode/, .idea/: Katalogi konfiguracyjne dla edytorów kodu (np. VS Code, IntelliJ IDEA).
  • .DS_Store, Thumbs.db: Pliki systemowe tworzone przez systemy operacyjne (macOS i Windows).

3. Dodaj pliki do repozytorium
Dodaj wszystkie pliki projektu do obszaru staging, przygotowując je do zatwierdzenia:

git add .

Kropka (.) oznacza dodanie wszystkich plików w bieżącym katalogu i jego podkatalogach.

4. Wykonaj pierwszy commit
Zatwierdź dodane pliki z wiadomością opisującą zmiany, na przykład:

git commit -m "Initial commit: Add Hello World project"

Komentarz w cudzysłowie ("...") powinien krótko opisywać, co zostało dodane lub zmienione.

Polecenie git add . dodaje wszystkie pliki (z wyjątkiem tych, które są wymienione w .gitignore) do staging area, a git commit -m “Initial commit: Add Hello World project” zatwierdza te pliki do repozytorium z komunikatem opisującym te zmiany.

Dodanie pliku .gitignore jest kluczowym krokiem w zarządzaniu projektem, ponieważ pomaga utrzymać repozytorium czyste, zorganizowane i wolne od niepotrzebnych plików. Dzięki temu zespół może skupić się na kodzie źródłowym i uniknąć problemów związanych z plikami specyficznymi dla środowiska lokalnego.

Krok 5: Utworzenie Repozytorium Zdalnego (na GitHubie)

Utworzenie repozytorium zdalnego na GitHubie pozwala na synchronizację lokalnego repozytorium z chmurą, co zapewnia dostępność projektu z dowolnego miejsca i umożliwia współpracę z innymi. Repozytorium zdalne działa jako centralne miejsce przechowywania kodu, które jest dostępne z dowolnego miejsca i umożliwia:

  1. Współpracę:
    Członkowie zespołu mogą pracować razem nad projektem, wprowadzać zmiany, przeglądać kod i komentować go.
  2. Bezpieczeństwo:
    Kopia zapasowa kodu jest przechowywana na serwerze zdalnym, co minimalizuje ryzyko utraty danych z powodu awarii sprzętu lub innych problemów lokalnych.
  3. Dostępność:
    Kod jest dostępny z dowolnego miejsca z dostępem do internetu, co ułatwia pracę zdalną i mobilność.

 (Wymagane konto na githubie!)

Kroki:

1. Zaloguj się do GitHub

  • Przejdź do GitHub i zaloguj się na swoje konto. Jeśli nie masz konta, zarejestruj się.

2. Utwórz nowe repozytorium

  • Kliknij przycisk „New” lub „Create new repository”
  • Wprowadź nazwę repozytorium, np. HelloWorld
  • Opcjonalnie dodaj opis, wybierz opcje, takie jak publiczne lub prywatne repozytorium
  • Kliknij „Create repository”

3. Skonfiguruj zdalne repozytorium

  • Po utworzeniu repozytorium, GitHub wyświetli instrukcje, jak połączyć swoje lokalne repozytorium z nowo utworzonym zdalnym repozytorium.
  • W terminalu, dodaj zdalne repozytorium jako origin
git remote add origin https://github.com/twoj_uzytkownik/HelloWorld.git

4. Wypchnij lokalne zmiany do repozytorium zdalnego

  • Wypchnij swoje lokalne zmiany do zdalnego repozytorium na GitHubie, używając polecenia
git push -u origin master

To polecenie wysyła lokalne zmiany do zdalnego repozytorium na GitHubie.

Krok 6: Testowanie Projektu

Testowanie projektu jest kluczowym etapem w cyklu życia oprogramowania. Upewnienie się, że aplikacja działa zgodnie z oczekiwaniami, pomaga zidentyfikować i naprawić błędy przed wdrożeniem. Regularne testowanie podczas rozwoju aplikacji zapewnia, że nowe funkcje nie wprowadzają regresji (czyli nie psują istniejących funkcji). Poniżej opisano kroki, które należy podjąć, aby przetestować projekt „Hello World”.

Dlaczego testowanie jest ważne?

  1. Weryfikacja funkcjonalności: Upewnia się, że aplikacja wykonuje zadania, do których została zaprojektowana.
  2. Wykrywanie błędów: Pomaga zidentyfikować błędy i problemy w kodzie, zanim aplikacja zostanie wdrożona na produkcję.
  3. Zapewnienie jakości: Regularne testowanie poprawia jakość kodu i stabilność aplikacji.
  4. Zapobieganie regresjom: Testowanie umożliwia wczesne wykrywanie błędów wprowadzonych przez nowe zmiany w kodzie.

Kroki:

1. Uruchom projekt

  • Aby przetestować aplikację „Hello World”, musisz skompilować i uruchomić projekt. W terminalu, w katalogu głównym projektu, wpisz:
dotnet run

To polecenie kompiluje i uruchamia aplikację. Powinieneś zobaczyć napis „Hello, World!” w terminalu.

2. Sprawdź stan repozytorium

  • Po uruchomieniu projektu i upewnieniu się, że działa poprawnie, możesz sprawdzić stan repozytorium Git, aby zobaczyć, czy są jakieś niezatwierdzone zmiany:
git status

To polecenie pokaże, czy są jakieś zmiany w lokalnym repozytorium, które nie zostały jeszcze dodane do staging (przygotowane do zatwierdzenia) lub zatwierdzone.

Testowanie projektu „Hello World” jest prostym, ale ważnym krokiem w procesie tworzenia oprogramowania. Umożliwia weryfikację, że kod działa zgodnie z oczekiwaniami, zanim zostanie on zatwierdzony i wypchnięty do repozytorium zdalnego. Regularne testowanie podczas rozwoju aplikacji jest kluczowe dla utrzymania wysokiej jakości kodu i stabilności projektu.

Kontynuując testowanie w kolejnych etapach rozwoju aplikacji, zyskasz pewność, że wprowadzone zmiany są bezpieczne i że aplikacja pozostaje funkcjonalna.

Krok 7: Wprowadzenie Zmian i Aktualizacja Repozytorium

Wprowadzanie zmian i aktualizacja repozytorium to kluczowy proces w zarządzaniu wersjami kodu za pomocą Git. Polega on na edytowaniu kodu źródłowego, dodawaniu zmian do obszaru staging, zatwierdzaniu tych zmian i synchronizowaniu ich z zdalnym repozytorium.

Kroki:

1 Edytowanie Plików

  • Otwórz plik Program.cs w ulubionym edytorze tekstu i wprowadź zmiany. Na przykład, zmień tekst w Console.WriteLine na „Hello, Git!”:
Console.WriteLine("Hello, Git!");

2. Dodanie Zmian do Staging

  • Po dokonaniu zmian, dodaj je do obszaru staging za pomocą polecenia git add:
git add Program.cs

3. Zatwierdzenie Zmian

  • Zatwierdź zmiany, dodając wiadomość opisującą, co zostało zmienione, używając git commit:
git commit -m "Update message to Hello, Git!"

4. Pobranie Zmian z Repozytorium Zdalnego

  • Przed wypchnięciem lokalnych zmian do zdalnego repozytorium, warto pobrać i scalić najnowsze zmiany z repozytorium zdalnego, aby upewnić się, że nie wystąpią konflikty:
git pull

5. Wypchnięcie Zmian do Repozytorium Zdalnego

  • Po zatwierdzeniu i scaleniu zmian, wypchnij je do repozytorium zdalnego, używając git push:
git push

6. Przeglądanie Historii Commitów

  • Możesz przeglądać historię commitów, aby zobaczyć wszystkie dokonane zmiany:
git log

7, Sprawdź stan repozytorium

git status

Wprowadzanie zmian i aktualizacja repozytorium są kluczowymi aspektami pracy z Gitem. Regularne zatwierdzanie i synchronizowanie zmian pomaga utrzymać porządek w projekcie, ułatwia współpracę i zapewnia, że najnowsze wersje kodu są zawsze dostępne dla całego zespołu.

Krok 8: Tworzenie osobnych gałezi (branches) pod nowe funkcjonalności.

Tworzenie osobnych gałęzi w Git jest kluczowym aspektem zarządzania wersjami, szczególnie w większych projektach lub podczas pracy zespołowej. Gałęzie pozwalają na równoległe rozwijanie nowych funkcji, naprawianie błędów, czy eksperymentowanie bez wpływu na główną linię kodu (zwykle nazwaną main lub master).

Główne zalety korzystania z gałęzi to:

  1. Izolacja Zmian:
    Każda gałąź jest niezależną linią rozwoju, co pozwala na wprowadzanie zmian bez ryzyka wpłynięcia na stabilną wersję kodu.
  2. Współpraca:
    Ułatwiają współpracę w zespole, pozwalając każdemu programiście pracować nad swoją funkcją bez wpływu na pracę innych.
  3. Łatwe Testowanie:
    Nowe funkcje mogą być testowane i weryfikowane na oddzielnych gałęziach przed scaleniem z główną gałęzią.
  4. Historia Zmian:
    Każda gałąź zachowuje pełną historię zmian, co ułatwia śledzenie i rozumienie, jakie modyfikacje zostały wprowadzone i dlaczego.

Kroki:

1. Tworzenie Nowej Gałęzi

  • Użyj polecenia git branch, aby utworzyć nową gałąź. Na przykład, aby utworzyć gałąź dla nowej funkcji, możesz nazwać ją feature/new-functionality
git branch feature/new-functionality

2. Przełączanie się na Nową Gałąź

  • Po utworzeniu nowej gałęzi, przełącz się na nią za pomocą git checkout
git checkout feature/new-functionality

Alternatywnie, możesz utworzyć i przełączyć się na nową gałąź jednym poleceniem:

git checkout -b feature/new-functionality

3. Praca na Gałęzi

  • Wprowadź zmiany, dodaj nowe funkcje, popraw błędy, a następnie dodaj zmiany do stagingu i zatwierdź je:
git add .
git commit -m "Add new functionality"

Aby opublikować gałąź na repozytorium zdalnym wykonaj polecenie:

git push origin feature/new-functionality

4. Powrót do Głównej Gałęzi

  • Po zakończeniu pracy nad nową funkcją, przełącz się z powrotem na główną gałąź (main lub master):
git checkout main

5. Scalanie Gałęzi

  • Po przetestowaniu i upewnieniu się, że zmiany działają poprawnie, scal nową gałąź z główną gałęzią. Upewnij się, że znajdujesz się na głównej gałęzi, a następnie wykonaj polecenie scalania:
git merge feature/new-functionality
  • Jeśli wystąpią konflikty podczas scalania, Git poprosi o ich ręczne rozwiązanie. Git wskaże, które pliki wymagają ręcznego rozwiązania konfliktów. Po rozwiązaniu konfliktów dodaj zmienione pliki do staging i zatwierdź je:
git add konfliktny-plik
git commit -m "Resolve merge conflicts"

6. Usuwanie Gałęzi

  • Po zakończeniu pracy i scaleniu gałęzi, możesz usunąć gałąź, która nie jest już potrzebna:
git branch -d feature/new-functionality
  • Uwaga: Używaj tej komendy tylko po scaleniu gałęzi z główną gałęzią, aby uniknąć utraty zmian.

Tworzenie i zarządzanie gałęziami w Git pomaga utrzymać porządek w projekcie, umożliwiając jednoczesną pracę nad wieloma funkcjonalnościami i łatwe integrowanie zmian w głównej linii kodu.

Podsumowanie

Teraz masz działający projekt „Hello” w C#, który jest zarządzany za pomocą Git. Powyższe kroki pokazują, jak zainicjalizować repozytorium Git, dodać projekt, utworzyć repozytorium na GitHubie i synchronizować zmiany między lokalnym i zdalnym repozytorium.

Używanie Gita do wersjonowania kodu pomaga śledzić zmiany, współpracować z innymi programistami i zarządzać historią projektu w sposób zorganizowany.

Dodaj komentarz

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