---
# System prepended metadata

title: 'ASP.NET Core #1'
tags: [ASP.NET, .Net PG]

---

# ASP.NET Core #1

## HTTP

Mechanizm pozwalający na wymianę danych pomiędzy komputerami - za pomocą sieci. Jest **bezstanowy**, czy nie posiada pamięci (czyli nie pamięta wcześniejszych zapytań, trzeba "przypominać" o niektórych rzeczach)

* **serwer** - świadczy usługi innym programom (klientom)
* **klient** - program, który korzysta z usług serwera

W dużym uproszczeniu, komunikacja polega na wysyłaniu wzajemnych komunikatów pomiędzy klientem i serwerem. Serwer i klient (klienci) komunikują się według schematu zapytanie-odpowiedź tzn. klient inicjuje komunikację, a serwer odpowiada na zapytania wysyłane przez klienta.

HTTPS - HTTP + Secure, dodaje dodatkowe szyfrowanie

## MVC - Model View Controller

Wzorzec architektoniczny służący do organizowania struktury aplikacji posiadającej graficzne interfejsy użytkownika (wiki)

* **Model** - jest to opis czegoś (student, samochód), zbiór danych coś opisujących. Często pokrywa się ze strukturą bazy danych.
* **Controller** - przyjmuje zapytania od klienta, wykonuje operacje na modelu (zmienia dane, dodaje nowe, usuwa itd), zmienia widok 
* **View** - część odpowiedzialna za wyświetlenie informacji dla użytkownika. Mogą zmieniać stan modelu, ale tylko wizualnie (np. wyświetlić datę w innym formacie)

## Routing

Klient może wysyłać dużą liczbę żądań do serwera, tak samo serwer może mieć dużą liczbę kontrolerów i modeli. 

Aby poprawnie zinterpretować zapytanie przesłane do serwera, wykorzystywany jest routing. Polega na pobraniu informacji z  adresu URL i wyboru kontrolera i akcji na tej podstawie.

Domyślny schemat routingu w ASP.NET Core wygląda tak:
`{controller}/{action}/{id?}` 
W przypadku nie podania nazwy akcji, domyślnie wybierana jest akcja Index, przy braku nazwy kontrolera domyslnie wybierany jest kontroler Home

**Przykłady:**
`localhost:5000/students/display`  - Wybrana zostanie akcja Display z kontrolera Students

`localhost:5000/cars/manual/23`  - Wybrana zostanie akcja Manual z kontrolera Cars, do której zostanie przekazany parametr o wartości 23 

**Wielkość liter w adresie URL nie ma znaczenia**

## Struktura projektu ASP.NET Core MVC
* **Dependencies** - biblioteki używane w naszym projekcie
* **Properties** - zawiera plik launchSettings.json, w którym znajdują się informacje dotyczące konfiguracji lokalnego serwera
* **wwwroot** - folder z plikami statycznymi, które mogą być wysyłane do klienta (zdjęcia, ikony, style css, skrypty JavaScript)
* **Controllers** - folder, w którym znajdują się kontrolery. Konwencja wymusza aby każdy z nich posiadał sufiks -Controller np. StudentsController, VehiclesController itd.
* **Models** - folder, w którym znajdują się klasy modelu
* **Views** - folder z widokami. Każdy kontroler, który zwraca widoki posiada swój podfolder o nazwie odpowiadającej nazwie kontrolera np. Students, Vehicles
* **appsettings.json** - plik zawierający informacje nt. podstawowej konfiguracji aplikacji
* **Program.cs** - punkt wejścia do aplikacji, zawiera w sobie klasę Program, która uruchamia serwer
* **Startup.cs** - zawiera w sobie klasę Startup, która posiada 2 metody: `ConfigureServices` oraz `Configure`. Pierwsza z nich pozwala na poinformowanie o kodzie, który chcemy wykorzystywać w różnych miejscach naszej aplikacji. Druga z kolei konfiguruje **HTTP request pipeline** czyli sposób w jaki każde zapytanie HTTP jest "obrabiane" zanim trafi do odpowiedniego kontrolera (opowieść o ludziach stojących w rurociągu i grających w głuchy telefon). Oprogramowanie, które przetwarza zapytanie HTTP nazywane jest **middleware** (oprogramowanie pośredniczące).

## Kod

### internal

```c#embedded
class Student 
{

}
```

Jak widać, ta klasa nie ma swojego operatora dostępu. Domyślnie jest to **internal**, czyli publicznie dostępne, ale tylko wewnątrz tego projektu.

### Przeciążenie metod (overload)

```c#embedded
public void Method() { /**/ }

public void Method(object model) { /**/ }

public void Method(string name, object model) { /**/ }
```
Przeciążenie metod to po prostu tworzenie metod o tej samej nazwie, ale o różnych parametrach (różna ilość, różne typy itd.)

### Kod c# w .cshtml

```
@kod
```
Wszystko co po @ jest traktowane jako C#

### Przesyłanie danych z kontrolera do widoku
```c#embedded
public class HomeController : Controller
{
    public IActionResult Index() 
    {
        var student = new Student () 
        {
            Id = 1,
            Index = 123456,
            FirstName = "Daniel",
            LastName = "Wilkiewicz"
        };

        return View (student);
    }
}
```
Do widoku o nazwie Index, zostanie przesłany obiekt `student` zawierający 4 właściwości.

### Odczytywanie w widoku danych przesłanych z kontrolera
```#htmlembedded
@model Student
@{
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <p>Id: @Model.Id</p>
    <p>Index: @Model.Index</p>
    <p>First name: @Model.FirstName</p>
    <p>Last name: @Model.LastName</p>
</div>
```

Widok otrzymał dane, ale aby móc je poprawnie zinterpretować potrzebne jest użycie słowa kluczowego `@Model`. W ten sposób informujemy widok o typie danych, z których korzystamy. Możemy teraz odwoływać się do przesłanego obiektu korzystając z właściwości `Model`. W powyższym przykładzie informujemy o tym, że przesłane dane są typu `Student`. Następnie możemy odwoływać się do nich w kodzie widoku, pamiętając o tym, żeby wyrażenie C# poprzedzać znakiem `@`

### Przesyłanie danych z widoku do kontrolera za pomocą parametrów

```c#embedded
public class HomeController : Controller
{
    public static List<Student> students = new List<Student>()
    {
        new Student()
        {
            Id=1,
            Index=123456,
            FirstName = "Daniel",
            LastName = "Wilkiewicz"
        },
        new Student()
        {
            Id=2,
            Index=35453,
            FirstName = "Krzysztof",
            LastName = "Milewski"
        },
    }


    public IActionResult Index(int id)
    {
        var student = students.FirstOrDefault(s => s.Id == id);
        return View(student);
    }
}
```

Metoda `FirstOrDefault` wyszukuje pierwszego studenta, którego pole `Id` jest równe przekazanemu parametrowi.
Parametr dla akcji `Index` zostaje przekazany za pomocą schematu routingu. Przechodząc pod adres `/home/index/1` przyjmuje on wartość 1. W przypadku nie podania wartości parametru i wykonania zapytania pod adres `/home/index` parametr `id` przyjmuje wartość domyślną dla typu `int` czyli 0. Spowoduje to błąd w działaniu aplikacji, gdyż nie istnieje student, którego pole `Id` jest równe 0. 

### LINQ

W dużym uproszczeniu jest to rodzaj operacji na kolekcjach.

## Git

System kontroli wersji. 

Sprawdzenie wersji git:
```
git --version
```

Klonowanie (pobieranie) repozytorium:
```
git clone adres.url.repozytorium
```

## Resharper
https://www.jetbrains.com/resharper/

###### tags: `.Net PG` `ASP.NET`