Michał Simoniuksztis o programowaniu w .NET

II. Implementacja rozwiązań Infrastructure as a service część 2 - ARM templates

Fri, 15 Oct 2021 16:36:25 +0200

Implementacja rozwiązań IaaS jest częścią tematu Develop Azure compute solutions egzaminu AZ-204.

Umiejętności badane w tej części egzaminu: * Uruchamianie maszyn wirtualnych (VM) * Konfiguracja, walidacja i wdrażanie *szablonów ARM* * Konfiguracja obrazów kontenerów * Publikacja obrazów w Azure Container Registry * Uruchamianie kontenerów za pomocą Azure Container Instance

1. Szablony ARM

Szablon ARM to plik w formacie JSON, który jest dokumentem konfiguracyjnym definiującym zasoby, które mają zostać wdrożone na platformie Azure wraz z ich konfiguracjami. Za pomocą szablonu ARM można utworzyć dowolny zasób. Szablony ARM są podstawowym elementem automatyzacji wdrażania infrastruktury Azure.

Korzystając z szablonów ARM, można sparametryzować elementy konfiguracji dla zasobów zdefiniowanych w szablonie. Można użyć parametrów dla często zmienianych elementów konfiguracji, takich jak nazwy maszyn wirtualnych, nazwy sieci wirtualnych itd. Można następnie użyć tego samego szablonu ARM wielokrotnie używając różnych parametrów, aby wdrożyć różne środowiska np. inny zestaw parametrów dla produkcji i inny dla QA.

Szablon ARM można skompilować i wyeksportować z portalu Azure lub napisać ręcznie. Ponadto można zacząć od kolekcji szablonów szybkiego startu dostępnych w Azure Portal w bloku wdrażania niestandardowego.

2. Wdrażanie szablonów ARM:

Po utworzeniu szablonu ARM przesyłamy go do usługi Azure Resource Manager. Resource Manager odbiera szablon w postaci pliku JSON, a następnie konwertuje go na operacje interfejsu REST API. W celu wdrożenia możemy użyć różnych narzędzi a w tym: * Azure Portal * Azure CLI * PowerShell (Az Module) * REST API * Azure Cloud Shell

3. Format szablonu ARM

W swojej najprostszej strukturze szablon składa się z następujących elementów:

powershell { "$schema": "https://schema.management.azure.com/schemas/2019-04-01/. deploymentTemplate.json#", "contentVersion": "", "apiProfile": "", "parameters": { }, "variables": { }, "functions": [ ], "resources": [ ], "outputs": { } }

$schema - Lokalizacja schematu JSON opisującego wersję języka szablonu.
contentVersion - Wersja szablonu (np. 1.0.0.0). Można użyć dowolną wartość, aby udokumentować znaczące zmiany w szablonie.
apiProfile - Wersja interfejsu API, która służy jako kolekcja wersji interfejsu API dla typów zasobów. Użyj tej wartości, aby uniknąć konieczności określania wersji interfejsu API dla każdego zasobu w szablonie.
parameters - Wartości parametrów podawane podczas wdrażania w celu dostosowania zasobów.
variables - Wartości używane jako fragmenty JSON w szablonie w celu uproszczenia wyrażeń języka szablonu.
functions - Funkcje zdefiniowane przez użytkownika, które są dostępne w szablonie.
resources - Typy zasobów, które są wdrażane lub aktualizowane w grupie zasobów lub subskrypcji.
outputs - Wartości zwracane po wdrożeniu.

Więcej na temat struktury i składni mozna przeczytać na stronie: Struktura i składnia szablonu ARM

4. Demo - Pobranie szablonu ARM maszyny wirtualnej z portalu Azure:

Aby utworzyć szablon ARM, zamiast tworzyć go od początku ręcznie, możemy go utworzyć w Azure Portal. Następnie możemy go pobrać, dodać do biblioteki lub wdrożyć.

Aby utworzyć szablon ARM, zaczynamy od utworzenia maszyny wirtualnej w Azure Portal, ale zamiast tworzyć maszynę wirtualną, eksportujemy szablon ARM dla tego wdrożenia (proces ten jest podobny dla większości zasobów na platformie Azure). Proces tworzenia maszyny wirtualnej w Azure Portal był opisany w poprzednim wpisie z tej serii (Implementacja-rozwiazan-infrastructure-as-a-service-czesc-1-maszyny-wirtualne).

Po kliknięciu guzika Przeglądanie + tworzenie, zamiast kliknąć guzik Utwórz wybieramy Pobierz szablon do automatyzacji. Spowoduje to utworzenie plików JSON szablonu i parametrów potrzebnych do wdrożenia opartego na szablonie ARM dla właśnie skonfigurowanej maszyny wirtualnej.

Na tym ekranie w górnym menu możemy kliknąć Pobierz, aby pobrać pliki szablonów i parametrów, możemy kliknąć Dodaj do biblioteki, aby dodać je do biblioteki w celu dalszych wdrożeń, lub możemy je wdrożyć bezpośrednio z tego miejsca za pomocą guzika Wdróż. Dodatkowo możemy zbadać utworzone pliki w oknie poniżej:

Pliki wygenerowanego szablonu dostępne są tutaj:

parameters.json

template.json

Schema: json "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#"

ContentVersion: json "contentVersion": "1.0.0.0",

Parameters: json "parameters": { "location": { "type": "string" }, "networkInterfaceName": { "type": "string" }, "networkSecurityGroupName": { "type": "string" } #... }

Variables: json "variables": { "nsgId": "[resourceId(resourceGroup().name, 'Microsoft.Network/networkSecurityGroups', parameters('networkSecurityGroupName'))]", "vnetId": "[resourceId(resourceGroup().name,'Microsoft.Network/virtualNetworks', parameters('virtualNetworkName'))]", "subnetRef": "[concat(variables('vnetId'), '/subnets/', parameters('subnetName'))]" }

Resources: json "resources": [ { "name": "[parameters('networkInterfaceName')]", "type": "Microsoft.Network/networkInterfaces", #... }, { "name": "[parameters('networkSecurityGroupName')]", "type": "Microsoft.Network/networkSecurityGroups", #... }, { "name": "[parameters('virtualNetworkName')]", "type": "Microsoft.Network/virtualNetworks", #... }, { "name": "[parameters('publicIpAddressName')]", "type": "Microsoft.Network/publicIpAddresses", #... }, { "name": "[parameters('virtualMachineName')]", "type": "Microsoft.Compute/virtualMachines", "apiVersion": "2020-06-01", "location": "[parameters('location')]", "dependsOn": [ "[concat('Microsoft.Network/networkInterfaces/', parameters('networkInterfaceName'))]" ], "properties": { #... } } ]

Outputs: json "outputs": { "adminUsername": { "type": "string", "value": "[parameters('adminUsername')]" } }

5. Demo - wdrożenie szablonu ARM maszyny wirtualnej:

Plik ze skryptem wdrożenia dostępny jest tutaj: deploy-win-vm-arm-template-by-azure-powershell.ps1

Przed wdrożeniem należy ustawić parametr adminPassword w pliku parameters.json. ```powershell

Login and set a subscription

Connect-AzAccount -SubscriptionName 'BizSpark' Set-AzContext -SubscriptionName 'BizSpark'

Create a Resource Group

New-AzResourceGroup -Name "iaas-demo-rg" -Location "WestEurope"

Deploy ARM Template

New-AzResourceGroupDeployment -Name mydeployment -ResourceGroupName 'iaas-demo-rg' -TemplateFile './vm-template/template.json' ` -TemplateParameterFile './vm-template/parameters.json' ```

I. Implementacja rozwiązań Infrastructure as a service część 1 - Maszyny wirtualne

Fri, 15 Oct 2021 16:28:25 +0200

Implementacja rozwiązań IaaS jest częścią tematu Develop Azure compute solutions egzaminu AZ-204.

Umiejętności badane w tej części egzaminu:

Uruchamianie maszyn wirtualnych (VM)
Konfiguracja, walidacja i wdrażanie szablonów ARM
Konfiguracja obrazów kontenerów
Publikacja obrazów w Azure Container Registry
Uruchamianie kontenerów za pomocą Azure Container Instance

1. Uruchamianie maszyn wirtualnych

Zacznijmy od ogólnego przeglądu tego, z czego składa się maszyna wirtualna. Maszyny wirtualne platformy Azure (VMs) są wdrażane w grupach zasobów i znajdują się w regionach platformy Azure. Zwykle chcemy umieścić maszynę wirtualną w regionie blisko aplikacji lub użytkowników, którzy będą korzystać z usług wdrożonych na tej maszynie wirtualnej. Podczas budowania maszyny wirtualnej wybieramy spośród wstępnie skonfigurowanych rozmiarów maszyn wirtualnych na podstawie liczby rdzeni procesora, ilości pamięci RAM, a także różnych możliwości wydajności dysku. Wybrany rozmiar zależy od obciążenia wdrażanego na tej maszynie wirtualnej. Rozmiar maszyny wirtualnej można łatwo zaktualizować lub obniżyć po wdrożeniu maszyny wirtualnej. Kolejnym kluczowym elementem wdrażania maszyny wirtualnej jest połączenie sieciowe maszyny wirtualnej z resztą środowiska i w razie potrzeby z Internetem. Kolejnym składnikiem maszyny wirtualnej są obrazy maszyn wirtualnych. Obrazy są podstawowym obrazem używanym do wdrażania na naszej maszynie wirtualnej, najczęściej systemów operacyjnych, takich jak Windows lub Linux. W portalu Azure Marketplace dostępnych jest wiele różnych obrazów maszyn wirtualnych opartych na wielu różnych systemach operacyjnych z róznymi edycjami, obrazy ze wstępnie skonfigurowanymi aplikacjami oraz sieciowe urządzenia wirtualne. Ostatnim składnikiem maszyny wirtualnej jest pamięć masowa. Każda utworzona maszyna wirtualna będzie miała co najmniej jeden dysk wirtualny do obsługi podstawowego systemu operacyjnego. W razie potrzeby można dodać dodatkowe dyski wirtualne w celu obsługi danych aplikacji.

Metody tworzenia maszyn wirtualnych na platformie Azure:

Podczas tworzenia maszyny wirtualnej na platformie Azure mamy do dyspozycji kilka narzędzi:

Azure Portal
Azure CLI
Azure PowerShell (Az Module)
Azure ARM Templates

2 Tworzenie maszyny wirtualnej w portalu Azure

Aby utworzyć maszynę wirtualną w portalu Azure należy przejść do usługi Maszyny Wirtualne i wcisnąć guzik utwórz maszynę wirtualną. Na stronie tworzenie maszyny wirtualnej pierwsza sekcja to informacje Podstawowe o tworzonej maszynie. Na górze strony można zobaczyć, że istnieją dodatkowe sekcje dotyczące dysków, sieci, zarządzania itp. Te sekcje umożliwiają tworzenie bardziej niestandardowych konfiguracji, takich jak dodawanie dodatkowych dysków lub dodawanie maszyny wirtualnej do istniejącej sieci wirtualnej, a nawet tworzenie bardziej szczegółowych reguł zabezpieczeń sieci.

W sekcji Podstawowe przypisujemy tworzoną maszynę wirtualną do subskrypcji i do grupy zasobów. Jeśli grupa zasobów nie istnieje to można ją utworzyć. Następnie definiujemy szczegóły instancji, w której nadajemy maszynie wirtualnej nazwę i wybieramy region, w którym chcemy wdrożyć maszynę wirtualną. Następnie, opcjonalnie, możemy określić zestawy i strefy dostępności. Następnie wybierzemy obraz maszyny wirtualnej z listy obrazów dostępnych w wybranym regionie.

Kolejna opcja to Azure Spot, która pozwala na użycie maszyny w obniżonej cenie lecz umożliwia platformie Azure zatrzymanie i zwolnienie maszyny wirtualnej, jeśli platforma Azure z dowolnego powodu potrzebuje z powrotem tej pojemności obliczeniowej.

Następnie definiujemy rozmiar maszyny wirtualnej, w przypadku tej demonstracji wybieramy najniższy z naszej listy rozmiarów maszyn wirtualnych dostępnych w regionie.

W sekcji Konto administratora definiujemy wymagane informacje dotyczące dostępu administracyjnego do maszyny wirtualnej. W systemie Windows jest to nazwa użytkownika i hasło, a w systemie Linux może to być nazwa użytkownika i hasło lub klucz publiczny SSH.

Na koniec definiujemy kilka reguł portów przychodzących, aby uzyskać dostęp do tej maszyny wirtualnej. W konfiguracji domyślnej maszyna wirtualna otrzyma publiczny adres IP w celu uzyskania dostępu do tej maszyny wirtualnej przez Internet. Ale domyślnie dostęp spoza sieci wirtualnej lub Internetu nie jest dozwolony. Dodanie tutaj reguł portów przychodzących jest sposobem na zezwolenie na dostęp sieciowy do maszyny wirtualnej poprzez określenie, które porty przychodzące chcemy otworzyć. Wybranie portu przychodzącego w tym miejscu doda regułę do grupy zabezpieczeń sieci, umożliwiając dostęp z dowolnego adresu IP na określonym porcie. Ponieważ jest to maszyna wirtualna Windows i chcemy uzyskać do niej zdalny dostęp, otworzymy protokuł RDP na porcie 3389. Pozwoli to na dostęp RDP do tej maszyny wirtualnej na tym porcie z dowolnego adresu IP. Możemy również dodać inne porty, takie jak 80 dla HTTP, 443 dla HTTPS i port 22 dla dostępu SSH do maszyny wirtualnej.

Dane do wprowadzenia w sekcji Podstawowe:

| Sekcja | Wartość | |:----------------|:---------------| | Subskrypcja | {subscription_name} | | Grupa zasobów | (new) iaas-demo-rg | | Nazwa maszyny wirtualnej | iaas-demo-win | | Region | Europa Zachodnia | | Opcje dostępności | Nie jest wymagana żadna nadmiarowość infrastruktury | | Obraz | Windows server 2019 Datacenter - Gen1 | | Rozmiar | Standard_DS1_v2 | | Username | iaas-demo-win-user | | Password | {jakieś-hasło} | | Publiczne porty ruchu przychodzącego | Zezwalaj na wybrane porty | | Wybierz porty wejściowe | RDP (3389) | | Przeglądanie + tworzenie | |

Widok w trakcie wdrażania maszyny:

Widok detali utworzonej maszyny wirtualnej:

Aby połączyć się do maszyny za pomocą protokołu RDP wybieramy guzik Połącz z górnego menu na stronie detali maszyny wirtualnej i pobieramy plik RDP:

3 Tworzenie maszyny wirtualnej w kodzie

Jako programiści jesteś przyzwyczajony do pisania kodu do tworzenia aplikacji. Na platformie Azure istnieje możliwość tworzenia maszyn wirtualnych i infrastruktury przy użyciu kodu. A wdrażanie infrastruktury, takiej jak maszyny wirtualne z kodem, zapewnia Twojej organizacji dużą wartość: * wdrażanie maszyn wirtualnych z kodem zwiększa spójność wdrożeń i tworzenia maszyn wirtualnych, dzięki czemu można za każdym razem tworzyć wiele maszyn wirtualnych w ten sam sposób. * jak każdy inny kod, kod infrastruktury można umieścić w repozutorium kodu źródłowego takim jak np. GIT. * kod infrastruktury może być użyty do wdrażania systemów produkcyjnych z wykorzystaniem automatyzacji. * dzięki wdrożeniom w kodzie, możesz wykorzystać ten kod do konstruowania podobnych środowisk takich jak DEV/TEST/STG.

Niezależnie od tego, czy tworzymy maszynę wirtualną za pomocą interfejsu wiersza polecenia platformy Azure, czy programu Azure PowerShell z modułem Az, proces tworzenia maszyny wirtualnej w kodzie składa się z tych samych kroków: 1. Logowanie i ustawienie aktywnej subskrypcji 2. Tworzenie grupy zasobów (resource group) 3. Tworzenie maszyny wirtualnej (VM) 4. Udostępnienie portu dostępu zdalnego (w systemie Windows jest to port TCP 3389. W przypadku RDP i Linux jest to port TCP 22 dla SSH.) 5. Pobranie publicznego adresu IP

3.1 Tworzenie maszyny wirtualnej za pomocą Azure CLI

Logowanie i ustawienie aktywnej subskrypcji

Za pomocą polecenia az login logujemy się na konto Azure. Po uruchomieniu polecenia uruchomi się przeglądarka internetowa z dialogiem logowania do konta Azure.

Za pomocą polecenia az account set --subscription ustawiamy aktywną subskrypcję.

```powershell

Login and set a subscription

az login az account set --subscription "" ```

Tworzenie grupy zasobów

Możemy utworzyć grupę zasobów za pomocą polecenia Azure CLI: az group create. Nadajemy tej grupie zasobów nazwę, wybieramy lokalizację w której chcemy utworzyć grupę zasobów. Możemy też oczywiście wdrożyć maszynę wirtualną w już istniejącej grupie zasobów.

powershell az group create \ --name "iaas-demo-rg" \ --location "westeurope"

Tworzenie maszyny wirtualnej Możemy utworzyć maszynę wirtualną za pomocą polecenia Azure CLI: az vm create. Jako parametry dodajemy nazwę grupy zasobów, nazwę maszyny wirtualnej, obraz systemu oraz dane uwierzytelniające służące do zalogowania się do systemu. Procedura różni się nieco dla systemów Windows i Linux.

Windows:

Obraz maszyny wirtualnej Windows 2019 Server Datacenter to win2019datacenter. Kolejne dwa parametry definiują nazwę użytkownika administratora i hasło administratora. Ponieważ jest to Windows, to konto będzie lokalnym kontem administratora, którego można użyć do zalogowania się do maszyny wirtualnej za pierwszym razem. Możesz określić rozmiar maszyny wirtualnej za pomocą parametru o nazwie size. Jeśli nic nie zostanie wybrane to domyślnie otrzymamy maszynę wirtualną Standard Ds1 v2.

powershell az vm create \ --resource-group "iaas-demo-rg" \ --name "iaas-demo-win" \ --image "win2019datacenter" \ --admin-username "iaasdemoadmin" \ --admin-password "iaasdemoadmin123$%^"

Linux:

Jeśli chcemy utworzyć maszynę wirtualną z Linuksem, wzorzec jest bardzo podobny. Jako obraz Linuksa możemy wybrać Ubuntu LTS. Możemy zmienić typ uwierzytelniania dla tej maszyny wirtualnej na ssh (domyślnym jest hasło). Lokalizacja tego klucza pochodzi z pliku na dysku lokalnym.

powershell az vm create \ --resource-group "iaas-demo-rg" \ --name "iaas-demo-linux" \ --image "UbuntuLTS" \ --admin-username "iaasdemoadmin" \ --authentication-type "ssh" \ --ssh-key-value ~/.ssh/id_rsa.pub

Powyższe dwa przykłady pokaują minimalne parametry potrzebne do utworzenia maszyny wirtualnej za pomocą Azure CLI. Dostępnych jest wiele innych opcji, takich jak dołączenie maszyny wirtualnej do już istniejącej sieci wirtualnej lub sieciowej grupy zabezpieczeń.

Udostępnienie portu dostępu zdalnego

Polecenie otwierające port dostępu zdalnego to az vm open-port. Należy określić nazwę grupy zasobów, nazwę maszyny wirtualnej oraz port, który chcemy otworzyć. To polecenie doda regułę otwierania portu (3389 dla Windows lub 22 dla SSH w Linuxie) w sieciowej grupie zabezpieczeń, do której jest dołączona jest maszyna wirtualna.

Windows: powershell az vm open-port \ --resource-group "iaas-demo-rg" \ --name "iaas-demo-win" \ --port "3389"

Linux: powershell az vm open-port \ --resource-group "iaas-demo-rg" \ --name "iaas-demo-linux" \ --port "22"

Pobranie publicznego adresu IP Aby pobrać publiczny adres IP za pomocą Azure CLI używamy polecenia az vm list-ip-addresses. Za pomocą tego polecenia określasz nazwę grupy zasobów i nazwę maszyny wirtualnej. Spowoduje to wyświetlenie publicznego adresu IP powiązanego z określoną maszyną wirtualną.

powershell az vm list-ip-addresses \ --resource-group "iaas-demo-rg" \ --name "iaas-demo-win"

Kod demo:

create-win-vm-by-azure-cli

create-linux-vm-by-azure-cli

3.2 Tworzenie maszyny wirtualnej za pomocą Azure Power Shell

Logicznie proces tworzenia maszyny wirtualnej jest taki sam jak dla Azure CLI.

Logowanie i ustawienie aktywnej subskrypcji:

Za pomocą polecenia Connect-AzAccount logujemy się na konto Azure. Po uruchomieniu polecenia uruchomi się przeglądarka internetowa z dialogiem logowania do konta Azure.

Za pomocą polecenia Set-AzContext -SubscriptionName ustawiamy aktywną subskrypcję.

```powershell

Login and set a subscription

Connect-AzAccount -SubscriptionName 'BizSpark' Set-AzContext -SubscriptionName 'BizSpark' ```

Tworzenie grupy zasobów

Grupę zasobów tworzymy za pomocą polecenia: New-AzResourceGroup. Nadajemy tej grupie zasobów nazwę i wybieramy lokalizację.

```powershell

Create a Resource Group

New-AzResourceGroup -Name "iaas-demo-rg" -Location "WestEurope" ```

Tworzenie maszyny wirtualnej i udostępnienie portu dostępu zdalnego

Krokiem wymaganym do utworzenia maszyny wirtualnej w programie PowerShell jest utworzenie obiektu PSCredential, który będzie zawierał nazwę użytkownika i hasło używane do poświadczeń konta administratora lokalnego na wdrażanej maszynie wirtualnej. Obiekt PSCredential definiujemy z nazwą użytkownika i hasłem skonwertowanym na bezpieczny ciąg jako parametrami wejściowymi. Aby skonwertować hasło na bezpieczny ciąg używamy polecenia ConvertTo-SecureString.

Polecenie New-AzVM tworzy maszynę wirtualną na platformie Azure. Jako parametry definiujemy nazwę grupy zasobów, nazwę maszyny wirtualnej i Credential. W ramach procesu tworzenia maszyny wirtualnej, za pomocą parametru OpenPorts, możemy określić porty które mają być otwarte na maszynie wirtualnej.

```powershell

Create a VM credentials

$username = 'iaasdemoadmin' $password = ConvertTo-SecureString 'iaasdemoadmin123$%^' -AsPlainText -Force $WindowsCred = New-Object System.Management.Automation.PSCredential ($username, $password)

Create a Windows VM

New-AzVM -ResourceGroupName 'iaas-demo-rg' -Name 'iaas-demo-win' -Image 'Win2019Datacenter' -Credential $WindowsCred ` -OpenPorts 3389 ```

Pobranie publicznego adresu IP

Aby pobrać publiczny adres IP można użyć polecenia Get‑AzPublicIpAddress, a następnie określić nazwę grupy zasobów i nazwę maszyny wirtualnej i użyć Select-Object, aby zwrócić tylko pole IpAddress ze zwróconego obiektu.

```powershell

Get the Public IP

Get-AzPublicIpAddress -ResourceGroupName 'iaas-demo-rg' -Name 'iaas-demo-win' | Select-Object IpAddress ```

Kod demo:

create-win-vm-by-azure-powershell

Import danych z pliku CSV do bazy danych Postgres za pomocą AWS Glue i S3 bucket

Fri, 08 Oct 2021 08:05:32 +0200

Import danych do bazy danych jest częstym zadaniem programisty. Niestety zadanie to często niesie ze sobą wiele wyzwań i obejmuje wiele dodatkowych zadań takich jak odkrywanie i wydobywanie danych z różnych źródeł, sprawdzanie poprawności, wzbogacanie, czyszczenie, normalizowanie i łączenie danych oraz ładowanie i organizowanie danych w bazach lub hurtowniach danych. Dodatkowym problemem jest często duży wolumen danych które muszą zostać zaimportowane.

AWS Glue rozwiązuje część z tych problemów.

AWS Glue

AWS Glue jest bezserwerową usługą integracji danych, która ułatwia odkrywanie, przygotowywanie i łączenie danych na potrzeby analiz, uczenia maszynowego i tworzenia aplikacji. AWS Glue zapewnia wszystkie możliwości potrzebne do integracji danych, dzięki czemu możesz rozpocząć analizę danych i oddanie ich do użytku w ciągu kilku minut, a nie miesięcy.

Praca z AWS Glue

Praca z AWS Glue składa się z trzech etapów. W pierwszym etapie AWS Glue odkrywa schemat danych do zaimportowania i zapisuje go do tabeli w AWS Glue Data Catalog. Zadanie to wykonywane jest poprzez crowlera.

W drugim etapie, na podstawie wygenerowanego schematu, AWS Glue wygeneruje skrypt zadania ETL job, które zaimportuje dane ze źródła, przekształci je i zapisze do miejsca docelowego.

Trzecim zadaniem AWS Glue jest uruchomienie wykonania utworzonego zadania, na podstawie wygenerowanego schematu i skryptu zadania.

Import danych z pliku CSV do bazy danych Postgres

1. Przygotowanie importowanego pliku

Jako przykładowy plik do importu użyty został plik title.basics.csv z tytułami filmów z bazy portalu IMDb, który pobrać można ze strony plików z danymi IMDb, dzięki uprzejmości IMDb (http://www.imdb.com). Używane za zgodą.

Pierwsze 10 wierszy z pliku wygląda następująco: tconst;titleType;primaryTitle;originalTitle;isAdult;startYear;endYear;runtimeMinutes;genres tt0000001;short;Carmencita;Carmencita;0;1894;\N;1;Documentary,Short tt0000002;short;Le clown et ses chiens;Le clown et ses chiens;0;1892;\N;5;Animation,Short tt0000003;short;Pauvre Pierrot;Pauvre Pierrot;0;1892;\N;4;Animation,Comedy,Romance tt0000004;short;Un bon bock;Un bon bock;0;1892;\N;12;Animation,Short tt0000005;short;Blacksmith Scene;Blacksmith Scene;0;1893;\N;1;Comedy,Short tt0000006;short;Chinese Opium Den;Chinese Opium Den;0;1894;\N;1;Short tt0000007;short;Corbett and Courtney Before the Kinetograph;Corbett and Courtney Before the Kinetograph;0;1894;\N;1;Short,Sport tt0000008;short;Edison Kinetoscopic Record of a Sneeze;Edison Kinetoscopic Record of a Sneeze;0;1894;\N;1;Documentary,Short tt0000009;short;Miss Jerry;Miss Jerry;0;1894;\N;40;Romance,Short

PLik title.basics.csv został umieszczony na S3 Bucket o nazwie imdb-glue

2. Utworzenie crawlera

Aby utworzyć crawlera w oknie AWS Glue wybieramy sekcję Crawlers i Add crawler.

W pierwszym kroku kreatora tworzącego nowego crawlera definiujemy jego nazwę:

W następnym kroku określamy typ źródła dla crawlera:

W kroku definicji żródła danych wejściowych wybieramy ścieżkę do S3 bucket w którym znajduje się plik do importu:

W kroku wyboru roli IAM wybieramy istnięjącą lub tworzymy nową rolę, która będzie umożliwi dostęp crawlerowi do importowanego pliku:

W kroku harmonogramu definiujemy jak często crawler ma być uruchamiany. W przykładzie wybieramy opcję uruchamiania na żądanie:

W kroku output wybieramy lub tworzymy bazę danych AWS Glue Data Catalog w której będą przechowywane odkryte przez crawlera metadane:

W ostatnim kroku możemy sprawdzić wprowadzone dane i zakończyć tworzenie crawlera:

Po utworzeniu crawlera możemy go uruchomić guzikiem Run crawler.

Wynikiem działania crawlera jest tabela utworzona w bazie AWS Glue Data Catalog, którą można podejrzeć w sekcji Databases->Tables:

Klikając w nazwę tabeli możemy podejrzeć wykryte metadane w niej zapisane:

Oraz wykryty schemat pliku do importu:

3. Utworzenie joba AWS Glue

AWS Glue ma teraz schemat danych, które chcemy zaimportować. Następnym krokiem jest zdefiniowanie zadania (AWS Glue job) importu tych danych do bazy danych Postgres. AWS Glue job jest skryptem wykonywalnym przez Spark, który AWS Glue pomaga nam wygenerować.

Aby AWS Glue job mógł zostać wykonany to muszą zaotać spełnione pewne warunki: * VPC w którym znajduje się baza danych Postgres musi mieć możliwość komunikacji z S3 Bucket. * AWS Glue job musi posiadać dostęp do VPC w którym znajduje się baza danych Postgres.

Utworzenie VPC Endpoint dla S3

Aby VPC w którym znajduje się baza danych Postgres miała możliwość komunikacji z S3 Bucket, należy utworzyć VPC Endpoint dla S3. VPC Endpoint dla S3 umożliwia AWS Glue korzystanie z prywatnych adresów IP w celu uzyskania dostępu do S3 bez dostępu do publicznego Internetu.

Aby skonfigurować dostęp do S3 w widoku VPC wybieramy sekcję Endpoints i naciskamy guzik Create Endpoint.

W sekcji Service category wybieramy wartość AWS services i w sekcji Service name wybieramy wartość com.amazonaws.eu-central-1.s3 z typem Gateway:

W sekcji VPC wybieramy identyfikator naszego VPC i zaznaczamy tablicę routingu dla tego VPC:

W sekcji Policy zostawiamy wartość Full Access:

Ustawienie dostępu AWS Glue JDBC Data Store do VPC z bazą Postgres

Aby umożliwić komunikację komponentów AWS Glue należy skonfigurować dla nich dostęp do bazy Amazon RDS. Aby to umożliwić należy stworzyć grupę zabezpieczeń z samoodnoszącą się regułą przychodzącą dla wszystkich portów TCP.

Grupę zabezpieczeń dla bazy Postgres konfigurujemy w widoku Amazon RDS -> Databases wybierając instancję naszej bazy Postgres i przechodząc do sekcji Security Groups w jej detalach. W sekcji Security Groups wybieramy grupę zabezpieczeń dla której chcemy mieć dostęp z AWS Glue i przechodzimy do jej detali w konsoli Amazon EC2.

W zakładce Inbound rules dodajemy nową samoodnoszącą się regułę wybierając typ All TCP i Custom Source z identyfikatorem tej grupy zabezpieczeń jako wartość.

Dodanie połączenia do bazy Postgres

Połączenie do bazy danych dodajemy w widoku AWS Glue w sekcji Databases -> Connections.

W pierwszym kroku nadajemy nazwę połączenia i definiujemy jego typ oraz silnik bazy danych:

W następnym kroku definiujemy dane połączenia do bazy danych:

W ostatnim kroku sprawdzamy poprawność wprowadzonych danych i kończymy dodawanie połączenia:

Utworzenie definicji joba AWS Glue

Tworzenie definicji odbywa się w widoku AWS Glue w sekcji Jobs.

W pierwszym kroku nadajemy nazwę zadania i wybieramy rolę IAM która ma uprawnienia do używanych przez zadanie zasobów. Definiujemy również typ zadania, wersję Glue i skrypt który będzie używany w zadaniu AWS Glue, dane te są domyślnie wypełnione w taki sposób, że AWS Glue wygeneruje skrypt zadania za nas i zapisze go w specjalnie utworzonym buckecie S3.

W drugim kroku wybieramy tabelę ze schematem danych do zaimportowania z AWS Glue Data Catalog:

W następnym kroku wybieramy rodzaj transformacji danych:

W następnym kroku wybieramy połączenie do docelowej bazy danych Postgres, które utworzyliśmy wcześniej:

W ostatnim kroku definiujemy mapowanie danych z pliku do kolumn w bazie danych:

Po naciśnięciu guzika Save job and edit script wygenerowany zostaje skrypt zadania:

Zadanie możemy uruchomić klikając guzik Run job. Zaznaczając nazwę zadania na liście zadań AWS Glue jobs możemy podejrzeć historię jego uruchomień:

Wyniki działania zadania podejrzeć możemy używając zapytania SQL i ulubionego klienta Postgres:

Plusy i minusy AWS Glue

Plusy:

AWS Glue jest usługą bezserwerową, więc nie musisz zarządzać zasobami.
AWS Glue jest łatwy w użyciu i szybki w konfiguracji.
Nie musisz pisać kodu, ale możesz!
AWS Glue integruje się z różnymi usługami AWS jako źródłowe lub docelowe punkty końcowe.
AWS Glue jest dobry we wnioskowaniu schematów danych.

Minusy:

Nie można kontrolować zasobów obliczeniowych używanych przez AWS Glue.
Pod maską Glue działa Apache Spark i akceptuje tylko skrypty Python lub Scala.
Zadania AWS Glue mają zimny czas startu.

Cena AWS Glue

Joby i crawlery AWS Glue są rozliczane według „godziny DPU”, co odpowiada godzinie pracy przy użyciu 4 procesorów wirtualnych i 16 GB pamięci. Koszt 1 DPU (0,44 USD/godz.). Chociaż jednostki DPU są wyceniane godzinowo, rozliczane są co sekundę, z minimum jedną minutą.

AWS Glue Catalog jest wyceniany według liczby skatalogowanych obiektów i liczby żądań do katalogu (pierwszy milion obiektów i żądań miesięcznie jest bezpłatny).

V. Bezpieczeństwo aplikacji ASP.NET MVC

Tue, 23 Aug 2016 14:59:24 Z

Ponieważ w dzisiejszych czasach coraz więcej transakcji jest wykonywanych za pośrednictwem internetu to programiści ASP.NET MVC muszą zadbać o to aby dane użytkowników ich aplikacji pozostały bezpieczne.

Konfiguracja uwierzytelnienia

Serwer IIS od wersji 7 jest podstawowym mechanizmem uwierzytelnienia ponieważ został wyposażony w siedmiu dostawców uwierzytelnienia. Są oni podzieleni na dwa różne podejścia: challenge-based i login redirection–based authentication. Pierwsze z nich polega na tym, że użytkownik musi zgłosić się do serwera po uwierzytelnienie. Drugie ma miejsce wtedy gdy klient wysyła dane uwierzytelniające do aplikacji i aplikacja na ich podstawie wie gdzie ma przekierować użytkownika. Domyślnie zainstalowany jest tylko dostawca uwierzytelnienia anonimowego (ang. Anonymous authentication provider).

Dostawcy uwierzytelnienia

Wybór mechanizmu uwierzytelnienia zależy od kilku czynników. Pierwszym z nich jest miejsce gdzie są przechowywane dane użytkownika które będą używane do sprawdzenia tożsamości użytkownika. Jeżeli używasz uwierzytelnienia opartego o Active Directory to powinieneś wybrać jedną ze standardowych metod challenge-based. Jeżeli używasz innej technologii to musisz użyć nadpisanego lub niestandardowego dostawcy. Jeżeli nie używasz żadnego dostawcy to prawdopodobnie uwierzytelnienie typu Forms będzie odpowiednie.

Anonymous authentication

Uwierzytelnienie anonimowe nie wymaga aby użytkownik podał jakiekolwiek dane uwierzytelniające ale w czasie konfiguracji trzeba wybrać konto użytkownika lub serwis który będzie wykorzystywany do dostępu do plików. Można to konto wybrać dla każdej strony lub puli aplikacji. Jeżeli wybrany użytkownik nie ma wystarczających uprawnień do zasobu to serwer zwróci Unauthorized. Użycie właściwości User z uwierzytelnieniem Anonymous spowoduje zwrócenie pustego ciągu znaków. Uwierzytelnienie Anonymous na serwerze IIS można ustawić za pomocą konfiguracji lub za pomocą komendy:

appcmd set config -section:anonymousAuthentication -enabled:true

Basic authentication

Uwierzytelnienie podstawowe (ang. Basic credentials) wymaga poświadczeń sprawdzanych przez domenę które są zakodowane używając Base64 ale wysyłane informacje nie są wysyłane bezpiecznym kanałem. Uwierzytelnienie podstawowe jest nakładką na tradycyjnych zabezpieczenia systemu Windows więc użytkownik musi posiadać albo konto na serwerze lub w Active Directory. Uwierzytelnienie podstawowe na serwerze IIS można ustawić za pomocą konfiguracji lub za pomocą komendy:

appcmd set config -section:basicAuthentication -enabled:true

Digest authentication

Uwierzytelnienie szyfrowane (ang. Digest authentication) jest podobne do uwierzytelnienia podstawowego z tym wyjątkiem, że jest przesyłane zaszyfrowane. Proces upewniania się przez serwer (ang. challenge-response process), że dane są wysyłane zaszyfrowaną drogą składa się z następujących kroków:

Serwer wysyła wyzwanie do klienta w odpowiedzi na żądanie strony zabezpieczonej.
Klient generuje unikalną wartość dla wyzwania.
Klient tworzy skrót wyzwania i wartości wyzwania.
Klient zwraca wartość wyzwania i skrót do serwera.
Serwer tworzy własną wersję skrótu aby upewnić się, że jest identyczna z tym który otrzymał od serwera.
Serwer tworzy nowy skrót wyzwania i wartości wyzwania po czym wysyła je do klienta.
Klient tworzy własną wersję skrótu aby sprawdzić poprawność otrzymanych danych.

Forms authentication

Uwierzytelnienie formularzy (ang Forms authentication) jest jednym z najczęściej używanych mechanizmów ponieważ pozwala na uwierzytelnienie użytkownika w dowolny sposób bez użycia systemu zabezpieczeń systemu Windows. konfigurując uwierzytelnienie formularzy tworzymy własną stronę logowania na której podajemy dane uwierzytelniające użytkownika które służą do porównania z danymi zapisanymi na serwerze, zwykle w bazie danych. Po udanym zalogowaniu, wezwanie do dostawcy członkostwa (Membership provider) zapewnia, że tokenu uwierzytelniania użytkownika jest ustawiony i że użytkownik może pozostać zalogowany przez resztę sesji. Jeżeli dane są potwierdzone przez system uwierzytelnienia to używamy metody FormsAuthentication.SetAuthCookie ustawiającej ciasteczko dla sesji użytkownika. Przykład kodu wysyłającego ciasteczko uwierzytelniające:

[ControllerAction]
public void Authenticate(string uname, string pass)
{
    User user = dbContext.Users.First (x=>x.UserName.Equals(uname();

    if (user != null && user.Password.Equals(EncryptHash(pass))
    {
        FormsAuthentication.SetAuthCookie(uname, false);
        RedirectToAction("Main", "DashBoard");
    }
    // unable to login
    RenderView("Index", new LoginViewData
    {
        ErrorMessage = "Invalid credentials."
    });
}

Jeżeli uwierzytelnienie się powiedzie to obiekt User jest wstawiany do HttpContext tak jak we wszystkich innych typach uwierzytelnienia. Można również dodać ten obiekt do obiektu wątku. Jeżeli chcemy wyczyścić ciasteczko uwierzytelnienia to możemy użyć metody FormsAuthentication.ClearAuthCookie.

Windows authentication

Uwierzytelnienie Windows używa danych użytkownika zalogowanego do systemu Windows i przesyła je w żądaniach HTTP. Istnieją dwa protokoły uwierzytelnienia Windows: NTLM i Kerberos. Protokoły te są wspierane tylko przez przeglądarki firmy Microsoft.

ASP.NET Impersonation authentication

Jest to dodatek do uwierzytelnienia Windows, które pozwala aplikacjom ASP.NET MVC tożsamości Windows w bardziej dynamiczny sposób. Dzięki temu dodatkowi można użyć tożsamości Windows aby otrzymać dostęp do zasobów takich jak sieć i pliki. Ustawienie w Web.config:

<configuration>
    <system.web>
        <identity impersonate="true" />
    </system.web>
</configuration>

Client Certificate authentication and IIS Client Certificate authentication

Uwierzytelnianie certyfikatu klienta (ang. Client Certificate authentication) dopasowuje certyfikat pomiędzy użytkownikiem i serwerem i używa tego dopasowania do uwierzytelnienia. Uwierzytelnienie certyfikatu klienta na serwerze IIS pozwala na sprawdzenie danych w Active Directory oraz na lokalnym serwerze. Jest to najbardziej skomplikowany mechanizm uwierzytelnienia i wymaga certyfikatu SSL zainstalowanego na serwerze i dla każdego klienta.

Custom authentication

Kiedy żadne z rozwiązań nie pasuje do naszej aplikacji możemy zmodyfikować mechanizm uwierzytelnienia. Najlepszym sposobem jest implementacja interfejsów System.Security.Principal.IIdentity i System.Security.Principal.IPrincipal. IPrincipal zawiera informacje o użytkowniku i jego rolach. IIdentity zawiera informacje o użytkownikach, czy są uwierzytelnieni i imiona. Są to dwa domyślne interfejsy woków uwirzytelnienia i autoryzacji w .NET. Jeżeli posiadamy własną implementację tych interfejsów to możemy ją powiązać z HttpContext i aktualnym wątkiem co pozwala na użycie atrybutu Authorize bez konieczności przerabiania kodu. Kilka domyślnych implementacji tych interfejsów przychodzi z .NET: WindowsIdentity and WindowsPrincipal, FormsIdentity and GenericPrincipal oraz GenericIdentity and GenericPrincipal

Przykład implementacji interfejsów:

public class CustomPrincipal : IPrincipal
{
    public CustomPrincipal(CustomIdentity identity)
    {
        this.Identity = identity;
    }    

    public IIdentity Identity { get; private set; }

    public bool IsInRole(string role)
    {
        return true;
    }
}

public class CustomIdentity : IIdentity
{
    public CustomIdentity(string name)
    {
        this.Name = name;
    }

    public string AuthenticationType
    {
        get { return "Custom"; }
    }

    public bool IsAuthenticated
    {
        get { return !string.IsNullOrEmpty(this.Name); }
    }

    public string Name { get; private set; }
}

Uzycie IIdentity i IPrincipal pozwala na wstawienie własnych obiektów do właściwości aktualnego wątku currentPrinciple oraz do właściwości User w HttpContext. W czasie przetwarzania żądania moduł HttpModule analizuje i sprawdza informacje o użytkowniku oraz dodaje te dane do HttpContext aby były dostępne dla reszty obsługi żądania. Te informację są również dodawane do wątku poprzez System.Threading.Thread.CurrentPrincipal. Pomimo, żeHttpContext jest dostępny dla obiektu HttpHandler, to HttpContext nie jest zwykle czymś do czego można dostać się poza projektem MVC.

Ustawienie CurrentPrincipal z HttpContext:

// Make sure the principals are in sync
System.Threading.Thread.CurrentPrincipal = System.Web.HttpContext.Current.User;

Egzekwowanie ustawień uwierzytelniania

Głównym sposobem wykonania uwierzytelnianie w ASP.NET MVC jest użycie atrybutów dziedziczących z klasy AuthorizeAttribute. jest to filtr który może być używany z akcjami, kontrolerami lub globalnie. Atrybut Authorize mówi systemowi, że każdy użytkownik wywołujący akcję kontrolera musi być uwierzytelniony. Atrybut AllowAnonymous jest atrybutem, który mówi systemowi, że użytkownik wywołujący akcję kontrolera nie musi być uwierzytelniony. Czasem może wystąpić sytuacja kiedy nie chcemy używać atrybutów wymuszających aby użytkownik był uwierzytelniony ale za to jeżeli jest to chcemy mięć dostęp do tych danych. W takich sytuacjach można w kodzie użyć właściwości Thread.CurrentPrincipal.Identity.IsAuthenticated oraz HttpContext.Current.User.Identity.IsAuthenticated.

Przykład dodania globalnego filtru:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
    filters.Add(new AuthorizeAttribute());
}

Dla wszystkich dostawców można użyć tego samego kodu aby dowiedzieć się czy użytkownik jest uwierzytelniony. Wyjątkiem jest dostawca uwierzytelnienia anonimowego, dla którego atrybut Authorize blokuje dostęp. Ponieważ uwierzytelnienie formularzy pozwala na niestandardowe rozwiązania to również w jego przypadku autoryzacja może być obsługiwana inaczej niż dla innych dostawców. Domyślnie w aplikacjach ASP.NET MVC uwierzytelnienie formularzy używa tokenu do przechowywania informacji pomiędzy żądaniami. ten token może być zapisany jako ciasteczko lub jako część zapytania query string. Token powinien być zabezpieczony, najlepiej używając HTTPS dla całej komunikacji. Filtr RequireHttpsAttribute może być dodany na poziomie akcji, kontrolera lub globalnie.

Przykład dodania filtru RequireHttpsAttribute do pliku Global.asax:

public static void RegisterGlobalFilters(GlobalFilterCollection filters)
{
    filters.Add(new HandleErrorAttribute());
    filters.Add(new AuthorizeAttribute());
    filters.Add(new RequireHttpsAttribute());
}

Użycie ciasteczek do zarządzania sesją użytkownika

Aplikacja MVC jest zaimplementowana w sposób bezstanowy, co oznacza, że aplikacja wie tylko tyle ile zostało jej powiedziane w żądaniu. Czasami istnieje potrzeba zachowania stanu użytkownika i poprzednich żądań. Do tego typu zadań bardzo przydatną funkcją jest sesja. Forms authentication używa ciasteczek do zarządzania tzw biletem uwierzytelnienia, który jest zaszyfrowaną wersją nazwy użytkownika przechowywanej w ciasteczku. to ciasteczko jest kontenerem HTTP który nie może być odczytany ani manipulowany po stronie klienta. Przykład kodu tworzącego obiekt FormsAuthenticationTicket:

FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
    1,
    userName,
    DateTime.Now,
    DateTime.Now.AddDays(90),
    createPersistentCookie, // a Boolean indicating whether a cookie
                            // should be created on the user's machine
    String.Join(";",rolesArr) //user's roles
);

// add cookie to response stream
string encTicket = FormsAuthentication.Encrypt(authTicket);

System.Web.HttpCookie authCookie = new System.Web.HttpCookie(FormsAuthentication.
    FormsCookieName, encTicket);
System.Web.HttpContext.Current.Response.Cookies.Add(authCookie);

Do obiektu FormsAuthenticationTicket możemy dostać się poprzez właściwość Ticket klasy FormIdentity. Klasa FormIdentity jest implementacją UserIdentity i można ją odczytać z klasy HttpContext lub z wątku. W powyższym przykładzie we właściwości UserData przechowane zostały role użytkownika ale można tam zapisać dowolną wartość. Właściwość Ticket można odszyfrować za pomocą metody FormsAuthentication.Encrypt.

Alternatywą dla ciasteczek jest przechowywanie danych sesji po stronie serwera. W takim wypadku z każdym żądaniem wysyłany jest identyfikator sesji klienta SessionId.

Konfiguracja dostawców członkostwa

Dostawcy członkostwa (ang. Membership providers) byli częścią ASP.NET od .NET 2.0. W pracy z klasycznym modelem konfiguracja i instalacja były wprowadzane za pomocą konfiguracji w pliku Web.config. Przykład konfiguracji dla SqlMembershipProvider:

<system.web>
    <membership>
        <providers>
        <clear/>
        <add name="AspNetSqlMembershipProvider" connectionStringName="sampleDB" enablePasswordRetrieval="false" enablePasswordReset="true" requiresQuestionAndAnswer="false" applicationName="/" requiresUniqueEmail="true" passwordFormat="Hashed" maxInvalidPasswordAttempts="3" minRequiredPasswordLength="8" minRequiredNonalphanumericCharacters="2" passwordAttemptWindow="15" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral />
        </providers>
    </membership>
</system.web>

Od czasu utworzenia frameworka, pewne aspekty członkostwa uległy zmianie. Przykładowo dla OAuth i OpenID użytkownik nie ma przypisanego hasła. W ASP.NET MVC 4 wprowadziło koncept SimpleMembership i SimpleRoles. Pozwala to na dostosowanie dostępu do magazynu danych poprzez określenie tabeli, klucza identyfikującego oraz nazwy użytkownika w czasie inicjalizacji. Metody SimpleMembership są zaimplementowane jako dostawcy implementujący rdzeń API ASP.NET. SimpleRoleProvider implementuje klasę bazową RoleProvider. SimpleMembershipProvider zostało wprowadzone do zarządzania interakcji z bazą danych. Dodano również klasę WebSecurity, która posiada wiele pomocniczych metod biznesowych. Domyślni dostawcy członkostwa którzy są częścią ASP.NET posiadają możliwość przechowywania informacji jako par klucz - wartość w specjalnej tabeli w bazie danych. SimpleMembership pozwala na użycie jakiejkolwiek tabeli zawierającej unikalne wartości nazwy użytkownika i identyfikatora. SimpleMembershipProvider wymaga dodatkowych tabel do przechowywania ról i informacji takich jak np hasło. Poniższy kod prezentuje jak utworzyć tabele. Trzeba zainicjować klasę WebSecurity przy uruchomieniu poprzez wywołanie metody InitializeDatabaseConnection.

WebSecurity.InitializeDatabaseConnection(string connectionString, string providerName,
    string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)

Klasa WebSecurity jest użyteczną nakładką na SimpleMembership. Zawiera metody Login, ResetPassword, CreateAccount, i ChangePassword. Pomimo tego, że ASP.NET MVC 4 posiada tylko SimpleMembershipProvider, to można napisać własnego dostawcę. Dostawcy są zwykle konfigurowani w pliku konfiguracyjnym. W przypadku SimpleMembership jest to zwykle connection string. Przykład konfiguracji:

<connectionStrings>
    <add name="DefaultConnection" connectionString="ConnectionStringHere" providerName="System.Data.SqlClient" />
</connectionStrings>
<appSettings>
    <add key="TableName" value="CustomLoginTable"/>
    <add key="IdColumn" value="Id"/>
    <add key="UsernameColumn" value="Username"/>
</appSettings>

Custom membership providers

Niestandardowy dostawca członkostwa może być utworzony poprzez dziedziczenie z klasy AuthorizeAttribute lub dziedziczenie z dostawcy uwierzytelnienia Forms i nadpisanie odpowiednich metod. Aby nadpisać klasę FormsAuthentication należy zwrócić uwagę na dwa aspekty autoryzacji które obracają się wokół biletu. Pierwszym jest klasa FormsAuthentication, która ustawia ciasteczko; drugim jest FormsAuthenticationModule wykonujący pracę z każdym żądaniem. Klasa FormsAuthentication posiada metodę SetAuthCookie przypisującą bilet do ciasteczka. Szyfrowanie jest wykonywane używając elementu konfiguracji serwera. W przypadku farmy serwerów trzeba się upewnić, że wszystkie serwery maja ten sam klucz. moduł HTTP FormsAuthenticationModule wyszukuje ciasteczko i bilet. Jeżeli odszyfrowanie sie nie powiedzie to użytkownik jest traktowany jako nieuwierzytelniony. Więcej o FormsAuthenticationModule.

Implementacja niestandardowego dostawcy wymaga dziedziczenia z klasy bazowej System.Web.Security.MembershipProvider, która dziedziczy z ProviderBase. Używając tego rozwiązania trzeba mieć na uwadze, że klasa WebSecurity nie będzie działać ponieważ wymaga zaimplementowania ExtendedMembershipProvider. Proces budowy niestandardowego dostawcy wymaga zaimplementowania 25 metod i właściwości, są to:

ApplicationName
ChangePassword
ChangePasswordQuestionAndAnswer
CreateUser
DeleteUser
Description
EnablePasswordReset
EnablePasswordRetrieval
FindUsersByEmail
FindUsersByName
GetAllUsers
GetNumberOfUsersOnline
GetPassword
GetUser
GetUserNameByEmail
Initialize
MaxInvalidPasswordAttempts
Name
PasswordAttemptWindow
PasswordFormat
RequiresQuestionAndAnswer
RequiresUniqueEmail
ResetPassword
UnlockUser
UpdateUser
ValidateUser

Więcej o tworzeniu niestandardowego dostawcy można przeczytać na stronie Implementing a Membership Provider.

Konfiguracja autoryzacji

Autoryzacja jest procesem nadawania użytkownikowi uprawnień do wykonania akcji na określonym zasobie. Najlepszym sposobem określenia uprawnień są role ponieważ są bardziej długotrwałe niż użytkownicy systemu. Tworząc role lepiej jest tworzyć je w oparciu o przywileje a nie stanowisko pracy np lepiej użyć CanEditOrder niż OrderPicker.

Tworzenie ról

System członkostwa ASP.NET opiera się na modelu dostawcy, który działa jako framework służący dla programistów w celu zwiększenia lub zmiany funkcjonalności wokół uwierzytelniania i zarządzania użytkownikami. Domyślnie ASP.NET posiada kilku dostawców członkostwa którzy posiadają standardowe implementacje uwierzytelnienia i autoryzacji. Ci dostawcy posiadają powiązanych dostawców ról jak np SqlRoleProvider współpracujący z SqlMembershipProvider. Jeżeli aplikacja używa autoryzacji opartej o system Windows jak np Active Directory to zarządzanie rolami jest częścią systemu. Uwierzytelnienie Forms używa innego zestawu tabel do zarządzania rolami. Można użyć narzędzia konfiguracji stron ASP.NET używając uwierzytelnienia Forms z dostawcą członkostwa np SimpleMembership. Ponieważ ASP.NET nie posiada szablonu do tworzenia ról to aby dodać role trzeba stworzyć odpowiedni interfejs użytkownika i wywołać Roles API. Uruchamiając nową aplikację możemy dodać odpowiednie role poprzez wykonanie odpowiedniego skryptu w bazie danych. Jeżeli chcemy wspierać role tworzone przez użytkowników to musimy napisać tę funkcjonalność samemu.

Autoryzacja ról poprzez konfigurację

W pliku Web.config można zarządzać autoryzacją. przykład konfiguracji dla SQL membership role provider:

<roleManager defaultProvider="AdminRoleProvider" enabled="true" cacheRolesInCookie="true">
    <providers>
    <clear/>
    <add name="SqlProvider" type="System.Web.Security.SqlRoleProvider" connectionStringName="DefaultConnection" applicationName="MyApplication" enablePasswordRetrieval="false" enablePasswordReset="true" requiresQuestionAndAnswer="true" requiresUniqueEmail="false" passwordFormat="Hashed" maxInvalidPasswordAttempts="5"
        passwordAttemptWindow/>
    </providers>
</roleManager>

Używając SimpleMembershipProvider z SimpleRole zamiast pliku konfiguracyjnego używa się kodu:

public static void InitializeDatabaseConnection(string connectionStringName, string
    userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)

Autoryzacja ról programowo

ASP NET MVC oferuje kilka dróg do utworzenia ról programowo. Przypisane role można sprawdzić na kilka sposobów: poprzez atrybut kontrolera lub akcji [Authorize(Roles=”Admin”)], lub w kodzie używając metody IsUserInRole lub GetRolesForUser. W kodzie można również odnieść się do ról użytkownika za pomocą metod takich jak RoleProvider.GetRolesForUser, HttpContext.User.IsInRole i RoleProvider.IsUserInRole. Role w atrybucie mogą być wymienione po przecinku, np:

[Authorize(Roles="Administrator,CanEditOrder")]

Przykład sprawdzania ról w kodzie:

string[] userRolesArray = Roles.GetRolesForUser();
string[] rolesForContentArray = DbContext.GetRolesForViewFromDb(thisViewName);
if (userRolesArray.Intersect(RolesForContentArray).Count > 0)
{
    // The user is authorized
}

Przykład użycia WebSecurity:

WebSecurity.RequireRoles("Admin", "OtherRole");

Własny dostawca ról

Własnego dostawcę ról można utworzyć implementując System.Web.Security.RoleProvider. Pozwala to dostosować role do naszych potrzeb w sytuacjach kiedy standardowi dostawcy ról nie spełniają naszych wymagań. Lista wymaganych właściwości i metod do zaimplementowania:

AddUsersToRoles
ApplicationName
CreateRole
DeleteRole
Description
FindUsersInRole
GetAllRoles
GetRolesForUser
GetUsersInRole
Initialize
IsUserInRole
Name
RemoveUsersFromRoles
RoleExists

Więcej można przeczytać na stronie Implementing a Role Provider.

Implementcaja autoryzacji serwisów WCF

Kiedy aplikacja jest klientem serwisu WCF to bardzo często trzeba zarządzać autoryzacją pomiędzy aplikacją a serwisem. To zarządzania uprawnieniami można użyć kolekcji Credentials przy tworzeniu pośrednika połączenia z serwisem (komenda Add Service Reference w VS). Można stworzyć poświadczenie używając nazwy użytkownika i hasła, określonych poświadczeń Windows lub WindowsIdentity.

Przykład przekazania poświadczeń używając pośrednika serwisu w kodzie serwera:

WCFServiceCient client = new WCFServiceCient();
client.ClientCredentials.UserName.UserName = "Apps User Name";
client.ClientCredentials.UserName.Password = "Apps Password";

Przykład przekazania poświadczeń Windows:

NetworkCredential credentials = new NetworkCredential();
credentials.Domain = "windows domain";
credentials.UserName = " Apps User Name";
credentials.Password = " Apps Password";

WCFServiceCient client = new WCFServiceCient();
client.ClientCredentials.Windows.ClientCredential = credentials;

Claims-based authentication

Uwierzytelnienie federacyjne pozwala aplikacji polegać na innej aplikacji w kwestii uwierzytelnienia (dostawca tożsamości jak Windows Azure lub Facebook). Kiedy dostawca uwierzytelni użytkownika to przesyła token do aplikacji który zawiera poświadczenia (ang. claims). Poświadczenia są porcjami informacji, które dostawca udostępnia aplikacji, np imię czy adres email. Uwierzytelnienie federacyjne jest przykładem uwierzytelnienia opartego o poświadczenia i jest używane do autoryzacji tak jak tradycyjny system oparty na rolach, ale może być o wiele bardziej ziarnisty. Używa po prostu innego podejścia do autoryzacji; zamiast autoryzowania dostępu w zależności od roli używa listy innych własności otrzymanych od zaufanego dostawcy.

Windows Azure Active Directory Access Control

Windows Azure Access Control Service (ACS) pozwala na zaimplementowanie uwierzytelnienia federacyjnego (ang. federated authentication). ACS pozwala na pracę z innymi standardowymi dostawcami tożsamości jak Windows Live ID i Facebook. Czterej podstawowi uczestnicy procesu uwierzytelniania ACS to strona ufająca (aplikacja), przeglądarka klienta, dostawca tożsamości i ACS. Ważne cechy ACS to:

Integracja z Windows Identity Foundation (WIF).
Wsparcie dla znanych dostawców tożsamości jak Facebook, Microsoft , Yahoo i Google.
Wsparcie dla Active Directory Federation Services (ADFS) 2.0.
Wsparcie dla protokołów OAuth 2.0 , WS-Trust i WS-Federation.
Wsparcie dla różnych formatów tokenów, a w tym JSON Web Token (JWT), Security Assertion Markup Language (SAML) 1.1, SAML 2.0 i Simple Web Token (SWT).
Portal web do zarządzania.

Kroki autoryzacji użytkownika przez ACS:

Klient wysyła żądanie do aplikacji.
Ponieważ żądanie nie jest uwierzytelnione to aplikacja odsyła użytkownika do ACS.
ACS przekierowuje żądanie do dostawcy tożsamości, którego może wybrać aplikacja lub użytkownik. Dostawca udostępnia stronę uwierzytelnienia.
Klient loguje się na tej stronie. Dostawca zatwierdza autoryzację i przesyła token do klienta.
Klient przekazuje token do ACS.
ACS sprawdza token i tworzy nowy token który zawiera poświadczenia i wysyła klienta z tokenem do aplikacji.
Aplikacja sprawdza token i poświadczenia. Po zatwierdzeniu odsyła odpowiedź na żądanie z kroku 1.

Uwierzytelnienie ACS może wydawać się skomplikowane ale przestrzeń nazw Microsoft.Web.WebPages.OAuth abstrachuje większość pracy przekształcając procedurę w dwie metody VerifyAuthentication i Login. OAuthWebSecurity.VerifyAuthentication jest głównym procesem używanym do tworzenia zwrotnego zewnętrznego uwierzytelniania. Po otrzymaniu uwierzytelnienia można zapisać ciasteczko, które pozwoli określić w kolejnych żądaniach czy użytkownik jest nadal uwierzytelniony. Kod pokazujący logowanie zewnętrzne z użyciem ACS:

public ActionResult ExternalLoginCallback(string returnUrl)
{
    // send the request for a login to the ACS
    AuthenticationResult result = OAuthWebSecurity.VerifyAuthentication(
        Url.Action("ExternalLoginCallback", new { ReturnUrl = returnUrl }));
    if (!result.IsSuccessful)
    {
        return RedirectToAction("ExternalLoginFailure");
    }
    // check for the access token
    if (result.ExtraData.Keys.Contains("accesstoken"))
    {
        Session["accesstoken "] = result.ExtraData["accesstoken"];
    }
    // login to the local application using information from provider
    if (OAuthWebSecurity.Login(
        result.Provider,
        result.ProviderUserId,
        createPersistentCookie: false))
    {
        return RedirectToLocal(returnUrl);
    }
    if (User.Identity.IsAuthenticated)
    {
        // If the current user is logged in add the new account
        OAuthWebSecurity.CreateOrUpdateAccount(
            result.Provider,
            result.ProviderUserId,
            User.Identity.Name);
        return RedirectToLocal(returnUrl);
    }
    else
    {
        // User is new, ask for their desired membership name
        string loginData = OAuthWebSecurity.SerializeProviderUserId(
            result.Provider,
            result.ProviderUserId);
        ViewBag.ProviderDisplayName =
            OAuthWebSecurity.GetOAuthClientData(result.Provider).DisplayName;
        ViewBag.ReturnUrl = returnUrl;
        return View("ExternalLoginConfirmation", new RegisterExternalLoginModel
        {
            UserName = result.UserName,
            ExternalLoginData = loginData,
            FullName = result.ExtraData["name"],
            Link = result.ExtraData["link"]
        });
    }
}

Tworzenie niestandardowych tokenów używając WIF

WIF (Windows Identity Foundation) jest częścią .NET Framework i może być używane do budowania aplikacji rozpoznających tożsamość. Można użyć go do zarządzania którykolwiek z wbudowanych mechanizmów obsługi tokenów, jak również do obsługi tokenów które przenoszą informacje. WIF abstrahuje protokoły WS-Trust i WS-Federation pozwalając programiście na użycie API przy budowaniu systemów obsługujących poświadczenia. ASP.NET MVC wspiera wykorzystanie uwierzytelniania prowadzonego przez federacje co jest krytyczne aby użyć scenariusza single sign-on lub przekazać ciężar i odpowiedzialność uwierzytelniania do innej aplikacji. WS-Trust jest specyfikacją WS-* i standardem OASIS, który dostarcza rozszerzenia do WS-Security; zajmującym się z wydawaniem, odnowienia i walidacją tokenów zabezpieczeń. WS-Federation jest rozszerzeniem WS-Trust, które zapewnia architekturę dla zapewnienia oddzielania między formatami tokenów, protokół do pobrania tych tokenów i zaufany mechanizm do zarządzania nimi wszystkimi. WS-Federation udostępnia model usług, który dostarcza informacji o tożsamości i tokenów dla wszelkiego rodzaju usług internetowych i aplikacji, z mnóstwem możliwych relacji zaufania. WS-Federation może być stosowany bezpośrednio przez klienta, ponieważ zarządza i określa syntaktyczny związek między klientem a serwerem. Jego jedynym celem jest umożliwienie wspólnego procesu dostępu do operacji tożsamości zarówno dla klientów i serwisów internetowych. Usługa tokenu zabezpieczeń (STS - security token service) jest składnikiem usługi, która buduje, podpisuje i zarządza tokenami protokołów WS-Trust i WS-Federation. WIF wykonuje całą pracę za programistę. Windows Azure ACS jest przykładem często używanego STS. Z wprowadzeniem WIF, poświadczenia zostały dodane klas bazujących na klasie System.Security.Claims.ClaimsPrincipal. Dzięki temu każda z klas ma dostęp do poświadczeń i programiści mogą użyć interfejsów IIdentity i IPrincipal do pracy z informacjami o tożsamości. Pomimo, że .NET Framework wspiera wiele typów tokenów to czasami trzeba użyć innych typów tokenów. Na szczęście nie trzeba zastępować istniejącego mechanizmu transferu (WS-Federation), tylko obsłużyć nowy typ tokenu. Definicja niestandardowego tokenu dla WIF:

<m:MyCustomToken xmlns:m="urn:mycustomtoken" m:Id="SomeID" m:Issuer="urn:SomeIssuer" m:Audience="https://mywebsite/" m:ValidFrom="2013-01-01" m:ValidTo="2099-12-31">
    <m:Claim Name="FirstName" Namespace="urn:firstname">John</m:Claim>
    <m:Claim Name="LastName" Namespace="urn:lastname">Doe</m:Claim>
    <m:Claim Name="Role" Namespace="urn:role">Supervisor</m:Claim>
    <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
        <SignedInfo>
            <CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/
xml-exc-c14n#" />
            <SignatureMethod Algorithm="http://www.w3.org/2000/09/
xmldsig#rsa-sha1" />
            <Reference URI="">
                <Transforms>
                    <Transform Algorithm="http://www.w3.org/2000/09/
xmldsig#enveloped-signature" />
                    <Transform Algorithm="http://www.w3.org/2001/10/
xml-exc-c14n#" />
                </Transforms>
                <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1" />
                <DigestValue>SomeDigestValueHere</DigestValue>
            </Reference>
        </SignedInfo>
        <SignatureValue>… not shown …</SignatureValue>
        <KeyInfo>
            <X509Data>
                <X509Certificate>… not shown …</X509Certificate>
            </X509Data>
        </KeyInfo>
    </Signature>
</m:MyCustomToken>

Ten token musi być również zarządzany jako klasa dziedzicząca z SecurityToken:

public class MyCustomToken : SecurityToken
{
    public List<Claim> Claims {get; set;}
    public XmlElemnt Signature {get; set;}
    public bool ValidateThisSignature()
    {
        // code to validate the signature
    }
}

Każdy token używany w systemie musi posiadać odpowiednią obsługę. Tworząc klasę obsługi tokenu trzeba dziedziczyć z SecurityTokenHandler, np:

public override ClaimsIdentityCollection ValidateToken(SecurityToken token)
{
    ClaimsIdentityCollection claimsIdentityCollection = new ClaimsIdentityCollection();
    if (token is MyCustomToken)
    {
        MyCustomToken mycustomtoken = token as MyCustomToken;
        if (mycustomtoken.ValidateThisSignature())
        {
            IClaimsIdentity newIdentity = new ClaimsIdentity((token as
                MyCustomToken).Claims);
        }
    }
    claimsIdentityCollection.Add(newIdentity);
    return claimsIdentityCollection;
}

Aby aplikacja mogła używać nowego tokenu należy ją skonfigurować jak poniżej:

<configSections>
    <!-- Registers the microsoft.IdentityModel configuration section -->
    <section name="microsoft.identityModel" type="Microsoft.IdentityModel.Configuration.MicrosoftIdentityModelSection,
Microsoft.IdentityModel, Version=3.5.0.0" />
</configSections>
<microsoft.identityModel>
    <service>
        <securityTokenHandlers>
            <remove type="Microsoft.IdentityModel.Tokens.WindowsUserNameSecurityTokenHandler,
Microsoft.IdentityModel" />
            <add type="MyCustomToken.CustomUserNamePasswordValidatorSecurityTokenHandler,
MyCustomToken" />
        </securityTokenHandlers>
    </service>
</microsoft.identityModel>

Obsługa tokenów SAML i SWT

SAML 2.0 jest protokołem opartym o XML, który używa tokenu zawierającego twierdzenia lub pakiety informacji, aby przekazać informacje o zleceniodawcy (zwykle użytkowniku końcowym) pomiędzy SAML authority lub identity provider a service provider. SAML 2.0 pozwala na webowe scenariusze uwierzytelnienia i autoryzacji a w tym single sign-on, federated identity i web services security. Ponieważ tokeny SAML są podpisywane kluczem asymetrycznym to użytkownik nie może tworzyć własnych tokenów. Tokeny SAML mogą również być szyfrowane. Token Simple Web Token (SWT) jest prostszym obiektem podpisywanym kluczem symetrycznym. JWT reprezentuje poświadczenia które mają zostać przetransferowane przez dwie strony. Poświadczenia w JWT są kodowane w formacie obiektu JSON, który jest podpisany cyfrowo używając JSON Web Signature (JWS) i mogą być szyfrowane używając JSON Web Encryption (JWE). JWT nie jest jeszcze skończony ale posiada duże wsparcie i ma zastąpić w przyszłości SWT. WIF opiera się na klasach obsługi tokenów, które tworzą, odczytują, zapisują i sprawdzają tokeny. Klasy obsługi tokenów są punktem rozszerzalności WIF. WIF posiada kilka wbudowanych klas obsługi tokenów, które mogą być nadpisane w razie potrzeby, należą do nich:

EncryptedSecurityTokenHandler
KerberosSecurityTokenHandler
MembershipUserNameSecurityTokenHandler
RsaSecurityTokenHandler
Saml2SecurityTokenHandler
SamlSecurityTokenHandler
SessionSecurityTokenHandler
UserNameSecurityTokenHandler
WindowsUserNameSecurityTokenHandler
X509SecurityTokenHandler

Klasa Saml2SecurityTokenHandler obsługuje serializację i deserializację SAML 2.0 Assertions-backed tokens do obiektu Saml2SecurityToken. Można ustawić STS który obsłuży token SAML 2.0 poprzez dodanie instancji Saml2SecurityTokenHandler do kolekcji SecurityTokenHandlerCollection. Dokonuje się tego zwykle w konfiguracji:

<system.webServer>
    <modules>
        <add name="WSFederationAuthenticationModule" type="Microsoft.IdentityModel.Web.WSFederationAuthenticationModule,
Microsoft.IdentityModel" preCondition="managedHandler" />
    </modules>
</system.webServer>
<configuration>
    <configSections>
        <section name="microsoft.identityModel" type="Microsoft.IdentityModel.Web.Configuration.
MicrosoftIdentityModelSection, Microsoft.IdentityModel" />
    </configSections>
</configuration>
<microsoft.identityModel>
    <service>
        <securityTokenHandlers>
            <securityTokenHandlerConfiguration>
                <clear/>
                <add type="Microsoft.IdentityModel.Tokens.Saml11.
Saml11SecurityTokenHandler, Microsoft.IdentityModel">
                    <samlSecurityTokenRequirement issuerCertificateValidationMode="PeerOrChainTrust" issuerCertificateRevocationMode="Online" issuerCertificateTrustedStoreLocation="LocalMachine" mapToWindows="false" useWindowsTokenService="false">
                        <nameClaimType value="http://schemas.xmlsoap.org/ws/2005/05/
identity/claims/name" />
                        <roleClaimType value="schemas.microsoft.com/ws/2006/04/
identity/claims/role" />
                    </samlSecurityTokenRequirement>
                </add>
            </securityTokenHandlerConfiguration>
        </securityTokenHandlers>
    </service>
</microsoft.identityModel>

Niektóre typy tokenów nie mają wbudowanej obsługi dostarczonej z WIF. Można dodać implementację niestandardowych tokenów wykonując następujące kroki:

Należy użyć klasy SecurityTokenHandler jako klasy bazowej.
Należy nadpisać następujące metody:

CanReadToken
ReadToken
CanWriteToken
WriteToken
CanValidateToken
ValidateToken

W konfiguracji należy dodać referencje do nowej klasy w sekcji . Poniżej przykład dla klasy SWTTokenHandler:

<system.identityModel>
    <identityConfiguration saveBootstrapContext=”true”>
        <securityTokenHandlers>
            <add type=”SWTToken.SWTTokenHandler, SWTToken” />
        </securityTokenHandlers>
    </identityConfiguration>
</system.identityModel>

Zarządzanie integralnością danych

Zarządzanie prywatnością, poczuciem bezpieczeństwa i integralnością danych ma kluczowe znaczenie dla bezpieczeństwa. Większość aplikacji ASP.NET MVC składa się z wprowadzania, wykonywania pracy na a następnie wyprowadzanie danych.

Terminologia związana z szyfrowaniem

Szyfrowanie jest procesem zamiany zwykłego tekstu na nieczytelny format (ang. ciphertext) który może zostać odszyfrowany tylko przez aplikacje które posiadają klucz odszyfrowujący.
Funkcja skrótu tworzy wartość w oparciu o ciągi danych w zbiorze danych. Zwracana wartość jest ciągiem o stałej długości i zawsze jest taka sama dla tego samego ciągu wejściowego. Po przesłaniu danych, wartość skrótu jest porównywana ze skrótem oryginalnych danych. Jeżeli są takie same to oznacza, że przesłane dane nie zostały zmienione. Funkcja skrótu jest często wykorzystywana do przechowywania haseł.
Secure Hash Algorithm (SHA) jest obecnie najpopularniejszym algorytmem tworzącym skróty. Posiada on kilka podtypów min SHA-0 do SHA-3.
Solenie jest procesem dodawania losowego ciągu do danych wejściowych przed utworzeniem skrótu lub przed szyfrowaniem. Solenie utrudnia nieautoryzowany dostęp do danych poprzez dodanie nieprzewidywalności.
Algorytmy symetryczne i niesymetryczne są używane w procesie szyfrowania. Szyfrowanie symetryczne używa tego samego klucza do szyfrowania i odszyfrowania danych. Szyfrowanie asymetryczne używa dwóch różnych kluczy, które są komplementarne. Klucz publiczny jest szeroko rozpowszechniony i jest wykorzystywany do szyfrowania, natomiast klucz prywatny służy do odszyfrowania danych zaszyfrowanych kluczem publicznym.
Advanced Encryption Standard (AES) jest najczęściej wykorzystywanym algorytmem szyfrowania symetrycznego.
Secure Sockets Layer (SSL) jest przykładem protokołu używającego szyfrowania asymetrycznego. Serwer web posiada i zarządza kluczem szyfrującym prywatnym podczas gdy publikuje klucz publiczny do wszystkich przeglądarek które odpytują serwer. Pozwala to przeglądarkom zaszyfrować informacje zanim wyślą je do serwera.
Rivest, Shamir, and Adleman (RSA) jest najpopularniejszym algorytmem szyfrowania asymetrycznego.

Przykład szyfrowania strumienia algorytmem symetrycznym:

using (RijndaelManaged rijndaelManaged = new RijndaelManaged())
{
    // assumes that the key and initialization vectors are already configured
    CryptoStream crypoStream = new CryptoStream(myManagedStream, rijndaelManaged.
        CreateEncryptor(),CryptoStreamMode.Write);
};

Przykład odszyfrowania strumienia zaszyfrowanego algorytmem symetrycznym:

using (RijndaelManaged rijndaelManaged = new RijndaelManaged())
{
    // assumes that the key and initialization vectors are already configured
    CryptoStream crypoStream = new CryptoStream(myManagedStream, rijndaelManaged.
        CreateDecryptor(),CryptoStreamMode.Read);
};

Przykład szyfrowania algorytmem asymetrycznym:

using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
{
    RSA.ImportParameters(RSAKeyInfo);
    encryptedData = RSA.Encrypt(DataToEncrypt, DoOAEPPadding);
    decryptedData = RSA.Decrypt(encrypyedData, DoOAEPPadding);
}

Parametr RSAKeyInfo jest typu RSAParameters i zawiera klucz publiczny.

Szyfrowanie sekcji konfiguracji aplikacji

W .Net Framework istnieją dwaj dostawcy szyfrowania konfiguracji: DPAPIProtectedConfigurationProvider i RsaProtectedConfigurationProvider. Drugi z nich pozwala na eksportowanie i importowanie klucza szłużącego do szyfrowania dzięki czemu pliki mogą być takie same na wielu serwerach. Za pomocą narzędzia aspnet_regiis.exe z opcjami -pe, -app i -prov można zaszyfrować sekcje pliku Web.config. Służy to do ochrony pliku w przypadku gdy trafi on przypadkowo do użytkownika. Odszyfrowanie odbywa się za pomocą opcji -pd.

Przykład szyfrowania sekcji:

aspnet_regiis -pe "ConnectionStrings" -app "/MachineDPAPI" -prov
"RsaProtectedConfigurationProvider"

Opcja -pe wskazuje sekcję która ma zostać zaszyfrowana. Opcja -app wskazuje wirtualną ścieżkę do aplikacji. Opcja -prov wskazuje wybranego dostawcę szyfrowania.

Kiedy chcemy użyć zaszyfrowanego pliku to musimy do konfiguracji załączyć klucz machineKey, który został użyty do szyfrowania np:

<machineKey validationKey="D61B3C89CB33A2F1422FF158AFF7320E8DB8CB5CDA1742572A487D94018787EF42682B20 2B746511891C1BAF47F8D25C07F6C39A104696DB51F17C529AD3CABE" decryptionKey="FBF50941F22D6A3B229EA593F24C41203DA6837F1122EF17" />

Podpisywanie danych aplikacji

Podpisywanie danych aplikacji zapewnia uwierzytelnianie, autoryzację i niezaprzeczalność. Pozwala to na sprawdzenie partnera komunikacyjnego i daje potwierdzenie, że podpisane dane aplikacji przyszły od partnera, a nie kogoś innego. .Net Framework zgrupował algorytmy szyfrowania i podpisu cyfrowego jako podklasy AsymmetricAlgorithm. Klasa abstrakcyjna ystem.Security.Cryptography.DSA definiuje metodę CreateSignature akceptującą skrót SHA-1, np:

// create the hash code of the text to sign
SHA1 sha = SHA1.Create();
byte[] hashcode = sha.ComputeHash(TextToConvert);

// use the CreateSignature method to sign the data
DSA dsa = DSA.Create();
byte[] signature = dsa.CreateSignature(hashcode);

Podpis i skrót muszą być wysłane do metody weryfikującej VerifySignature jako tablice bajtów, np:

// create the hash code of the text to verify
SHA1 sha = SHA1.Create();
byte[] hashcode = sha.ComputeHash(TextToVerify);

// use the VerifySignature method to verify the DSA signature
DSA dsa = DSA.Create();
bool isSignatureValid = dsa.VerifySignature(hashcode, signature);

Implementacja zabezpieczeń w ASP.NET

Wiele aspektów ASP.NET MVC musi być zabezpieczone. Dotyczy to komunikacji pomiędzy klientem i serwerem jak również przechowywania prywatnych danych.

Certyfikat SSL

SSL jest standardową technologią używaną do ustanowienia szyfrowanego połączenia pomiędzy przeglądarką a serwerem. SSL używa PKI, gdzie klucz publiczny jest związany z firmą lub za pośrednictwem strony trzeciej albo CA. Przed użyciem SSL trzeba włączyć wiązanie HTTPS na serwerze. Później należy wysłać informacje identyfikacyjne wraz z Certificate Signing Request (CSR) do CA w celu sprawdzenia. Po potwierdzeniu informacji CA przysyła dokument zawierający certyfikat który można załadować na serwer. Kiedy wiązanie HTTPS jest dostępne to można użyć atrybutu RequireHttps globalnie lub na poziomie kontrolerów i akcji aby były wykonywane tylko bezpiecznym połączeniem.

Solenie i haszowanie haseł

Przechowywanie haseł jako czysty tekst nie jest bezpieczne. Dwoma głównymi typami ataków na hasła są dictionary attack i brute-force attack. Najprostszą ochroną haseł jest solenie i tworzenie skrótu przed zapisaniem do bazy danych. Losowe ciągi służące do solenia można generować za pomocą Cryptographically Secure Pseudo-Random Number Generator (CSPRNG). Pozwala na to metoda RNGCryptoServiceProvider.GetBytes.

Przykład użycia losowego ciągu przed soleniem i haszowaniem:

public static string CreateTheHash(string passwordToHash)
{
    // Generate the random salt
    RNGCryptoServiceProvider RNGcsp = new RNGCryptoServiceProvider();
    byte[] salt = new byte[NUMBER_OF_BYTES_FOR_THE_SALT];
    RNGcsp.GetBytes(salt);
    // Hash the password and encode the parameters
    byte[] hash = PBKDF2(passwordToHash, salt, PBKDF2_ITERATIONS, NUMBEROFBYTESINHASH);
    return PBKDF2_ITERATIONS + ":" + Convert.ToBase64String(salt) + ":" + Convert.ToBase64String(hash);
}

/// <summary>
/// Computes the PBKDF2-SHA1 hash of a password.
/// </summary>
/// <param name = "password">The password to hash.</param>
/// <param name = "salt">The salt.</param>
/// <param name = "iterations">The PBKDF2 iteration count.</param>
/// <param name = "outputBytes">The length of the hash to generate, in bytes.</param>
/// <returns>A hash of the password.</returns>
private static byte[] PBKDF2(string password, byte[] salt, int iterations, int outputBytes)
{
    Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, salt);
    pbkdf2.IterationCount = iterations;
    return pbkdf2.GetBytes(outputBytes);
}

/// <summary>
/// Validates a password against the stored, hashed value.
/// </summary>
/// <param name = "password">The password to check.</param>
/// <param name = "goodHash">A hash of the correct password.</param>
/// <returns>True if the password is correct. False otherwise.</returns>
public static bool ValidatePassword(string password, string goodHash)
{
    // Extract the parameters from the hash
    char[] delimiter =
    {
    ':'
    }

    ;
    string[] split = goodHash.Split(delimiter);
    int iterations = Int32.Parse(split[ITERATION_INDEX]);
    byte[] salt = Convert.FromBase64String(split[SALT_INDEX]);
    byte[] hash = Convert.FromBase64String(split[PBKDF2_INDEX]);
    byte[] testHash = PBKDF2(password, salt, iterations, hash.Length);
    return hash == testHash )
    ;
}

Ponieważ użytkownik nie jest w stanie zobaczyć swojego starego hasła to należy użytkownikowi zapewnić możliwość zresetowania hasła. Proces ten musi również być zabezpieczony. Zwykle wykonuje się to za pomocą tzw pętli email. Pierw tworzy się losową wartość zapisaną w bazie danych i jest przypisana do jednego konta. Tę wartość wysyła się to użytkownika mailem z linkiem do resetowania hasła i limitem czasowym na wykorzystanie.

Użycie Html.Encode i biblioteki AntiXSS

Atak JavaScript injection polega na wstrzyknięciu przez hakera kodu JavaScript do strony poprzez wstawienie kodu do adresu strony lub do formularza Przykładowo do formularza z komentarzem można by było wstawić skrypt:

<script src='http://imahacker.com/hackyou.js'></script>

Jedną z technik zapobiegania jest kodowanie listy znaków. Pomocne są do tego helpery MVC:

<% Html.Encode(review.Title) %>

Kodowanie danych można wykonać również przed ich wyświetlaniem:

public ActionResult Create(string message)
{
    var newEntry = new Entry();
    newEntry.Message = Server.HtmlEncode(message);
    newEntry.EntryDate = DateTime.Now;
    db.Entries.InsertOnSubmit(newEntry);
    db.SubmitChanges();
    return RedirectToAction("Index");
}

Poza kodowaniem danych Microsoft oferuje bibliotekę zbudowana specjalnie do ochrony przed tego typu atakami. Biblioteka AntiXSS używa podejścia z akceptowalną listą znaków które zostaną kodowane przed wyświetleniem aby zapobiec atakom XSS. Bibliotekę można pobrać jako pakiet NuGet.

Odroczona walidacja i obsługa żądań niezweryfikowanych

Standardowym zachowaniem w ASP.NET 4.5 jest to, że wszystkie dane wysyłane z żądania klienta do serwera muszą przejść przez proces walidacji. Jednakże pozwala to również na odroczenie walidacji dopóki te dane nie są używane. Działanie to jest nazywane lazy request validation, ponieważ minimalizuje pracę wykonywaną przez serwer w celu wykonania walidacji JIT. Jest to szczególnie użyteczne jeżeli mamy dane z wielu stron które wykonują wiele żądań do serwera. Można skonfigurować aplikację aby używała tej formy odroczonej walidacji poprzez ustawienie wartości atrybutu requestValidationMode na “4.5” w sekcji httpRuntime pliku Web.config, np:

<httpRuntime requestValidationMode="4.5" ... />

Tak skonfigurowany system sprawdza poprawność tylko kiedy chcemy otrzymać dostęp do konkretnej wartości czyli Request.Form[“description”] nie będzie powodowało sprawdzania wartości equest.Form[“title”]. W starszych wersjach walidacja żądania była wykonywana na całej kolekcji. W ASP.NET 4.5 i ASP.NET MVC 4 programista ma dostęp do niesprawdzonych danych żądania. Właściwość Unvalidated klasy HttpRequest daje dostęp do wszystkich danych żądania, w tym Form, Cookies i QueryString, np:

var s = context.Request.Unvalidated.Form["some_value"];

Zapobieganie atakom SQL injection

Atak SQL injection występuje kiedy haker wstawi komendę SQL do niezabezpieczonego zapytania. Przykład niezabezpieczonej komendy:

con.Open();
SqlCommand com = new SqlCommand("Select * from Employee where EmpID =" +
    txtID.Text, con);
dr = com.ExecuteReader();

Jeżeli wartość txtID jest wstawiana z formularza to w jej wartości można przekazać dodatkowe komendy SQL przykładowo usuwające wszystkie rekordy w tabeli. Użycie średnika i komentarza na koncu komendy (—) powoduje, że SQL Server wykona komendę, np: 1;delete from Employee;—

Ochronę przed tym rodzajem ataków zapewnia stosowanie parametryzacji zapytań używając SQLParameters, np:

SqlDataAdapter adapter = new SqlDataAdapter("AuthorLogin", conn);
adapter.SelectCommand.CommandType = CommandType.StoredProcedure;
SqlParameter param = adapter.SelectCommand.Parameters.Add("@id",
    SqlDbType.VarChar, 11);
param.Value = submittedId;

// ...

SqlDataAdapter adapter = new SqlDataAdapter(
"SELECT username, email FROM user WHERE id = @id", conn);
SQLParameter param = adapter.SelectCommand.Parameters.Add("@id",
    SqlDbType.VarChar, 11);
paarm.Value = submittedId;

Zapobieganie cross-site request forgeries (XSRFs)

Ataki CSRF wykorzystują uprawnienia ofiary do wykonania operacji w przeciwnym razie wymagającej jej zgody. Zabezpieczenie polega na użyciu metody AntiForgery formularza i tokenu ValidateAntiForgeryToken, np:

[RequireSession]
[AcceptVerbs(HttpVerbs.Post)]
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Login(string username, string password, string remember, string deviceToken, string apid)
{
}

// Sample of Razor View code
@using (Html.BeginForm("Login", "Authorize"))
{
    @Html.AntiForgeryToken();
}

Daje to w rezultacie kod HTML postaci:

<form action="..." method="post">
    <input name="__RequestVerificationToken" type="hidden" value="J58uHtyhGtyHgf8kkjgFDeRgjjKKk6khgCvb/ywruFIUUYYVHHHgfft87/gGsQUf/YuP" />
    <!-- your form fields. -->
    <input type="submit" value="Submit"/>
</form>

IV. Rozwiązywanie problemów i debugowanie aplikacji web

Thu, 11 Aug 2016 20:00:59 Z

Rozwiązywanie problemów i debugowanie aplikacji jest normalnym procesem w czasie tworzenia i modyfikacji aplikacji. Na szczęście Visual Studio posiada wiele narzędzi do śledzenia kodu w czasie uruchomienia aplikacji. Możliwość przechwycenia i zrozumienia błędów w środowisku produkcyjnym i programistycznym jest potężnym narzędziem, które pomaga upewnić się, że ASP.NET MVC poprawnie zarządza aplikacją.

Zapobiegania i rozwiązywania problemów w czasie wykonywania

Performance Wizard

Rozwiązywanie problemów z wydajnością ma kluczowe znaczenie dla tworzenia solidnych aplikacji. Narzędzie Performance Wizard w Visual Studio pozwala na skonfigurowanie profilowania aplikacji, które umożliwia przechwycenie informacji o użyciu CPU, pamięci i zasobach. Profiler wykonuje kompletne śledzenie wszystkich wywołań w aplikacji. Pozwala to śledzić logiczny przepływ w aplikacji. Performance Wizard posiada kilka różnych metod monitorowania. Należą do nich: CPU sampling (rekomendowana), Instrumentation, .NET memory allocation (sampling) i Resource contention data (concurrency).
CPU sampling dostarcza informacji o pracy wykonywanej przez aplikację oraz jej wpływie na CPU. Próbkowanie jest lekkie i nie obciąża znacząco aplikacji. Polega na zbieraniu informacji co pewien okres cykli CPU. CPU sampling jest bardziej jak sprawdzanie początkowe mówiące o tym gdzie powinniśmy zbadać naszą aplikację dokładniej.
Instrumentation - instrumentacja jest bardziej inwazyjnym procesem. Narzędzie monitorujące dodaje kod do monitorowanych assembly (programista nie musi nic robić). ten kod pozwala zbadać dokładnie informacje w assembly, takie jak czasy wykonywania metod oraz wywoływaniawejściowe i wyjściowe w assembly. Monitorowane są również czasy spędzone na wykonywaniu poszczególnych metod w assembly niezależnie od zewnętrznych wywołań assembly. Taka analiza pozwala lepiej poznać problemy wydajnościowe.
.NET memory allocation jest sposobem na sprawdzenie problemów wydajnościowych zależnych od pamięci. Analiza obejmuje zarządzanie pamięciom aplikacji dla każdego obiektu w pamięci od momentu tworzenia do zbierania śmieci. Monitor może pracować w dwóch trybach. Pierwszy jest mniej inwazyjny i polega na próbkowaniu. Drugi korzysta z instrumentacji i daje dużo głębsze spojrzenie na pracę pamięci.
Resource contention data (concurrency) jest to monitor wydajności użyteczny przy monitorowaniu aplikacji wielowątkowych. Monitor ten daje informacje o interakcjach pomiędzy wątkami i systemem, wykorzystaniem procesora, zajętości I/O i wiele innych użytecznych metryk.
Po wybraniu metody profilowania należy wybrać aplikację która ma być analizowana. Wy zakończeniu Performance Wizard aplikacja zostaje uruchomiona i należy zacząć jej używać, szczególnie miejsca które chcemy zbadać. Po zamknięciu aplikacji zostanie wygenerowany raport. Poprzez wybór Analyze | Start Performance Analysis można generować ten sam raport wielokrotnie.

Visual Studio Profiler

Visual Studio Profiler wykonuje kompletne śledzenie wywołań występujących w aplikacji. Również używa próbkowania. Domyślne ustawienia dają w wyniku duży zestaw danych profilowania, które dostarczają informacji na temat mechanizmów działania aplikacji. Profiler wykrywa wszystkie wywołane metody i całą pamięć używaną do przetwarzania tych wywołań. Narzędzie zawiera szczegółowe informacje, takie jak ilość pamięci przeznaczonej dla różnych typów oraz ilość czasu spędzonego na tworzenie i usuwanie tych typów. Podczas gdy performance monitoring skupia się na wydajności to profiler monitoruje całą aktywność i dokumentuje ją. Uruchomienie profilera odbywa się w oknie Analyze | Profiler. Sekcja Hot Path określa najdroższe ścieżki kodu aplikacji i podąża tymi ścieżkami, aż wykryje wyższy poziom przetwarzania przeprowadzanego (a nie delegowanego) przez jedną funkcję. Sekcja Functions Doing Most Individual Work pomaga określić, gdzie dodatkowy czas może być wyeliminowany z wykonywania aplikacji, poprawiając tym samym wydajność aplikacji. Więcej informacji można znaleźć na stronie MSDN: Configuring Performance Sessions.

Windows Performance Monitor

Narzędzie systemu Windows Performance Monitor pozwala śledzić wiele charakterystyk uruchomionych aplikacji. Posiada ono setki indywidualnych monitorów z których niektóre są przeznaczone do śledzenia ASP.NET. Pojedyncze monitory są albo licznikami wydajności systemu albo licznikami wydajności aplikacji. Liczniki wydajności systemu są skupione na aplikacji i jej przebiegu uruchamiania, zatrzymywania i trwania. Liczniki wydajności aplikacji są skupione na detalach które dzieją się w aplikacji takich jak błędy, żądania i pamięć podręczna. Narzędzie to można uruchomić z menu RUN wpisując perfmon. Po uruchomieniu monitora można uruchomić Performance Monitor klikając jego nazwę w lewym panelu. Pojawi się okno w którym za pomocą guzika plus można dodać liczniki.

Tracing, Logging i Debugging

Śledzenie (ang. tracing) jest funkcjonalnością pozwalającą na analizowanie aplikacji w czasie uruchomienia. Wyrażenia śledzące są dostępne w przestrzeni nazw System.Diagnostic i pozwalają zapisywać informacje do jednej lub wielu klas nasłuchu TraceListener. Zaimplementowane klasy nasłuchu to TextWriterTraceListener, EventLogTraceListener, DelimitedListTraceListener i XmlWriterTraceListener. Klasa nasłuchu może zapisywać informacje do pliku tekstowego lub innego formatu. Aby zapisać informacje z dowolnego miejsca w kodzie należy użyć obiektu klasy Trace i jednej z metod Write, WriteIf, WriteLine lub WriteLineIf. Jeżeli istnieje taka potrzeba to można stworzyć własną klasę nasłuchu TraceListener. Śledzenie można włączyć lub wyłączyć w każdej chwili. Aby uruchomić śledzenie należy wykonać kilka kroków konfiguracyjnych. Najpierw trzeba utworzyć co najmniej jedną klasę nasłuchu Systems.Diagnostics.TraceListeners. Najprostszą metodą jest dodanie wpisu w pliku konfiguracyjnym:

<configuration>
    <system.diagnostics>
        <trace autoflush="false" indentsize="4">
            <listeners>
                <add name="myListener" type="System.Diagnostics.TextWriterTraceListener" initializeData="TracingInfo.log" />
                <remove name="Default" />
            </listeners>
        </trace>
    </system.diagnostics>
</configuration>

Przykład zapisu informacji do śledzenia:

Trace.WriteLine(“Message”)

Logowanie (ang. logging) jest procesem przechwytywania informacji o aplikacji i zapisywania ich. Generalnie jest dodawane do metod które wykonują jakąś pracę i o których wykonaniu chcemy mieć informacje takie jak czas wykonania, start, ilość danych itp. Logowanie można wykonać za pomocą narzędzi zewnętrznych jak NLog i Log4net lub użyć przestrzeni nazw System.Diagnostics do przechwycenia tych informacji. Większość narzędzi logujących pozwala na zapisywanie informacji wg poziomów krytyczności jak np Error, Info i Debug. Pozwala to konfigurować poziom krytyczności który ma być zapisywany dla danego środowiska.

Logowanie błędów może być obsługiwane automatycznie poprzez użycie atrybutu HandleErrorAttribute, przez nadpisanie metody kontrolera OnException lub przez użycie własnego filtru obsługującego błędy. Przykład użycia HandleErrorAttribute:

[HandleError(ExceptionType=typeof(System.IOException), View="FileError")]

Przykład użycia metody OnException:

protected override void OnException(ExceptionContext exceptionContext)
{
    if (exceptionContext.IsChildAction)
    {
        //we don't want to display the error screen if it is a child action,
        base.OnException(exceptionContext);
        return;
    }

    // log the exception in your configured logger
    Logger.Log(exceptionContext.Exception);

    //handle when the app is not configured to use the custom error path
    if (!exceptionContext.HttpContext.IsCustomErrorEnabled)
    {
        exceptionContext.ExceptionHandled = true;
        this.View("ErrorManager").ExecuteResult(this.ControllerContext);
    }
}

Zarządzanie wyjątkami może również odbywać się globalnie w metodzie Application_Error pliku Global.asax.

Code contracts

Kontrakty kodu (ang. code contracts) zostały dodane z .NET Framework 4.0 i są sposobem aby metoda była odpowiedzialna za definiowanie i publikowanie własnych warunków wewnętrznych. te warunki zawierają warunki wstępne (ang. preconditions), które definiują akceptowane parametry metody; warunki niezmienne (ang. invariant conditions) które określają definicję rzeczy które nie mogą być zmienione w czasie życia klasy; oraz warunki oczekiwane (ang. postconditions) które definiują oczekiwania co do zwracanego wyniku. Kontrakty kodu zgłaszają wyjątki jeżeli warunki nie zostaną spełnione i dają instrukcje w czasie programowania o tym jakie są oczekiwania w czasie wywoływania metod kontraktowych. Narzędziem ułatwiającym pracę z kontraktami jest Code Contracts Editor Extensions i można je pobrać z Visual Studio Gallery. Po dodaniu tego narzędzia we właściwościach projektu pojawia się dodatkowa zakładka. Używanie kontraktów wymaga od programisty innego podejścia do zarządzania przepływem wyjątków w aplikacji. Kontrakty są sposobem na zakodowanie zależności i udostępnienie ich dla klienta metody. Stary sposób sprawdzania parametru:

internal Article GetArticle(int id)
{
    if (id <= 0)
    {
        throw new ArgumentException("id");
    }
    // some work here
}

Dzięki kontraktom można go zastąpić w poniższy sposób:

internal Article GetArticle(int id)
{
    System.Diagnostics.Contracts.Contract.Requires(id > 0);
    // some work here
}

Jeżeli kontrakt nie zostanie spełniony to kod zgłosi wyjątek ContractException.

Invariant conditions sprawdza czy klasa nie znajduje się w niedozwolonym stanie, np:

[ContractInvariantMethod]
protected void ManageInvariant()
{
    System.Diagnostics.Contract.Invariant(this.Id < 0);
}

Aplikacja może naruszyć tę zasadę tylko w czasie wykonywania prywatnych metod.

Kontrakt postconditions można dodać poprzez użycie metody Ensures, np:

internal Article GetArticle(int id)
{
    System.Diagnostics.Contracts.Contract.Requires(id > 0);
    System.Diagnostics.Contracts.Contract.Ensures(
        Contract.Results<Article>() != null);
    // some work here
}

Więcej informacji dostępnych na stronie MSDN Code Contracts

Niepowodzenie kontraktu może być zarządzane na różne sposoby poprzez zarejestrowanie obsługi zdarzenia Contract.ContractFailed.

Health monitoring

Monitorowanie stanu (ang. Health monitoring) jest systemem wbudowanym w ASP.NET, który śledzi różne zdarzenia zachodzące wewnątrz aplikacji web. Zdarzenia cyklu życia aplikacji są zgłaszane kiedy aplikacja startuje i jest zatrzymywana, w czasie procesu startu i zatrzymania i podczas regularnych kontroli. Zdarzenia bezpieczeństwa są zgłaszane kiedy próba logowania się nie powiedzie lub kiedy nieautoryzowany użytkownik próbuje otrzymać dostęp do zabezpieczonego zasobu. Błędy aplikacji pokrywają wszystkie błędy które mogą być zgłoszone. Monitorowanie jest dodawane w konfiguracji. Istnieją specjalne mapowania dla specyficznych błędów, błędów infrastruktury, błędów przetwarzania, awarii i innych zdarzeń. Każde zdarzenie może być obsługiwane inaczej poprzez odpowiednia konfigurację. >NET Framework posiada przykładową kompletną konfigurację Web.config w której można podejrzeć wszystkie możliwe zdarzenia, dostawców i inne opcje monitorowania. Przykładowy plik można znaleźć w %WINDIR%\Microsoft.NET\Framework\version\CONFIG. Przykład konfiguracji:

<healthMonitoring>
    <bufferModes>
        <add name="Critical Notification" maxBufferSize="100" maxFlushSize="20" urgentFlushThreshold="1" regularFlushInterval="Infinite" urgentFlushInterval="00:01:00" maxBufferThreads="1" />
        <add name="Logging" maxBufferSize="1000" maxFlushSize="200" urgentFlushThreshold="800" regularFlushInterval="00:30:00" urgentFlushInterval="00:05:00" maxBufferThreads="1" />
    </bufferModes>
    <providers>
        <add name="EventLogProvider" type="System.Web.Management.EventLogWebEventProvider, System.Web" />
    </providers>
    <profiles>
        <add name="Default" minInstances="1" maxLimit="Infinite" minInterval="00:01:00" custom="" />
        <add name="Critical" minInstances="1" maxLimit="Infinite" minInterval="00:00:00" custom="" />
    </profiles>
    <rules>
        <add name="All Errors Default" eventName="All Events" provider="EventLogProvider" profile="Default" minInstances="1" maxLimit="Infinite" minInterval="00:01:00" custom="" />
        <add name="Failure Audits Default" eventName="App Lifetime Events" provider="EventLogProvider" profile="Default" minInstances="1" maxLimit="Infinite" minInterval="00:01:00" custom="" />
    </rules>
    <eventMappings>
        <add name="All Events" type="System.Web.Management.WebBaseEvent,System.Web" startEventCode="0" endEventCode="2147483647" />
        <add name="Heartbeats" startEventCode="0" endEventCode="2147483647" type="System.Web.Management.WebHeartbeatEvent,System.Web" />
        <add name="App Lifetime Events" startEventCode="0" endEventCode="2147483647" type="System.Web.Management.WebApplicationLifetimeEvent" />
    </eventMappings>
</healthMonitoring>

Sekcja definiuje okres oczekiwania przed zapisem do dostawcy. Sekcja definiuje dostawców używanych do zapisywania zdarzeń. Sekcja pozwala zdefiniować zestawy parametrów używanych przy konfiguracji zdarzeń. Sekcja tworzy powiązanie pomiędzy dostawcami i zdarzeniami. Sekcja pokazuje, że aplikacja jest mapowana do logowania zdarzeń, heartbeats i zdarzeń cyklu życia aplikacji. Więcej na ten temat można przeczytać na stronie MSDN Logging Error Details with ASP.NET Health Monitoring

Projektowanie strategii obsługi wyjątków

Wyjątki są standardową częścią aplikacji. Nawet jeżeli aplikacja jest wolna od błędów to może zgłaszać wyjątki lub mogą występować inne problemy zależne od czynników zewnętrznych jak np problemy z siecią. Projektując aplikację ASP.NET MVC należy rozważyć potencjalne punkty w których mogą pojawić się problemy jak np wywołania serwisu sieciowego lub dostęp do plików. należy zastanowić się co zrobić w sytuacji występowania błędu, czy powiadomić o tym fakcie użytkownika a jeżeli tak to jaką informację wyświetlić. Należy również pomyśleć o opcjach odzyskiwania aby utrzymać aplikację w stanie ciągłego działania oraz o tym jakie informacje diagnostyczne należy przechwycić.

Obsługa wyjątków pomiędzy warstwami

Zazwyczaj warstwy w wielowarstwowych aplikacjach obsługują dwa zestawy wyjątków: własne wyjątki i wyjątki z warstwy położonej bezpośrednio pod nią w stosie. Przykładowo warstwa UI nie powinna obsługiwać wyjątku zgłoszonego w warstwie dostępu do danych. taki wyjątek powinien być obsłużony w warstwie biznesowej.

Własne strony błędów

Choć IIS posiada własne strony błędów to jest to raczej bardzo rzadkie żeby te strony były używane przez aplikacje oraz aby prowadziły odpowiedni poziom informacji wyświetlanych użytkownikowi. W ASP.NET MVC można tworzyć niestandardowe strony do wyświetlania błędów. Te strony mogą być zgodne ze stylem wyglądu zdefiniowanym dla aplikacji ale pokazywać dane specyficzne dla błędu. Strony błędów można tworzyć tak jak każdą inną kombinację kontrolera i widoków. Definiuje się kontroler obsługi błędów i tworzy się widoki do zarządzania różnymi typami błędów. Odnośniki do stron błędów mogą być dodane w kodzie jak i w konfiguracji. W aplikacji MVC można np stworzyć kontroler ErrorManagerController, który będzie posiadał różne akcje dla każdego możliwego statusu HTTP oraz domyślną akcję ServerError. Strona Global.asax jest jednym ze sposobów użycia własnych stron błędów. można użyć metody wspólnej dla ASP.NET i ASP.NET MVC którą jest Application_Start. Można również użyć metody Application_Error która jest globalną obsługą błędów która jest wywoływana kiedy nieobsłużony wyjątek trafia do stosu aplikacji. Przykład metody Application_Error:

public void Application_Error(Object sender, EventArgs e)
{
    if (Server != null)
    {
        //Get the context
        HttpContext appContext = ((MvcApplication)sender).Context;
        Exception ex = Server.GetLastError().GetBaseException();
        //Log the error using the logging framework
        Logger.Error(ex);
        //Clear the last error on the server so that custom errors are not fired
        Server.ClearError();
        //forward the user to the error manager controller.
        IController errorController = new ErrorManagerController();
        RouteData routeData = new RouteData();
        routeData.Values["controller"] = "ErrorManagerController";
        routeData.Values["action"] = "ServerError";
        errorController.Execute(
            new RequestContext(new HttpContextWrapper(appContext), routeData));
    }
}

Obsługę błędów można również dodać poprzez konfigurację dodając sekcję do , np:

<customErrors mode="RemoteOnly" defaultRedirect="ErrorManager/ServerError">
    <error statusCode="400" redirect="ErrorManager/Status400" />
    <error statusCode="403" redirect="ErrorManager/Status403" />
    <error statusCode="404" redirect="ErrorManager/Status404" />
</customErrors>

Element customErrors posiada dwa interesujące atrybuty: mode i defaultRedirection. Atrybut mode może mieć trzy wartości: On, Off i RemoteOnly. RemoteOnly oznacza, że strona ma być wyświetlana dla zdalnych użytkowników a dla lokalnych będzie wyświetlana standardowa strona błędu. Atrybut defaultRedirection jest adresem strony która będzie wyświetlona jeżeli błąd nie będzie obsługiwany przez bardziej specyficzną stronę. Błędy HTTP 500 są obsługiwane przez inne rodzaje obsługi niż konfiguracja, np przez filtry lub zdarzenie OnException. Aby błędy były wyświetlane należy również ustawić właściwość w .

First chance exceptions

Wyjątki First chance exceptions są wyjątkami które są bezpośrednio wyrzucane, zanim zostaną obsłużone przez error handler. Przykładem takiego wyjatku może być wyjątek zgłaszany w metodzie Application_Start pliku Global.asax. Można dodać obsługę takich wyjątków do aplikacji. Ta obsługa będzie wywoływana dla każdego wyjątku zgłoszonego w aplikacji. Można w niej dodać logowanie lub inną czynność diagnostyczną. Należy zwrócić szczególną uwagę aby obsługa tych wyjątków sama nie zgłaszała wyjątków ponieważ może to doprowadzić do kaskady wyjątków i spowodować przepełnienie stosu. Przykład przechwytywania FirstChanceExceptions w Global.asax:

protected void Application_Start()
{
    AppDomain.CurrentDomain.FirstChanceException +=
        CurrentDomain_FirstChanceException;

    AreaRegistration.RegisterAllAreas();
    WebApiConfig.Register(GlobalConfiguration.Configuration);
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
    AuthConfig.RegisterAuth();
}
protected void CurrentDomain_FirstChanceException(object sender,
    System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)
{
    if (e.Exception is NotImplementedException)
    {
        // do something special when the functionality is not implemented
    }
}

Aby być pewnym, że Visual Studio przechwyci FirstChanceException,należy zaznaczyć w opcjach DEBUG Exceptions zgłaszanie i obsługę Common Language Runtime Exception.

Testowanie aplikacji web

Testowanie kodu jest jednym z podstawowych wymagań oprogramowania, ale nie jest to jeden z najbardziej powszechnie pomijanych lub minimalnie zarządzanych obszarów rozwoju oprogramowania. Jednym ze sposobów zarządzania nieoczekiwanych zdarzeń w kodzie jest pisanie i utrzymywanie testów jednostkowych. Testowanie jednostkowe to proces tworzenia testów wielokrotnego użycia które sprawdzają poprawność konkretnego podzbioru funkcjonalności. Istnieją dwa ważne aspekty wykonywania testu jednostkowego. Test powinien dokładnie pokrywać testowany obszar funkcjonalności. Testy powinny być napisane zarówno dla pozytywnego przepływu w stosie wywołań jak i negatywnego przepływu a w tym testować również przypadki wystąpienia błędu w niższej warstwie stosu.

Testy jednostkowe

W aplikacji ASP.NET MVC można tworzyć testy jednostkowe dla prostych metod, modeli, metod aplikacji i akcji w kontrolerach poprzez sprawdzanie zwracanego rezultatu. W Visual Studio można dodać projekt z testami jednostkowymi poprzez Add New Project | Unit Test Project. Dobrą praktyką jest pisanie testów dla każdej klasy osobno i nadawanie im nazw które jednoznacznie określają co jest testowane. Przykład metody do testowania:

public double Add(object initNumber, object additional)
{
    double baseNumber = Convert.ToDouble(initNumber);
    double addingNumber = Convert.ToDouble(additional);
    return baseNumber + addingNumber;
}

Gdy parametry wejściowe są nieodpowiedniego typu to zgłoszony zostanie wyjątek InvalidCastException. Przykład testu dla tej metody:

[TestMethod]
public void Add_Test()
{
    CalculationManager manager = new CalculationManager ();
    Assert.IsTrue(manager.Add(2, 2).Equals(4), "2 + 2 = 4");
    Assert.IsTrue(manager.Add(2, 2.5).Equals(4.5), "2 + 2.5 = 4.5");
    try { manager.Add(DateTime.Now, 2.5);}
    catch (Exception ex){ Assert.IsInstanceOfType(ex,
        typeof(InvalidCastException), "Today + 2 = oops");}
}

Przykład testu akcji kontrolera:

[TestMethod]
public void Index_Test()
{
    CalculationController controller = new CalculationController();
    Assert.IsInstanceOfType(controller.Index(), typeof(ExpectedViewResult));
}

Testy jednostkowe powinny być wykonywane bez żadnych zależności, tzn, że powinny być niezależne od bazy danych lub UI.

Tworzenie mock’ów

Funkcja Fakes w VS 2012 oferuje wiele wsparcia podczas pisania testów jednostkowych. Funkcja Fakes wprowadza dwa sposoby na zarządzanie zależnościami w czasie tworzenia testów: shims i stubs. Shim jest fragmentem kodu który przechwytuje wywołanie do assembly w celu zwrócenia obiektu i zwraca jego makietę. Jest używany do zastępowania klas zewnętrznych. Stub jest kodem który zastępuje klasę przez ograniczony podzbiór klas makiet. jest używany do zastępowania innych klas w aplikacji. Przykład użycia shim do kontroli czasu zwracanego przez DateTime.Now:

using (ShimsContext.Create())
{
    // insert the delegate that returns call for DateTime.Now
    System.Fakes.ShimDateTime.NowGet = () => new DateTime(2010, 1, 1);
    MethodThatUsesDateTimeNow();
}

Przykład użycia stub:

public interface ICalculator
{
    double Add(double firstNumber, double lastNumber);
}

public class Mathematics
{
    private ICalculator calculator;
    public Mathematics (ICalculator calc)
    {
        calculator = calc;
    }
    public double AddNumbers()
    {
        return calculator.Add(1,1);
    }
}
// ...
[TestMethod]
public void TestAdd()
{
    // Create the fake calculator:
    ICalculator calculator = new Calculator.Fakes.StubICalculator()
    {
        // Define each method:
        Add = (a,b) => { return 25; }
    };

    // In the completed application, item would be a real one:
    var item = new Mathematics(calculator);

    // Act:
    double added = item.AddNumbers();
    Assert.AreEqual(25, added);
}

Visual Studio Web Tests

W edycji Visual Studio Ultimate 2012 można tworzyć i uruchamiać testy wydajności i obciążenia (web performance tests i load tests). Pierw tworzy się testy web które chcemy uruchomić podczas trwania testu obciążenia. Te testy mogą być skalowane od jednego do wielu użytkowników aby sprawdzić jak aplikacja zachowuje się w czasie obciążenia. Liczba użytkowników może zostać ustalona na stałe lub być inkrementowana. Można również ustawić progi oparte na systemie, który będzie monitorować gdy aplikacja osiągnie próg obciążenia procesora lub pamięci. Testowanie rozwiązania obejmują test dymu, testy warunków skrajnych oraz testy wydajności (smoke test, stress test i performance test). Test typu smoke używa małego obciążenia w krótkim czasie. Można użyć go od razu po wdrożeniu aplikacji na nowe środowisko aby mieć pewność, że aplikacja działa prawidłowo. Test typu stress uruchamia aplikację pod dużym obciążeniem przez długi okres czasu ujawniać zachowania aplikacji w warunkach dużego obciążenia. Test typu performance bada reagowania aplikacji.

Aby utworzyć testy należy dodać projekt Web Test and Load Project po czym należy skonfigurować przepływ testów które będą używane w teście. Najprostszym sposobem jest nagranie serii akcji w aplikacji web. W nowym projekcie powinien znajdować się plik .webtest który należy otworzyć i rozpocząć nagrywanie przepływu. Istnieją trzy podejścia przy wykonywaniu testów obciążeniowych: constant, step i goal-based. Typ constant pozwala na ustawienie stałej liczby użytkowników i użycie ich dla całego wykonania testu. Typ step dodaje użytkowników do testu stopniowo. Należy ustawić cztery wartości dla tego testu: Initial user count, Maximum user count, Step duration i Step user count. Typ goal-based ładuje test tak jak typ step jednakże różni się tym, że nie zlicza uruchomionych użytkowników jako kluczowej informacji tylko zlicza użytkowników jako sposób na dotarcie do innych celów, np obciążenie procentowe CPU i procentowe zużycie pamięci.

Debugowanie aplikacji Windows Azure

Debugowanie aplikacji web może być dużym wyzwaniem. Dodanie aplikacji w aspekcie zdalnym do Windows Azure może uczynić debugowanie jeszcze bardziej skomplikowanym. Dlatego na potrzeby Windows Azure dodano dodatkowe dedykowane narzędzia diagnostyczne Windows Azure–specific diagnostics API, Microsoft.WindowsAzure.Diagnostics. Uruchomienie diagnostyki w aplikacji wdrożonej na Windows Azure wymaga kilku kroków. Pierw należy dodać informacje do pliku ServiceDefinition.csdef aby można było zaimportować moduł Diagnostics. Należy także upewnić się, że informacja jest dodana do pliku ServiceConfiguration.cscfg aby moduł diagnostyki miał dostęp do bazy danych i innych usług biznesowych. Kiedy diagnostyka jest już dostępna w aplikacji to można ją wywołać z poziomu kodu lub użyć wbudowanego monitora zdarzeń. Aby skonfigurować nowy monitor należy utworzyć nowy plik Diagnostics.wadcfg, który zawiera wpisy konfiguracyjne ustawiające odpowiednie liczniki. Po zapisaniu informacji diagnostycznych można programistycznie pobrać te informacje z serwera lub dostać je na żądanie. Przykład pliku ServiceDefinition.csdef:

<ServiceDefinition name="WindowsAzure1" xmlns=http://schemas.microsoft.com/ServiceHosting/2008/10/ServiceDefinition schemaVersion="2013-03.2.0">
    <WebRole name="WebRole1">
        <!-- Other configuration information here ->
        <Imports>
        <Import moduleName="Diagnostics" />
        </Imports>
    </WebRole>
</ServiceDefinition>

Przykład pliku ServiceConfiguration.cscfg:

<ServiceConfiguration serviceName="WindowsAzure2" xmlns="http://schemas.microsoft.com/ServiceHosting/
        2008/10/ServiceConfiguration" osFamily="3" osVersion="*" schemaVersion="2013-03.2.0">
    <Role name="WebRolePrimary">
        <Instances count="1" />
        <ConfigurationSettings>
            <Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString" value="UseDevelopmentStorage=true" />
            <!—- this version is for deployment on the azure server
            <Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics
                .ConnectionString" value="DefaultEndpointsProtocol
                =https;AccountName=demoapp;AccountKey=[your key]" /> -->
        </ConfigurationSettings>
    </Role>    
</ServiceConfiguration>

Przykład dodania dwóch liczników wydajności w pliku Diagnostics.wadcfg:

<DiagnosticMonitorConfiguration xmlns="http://schemas.microsoft.com/ServiceHosting/2010/10/DiagnosticsConfiguration" configurationChangePollInterval="PT1M" overallQuotaInMB="4096">

    <PerformanceCounters bufferQuotaInMB="0" scheduledTransferPeriod="PT30M">
        <PerformanceCounterConfiguration counterSpecifier="\Process(WaWorkerHost)\Thread Count" sampleRate="PT30S" />
        <PerformanceCounterConfiguration counterSpecifier="\.NET CLR Interop(_Global_)\# of marshalling" sampleRate="PT30S" />
    </PerformanceCounters>

    <DiagnosticInfrastructureLogs bufferQuotaInMB="0" scheduledTransferLogLevelFilter="Verbose" scheduledTransferPeriod="PT30M" />

</DiagnosticMonitorConfiguration>

W Windows Azure można również skonfigurować IntelliTrace dla aplikacji. Aby tego dokonać należy wdrożyć aplikację używając Visual Studio Ultimate 2012 i dodać pewne zmiany w czasie konfiguracji wdrożenia. Informacje zbierane przez IntelliTrace mogą być pobrane za pomocą Visual Studio. Należy zaznaczyć pole wyboru Enable IntelliTrace i wybrać informacje które mają być zbierane. Do wyboru są dwie główne kategorie: tylko zdarzenia lub zdarzenia i informacje o wywołaniach. Wybranie tylko zdarzeń ma minimalny wpływ na wydajność aplikacji lecz zbieranie informacji o wywołaniach ze zdarzeniami może mieć duży wpływ na działanie aplikacji. Po pobraniu kopii dzienników można otworzyć je w oknie Server Explorer wybierając Windows Azure Compute.

III. Programowanie interfejsu użytkownika

Mon, 08 Aug 2016 19:42:24 Z

Doświadczenie użytkownika końcowego aplikacji jest bardzo istotne, szczególnie dla stron internetowych. Wiele czynników wpływa na UX.

Optymalizacja SEO

Wiele firm, szczególnie e-comerce, opierają się na wyszukiwarkach aby pomóc użytkownikom dostać się do ich stron.
W ramach swoich działań SEO, trzeba usunąć przeszkody, które mogłyby utrudnić wyszukiwarkom skuteczne zindeksowanie witryny. należy upewnić się, że w kodzie nie ma brakujących lub niekompletnych tagów HTML oraz, że treść jest odseparowana od prezentacji i skryptów. Jest to bardzo istotne ponieważ większość kodu HTML jest tworzone przez helpery i jest współdzielona z szablonów i nie jest zwykle sprawdzana.
Narzędzia analityczne pomagają sprawdzić poprawność kodu HTML w aplikacji. Należą do nich IIS SEO Toolkit i Internet Explorer Developer Toolbar. W3C posiada walidator sieciowy który sprawdza poprawność HTML i CSS.
IIS SEO Toolkit nie jest narzędziem wbudowanym w IIS. Należy go pobrać ze strony Microsoft.com. Można dzięki niemu analizować strony i aplikacje, tworzyć mapy stron oraz tworzyć zasady wykluczeń dla robotów a także pliku robots.txt w którym definiujemy które strony nie powinny być zindeksowane.
Technologia jest ciągle ulepszana, pozwalając ludziom z upośledzeniami używać internetu coraz bardziej skutecznie. WAI-ARIA jest systemem znaczników który wspomaga technologię i pozwala użytkownikom na lepsze zrozumienie treści. Przykład kodu HTML z ARIA:

<html>

<head>
    <title>ARIA Example: Hello</title>
</head>

<body>
    <div role="application">
        <div id="name" class="name">
            <h2>Hello</h2>
            <p>
                <strong>Instructions:</strong> Insert your name in the box below. An
                <abbr title="Accessible Rich Internet Application">ARIA</abbr> dialog box will display the result. To start over, press the Try Again button.
            </p>
            <p class="input">
                <label id="name_label" for="name_text">Insert your Name:</label>
                <input type="text" id="name_text" size="3" aria-labelledby="name_label" aria-invalid="false" />
            </p>
            <p id="name_alert" role="alert" class="feedback"></p>
            <p class="input">
                <input class="button" id="name_check" type="button" role="button" aria-pressed="false" value="Check Name" />
                <input class="button" id="name_again" type="button" role="button" aria-pressed="false" value="Try Again" />
            </p>
        </div>
    </div>
</body>

</html>

ASP.NET MVC nie posiada wbudowanego wsparcia dla ARIA ale rozszerzalna natura ASP.NET MVC pozwala na utworzenie helperów HTML zgodnych z ARIA, np:

public static IHtmlString ARIATextBoxFor<TModel, TProperty>(this HtmlHelper<TModel>
    helper, Expression<Func<TModel, TProperty>> exp)
{
    ModelMetadata metadata = ModelMetadata.FromLambdaExpression(exp,
        helper.ViewData);
    var attr = new RouteValueDictionary();
    if (metadata.IsRequired)
    {
        attr.Add("aria-required", true);
    }
    return helper.TextBoxFor(exp, attr);
}

Globalizacja i lokalizacja

Globalizacja jest przygotowaniem technicznym aplikacji do wsparcia wielu kultur i dzieli się na umiędzynarodowienie (I18N) i lokalizację. Umiędzynarodowienie jest procesem w którym przystosowujemy aplikację do obsługi wielu kultur. Lokalizacja jest procesem tworzenia treści specyficznej dla danej lokalizacji.
najwyższym poziomem lokalizacji jest język. Podkategorią języka jest narodowość np j. angielski jest inny w UK i USA. Oba są tym samym językiem ale mają swoje kody narodu US i UK. kiedy aplikacja obsługuje globalizację to w pierwszej kolejności wyszukuje tłumaczenia dla narodowości a później dla języka a na końcu w języku domyślnym. Kiedy żądanie HTTP jest wysyłane do serwera to zawiera nagłówek podobny do poniższego:

GET http://localhost/HTTP/1.1
Connection: keep-alive
Cache-Control: max-age=0
Accept-Language: en-US,en;q=0.8

Aby aplikacja mogła to obsłużyć należy dodać do pliku Web.config wpis:

<globalization culture="auto" uiculture="auto" enableclientbasedculture="true"/>

To ustawienie mówi ASP.NET MVC aby automatycznie ustawić narodowość klienta i po otrzymaniu żądania w innym języku niż domyślny ASP.NET ładuje tę informację do właściwości CurrentThread.CurrentUICulture.

Globalizacja wymaga aby wszystkie treści które mogą być wyświetlane zostały umieszczone w plikach zasobów. Przy tworzeniu plików zasobów powinno unikać się powtórzeń ponieważ zwiększają one koszt tłumaczenia. klasa pomocnicza ResourceManager pomaga zwrócić przetłumaczone zasoby. ResourceManager pobiera język z klasy CultureInfo.
Alternatywą dla plików z zasobami jest tworzenie osobnych stron dla różnych języków. Aby użyć tego podejścia należy nadpisać metodę Controller.OnActionExecuted tak aby budowała ścieżkę do widoku na podstawie klasy UICulture aktualnego wątku.
W ASP.NET zaleca się aby pliki zasobów były rozdzielone na języki a sugerowana konwencja nazewnictwa to .
Pliki zasobów mogą być używane przez wiele widoków. Dla języków zachodnich w których czyta się zwykle od prawej do lewej trzeba użyć innego zestawu widoków.
Należy zapewnić zasoby globalizacji dla jQuery. Java Script nie może pobrać kultury z przeglądarki, nawet jeżeli ta informacja jest dostępna i przesyłana przez przeglądarkę. Microsoft utworzył moduł globalizacji dla jQuery. Przykład dołączenia plików JS dla globalizacji:

<script src="scripts/jquery.globalize/globalize.js" type="text/javascript"></script>
<script src="scripts/jquery.globalize/cultures/globalize.cultures.js" type="text/javascript"></script>

Aby używać języka po stronie klienta należy zapisać go do zmiennej np:

var language = "@Request.UserLanguages[0]";
jQuery.preferCulture(language);

Lub ustawić jako język w przestrzeni globalnej:

$.global.preferCulture(language)

Można umożliwić użytkownikom wybór kultury w której chcą obsługiwać aplikację. kiedy użytkownik wybierze narodowość to można ją zapisać w sesji lub jako ciasteczko. Później należy nadpisać domyślny jeżyk z przeglądarki przez język wybrany przez użytkownika. Dobrym miejscem na nadpisanie języka jest filtr akcji, np:

Thread.CurrentThread.CurrentUICulture = new CultureInfo("es-MX");

Pliki z zasobami można aktualizować lub tworzyć z pomocą narzędzi takich jak Assembly Linker i Resource File Generator. przykład utworzenia pliku tłumaczen przez Assembly Linker:

al.exe /t:lib /embed:strings.de-DE.resources /culture:de-DE /out:MyApp.de-DE.resources.dll

Implementacja kontrolerów i akcji MVC

Atrybuty i filtry

Atrybuty filtrów pozwalają na zbadanie i podjęcie akcji na podstawie informacji zawartych w żądaniu przed i po wywołaniu akcji.
ASP.NET MVC posiada wbudowane atrybuty pomagające przy uwierzytelnieniu, autoryzacji, zabezpieczeniu dostępu i zarządzaniu błędami. jeżeli istnieje taka potrzeba to można zbudować własne filtry.
Główną rolą atrybutów jest analiza informacji, szczególnie zawartych w klasie HttpContext, przychodzących i wychodzących z kontrolera.
Atrybuty filtrów dziedziczą z klasy System.Web.Mvc.FilterAttribute i pozwalają programiście na wstawienie pewnej logiki do przetwarzania akcji kontrolerów.
Jeden zestaw atrybutów standardowych zawiera tradycyjne filtry sprawdzające pewne oczekiwania . Są to filtry RequireHttpsAttribute, ValidateAntiForgeryTokenAttribute, ValidateInputAttribute, AuthorizeAttribute, AllowAnonymous i ChildActionOnlyAttribute. Wszystkie można znaleźć w przestrzeni nazw System.Web.Mvc.
Filtry HandleErrorAttribute i ActionFilterAttribute są bardziej podobne do kodu otaczającego akcję niż do filtrów. Pierwszy obsługuje wyjątki występujące w akcjach, domyślnie w ASP.NET MVC wyświetlany jest widok ~/Views/Shared/Error. Filtr ten pozwala na użycie różnych widoków dla różnych wyjątków. Aby zmienić jego zachowanie należy przesłonić metodę OnException atrybutu. Atrybut ActionFilterAttribute jest klasą abstrakcyjną z której filtry dziedziczą. Pozwala ona na tworzenie własnych filtrów i klas które mogą być atrybutami akcji. podstawowe metody do nadpisania to:
OnActionExecuting - wywoływana przed wywołaniem akcji. Pozwala na zbadanie informacji dostępnych w HttpContext i podjęcie decyzji czy akcja powinna być kontynuowana.
OnActionExecuted - pozwala zbadać wynik akcji i zdecydować czy coś musi sie wydarzyć w tym punkcie.
OnResultExecuting - wywoływana przed przetworzeniem wyniku akcji.
OnResultExecuted - wywoływana po przetworzeniu wyniku akcji ale przed załadowaniem wyniku do strumienia wyjściowego.
Atrybuty akcji mogą być zamieszczone w trzech miejscach. Dla poszczególnych akcji kontrolerów. Dla klasy kontrolera co spowoduje, że zostaną zastosowane dla wszystkich akcji kontrolera. Globalnie co spowoduje, ze wszystkie akcje aplikacji będą używać tego filtru. Aby dodać filtr globalny należy dodać linię kodu w metodzie RegisterGlobalFilters w pliku App_Start/FilterConfig.cs:

filters.Add(new RequireHttpsAttribute());

Implementacja akcji i wyników akcji

ASP.NET MVC zapewnia programistom dużą elastyczność w jaki sposób mogą one przetwarzać przychodzące żądania . początkowa granica akcji rozpoczyna się w momencie w którym routing okresli która akcja musi być wywołana aby pasowała do ścieżki URL. Ta początkowa granica zawiera również dopasowanie parametrów wejściowych. kiedy decyzja o trasie jest podjęta to przepływ zostaje przekazany do obsługi zdarzeń i atrybutów filtrów.
Wynikiem akcji aplikacji MVC są wyniki akcji Action results. Są one ostatnim krokiem obsługi HttpRequest i są odpowiedzialne za zapis informacji do strumienia odpowiedzi.
Powszechnie stosowany wynik ViewResultBase jest bazowym wynikiem zwracającym HTML do klienta.
ViewResult i PartialViewResult dziedziczą z ViewResultBase.
Jeżeli akcja zwraca plik to istnieją wyniki akcji FileResult i ContentResult, pierwszy dla treści binarnej a drugi dla ASCII. Zwracając ContentResult należy zdefiniować treść jako ciąg znaków, podać kodowanie i określić typ treści ContentType np application/pdf. FileResult wymaga podania ContentType i FileDownloadName.
JavaScriptResult i JsonResult są zaprojektowane tak aby wspierać przetwarzanie po stronie klienta poprzez zwracanie kodu JavaScript lub obiektów JSON.
RedirectResult i RedirectToRouteResult przekierowują przetwarzanie do innego adresu URL lub innej akcji MVC.
EmptyResult reprezentuje brak wyniku.

Implementacja wiązania danych

Model binding jest elastycznym procesem który mapuje pola w interfejsie użytkownika na właściwości modelu. Istnieją trzy typy wiązania modelu: strongly-typed binding, weakly-typed binding, i using the value provider.
Strongly-typed binding jest narzędziem działającym w dwie strony w taki sposób, że helper HTML rozumie atrybuty w modelu i może ustawić sprawdzanie danych po stronie klienta bazując na tych informacjach. Framework może zidentyfikować te informacje kiedy są przesyłane z powrotem do metody akcji. W modelu można używać atrybutów sprawdzających poprawność danych jak np Required lub DataType(DataType.Password). Przykład silnie typowanego wiązania pola tekstowego:

@Html.TextBoxFor(m => m.UserName)

Do klas wiązania danych należą: DefaultModelBinder, LinqBinaryModelBinder, ModelBinderAttribute i ModelBinderDictionary.

Weakly-typed binding jest wiązaniem jednostronnym które nie dostarcza sprawdzania danych po stronie klienta ale tworzy model kiedy żądanie jest zwracane. Można dodać helpery pomocnicze w Weakly-typed binding oraz dodać listę akceptowanych i blokowanych atrybutów które powinny być wypełniane z formularza poprzez użycie parametrów Include i Exclude w atrybucie Bind. Przykład:

@Html.TextBox("model.UserName")
// ...
Public ActionResult Login([Bind(Prefix="login")]LoginUser user)
// ...
Public ActionResult Save([Bind(Exclude="Salary")]Employee emp)

Kiedy nie mamy dostępu do wiązania typów z formularzem a otrzymujemy żądanie POST to możemy użyć obiektu ValueProvider aby umożliwić wiązanie do modelu.
Istnieją cztery główne rodzaje wiązania ValueProvider w ASP.NET MVC wyspecjalizowane w wiązaniu innych stosów żądań.
FormsValueProvider pozwala na pracę z danymi zwracanymi jako wartości formularza.
QueryStringProvider pozwala na pracę z danymi zawartymi w query string.
HttpFileCollectionValueProvider - pozwala na pracę z załącznikami zawartymi w żądaniu.
RouteDataValueProvider - pozwala na pracę z danymi trasowania lub URL.
Dane zwracane przez wybranego dostawcę można wiązać z modelem używając metody rozszerzającej ToValueProvider obiektu FormCollection. ten proces próbuje dopasować pola z wartością do pustego modelu.

Public ActionResult Save(FormCollection formColl)
{
    Employee emp = new Employee();
    If (TryUpdateModel(emp, formColl.ToValueProvider())
    {
        UpdateModel(emp, formColl.ToValueProvider());
    }
    // more code here
}

Routing

Jeżeli w aplikacji istotne jest SEO to rozważ nadawanie adresów URL zrozumiałych dla człowieka np Product/ zamiast Product/1. Jeżeli powiązanie pomiędzy adresem URL a treścią strony nie jest jasne to może być wymagane wsparcie dla wielu różnych dróg do dotarcia do określonej strony, np wg tytułu, ISBN lub nazwy autora. Odpowiednio skonfigurowany routing pomaga aplikacji szybko zdecydować która akcja powinna obsłużyć żądanie.
Kolejność tras zawartych w RouteCollection lub tablicy routingu jest istotna. Routing wyszukuje na liście tras pierwszego dopasowania dla przychodzącego wzoru. Lista tras powinna zaczynać się od ignorowanych adresów, potem bardziej specyficzne adresy a na końcu adresy ogólne. Domyślna obsługa tras jest zapisana w metodzie RegisterRoutes w pliku App_Start/RouteConfig.cs. Aby dodać trasę do RouteCollection użyj funkcji MapRoute. Metoda ta przyjmuje nazwę i wzór adresu jako parametry wymagane oraz domyśle wartości i ograniczenia jako parametry dodatkowe.
Tworząc trasę można dodać domyślne wartości które mają zastąpić brakujące części w adresie URL. Jako częśc tej operacji można oznaczyć parametry jako opcjonalne tak aby obsługa routingu wiedziała żeby sprawdzić przesłonięte metody z innymi parametrami. Można również użyć tej strategii aby obsłużyć specjalne wymagania jak np tworzenie prostych adresów URL które serwer będzie tłumaczył na bardziej złożoną kombinację kontrolerów i akcji. Przykład RouteConfig.cs:
```
public static void RegisterRoutes(RouteCollection routes)
{
  routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
  routes.MapRoute(
      name: "Default",
      url: "{controller}/{action}/{id}",
      defaults: new { controller = "Home",
          action = "Index", id = UrlParameter.Optional },
      constraints: new { id = @"\d+" }
  );
}
```
Enumeracja UrlParameter.Optional oznacza, że parametr jest parametrem opcjonalnym.
Ograniczenia (ang. constraints) są sposobem na filtrowania żądanych adresów URL i zdefiniowania innego routingu dla elementów w oparciu o ich typ lub zawartość. Obsługa routingu traktuje ograniczenia jako wyrażenie regularne i wylicza odpowiednią zmienną w celu ustalenia, czy istnieje dopasowanie. Powszechnie stosowanym ograniczeniem jest ograniczenie trasy tylko do takich w których jako odpowiedni segment adresu rozpoznano liczbę, generalnie do wyszukiwania id, np: constraints: new { id = @”\d+” }. Przykład tras określających różne metody dla różnych typów parametru:
```
routes.MapRoute(
  name: "Videos",
  url: "Product/Details/{id}",
  defaults: new { controller = "DVD", action = "Index",
  Page = UrlParameter.Optional },
  constraints: new { id = @"[a-zA-Z]+"}
);
routes.MapRoute(
  name: "Videos2",
  url: "Product/Details/{id}",
  defaults: new { controller = "DVD", action = "Details",
  Page = UrlParameter.Optional },
  constraints: new { id = @"\d+" }
);
```
W aplikacji ASP.NET MVC można również zdefiniować trasy które mają być ignorowane. Służy do tego metoda IgnoreRoute. Ponieważ routing analizuje trasy w kolejności to trasy ignorowane powinny znajdować się przed trasami które chcesz zidentyfikować jako akcje. Ponieważ ASP.NET MVC opiera się na IIS to żądanie do poszczególnego pliku przechodzi przez obsługę tras MVC ponieważ adres URL nie jest rozpoznawany przez IIS jako taki który powinien przejść przez MvcHttpHandler. Wzór dopasowania dla plików ignorowanych jest troszkę inny od mapowania. Poniższy przykład ignoruje żądania do stron .htm lub .html:

routes.Ignore("{*allhtml}", new {allhtml=@".*\.htm(/.*)?});

Duże i złożone aplikacje ASP.NET MVC mogą wymagać obsługi setek akcji w kontrolerach. Podział na obszary (ang. area) umożliwia podział funkcjonalności na grupy logiczne. Tworzy to nowe kopie folderów dla modeli, widoków i kontrolerów w folderze obszaru. Każdy obszar ma swój routing odseparowany od innych obszarów. Obszary są rozdzielone w aplikacji poprzez AreaName/Controller/Action.

Punkty rozszerzalności MVC

ASP.NET MVC zapewnia programistom wielu punktach rozszerzalności które umożliwiają wstawienie potrzebnej funkcjonalności do aplikacji. W czasie przetwarzania żądania można przechwycić je i rozszerzyć w każdym kroku.

Action Filters

Jednym z najpotężniejszych punktów rozszerzalności i najczęściej wykorzystywanym jest możliwość używania filtrów akcji (ang. action filter). Można nadpisać istniejące filtry lub stworzyć własne implementując interfejs IActionFilter i przypisując go kiedy jest wymagany. Filtry akcji pozwalają dostać się do stosu przetwarzania, zanim akcja zostanie wykonana, lub bezpośrednio po wykonaniu akcji. Cztery główne typy filtrów to:

Authorization - jest zaimplementowany wSystem.Web.Mvc.IAuthorizationFilter i ma na celu ocenę bezpieczeństwa oparte o to, czy metody powinny być wykonywane w zależności od uwierzytelnienia i uprawnień.
Action - jest zaimplementowany w System.Web.Mvc.IActionFilter i pozwala programiście na otoczenie wykonania akcji przez dodatkową logikę a w tym wprowadzić dodatkowe informacje do akcji, przetestować dane wchodzące i wychodzące oraz przerwanie wykonania akcji. Posiada dwie metody: OnActionExecuting, która jest wykonywana kiedy akcja jest wywoływana i OnActionExecuted, która jest wywoływana po wykonaniu akcji.
Result - jest zaimplementowany w System.Web.Mvc.IResultFilter i otacza wynik zwracany przez akcję. Pozwala na wykonanie dodatkowego przetwarzania wyniku akcji. Posiada on dwie metody: OnResultExecuting, która jest wywoływana przed wykonaniem wyniku i OnResultExecuted, która jest wywoływana kiedy wynik zakończyła realizację.
Exception - zaimplementowany w System.Web.Mvc.IExceptionFilter i jest wykonywany kiedy zgłoszony zostanie nieobsłużony wyjątek w jakimkolwiek etapie życia akcji.

Controller factory

W ASP.NET MVC można utworzyć własną fabrykę kontrolerów (ang. controller factory), która pozwala na wykonywanie nietradycyjnych decyzje o tym, jak są skonstruowane kontrolery. Takie podejście jest użyteczne kiedy trzeba przekazać pewne informacje jak np zależności lub referencje w czasie wykonywania. Najczęstszym powodem utworzenia fabryki jest wsparcie dla Dependency Injection (DI) i Inversion of Control (IoC). Utworzenie własnej fabryki wymaga zaimplementowania interfejsu Web.Mvc.IControllerFactory. Interfejs ten posiada trzy metody:

CreateController - obsługuje tworzenie kontrolerów.
ReleaseController - czyści zasoby kontrolera.
GetControllerSessionBehavior - definiuje i kontroluje współpracę kontrolera z sesją. Po utworzeniu fabryki kontrolerów trzeba ją zarejestrować w metodzie Application_Start pliku Global.asax:

ControllerBuilder.Current.SetControllerFactory(
    typeof(MyCustomControllerFactory());

Action results

Poza zdefiniowanymi wynikami akcji w ASP.NET MVC można utworzyć własne wyniki poprzez dziedziczenie z klasy System.Web.Mvc.ActionResult i nadpisanie metody ExecuteResult, np:

public class CustomResult<T> : ActionResult
{
    public T Data { private get; set; }

    public override void ExecuteResult(ControllerContext context)
    {
        // do work here
        string resultFromWork = "work that was done";
        context.HttpContext.Response.Write(resultFromWork);
    }
}

View engines

Nadpisanie silnika widoków pozwala na wtrącenie dodatkowej logiki w czasie renderowania HTML. Można również stworzyć i zarejestrować swój własny silnik widoków. Oba główne silniki widoków dziedziczą z klasy abstrakcyjnej System.Web.Mvc.VirtualPathProviderViewEngine. W zależności od tego co ma zostać zmienione w silniku można pominąć klasę VirtualPathProviderViewEngine i stworzyć własną implementację interfejsu System.Web.Mvc.IViewEngine który posiada trzy metody: FindView, FindPartialView i ReleaseView. Można również nadpisać któryś z istniejących silników.

Przykład własnego silnika widoków:

public class CustomViewEngine : VirtualPathProviderViewEngine
{
    public MyViewEngine()
    {
        this.ViewLocationFormats = new string[]
            { "~/Views/{1}/{2}.mytheme ", "~/Views/Shared/{2}.mytheme" };
        this.PartialViewLocationFormats = new string[]
            { "~/Views/{1}/{2}.mytheme ", "~/Views/Shared/{2}. mytheme " };
    }

    protected override IView CreatePartialView
        (ControllerContext controllerContext, string partialPath)
    {
        var physicalpath =
            controllerContext.HttpContext.Server.MapPath(partialPath);
        return new myCustomView (physicalpath);
    }

    protected override IView CreateView
        (ControllerContext controllerContext, string viewPath, string masterPath)
    {
        var physicalpath = controllerContext.HttpContext.Server.MapPath(viewPath);
        return new myCustomView(physicalpath);
    }
}

Przed użyciem własnego silnika trzeba go zarejestrować w metodzie Application_Start:

ViewEngines.Engines.Add(new CustomViewEngine());

W trakcie tworzenia własnego silnika widoków może okazać się konieczne utworzenie klasy widoku lub dodanie funkcjonalności do istniejącej klasy. Praca która wyświetla i przesyła informacje o stronie do odpowiedzi jest wykonywana w tej klasie. Utworzenie własnej klasy widoku wymaga zaimplementowania interfejsu System.Web.Mvc.IView i metody Render, która pobiera jako parametry System.IO.TextWriter i System.Web.Mvc.ViewContext (ViewContext zawiera informacje o obiektach HttpContext, ViewBag i FormData). Obiekt TextWriter jest narzędziem które jest używane do pobrania informacji, parsowania i wstawienia ich do obiektu HttpResponse. Przykład niestandardowej klasy widoku:

public class MyCustomView : IView
{
    private string _viewPhysicalPath;

    public MyCustomView(string ViewPhysicalPath)
    {
        viewPhysicalPath = ViewPhysicalPath;
    }

    public void Render(ViewContext viewContext, System.IO.TextWriter writer)
    {
        string rawcontents = File.ReadAllText(_viewPhysicalPath);
        string parsedcontents = Parse(rawcontents, viewContext.ViewData);
        writer.Write(parsedcontents);
    }

    public string Parse(string contents, ViewDataDictionary viewdata)
    {
        return Regex.Replace(contents, "\\{(.+)\\}", m => GetMatch(m,viewdata));
    }

    public virtual string GetMatch(Match m, ViewDataDictionary viewdata)
    {
        if (m.Success)
        {
            string key = m.Result("$1");
            if (viewdata.ContainsKey(key))
            {
                return viewdata[key].ToString();
            }
        }
        return string.Empty;
    }
}

Model binding

Wiązanie modeli (ang. model binding) jest narzędziem ułatwiającym komunikację jedno i dwu kierunkową pomiędzy modelami i formularzami. Czasami nie ma bezpośredniej korelacji pomiędzy widokiem i modelem. W takich wypadkach można utworzyć niestandardowy modelu wiązania. Przykład niestandardowej klasy wiązania z listą właściwości używanych w różnych modelach, które są pobierane z trzech pól formularza i mają być wiązane jako DateTime:

public class DropDownDateTimeBinder : DefaultModelBinder
{
    private List<string> DateTimeTypes = new List<string>{ "BirthDate",
        "StartDate", "EndDate" };

    protected override void BindProperty(ControllerContext contContext,
        ModelBindingContext bindContext, PropertyDescriptor propDesc)
    {
        if (DateTimeTypes.Contains(propDesc.Name))
        {
            if (!string.IsNullOrEmpty(
                contContext.HttpContext.Request.Form[propDesc.Name + "Year"])
            {
                DateTime dt = new DateTime(int.Parse(
                        contContext.HttpContext.Request.Form[propDesc.Name
                    + "Year"]),
                    int.Parse(contContext.HttpContext.Request.Form[propDesc.Name +
                        "Month"]),
                    int.Parse(contContext.HttpContext.Request.Form[propDesc.Name +
                        "Day"]));
                propDesc.SetValue(bindContext.Model, dt);
                return;
            }
        }
        base.BindProperty(contContext, bindContext, propDesc);
    }
}

Rejestracja klasy odbywa się w metodzie Application_Start pliku Global.asax:

ModelBinders.Binders.DefaultBinder = new DropDownDateTimeBinder();

Zamiast nadpisania domyślnej klasy DefaultModelBinder można utworzyć własne klasy wiązań. Klasa musi implementować System.Web.Mvc.IModelBinder i implementować metodę BindModel. Taką klasę również rejestrujemy w Application_Start pliku Global.asax:

ModelBinders.Binders.Add(typeof(MyNewModelBinder), new MyNewModelBinder ());

Routing

Domyślny moduł obsługi routingu daje programiście wiele możliwości lecz czasami może zaistnieć potrzeba dodania dodatkowej funkcjonalności. ASP.NET MVC pozwala na utworzenie własnych modułów obsługi routingu. Można albo nadpisać istniejący moduł albo całkowicie go zastąpić. Główny moduł obsługi tras jest zaimplementowany w klasie System.Web.Mvc.MvcRouteHandler. Nadpisując klasę MvcRouteHandler trzeba nadpisać metodę GetHttpHandler ponieważ pozwala ona na badanie wartości i ich zmianę jeżeli to konieczne. Przykład niestandardowego modułu routingu:

public class MyCustomRouteHandler : MvcRouteHandler
{
    protected override IHttpHandler GetHttpHandler(RequestContext reqContext)
    {
        string importantValue = reqContext.HttpContext.Request.Headers.Get(
            "User-Agent");
        if (!string.IsNullOrWhiteSpace(importantValue))
        {
            reqContext.RouteData.Values["action"] = importantValue +
                reqContext.RouteData.Values["action"];
        }
        return base.GetHttpHandler(reqContext);
    }
}

Rejestracja niestandardowego modułu routingu dla poszczególnych tras odbywa się w metodzie MapRoute:

routes.MapRoute(
    "Home",
    "{controller}/{action}",
    new { controller = "Home", action = "Index"
    ).RouteHandler = new MyCustomRouteHandler ();

Jeżeli potrzebujemy całkowitego nadpisania modułu routingu to należy zaimplementować interfejs System.Web.Routing.IRouteHandler i metodę GetHttpHandler. Rejestracja w systemie jest trochę inna ponieważ metoda MapRoute automatycznie mapuje na MvcRouteHandler:

Route watermarkRoute = new Route("images/{name}",
    new WaterMarkRouteHandler("CodeClimber - 2011"));
routes.Add("image", watermarkRoute);

Redukcja obciążenia sieci

Gdy pasmo jest minimalne lub zdławione, można podwyższyć dobre doświadczenia użytkownika poprzez zapewnienie, że liczba i rozmiar plików, których potrzebuje pobrać jest minimalna.

Większość nowoczesnych przeglądarek ogranicza liczbę jednoczesnych połączeń do tej samej domeny do sześciu.
Istnieje kilka procesów które można uruchomić aby zmniejszyć rozmiar plików i zmniejszyć ilość plików do pobrania. ASP.NET MVC wspiera minimalizację plików JavaScript i CSS. W tym procesie usuwane są komentarze, białe znaki oraz inne nieużywane i zaśmiecające plik znaki. Proces ten również zmniejsza nazwy metod i zmiennych w plikach JavaScript. Minifikacja w ASP.NET MVC odbywa się po przełączeniu trybu kompilacja debug na false:

<compilation debug="false" />

Można tego również dokonać dodając wpis do metody RegisterBundles:

BundleTable.EnableOptimizations = true;

Innym procesem oferowanym w ASP.NET MVC jest tworzenie pakietów skryptów (ang. bundle). ASP.NET MVC bundling pozwala na tworzenie jednego pliku połączonego z wielu innych plików tak aby zmniejszyć liczbę połączeń pobierających pliki. Przykład tworzenia pakietu w pliku BundleConfig.cs:

bundles.Add(new ScriptBundle("~/bundles/myBundle").Include("~/Scripts/myScript1.js",
    "~/Scripts/myScript2.js",
    "~/Scripts/myScript3.js"));

Aby odwołać sie do pakietu używamy poniższego kodu:

@BundleTable.Bundles.ResolveBundleUrl(("~/bundles/myBundle")

Do pakietu dodawany jest hashtag dzięki któremu przeglądarka wie czy ma pobrać nową wersję pliku czy też tą która jest zapisana w pamięci podręcznej.

IIS pozwala na skonfigurowanie serwera tak aby przesyłał skompresowaną treść do przeglądarek które akceptują spakowaną treść. Serwer może skompresować statyczne pliki jak JS i CSS jak również wszystkie inne pliki dynamiczne. Można ustawić minimalny rozmiar pliku dla którego uruchamiana będzie kompresja. Przeglądarki akceptujące spakowaną treść przesyłają nagłówek:

Accept-Encoding: gzip, deflate

Przykład wysyłania pliku skompresowanego przez System.IO.Compression.GZipStream jako ContentResult:

using (FileStream oFileStream = article.LocalFile.OpenRead())
{
    using (FileStream cFileStream = File.Create(
        Guid.NewGuid().ToString() + ".gz"))
    {
        using (GZipStream compressionStream =
            new GZipStream(cFileStream, CompressionMode.Compress))
        {
            oFileStream.CopyTo(compressionStream);
            StreamReader reader = new StreamReader(compressionStream);
            results = reader.ReadToEnd();
        }
    }
}

Zwracając ContentResult należy rozważyć dodanie typu MIME.

Content Delivery Network (CDN) pozwalają na rozprowadzanie treści przez cały szereg dostawców co daje pewne korzyści. Twój serwer musi przetworzyć mniej operacji GET do pobrania zdjęć, skryptów itp. CDN potrafi umieścić treść bliżej klienta co prowadzi do potencjalnego mniejszego czasu pobierania plików i wzrostu wydajności.

I. Architektura aplikacji MVC

Sun, 31 Jul 2016 13:05:50 Z

Podział aplikac ASP.NET MVC ji na warstwy

ASP.NET MVC wprowadza poziom separacji zagadnień SoC poprzez podział aplikacji na model, widok i kontroler.
Widok (ang. View) jest fragmentem widocznym przez użytkownika. Widok w ASP.NET MVC może używać dwóch silników wyświetlania: Razor i Web Forms.
Kontroler (ang. Controller) parsuje żądanie HTTP i wysyła komendy do modelu aby zaktualizować jego stan oraz do widoku aby odświeżyć prezentację modeli w widoku.
Model (ang. Model) zarządza danymi i logiką biznesową.
Planując podział aplikacji trzeba brać pod uwagę skalowalność (pamięć podręczną, przetwarzanie po stronie klienta przeciw przetwarzaniu po stronie serwera oraz dostęp do danych).
ASP.NET Entity Framework pozwala na trzy podejścia w tworzeniu modelu.
Bezstanowa natura ASP.NET MVC uniemożliwia użycie niektórych funkcji Entity Framework, dlatego najlepiej jest użyć warstwy abstrakcji dostępu do danych tworząc warstwę modelu np korzystając ze wzorca repozytorium.

Aplikacje rozproszone

Tradycyjnym podejściem służącym do przesyłania danych jest użycie serwisów sieciowych (ang. web services). W ciągu ostatnich lat używano różnych podejść do ich tworzenia. Serwisy ASMX używające WSDL zostały zastąpione przez WCF używające SOAP, które są powoli wypierane przez ASP.NET Web API używające podejścia REST oraz wzorców MVC do zarządzania żądaniami HTTP.
Projektowanie środowiska rozproszonego może być bardzo ciężkim zadaniem ponieważ każda część aplikacji która jest wdrożona samodzielnie musi komunikować się z innymi częściami aplikacji.
Aplikacje hybrydowe są aplikacjami które są wdrożone w środowisku rozproszonym częściowo wewnątrz firmy i częściowo w chmurze poza firmą. Tworząc takie rozwiązania trzeba mieć na uwadze ryzykowną naturę komunikacji sieciowej i rozważyć koncept powtarzania wiadomości.
Projektując środowisko rozproszone ważnym punktem to rozważenia jest obsługa stanu aplikacji oraz czy aplikacja powinna obsługiwać sesję.
Rozproszone aplikacje mogą poprawić niezawodność, dostępność i skalowalność. Jednym ze sposobów na poziomie serwerowym jest użycie farm serwerów.

Cykl życia w Windows Azure

Windows Azure jest chmurą obliczeniową używana do budowania, wdrażania i zarządzania aplikacjami.
Windows Azure zapewnia podejścia PaaS (platform as a service) i IaaS (infrastructure as a service)
Windows Azure udostępnia trzy typy rozwiązań: Virtual Machines, Web Sites i Cloud Services.
Istnieją trzy typy roli w Windows Azure: Web, Worker i VM. Rola Web jest używana do uruchamiania IIS, rola Worker do aplikacji warstwy pośredniej. Rola VM jest używana w przypadkach kiedy pozostałe nie spełniają warunków udostępniając całą maszynę wirtualną.
Ponieważ Windows Azure jest systemem bezstanowym to żadne zmiany w systemie gdy rola jest uruchomiona nie są zapisywane do następnego uruchomienia. Dlatego programista może ustawić zestaw zadań startowych używających naarzędzia AppCmd.exw.
Zadania startowe w Windows Azure są używane do wykonywania akcji przed wystartowaniem roli typu Web lub Worker. Pozwalają na rejestrację komponentów COM, instalację komponentów lub ustawienie kluczy rejestru.
Zadania startowe są definiowane w elemencie Task który jest węzłem elementu Startup w pliku ServiceDefinition.csdef. Typowym zadaniem jest aplikacja konsolowa lub plik wsadowy który startuje skrypty Windows PowerShell. Zadanie startowe jest wykonywane za każdym razem gdy rola zostaje ponownie uruchomiona. Zadania pozwalają uruchomić procesy i aplikacje wspomagające główną aplikację.
Po wykonaniu zadania wywoływana jest metoda OnStart którą można nadpisać aby zaimplementować własną funkcjonalność. metoda ta musi zwracać true aby uruchomienie nie zatrzymało się błędem.
Po wykonaniu OnStart uruchamiana jest metoda Run, która nie zwraca wyniku. Można ją nadpisać i uruchamiać w niej aplikacje równolegle.
Po wyłączeniu wywoływana jest metoda OnStop która również nie zwraca żadnego wyniku. Jest używana do zamknięcia i czyszczenia uruchomionych procesów.

Zarządzanie stanem aplikacji

Zarządzanie stanem może być ważną częścią aplikacji. W aplikacjach www jest skomplikowane ponieważ z definicji protokół HTTP jest bezstanowy. ASP.NET MVC oferuje wiele dróg implementacji stanu. Kiedy wybieramy jeden z nich musimy wziąć pod uwagę czynniki takie jak: miejsce przechowywania i używania stanu (klient czy serwer), ilość danych do przechowania oraz opóźnienia.
W ASP.NET MVC stan aplikacji może być przechowywany w: Cache, Session, Cookies, QueryString, Context.Items i Profile.
Obiekt Cache zapewnia szerszy zakres niż inne rodzaje ponieważ jego dane są dostępne dla wszystkich klas aplikacji. Obiekt Cache umożliwia przechowywanie par klucz-wartość dostępnych dla każdego użytkownika lub stronę w domenie aplikacji. Jest przetwarzany w wewnętrznym procesie dlatego jest dostępny na indywidualnym serwerze. W scenariuszach wieloserwerowych trzeba zapewnić aby każdy serwer miał własną kopię obiektu.
Najbardziej powszechnym sposobem zarządzania stanem jest sesja. Sesja może być przechowywana w bazie SQL Server, na osobnym serwerze lub w pamięci serwera IIS. Sesję można skonfigurować tak aby przekazywała session ID w cookie lub query string. Implementując sesję można użyć domyślnego magazynu przychodzącego z ASP.NET lub utworzyć własny dziedzicząc z klasy SessionStateStoreProviderBase.
Cookies są małymi porcjami informacji (do 4 KB) przechowywanymi po stronie klienta które mogą być utrwalane w sesji. Są przypisane do konkretnej domeny lub subdomeny i przesyłane do serwera z każdym żądaniem. Cookies można odczytać używając HttpContext.Request.Cookies i zapisać używając HttpContext.Response.Cookies. Cookie może posiadać również datę wygaśnięcia.
Query string jest również miejscem gdzie można wstawić pewną ograniczoną ilość informacji (długość żądania URL jest ograniczona),które mogą być przesłane do serwera i z powrotem dla konkretnego użytkownika. ASP.NET MVC zapewnia łatwy dostęp do query string poprzez HttpContext.Request.QueryString[“attributeName”] po stronie serwera i window.location.href po stronie klienta.
Context.Items zawiera informacje dostępne dla jednego żądania. Zwykle używa się go do dodania informacji do żądania w komunikacji między modułami HTTP, np. informacje o uwierzytelnieniu.
Profile jest przechowywane w bazie danych dla nazwy użytkownika i może być dostępne używając HttpContext.Profile[“miscellaneousData”]. Profile jest częścią dostawcy Membership and Roles i trzeba skonfigurować dostawcę w pliku konfiguracyjnym oraz używać ASP.NET membership.
Istnieje również możliwość przechowywania informacji o stanie po stronie klienta np używając HTML5 Web Storage API. Niestety ASP.NET MVC nie posiada domyślnych narzędzi do pracy z informacjami przechowywanymi po stronie klienta poza biblioteką jQuery. HTML5 Web Storage pozwala na wybór pomiędzy sessionStorage a localStorage. Zasięg sessionStorage pozwala na dostęp do zasobów dla stron w tej samej domenie URL. Obiekty w sessionStorage są przechowywane do czasu zamknięcia okna. Zasięg localStorage rozszerza sessionStorage i pozwala na przechowywanie obiektów poza zasięg życia okna komunikującego się z tym samym URL. HTML5 Web Storage API posiada również zdarzenia obsługujące zmiany w magazynie danych.
Skalowalność jest głównym problemem przy określaniu, jak najlepiej zarządzać stanem. Projektowanie skalowalnej architektury odrzuca automatycznie pewne dostępne rozwiązania jak np. proces w serwerze przechowujący stan ponieważ serwer może nie mieć dostępu do procesu innego serwera w klastrze.
ASP.NET MVC wspiera również protokoły bezstanowe pomocne przy skalowalności. Mechanizmy których można użyć przy obsłudze bezstanowej aplikacji to utworzenie identyfikatora przy pierwszym żądaniu użytkownika i przesyłanie go z każdym następnym żądaniem, użycie ukrytego pola przekazującego dane między żądaniami, dodanie funkcjonalności w kodzie JavaScript po stronie klienta obsługującej HTML5 Web Storage i wysyłającej do serwera potrzebne informacje, dodanie unikalnego fragmentu do query string lub adresu URL.

Przykład konfiguracji sesji InProc w pliku Web.config:

<system.web>
    <sessionState mode="InProc" cookieless="false" timeout="20" sqlConnectionString="data source=127.0.0.1;Trusted_Connection=yes" stateConnectionString="tcpip=127.0.0.1:42424"
/>
</system.web>

Przykład konfiguracji sesji StateServer w pliku Web.config:

<system.web>
    <sessionState mode="StateServer" stateConnectionString="192.168.1.103:42424" />
</system.web>

Przykład konfiguracji ASP.NET Membership w pliku Web.config:

<profile defaultprovider="DefaultProfileProvider" inherit="MyApplication.Models.CustomProfile"/>

Projektowanie strategii buforowania

Caching jest strategią pomagającą poprawić wydajność. Polega na przechowywaniu często uzywanych danych w pamięci o szybkim czasie dostępu.

Page output caching

Page output caching jest strategią dzieloną pomiędzy klientów i serwery. typy buforowania stron zawierają pełne i częściowe buforowanie strony. Przeglądarka może buforować każde żądanie HTTP GET przez zdefiniowany okres czasu. ASP.NET MVC pozwala na ustawienie czasu przez użycie filtru:

[OutputCache(Duration=120, VaryByParam="Name", Location="ServerAndClient")]
Public ActionResult Index()
{
    Return View("Index",myData);
}

Niestety OutputCache działa dobrze tylko do buforowania całych stron.

Donut caching (buforowanie pączkowe) i donut hole caching są typami częściowego buforowania stron. Pierwsze buforuje większość strony umożliwiając na część zawartości dynamicznej. Drugie pozwala na większość treści dynamicznej i część buforowanej. Razor nie obsługuje bezpośrednio Donut caching ale można użyć Substitution API i utworzyć helper MVC. Donut hole caching jest obsługiwane przez podzielenie fragmentów strony na różne akcje i użycie widoków częściowych które są buforowane np:

[ChildActionOnly] [OutputCache(Duration=60)]
public ActionResult ProductsChildAction()
{
    // Fetch products from the database and
    // pass it to the child view via its ViewBag
    ViewBag.Products = Model.GetProducts();
    return View();
}

można również dodać atrybut buforowania do całego kontrolera.

Windows AppFabric jest przykładem narzędzia tworzącego zawartość buforowaną podzieloną pomiędzy wiele serwerów w farmie. jest to zestaw serwisów zbudowany na Windows server które zarządzają buforowaniem rozproszonym. Może również zarządzać sesją w ASP.NET MVC.

Data caching

Data caching jest techniką po stronie serwera pozwalającą na wstawienie pośredniego bufora pomiędzy logikę biznesową i bazę danych. pozwala na ponowne użycie danych bez odczytu bezpośrednio z bazy danych do czasu, aż dane są nieaktualne lub ich czas życia wygaśnie.
Można użyć .NET 4 Caching Framework. Domyślna implementacja używa ObjectCache i MemoryCache. Generalnie buforowanie polega na utworzeniu implementacji interfejsu ICacheProvider użytej jako warstwa pośrednicząca pomiędzy logiką a dostępem do danych.

Application caching

Application caching jest właściwością HTML 5 która pozwala na tworzenie manifestu buforowania który opisuje ustawienia dla całej strony lub aplikacji i daje dostęp do pamięci podręcznej przeglądarki.
Dostęp dla programistów z poziomu Application Cache API (AppCache) Przykład manifestu:

# Cached entries.
CACHE:
/favicon.ico
default.aspx
site.css
images/logo.jpg
scripts/application.js
# Resources that are "always" fetched from the server.
NETWORK:
login.asmx
FALLBACK:
button.png offline-button.png

Sekcja CACHE opisuje zasoby które powinny być buforowane. Sekcja NETWORK opisuje zasoby które nie powinny być buforowane. Sekcja FALLBACK definiuje zasoby które powinny być zwrócone jeżeli zasoby nie zostaną odnalezione.

Definicja referencji do manifestu powinna być zapisana w tagu HTML:

<html manifest="site.manifest">

Manifest musi mieć ustawiony MIME-type o wartości “text/cache-manifest”.

HTTP caching

HTTP caching jest mechanizmem buforowania wbudowanym w protokół HTTP który obsługuje własną wersję wyliczenia wygaśnięcia i używa jej do określenia odpowiedzi która ma zostać wysłana do klienta.

Implementacja WebSocket

HTTP polling jest metodą JavaScript służącą do odpytywania serwera w regularnych odstępach czasu o nowe informacje o których powinien wiedzieć klient. Niestety nie jest to wydajna metoda ale działa w każdej przeglądarce wspierającej JavaScript.
HTTP long polling jest sposobem w którym ustanawia się długowieczne połączenie do serwera w celu monitorowania zmian. Połączenie zostaje utrzymane do czasu otrzymania wiadomości lub upływu określonego czasu po czym znowy zostaje ustanowione.
WebSockets jest sposobem zapewnienia dwustronnej komunikacji pomiędzy serwerem a klientem. Klient łączy się przez HTTP i wysyła żądanie aktualizacji do serwera, który ustanawia połączenie WebSockets. Trzeba zaimplementować komunikację po jednej i drugiej stronie aby współpracować z WebSockets. Kiedy tego dokonamy to każda komenda jest obsługiwana jak zdarzenie zgłaszane kiedy wiadomość jest otrzymywana.
WebSockets może być użyte do długotrwałej dwustronnej komunikacji. Nie zawsze jest najlepszym rozwiązaniem, szczególnie kiedy klientem jest starsza przeglądarka która nie wspiera HTML 5.
WebSockets wymaga ASP.NET 4.5 i IIS 8.

Przykład kodu jQuery ustanawiającego połączenie WebSocket:

var socket;
$(document).ready(function () {
    socket = new WebSocket("ws://localhost:1046/socket/handle");
    socket.addEventListener("open", function (evnt) {
        $("#display").append('connection');}, false);
    socket.addEventListener("message", function (evnt) {
        $("#display ").append(evnt.data);}, false);
    socket.addEventListener("error", function (evnt) {
        $("#display ").append('unexpected error.');}, false);

Przykład połączenie w ASP.NET MVC:

public async Task MyWebSocket(AspNetWebSocketContext context)
{
    while (true)
    {
        ArraySegment<byte> arraySegment = new ArraySegment<byte>(new byte[1024]);
        // open the result. This is waiting asynchronously
        WebSocketReceiveResult socketResult =
            await context.WebSocket.ReceiveAsync(arraySegment,
            CancellationToken.None);
        // return the message to the client if the socket is still open
        if (context.WebSocket.State == WebSocketState.Open)
        {
            string message = Encoding.UTF8.GetString(arraySegment.Array, 0,
                socketResult.Count);
            userMessage = "Your message: " + message + " at " +
                DateTime.Now.ToString();
            arraySegment = new
                ArraySegment<byte>(Encoding.UTF8.GetBytes(message));
                // Asynchronously send a message to the client
            await context.WebSocket.SendAsync(arraySegment,
                WebSocketMessageType.Text,
                true, CancellationToken.None);
        }
        else { break; }
        }
}

HTTP modules and handlers

Umożliwiają programiście na bezpośrednią interakcję z żądaniami HTTP. Kiedy żądanie startuje to jest przetwarzane przez wiele modułów HTTP modules, takich jak sesja i moduł uwierzytelnienia. Różniej żądanie jest przetwarzane przez jeden HTTP handler zanim wróci z powrotem przez stos żądania żeby ponownie być przetworzonym przez moduły.

Moduły pasują do przetwarzania w drodze do handlera i w drodze powrotnej od handlera. Moduł synchroniczny posiada metodę Init która umożliwia ustawienie obsługi jednego ze zdarzeń załączonych do żądania.
Moduł asynchroniczny jest trudniejszy w obsłudze ale z async, await i Task można utworzyć moduł który potrafi obsłużyć długotrwałe zadanie bez zatrzymywania procesu.
Moduły pozwalają na przechwycenie, dzielenie i modyfikację każdego żądania.
Utworzenie modułu wymaga implementacji interfejsu System.Web.IHttpModule który ma dwie metody void Init(HttpApplication) i Dispose. System.Web.HttpApplication posiada zdefiniowane 22 zdarzenia które mogą być subskrybowane w metodzie Init i pozwalają modułowi na pracę w różnych stadiach obsługi żądania.
Plik Web.config posiada sekcję odpowiedzialną za konfigurację modułu HTTP aplikacji.
Handlery są celem żądań i wysyłają żądania do pojedynczego URL. Handlery mogą być synchroniczne i asynchroniczne w zależności od klasy z której dziedziczą.
Handler musi implementować interfejs IHttpHandler z metodą ProcessRequest(HttpContext) i właściwością IsReusable.
Wybór pomiędzy modułem a handlerem zależy od miejsca w którym trzeba zmienić funkcjonalność. Jeżeli musisz obsłużyć specyficzny adres URL to prawdopodobnie potrzebujesz utworzyć handler. Jeżeli chcesz zadziałać kiedy coś się wydarzy w czasie przetwarzania to powinieneś użyć modułu.

Przykład asynchronicznego modułu:

private async Task ScrapePage(object caller, EventArgs e)
{
    WebClient webClient = new WebClient();
    var downloadresult = await webClient.DownloadStringTaskAsync("http://www.msn.com");
}
public void Init(HttpApplication context)
{
    EventHandlerTaskAsyncHelper helper =
        new EventHandlerTaskAsyncHelper(ScrapePage);
    context.AddOnPostAuthorizeRequestAsync(
        helper.BeginEventHandler, helper.EndEventHandler);
}

Przykład asynchronicznego handlera:

public class NewAsyncHandler : HttpTaskAsyncHandler
{
    public override async Task ProcessRequestAsync(HttpContext context)
    {
        WebClient webClient = new WebClient();
        var downloadresult = await
        webClient.DownloadStringTaskAsync("http://www.msn.com");
    }
}

II. Projektowanie interfejsu użytkownika

Sun, 31 Jul 2016 12:47:54 Z

Interfejs użytkownika w aplikacjach web

Język HTML pozwala opisać strukturę informacji zawartych wewnątrz strony internetowej. CSS wprowadza dodatkową kontrolę nad wyglądem i prezentacją strony internetowej. Kombinacja HTML i CSS pozwala różnym stronom wyglądać inaczej od pozostałych pomimo użycia tych samych konstrukcji.
Podstawową funkcją ASP.NET MVC jest dostarczanie informacji do użytkownika serwisu. HTML i CSS pozwalają na formatowanie tych informacji w atrakcyjny wizualnie sposób.
Dynamiczna zawartość strony jest głównym powodem do korzystania z ASP.NET MVC.
Używając silnika wyświetlania Razor, plik Views\Shared_Layout.cshtml zawiera główny szablon aplikacji a w tym odnośnik do plików ze stylami CSS, podstawowe elementy UI jak na menu, nagłówki i stopkę.
Silnik wyświetlania ASPX używa pliku Views\Shared\Site.Master.
Plik szablonu bazowego dziedziczy z System.Web.Mvc.ViewMasterPage niezależnie od silnika wyświetlania.

<%@ Master Language="C#" Inherits="System.Web.Mvc.ViewMasterPage" %>

Helpery są konstrukcjami kodu ASP.NET MVC tworzącymi kod HTML.

Helper wyświetlający style css w silniku Razor:

@Styles.Render("~/Content/css")

Przykład szablonu w pliku Views\Shared_Layout.cshtml:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <title>@ViewBag.Title - My ASP.NET MVC Application</title>
    <link href="~/favicon.ico" rel="shortcut icon" type="image/x-icon" />
    <meta name="viewport" content="width=device-width" />
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")
</head>
<body>
    <header>
        <div class="content-wrapper">
            <div class="float-left">
                <p class="site-title">
                    @Html.ActionLink("your logo here", "Index", "Home")
                </p>
            </div>
            <div class="float-right">
                <section id="login">
                    @Html.Partial("_LoginPartial")
                </section>
                <nav>
                    <ul id="menu">
                        <li>@Html.ActionLink("Home", "Index", "Home")</li>
                        <li>@Html.ActionLink("About", "About", "Home")</li>
                        <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                    </ul>
                </nav>
            </div>
        </div>
    </header>
</body>

Nowe tagi HTML 5

- sekcja strony zawierająca niezależną treść.
- treść powiązana do otaczającej treści.
- podpis ilustracji.
- ilustracja.
- stopka dokumentu lub sekcji.
- nagłówek dokumentu lub sekcji.
- sekcja z odnośnikami.
- grupa treści które są ze sobą powiązane.

Projektowanie zachowania UI

Walidacja po stronie klienta jest istotną właściwością JavaScript i ASP.NET MVC dzięki której eliminowane są przesyłania danych pomiędzy klientem a serwerem poprzez sprawdzenie po stronie klienta czy dane wprowadzone do formularza są poprawne. Zasady walidacji ASP.NET MVC są zbudowane w oparciu o adnotacje. Przykład klasy z adnotacjami służącymi do walidacji:

namespace ArticleApp.Models {
    public class Article {
        public int ID { get; set; }
        [Required] [StringLength(50,MinimumLength=5)]
        public string Title { get; set; }
        [RegularExpression[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}")]
        AuthorEmail { get; set;}
        [DataType(DataType.Date)]
        [Range(300, 3000)]
        public int NumberOfAuthors { get; set; }
        [Required]
        public DateTime CreateDate { get; set; }
        [Required]
        public string Description { get; set; }
        [Range(1, 250)]
        [DataType(DataType.Currency)]
        [Required]
        public decimal Price { get; set; } 
    }
    public class ArticleDBContext : DbContext
    {
        public DbSet<Article> Articles { get; set; }
    }
}

Przykład widoku dodawania nowego artykułu:

@model MvcApplication1.Models.Article @{ ViewBag.Title = "Create"; }
<h2>Create</h2> @using (Html.BeginForm()) { @Html.ValidationSummary(true)
<fieldset>
    <legend>Articles</legend>
    <div class="editor-label">
        @Html.LabelFor(model => model.Title)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.Title) @Html.ValidationMessageFor(model => model.Title)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.CreateDate)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.CreateDate) @Html.ValidationMessageFor(model => model.CreateDate)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.Description)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.Description) @Html.ValidationMessageFor(model => model.Description)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.Price)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.Price) @Html.ValidationMessageFor(model => model.Price)
    </div>
    <p>
        <input type="submit" value="Create" />
    </p>
</fieldset>
}
<div>
    @Html.ActionLink("Back to List", "Index")
</div>
@section Scripts { @Scripts.Render("~/bundles/jqueryval") }

Sprawdzenie poprawności modelu po stronie akcji kontrolera:

[HttpPost]
public ActionResult Create(Article article)
{
    if (ModelState.IsValid)
    {
        db.Articles.Add(article);
        db.SaveChanges();
        return RedirectToAction("Index");
    }
    return View(article);
}

Aby UI mogło wykonać akcję walidacji po stronie serwera należy dodać atrybut System.Web.Mvc.RemoteAttribute do walidacji w modelu. Atrybut Remote akceptuje nazwę kontrolera i akcji które mają być wywołane. Walidacja po stronie serwera wymaga też dodatkowej konfiguracji.

Wpis wymagany w konfiguracji aby można było wykonać walidację po stronie serwera:

<appSettings>
    <add key="ClientValidationEnabled" value="true" />
    <add key="UnobtrusiveJavaScriptEnabled" value="true" />
</appSettings>

Przykład modelu z walidacją po stronie serwera:

[Required]
[StringLength(6, MinimumLength = 3)]
[Remote("IsUserAvailable", "Validation")]
[RegularExpression(@"(\S)+", ErrorMessage = "White space is not allowed.")]
[Editable(true)]
public string UserName { get; set; }

Przykład walidacji po stronie serwera:

public JsonResult IsUserAvailable(string username)
{
    if (!WebSecurity.UserExists(username))
    {
        return Json(true, JsonRequestBehavior.AllowGet);
    }
    string suggestedUID = String.Format(CultureInfo.InvariantCulture,
        "{0} is not available.", username);
    for (int i = 1; i < 100; i++)
    {
        string altCandidate = username + i.ToString();
        if (!WebSecurity.UserExists(altCandidate))
        {
            suggestedUID = String.Format(CultureInfo.InvariantCulture,
                "{0} is not available. Try {1}.", username, altCandidate);
            break;
        }
    }
    return Json(suggestedUID, JsonRequestBehavior.AllowGet);
}

Biblioteki JavaScript mogą być pomocne przy projektowaniu UI. Przykładowo dzięki jQuery można manipulować drzewem DOM, tworzyć efekty i animacje dzięki czemu strona staje się bardziej interaktywna.
JavaScript jest interpretowanym językiem skryptowym bazującym na prototypowniu.

Przykład kodu JavaScript używającego prototypów:

var Contact = function(pageTitle) {
    this.pageTitle = pageTitle;
    this.bindEvents(); // binding events as soon as the object is instantiated
    this.additionalEvents(); // additional events such as DOM manipulation etc
};
var Contact.prototype.bindEvents = function() {
    $('ul.menu').on('click', 'li.email, $.proxy(this.toggleEmail, this));
};
var Contact.prototype.toggleEmail = function(e) {
    //Toggle the email feature on the page
};

AJAX służy do asynchronicznej aktualizacji części strony bez całkowitego jej przeładowania. ASP.NET MVC posiada przestrzeń nazw System.Web.MVC.Ajax która zawiera zestaw rozszerzeń wspierających użycie AJAX.

Przykład formularza używającego AJAX:

@model MvcApplication1.Models.Article @{ ViewBag.Title = "Create"; }
<link rel="stylesheet" href="http://code.jquery.com/ui/1.9.2/themes/base/jquery-ui.css" />
<script src="http://code.jquery.com/jquery-1.8.3.js"></script>
<script src="http://code.jquery.com/ui/1.9.2/jquery-ui.js"></script>
<link rel="stylesheet" href="/resources/demos/style.css" />
<script>
    $(function () {
        $(".ReleaseDate").datepicker();
    });
</script>
<h2>Create</h2> @using (Ajax.BeginForm("PerformAction", new AjaxOptions { OnSuccess = "OnSuccess", OnFailure = "OnFailure" })) {
<fieldset>
    <legend>Article</legend>
    <div class="editor-label">
        @Html.LabelFor(model => model.Title)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.Title) @Html.ValidationMessageFor(model => model.Title)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.CreateDate)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model. CreateDate) @Html.ValidationMessageFor(model => model. CreateDate)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.Description)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model. Description) @Html.ValidationMessageFor(model => model. Description)
    </div>
    <div class="editor-label">
        @Html.LabelFor(model => model.Price)
    </div>
    <div class="editor-field">
        @Html.EditorFor(model => model.Price) @Html.ValidationMessageFor(model => model.Price)
    </div>
    <p>
        <input type="submit" value="Create" />
    </p>
</fieldset>
}
<p id="errorMessage" />
<script type="text/javascript">
    function OnSuccess(response) {
        //do something
    }

    function OnFailure(response) {
        //show failure
        document.getElementById('errorMessage').innerHTML = 'THERE WAS AN ERROR';
    }
</script>
<div>
    @Html.ActionLink("Back to List", "Index")
</div>
@section Scripts { @Scripts.Render("~/bundles/jqueryval") }

Komponowanie szablonu UI

Partial view

Widok częściowy jest sposobem na użycie tej samej funkcjonalności na wielu stronach. Pozwala na zawieranie pod-widoku w wielu miejscach aplikacji. Zwykle przechowuje się je w folderze Views/Shared
Widok częściowy można utworzyć poprzez menu kontekstowe na folderze z widokami i wybranie opcji Add View oraz zaznaczenie Create as a partial view.
Użycie modelu w widoku częściowym wymaga dodania jego deklaracji:

@model ApplicationName.Models.ModelName

Wstawienie widoku do aplikacji odbywa się za pomocą składni @Html.Partial np:

<section id="login">
    @Html.Partial("_LoginPartial")
</section>

Razor

Silnik Razor pozwala na tworzenie szablonów które mogą być używane wielokrotnie. Szablony są przypisywane według typu obiektu, mogą służyć do wyświetlania (DisplayTemplates) lub edycji (EditTemplates). Szablony są przechowywane w ~Views/Shared/EditorTemplates i wywoływane przez @Html.EditorFor i @Html.DisplayFor, np:

@Html..EditorFor(model=>model.Article)

Razor tag @RenderBody() wstawia różne widoki do aplikacji z użyciem tagu
.
Widoki i widoki częściowe powinny być używane wielokrotnie wszędzie gdzie jest to możliwe. Jeżeli widoki lub widoki częściowe używają tego samego modelu i kontrolera to można sprawdzić poprawność modelu za pomocą adnotacji i helperów HTML. W innym przypadku trzeba obsłużyć sprawdzanie poprawności samemu używając np AJAX do sprawdzenia poprawności po stronie klienta lub modyfikując kontroler i modele do tego zadania.
Szablony master lub layout mogą być przełączane w locie z wykorzystaniem kodu. ponieważ szablony zawierają zwykle informacje o bibliotekach JavaScript i stylach CSS to ich przełączenie może zmienić znacząco UI.
Biblioteka Modernizr.js ułatwia pisanie warunkowego kodu JavaScript i CSS w celu ustalenia, czy przeglądarka obsługuje funkcję, zwłaszcza HTML5.

Przykład kompletnego szablonu tworzonego przez Visual Studio:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@ViewBag.Title - My ASP.NET Application</title>
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")

</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="container">
            <div class="navbar-header">
                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("Application name", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
            </div>
            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("About", "About", "Home")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                </ul>
                @Html.Partial("_LoginPartial")
            </div>
        </div>
    </div>
    <div class="container body-content">
        @RenderBody()
        <hr />
        <footer>
            <p>&copy; @DateTime.Now.Year - My ASP.NET Application</p>
        </footer>
    </div>

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap")
    @RenderSection("scripts", required: false)
</body>
</html>

Wykrywanie cech przeglądarki

Ponieważ nie wszystkie przeglądarki obsługują standardy W3C w taki sam sposób to należy być ostrożnym wybierając sposób wyświetlania informacji. Biblioteki takie jak jQuery lub Modernizer pomagają w dostosowaniu wyglądu we wszystkich przeglądarkach.
Powszechną metodą wykrywania przeglądarki jest użycie Java Script do sprawdzenia nagłówka userAgent.

Przykład wykrywania czy przeglądarka użytkownika to Microsoft Internet Explorer:

<script type="text/javascript">
    if ( navigator.userAgent.indexOf("MSIE")>0 )
    {
        <!--[if lte IE 7]>
        <style TYPE="text/css">
            @import url(ie7.css);
        </style>
        <![endif]-->
    }
</script>

Przykład sprawdzenia czy metoda window.addEventListener jest wspierana przez przeglądarkę:

<script type="text/javascript">
    if(window.addEventListener)
    {
        // Browser supports "addEventListener"
        window.addEventListener("load", myFunction, false);
    }
    else if(window.attachEvent)
    {
        // Browser supports "attachEvent"
        window.attachEvent("onload", myFunction);
    }
</script>

Ponieważ nie wszystkie przeglądarki w pełni wspierają HTML5 to zalecaną metodą obsługi niektórych cech jest użycie alternatyw dla tych właściwości kiedy przeglądarka nie potrafi obsłużyć zasobu. Przykładowo tag pozwala na użycie alternatywnych zasobów do wyświetlenia i jeżeli wszystkie zawiodą to jeszcze odnośnika z którego można pobrać materiał wideo, np:

<video>
    <source src="video.mp4" type='video/mp4' />
    <source src="video.webm" type='video/webm' />
    <object type="application/x-silverlight-2">
        <param name="source" value="http://url/player.xap">
        <param name="initParams" value="m=http://url/video.mp4">
    </object>
    Download the video <a href="video.mp4">here</a>.
</video>

Aby obsłużyć wiele przeglądarek, w tym także przeglądarki urządzeń mobilnych można użyć różnych widoków dla specyficznych urządzeń lub użyć CSS3 media queries i tagu .
Informacje o dostępnych rodzajach widoków są dostępne w System.Web.Mvc.VirtualPathProviderViewEngine.DisplayModeProvider. Domyślnie istnieją tam dwa wpisy mobile i default. Widok mobilny może być stworzony w tym samym folderze lecz musi posiadać słowo mobile w nazwie np Index.Mobile.cshtml.
Dostosowanie widoku dla konkretnej platformy i przeglądarki jest możliwe dzięki DisplayModeProvider. Przykład dodania dostosowania widoku dla Windows Phone:

DisplayModeProvider.Instance.Modes.Insert(0, new DefaultDisplayMode("iemobile")
{
    ContextCondition = (context => context.GetOverriddenUserAgent().IndexOf
        ("iemobile", StringComparison.OrdinalIgnoreCase) >= 0)
});

Kiedy serwer otrzyma żądanie iemobile to będzie próbował znaleźć widok Index.iemobile.cshtml.

Aby aplikacja była responsywna i dostosowywała się do rozmiarów przeglądarki można użyć stylu CSS i dodanie tagu . Dodatkowo można użyć @media query które sprawdzają pewne funkcje multimedialne jak szerokość, wysokość i kolory np:

/* header */
header .content-wrapper {
    padding-top: 20px;
}
/* logo */
.site-title {
    color: #c8c8c8;
    font-family: Rockwell, Consolas, "Courier New", Courier, monospace;
    font-size: 2.3em;
    margin: 0;
}
@media only screen and (max-width: 850px) {
    /* header mobile */
    header .float-left,
    header .float-right {
        float: none;
    }
    /* logo mobile */
    header .site-title {
        margin: 10px;
        text-align: center;
    }

Aby właściwości CSS3 działały dobrze we wszystkich przeglądarkach można użyć rozszerzeń specyficznych dla dostawcy (vendor prefix) np -ms-, -mso- dla Microsoft, -moz- dla Mozilla, -webkit- dla Google i Apple i -o-, -xv- dla Opera. Przykład CSS z rozszerzeniami specyficznymi dla dostawcy:

<style>
.corners
{
    width: 350px;
    margin: 0px;
    background-color: #222;
    color: #fff;
    padding: 8px;
    /* regular style */
    border-radius: 15px;
    /* -moz extension */
    -moz-border-radius: 18px;
}
</style>

Planowanie responsywnego układu UI

ASP.NET MVC obsługuje wiele podejść dla użytkowników mobilnych. Można utworzyć nadpisane widoki, które są uniwersalne dla każdego urządzenia mobilnego lub specyficzne dla urządzenia. System.Web.Mvc.VirtualPathProviderViewEngine.DisplayModeProvider ocenia przychodzące żądania i na podstawie wartości userAgent przekierowuje do skonfigurowanego DisplayModeProviders.
Innym sposobem jest użycie tagu viewport i @media queries.
Biblioteka z repozytorium jQuery Mobile MVC umożliwia wykorzystanie znaczników, aby zapewnić dodatkowe funkcje obsługiwane przez przeglądarkę klienta. Jeśli przeglądarka nie obsługuje funkcjonalności, biblioteka jQuery będzie obniżać funkcjonalności.
Można zmodyfikować plik global.asax w celu dostosowania różnych przeglądarek mobilnych, np:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Http;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using System.Web.WebPages;
namespace MvcApplication
{
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            DisplayModeProvider.Instance.Modes.Insert(0, new
                DefaultDisplayMode("windows")
            {
                ContextCondition = (context => context.GetOverriddenUserAgent().IndexOf
                    ("Windows", StringComparison.OrdinalIgnoreCase) >= 0)
            });
            AreaRegistration.RegisterAllAreas();
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            AuthConfig.RegisterAuth();
        }
    }
}

XI. Szyfrowanie i zarządzanie assembly

Thu, 17 Mar 2016 18:48:25 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Szyfrowanie symetryczne i asymetryczne - wybór odpowiedniego algorytmu szyfrowania.
Certyfikaty - tworzenie i zarządzanie certyfikatami, różne rodzaje certyfikatów i magazyny certyfikatów.
Klucze szyfrujące - tworzenie i zarządzanie kluczami szyfrującymi w .NET.
System.Security - implementacja przestrzeni nazw System.Security.
Hash data - tworzenie podpisów cyfrowych i opcje tworzenia skrótów danych.
Strumienie szyfrowane - użycie klasy CryptoStream do szyfrowania strumieni.
Zarządzanie assembly - wersjonowanie, podpisywani używając silnych nazw za pomocą Visual Studio oraz sn.exe, GAC i użycie technik pozwalających na użycie assembly o różnych wersjach na tej samej maszynie.

Użycie szyfrowania

Szyfrowanie (ang. Encryption) jest procesem transformacji danych, który utrudnia osobie nieupoważnionej, aby odczytała te dane. Dane zaszyfrowane nazywane są szyfrogramem (ang. ciphertext). Odszyfrowywanie (ang. Decryption) jest procesem odwrotnym który przekształca zaszyfrowane dane w zwykłe dane. Im trudniej jest odszyfrować dane tym lepszy jest algorytm szyfrujący. Nie ma szyfrów niemożliwych do odszyfrowania ale niektóre algorytmy szyfrujące są tak skomplikowane, że czas ich odszyfrowania może zajmować bardzo długi czas.

Wybór odpowiedniego algorytmu szyfrującego

Szyfrowanie może być wykonywane na dwa sposoby. Pierwszy zwany jest szyfrowaniem symetrycznym (ang. symmetric encryption lub shared secret) a drugi zwany jest szyfrowaniem niesymetrycznym (ang. asymmetric encryption lub public key).

W .NET Framework algorytmy szyfrowania zaimplementowane są na trzy sposoby:

Klasy zarządzane - nazwy tych klas składają się z nazwy algorytmu i sufiksu Managed, np RijndaelManaged dla algorytmu Rijndael. Zarządzane implementacje są nieco wolniejsze od innych implementacji i nie są certyfikowane przez Federal Information Processing Standards (FIPS).
Klasy opakowujące natywną implementację Cryptography API (CAPI) - nazwy tych klas składają się z nazwy algorytmu i sufiksu CryptoServiceProvider, np klasa DESCryptoServiceProvider dla algorytmu DES. Implementacje CAPI są odpowiednie dla starszych systemów.
Klasy opakowujące natywną implementację Cryptography Next Generation API (CNG) - nazwy tych klas składają się z nazwy algorytmu i sufiksu CNG, np klasa ECDiffieHellmanCng dla algorytmu ECDH. Algorytmy CNG mogą być używane w systemach od Windows Vista.

Wszystkie klasy szyfrujące są zdefiniowane w przestrzeni nazw System.Security.Cryptography i są częścią rdzenia biblioteki .NET.

Szyfrowanie symetryczne

Szyfrowanie symetryczne wykonywane jest za pomocą klucza szyfrującego, który m jest tablica bajtowa. Ten sam klucz używany jest również do odszyfrowania danych. Algorytmy symetryczne polegają na tym, że tylko uprawniona osoba posiada dostęp do klucza szyfrującego.
Algorytmy symetryczne w .NET używają trybu łańcuchowego nazywanego cipher block chaining. Taki rodzaj algorytmów działa w następujący sposób. Jeżeli ilość danych jest większa niż zdefiniowana wielkość bloku, to są dzielone na mniejsze bloki o zdefiniowanym rozmiarze. Pierwszy blok jest szyfrowany używając losowego bloku danych o tym samym rozmiarze, zwanym wektorem inicjującym (initialization vector - IV), oraz kluczem szyfrującym. Następne bloki są szyfrowane używając wyniku poprzedniego bloku i tego samego klucza. Rozmiar bloku zależy od algorytmu. Jeżeli ostatni blok jest mniejszy niż rozmiar, będzie dopełniony danymi do pełnego rozmiaru bloku. Aby odszyfrować dane trzeba posiadać IV oraz klucz szyfrujący. IV nie musi być trzymany w tajemnicy ale klucz szyfrujący owszem.
Algorytmy symetryczne implementowane w .NET Framework:

AES - Advanced Encryption Standard. Ten algorytm jest implementowany przez dwie klasy: AesManaged i AesCryptoServiceProvider.
DES - Data Encryption Standard. Ten algorytm jest implementowany przez klasę DESCryptoServiceProvider.
RC2 - Rivest Cipher. Ten algorytm jest implementowany przez klasę RC2CryptoServiceProvider.
Rijndael - Ten algorytm jest implementowany przez klasę RijndaelManaged.
TripleDES - Triple Data Encryption Standard. Ten algorytm jest implementowany przez klasę TripleDESCryptoServiceProvider.

Wszystkie te klasy dziedziczą z klasy bazowej System.Security.Cryptography.SymmetricAlgorithm.

Lista właściwości klasy SymmetricAlgorithm:

BlockSize - pobiera lub ustawia rozmiar bloku.
FeedbackSize - pobiera lub ustawia rozmiar informacji zwrotnych. Rozmiar ten reprezentuje ilość danych w bitach, które są zawracane do następnej operacji szyfrowania lub odszyfrowywania. Rozmiar ten musi być mniejszy niż rozmiar bloku.
IV - pobiera lub ustawia IV. Kiedy tworzymy nową instancje algorytmu symetrycznego to IV generowane. Można również wygenerować je za pomocą metody GenerateIV. Rozmiar IV musi być taki sam jak rozmiar bloku podzielony przez osiem.
Key - pobiera lub ustawia klucz szyfrujący. Poprawne wielkości klucza szyfrującego zależne są od algorytmu i są wymienione w liście LegalKeySizes.
KeySize - pobiera lub ustawia rozmiar klucza szyfrującego.
LegelBlockSizes - Pobiera listę dozwolonych wartości rozmiaru bloku dla konkretnego algorytmu.
LegalKeySizes - Pobiera listę dozwolonych wartości rozmiaru klucza dla konkretnego algorytmu.
Mode - pobiera lub ustawia tryb operacji algorytmu. Wartości są enumeracją System.Security.Cryptography.CipherMode.
Padding - pobiera lub ustawia tryb wypełnienia używany przez algorytm. Wartości są enumeracją System.Security.Cryptography.PaddingMode.

Lista metod klasy SymmetricAlgorithm:

Clear - zwalnia wszystkie zasoby używane przez klasę algorytmu. Należy wywołać te metodę aby zwolnić wszystkie zasoby po zakończeniu pracy z obiektem szyfrującym.
Create() - metoda statyczna tworząca nowy obiekt szyfrujący z domyślnym algorytmem, dla .NET 4.5 jest to RijndaelManaged.
Create(String) - metoda statyczna tworząca nowy obiekt szyfrujący z wybranym algorytmem. Nazwa może być nazwą algorytmu lub nazwą klasy.
CreateDecryptor() - tworzy obiekt odszyfrowujący używając klucza i IV zdefiniowanych we właściwościach obiektu.
CreateDecryptor(Byte[], Byte[]) - tworzy obiekt odszyfrowujący używając klucza i IV zdefiniowanych jako parametry.
CreateEncryptor() - tworzy obiekt szyfrujący używając klucza i IV zdefiniowanych we właściwościach obiektu.
CreateEncryptor(Byte[], Byte[]) - tworzy obiekt odszyfrowujący używając klucza i IV zdefiniowanych jako parametry.
GenerateIV - tworzy losowy wektor IV używany przez algorytm. Zwykle nie wywołuje się tej metody bezpośrednio.
GenerateKey - generuje losowy klucz używany przez algorytm.
ValidKeySize - zwraca true jeżeli rozmiar klucza jest odpowiedni dla danego algorytmu.

Przebieg szyfrowania zwykłego tekstu algorytmem symetrycznym jest następujący:

Tworzymy obiekt algorytmu symetrycznego poprzez wywołanie metody Create klasy SymmetricAlgorithm, opcjonalnie ustawiając parametr z nazwą wybranego algorytmu.
Jeżeli chcemy to możemy ustawić klucz szyfrujący i wektor IV, lecz nie jest to wymagane gdyż są one domyślnie generowane.
Generujemy obiekt szyfrujący wywołując metodę CreateEncryptor. Można wybrać klucz i wektor lecz nie jest to konieczne.
Wywołujemy metodę TransformFinalBlock na obiekcie szyfrującym, która pobiera na wejściu tablicę bajtową reprezentującą dane, offset - gdzie zacząć szyfrowanie i długość danych do szyfrowania. Metoda zwraca zaszyfrowane dane.

Przykład szyfrowania:

byte[] EncryptData(byte[] plainData, byte[] IV, byte[] key) {

    SymmetricAlgorithm cryptoAlgorythm = SymmetricAlgorithm.Create();

    ICryptoTransform encryptor = cryptoAlgorythm.CreateEncryptor(key, IV);

byte[] cipherData = encryptor.TransformFinalBlock(plainData, 0, 
        plainData.Length);

return cipherData;
}

Przebieg odszyfrowania zaszyfrowanego tekstu algorytmem symetrycznym jest następujący:

Tworzymy obiekt algorytmu symetrycznego poprzez wywołanie metody Create klasy SymmetricAlgorithm, opcjonalnie ustawiając parametr z nazwą wybranego algorytmu który został użyty do szyfrowania.
Jeżeli chcemy to możemy ustawić klucz szyfrujący i wektor IV, lecz nie jest to wymagane ponieważ można podać je później.
Tworzymy obiekt odszyfrowujący wywołując metodę CreateDecryptor. Jeżeli nie podaliśmy klucza i wektora wcześniej to teraz musimy je ustawić. Klucz szyfrujący i wektor IV muszą być takie same jak przy szyfrowaniu.
Wywołujemy metodę TransformFinalBlock na obiekcie odszyfrowującym, który pobiera na wejściu tablicę bajtową z zaszyfrowanymi danymi, offset - gdzie zacząć odszyfrowywanie i długość danych do odszyfrowywania. Metoda zwraca odszyfrowane dane.

Przykład odszyfrowania:

byte[] DecryptData(byte[] cipherData, byte[] IV, byte[] key) {

    SymmetricAlgorithm cryptoAlgorythm = SymmetricAlgorithm.Create();

    ICryptoTransform decryptor = cryptoAlgorythm.CreateDecryptor(key, IV);

byte[] plainData = decryptor.TransformFinalBlock(cipherData, 0,
        cipherData.Length);

return plainData;
}

Największym wyzwaniem przy użyciu algorytmów symetrycznych jest zachowanie tajności klucza szyfrującego.

Szyfrowanie asymetryczne

Głównym powodem używania szyfrowania asymetrycznego jest uniknięcie udostępniania klucza szyfrowania. Szyfrowanie asymetryczne używa dwóch matematycznie powiązanych kluczy, które uzupełniają się nawzajem. Wiadomość zaszyfrowana jednym z nich może być odszyfrowana jedynie drugim. Jeden klucz jest kluczem publicznym którym dane są szyfrowane. Drugi klucz który służy do odszyfrowania wiadomości nazywany jest kluczem prywatnym.

Szyfrowanie asymetryczne jest wolniejsze od symetrycznego, lecz jego największą zaletą jest to, że nie potrzeba przekazywać klucza szyfrującego aby algorytm działał.

Algorytmy asymetryczne implementowane w .NET Framework:

DSA - Digital Signature Algorithm. Służy do tworzenia podpisów cyfrowych, które pomagają chronić integralność danych. Klasa implementująca ten algorytm to DSACryptoServiceProvider. Algorytmu DSA należy używać jedynie dla zgodności z przestarzałymi aplikacjami.
ECDiffieHellman - Elliptic Curve Diffie-Hellman Algorithm. Klasa implementująca ten algorytm to ECDiffieHellmanCng.
ECDsa - Elliptic Curve Digital Signature Algorithm (ECDSA). Klasa implementująca ten algorytm to ECDsaCng.
RSA - Klasa implementująca ten algorytm to RSACryptoServiceProvider.

Wszystkie te klasy dziedziczą z klasy bazowej System.Security.Cryptography.AsymmetricAlgorithm.

Przebieg szyfrowania zwykłego tekstu algorytmem asymetrycznym jest następujący:

Uzyskania klucza publicznego odbiorcy.
Utworzenie nowego obiektu asymetrycznego szyfrowania.
Ustawienie klucza publicznego.
Szyfrowanie danych
Wysłanie danych do odbiorcy.

Przebieg odszyfrowania zaszyfrowanej wiadomości algorytmem asymetrycznym jest następujący:
1. Odebranie danych od wysyłającego.
2. Utworzenie nowego obiektu asymetrycznego szyfrowania.
3. Ustawienie klucza prywatnego.
4. Odszyfrowanie danych.

Jeżeli dane zostały zmienione lub nie zostały zaszyfrowane odpowiadającym kluczem publicznym to zgłoszony zostanie wyjątek CryptographicException.

Istnieją dwa sposoby obsługi kluczy. Pierwszy polega na bezpośrednim wysłaniu klucza publicznego. Drugi polega na umieszczeniu klucza w pojemniku dostawcy usług kryptograficznych.

Jednym z typowych scenariuszy jest użycie szyfrowania asymetrycznego do wymiany kluczy potrzebnych do szyfrowania symetrycznego stosując następujący przepływ:

Obie strony generują pary kluczy prywatnych i publicznych.
Strony wymieniają się kluczami publicznymi.
Każda ze stron generuje klucz symetryczny który może służyć do szyfrowania danych.
Każda ze stron szyfruje klucz symetryczny używając algorytmu asymetrycznego i klucza publicznego otrzymanego od drugiej strony.
Każda ze stron wysyła zaszyfrowany klucz symetryczny do drugiej strony.
Obie strony używają swojego klucza prywatnego do odszyfrowania klucza szyfrowania symetrycznego.
Strony zaczynają wymieniać się danymi używając algorytmu symetrycznego i klucza z poprzedniego kroku.

Innym typowym scenariuszem jest użycie szyfrowania asymetrycznego do podpisania danych, zapewniając w ten sposób zarówno autentyczność i tożsamość.

Szyfrowanie strumieni

Strumienie reprezentują plik, urządzenie I/O lub kanał komunikacyjny i potrafią wykonywać trzy podstawowe zadania:

Read - można czytać dane ze strumienia do struktury danych.
Write - można zapisać dane ze struktury danych do strumienia.
Seek - można zmienić aktualną pozycję w strumieniu gdzie następna operacja odczytu lub zapisu działa.

Bardzo ważną właściwością strumieni w .NET jest to, że mogą być łączone poprzez przekazywanie danych wyjściowych ze strumienia do wejścia innego strumienia. Czasami chcemy aby dane przechodzące przez strumień były zaszyfrowane. Można zaszyfrować dane przed wysłaniem do strumienia bądź połączyć strumienie tak aby jeden z nich odpowiadał za szyfrowanie. Jednym ze strumieni w .NET jest CryptoStream, który potrafi szyfrować i deszyfrować dane które przez niego przechodzą.

Praca ze strumieniami szyfrowanymi wygląda następująco:

Tworzymy obiekt algorytmu symetrycznego poprzez wywołanie metody Create klasy SymmetricAlgorithm, opcjonalnie wybierając nazwę algorytmu szyfrującego jako parametr wejściowy.
Jeżeli chcemy to możemy ustawić klucz szyfrujący i wektor IV, lecz nie jest to wymagane gdyż są one domyślnie generowane.
Tworzymy obiekt szyfrujący wywołując metodę CreateEncryptor. Można wybrać klucz i wektor lecz nie jest to konieczne.
Tworzymy obiekt strumienia CryptoStream. Konstruktor przyjmuje trzy parametry. Pierwszym jest strumień szyfrowanych danych; drugi to obiekt szyfrujący; trzeci to tryb strumienia który w tym wypadku to Write.
Zapisujemy dane do obiektu strumienia CryptoStream wywołując jedną z metod zapisu udostępnianych przez CryptoStream, używając StreamWriter, lub łącząc go z innym strumieniem.
Kiedy skończymy zapis należy wyczyścić obiekt CryptoStream wywołując metodę Clear po czym Dispose.

Przykładowy blok kodu demonstrujący taką operację:

byte[] EncryptString(string plainData, byte[] IV, byte[] key) {

    SymmetricAlgorithm cryptoAlgorythm = SymmetricAlgorithm.Create();

    ICryptoTransform encryptor = cryptoAlgorythm.CreateEncryptor(key, IV);

byte[] cipherData = newbyte[0];

using (MemoryStream msEncrypt = new MemoryStream()) {
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt,
                encryptor,
                CryptoStreamMode.Write)) {

            StreamWriter swEncrypt = new StreamWriter(csEncrypt);

            swEncrypt.Write(plainData);
            swEncrypt.Close();
            csEncrypt.Clear();
            cipherData = msEncrypt.ToArray();
        }
    }

return cipherData;
}

Odszyfrowanie strumienia wygląda następująco:

Tworzymy obiekt algorytmu symetrycznego poprzez wywołanie metody Create klasy SymmetricAlgorithm, opcjonalnie wybierając nazwę algorytmu szyfrującego jako parametr wejściowy.
Jeżeli chcemy to możemy ustawić klucz szyfrujący i wektor IV, możemy również uczynić to w następnym kroku.
Tworzymy obiekt deszyfrujący wywołując metodę CreateDecryptor. Jeżeli nie uczyniliśmy tego wcześniej to teraz trzeba wybrać klucz i wektor które zostały użyte do szyfrowania.
Tworzymy obiekt strumienia CryptoStream. Konstruktor przyjmuje trzy parametry. Pierwszym jest strumień szyfrowanych danych; drugi to obiekt deszyfrujący; trzeci to tryb strumienia który w tym wypadku to Read.
Odczytujemy dane z obiektu strumienia CryptoStream za pomocą jednej z jego metod odczytu, używając obiektu StreamReader lub połączenia do innego strumienia.
Kiedy skończymy zapis należy wyczyścić obiekt CryptoStream wywołując metodę Clear po czym Dispose.

Przykładowy blok kodu demonstrujący taką operację:

stringDecryptString(byte[] cipherData, byte[] IV, byte[] key) {

    SymmetricAlgorithm cryptoAlgorythm = SymmetricAlgorithm.Create();

    ICryptoTransform decryptor = cryptoAlgorythm.CreateDecryptor(key, IV);

string plainText = string.Empty;

using (MemoryStream msDecrypt = new MemoryStream(cipherData)) {
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt,
                decryptor,
                CryptoStreamMode.Read)) {

            StreamReader srDecrypt = new StreamReader(csDecrypt);

            plainText = srDecrypt.ReadToEnd();
            srDecrypt.Close();
            csDecrypt.Clear();
        }
    }

return plainText;
}

Bardzo często spotykanym scenariuszem jest zaszyfrowanie i skompresowanie danych po czym wysłanie ich przez sieć. Kompresowanie tekstu jest bardziej efektywne niż danych binarnych więc należy zacząć od operacji kompresji danych po czym dopiero je zaszyfrować. Strona odbierająca musi wykonać operacje w odwrotnej kolejności.

Funkcja skrótu danych (Hash)

Funkcja skrótu to proces mapowania danych binarnych o zmiennej długości do danych binarnych stałego rozmiaru. Stosowanie tej samej funkcji skrótu do dwóch identycznych struktur danych, daje taki sam efekt.
Funkcje skrótu są używane w kilku standardowych scenariuszach:

Indeksowanie danych - zamiast dopasować dane, gdy klucz indeksu posiada zmienną długość, można obliczyć
wartość skrótu klucza indeksu i wyszukiwać tą wartość zamiast klucza. Wartość funkcji skrótu jest zwykle krótsza niż oryginalna wartość, więc jej wyszukiwanie jest zwykle szybsze. Istnieje możliwość, że dwa lub więcej kluczy indeksu może wywoływać tę samą wartość skrótu. W takim wypadku algorytm indeksujący używa techniki zwanej hash bucket gdzie wartości indeksu posiadające tą samą wartość skrótu są grupowane razem.
Integralność danych - integralności danych stosuje się w celu zapewnienia, że dane dotrą do miejsca przeznaczenia bez zmian. Nadawca oblicza kryptograficzny skrót danych, które chce wysłać, a następnie wysyła te dane, skrót i informacje o technice stosowanej do obliczenia skrótu do odbiorcy. Odbiorca może zastosować ten sam algorytm na danych i porównać wynik z otrzymanymi danymi. Jeżeli są takie same to znaczy, że dane nie uległy zmianie po wykonaniu skrótu.
Autentyczność danych - autentyczności danych stosuje się, gdy odbiorca chce upewnić się, że dane pochodzą od właściwego nadawcy i, że nie zmieniły się po drodze. Nadawca oblicza kryptograficzny skrót danych i podpisuje go własnym kluczem prywatnym. Odbiorca tworzy ponownie skrót i odszyfrowuje otrzymany podpis używając klucza publicznego wysyłającego po czym porównuje dane.
Przechowywanie haseł - przechowywanie haseł jako zwykły tekst jest niebezpieczną i niezalecaną techniką. Aby chronić hasła zwykle stosuje się do nich funkcje skrótu przed ich zapisaniem.

Istnieją dwa rodzaje algorytmów funkcji skrótów: z kluczem lub bez klucza. Algorytmy bez klucza są zwykle używane tylko w scenariuszach integralności danych.

Lista Algorytmów tworzenia skrótów zaimplementowanych w .NET:

SHA1 - implementacja algorytmu SHA tworząca skrót o rozmiarze 160 bitów.
SHA256 - implementacja algorytmu SHA tworząca skrót o rozmiarze 256 bitów.
SHA512 - implementacja algorytmu SHA tworząca skrót o rozmiarze 512 bitów.
SHA384 - implementacja algorytmu SHA tworząca skrót o rozmiarze 384 bitów.
MD5 - implementacja algorytmu Md5. Używaj tylko dla kompatybilności ze starymi aplikacjami.
RIPEMD160 - implementacja algorytmu RIPEMD. Używaj tylko dla kompatybilności ze starymi aplikacjami.

Wszystkie klasy skrótów dziedziczą z abstrakcyjnej klasy bazowej System.Security.Cryptography.HashAlgorithm.

Właściwości klasy HashAlgorithm:

CanReuseTransform - właściwość tylko do odczytu zwracająca true jeżeli aktualna transformacja może być użyta ponownie.
CanTransformMultipleBlocks - właściwość tylko do odczytu zwracająca true jeżeli wiele bloków może być transformowanych.
Hash - właściwość tylko do odczytu zwracająca obliczoną wartość skrótu.
HashSize - właściwość tylko do odczytu zwracająca rozmiar obliczonego skrótu w bitach.
InputBlockSize - właściwość tylko do odczytu zwracająca rozmiar bloku wejściowego.
OutputBlockSize - pobiera rozmiar bloku wyjściowego.

Metody klasy HashAlgorithm:

Clear - zwalnia wszystkie używane zasoby.
ComputeHash(Byte[]) - wylicza skrót dla tablicy bajtów.
ComputeHash(Stream) - wylicza skrót dla strumienia.
ComputeHash(Byte[], Int32, Int32) - wylicza skrót dla regionu w tablicy bajtów.
Create() - tworzy nowy obiekt algorytmu skrótów używając domyślnego algorytmu, w .NET 4.5 jest to SHA1.
Create(String) - tworzy nowy obiekt algorytmu skrótów używając wybranego algorytmu.
TransformBlock - oblicza skrót dla określonego regionu wejściowej tablicy bajtowej inputBuffer i kopiuje wynik do określonego regionu w tablicy outputBuffer.
TransformFinalBlock - oblicza skrót dla określonego regionu wejściowej tablicy bajtowej inputBuffer.

Zwykle używamy tylko metod Create i ComputeHash. Metody TransformBlock i TransformFinalBlock są używane gdy chcemy obliczyć skrót tylko dla części danych.

Algorytmy skrótów z kluczem dziedziczą z klasy System.Security.Cryptography.KeyedHashAlgorithm.
W porównaniu z algorytmami bez klucza klasaKeyedHashAlgorithm posiada jedną istotną właściwość:

Key - pobiera lub ustawia wartość klucza używanego przez algorytm. jeżeli chcemy zmienić klucz po rozpoczęciu operacji tworzenia skrótu to zgłoszony zostanie wyjątek CryptographicException.

Schemat działania przy tworzeniu skrótu jest następujący:

Tworzymy obiekt algorytmu funkcji skrótu.
Jeżeli algorytm używa klucza to ustawiamy wartość klucza.
Wywołujemy metodę ComputeHash.
Zapisujemy skrót danych.

Przykładowy blok kodu demonstrujący taką operację:

stringComputeHash(string input)
{
    HashAlgorithm sha = SHA256.Create();
byte[] hashData = sha.ComputeHash(Encoding.Default.GetBytes(input));
return Convert.ToBase64String(hashData);
}

Schemat działania przy weryfikacji skrótu dla danych jest następujący:

Tworzymy obiekt algorytmu funkcji skrótu taki sam jak przy tworzeniu skrótu.
Jeżeli algorytm używa klucza to ustawiamy wartość klucza taką samą jak przy tworzeniu skrótu.
Wyodrębniamy oryginalny skrót danych.
Wywołujemy metodę ComputeHash.
Porównujemy oryginalny skrót z tym wyliczonym.

Przykładowy blok kodu demonstrujący taką operację:

boolVerifyHash(string input, string hashValue) 
{
    HashAlgorithm sha = SHA256.Create();
byte[] hashData = sha.ComputeHash(Encoding.Default.GetBytes(input));
return Convert.ToBase64String(hashData) == hashValue;
}

Tworzenie i zarządzanie certyfikatami

Kiedy dwie strony komunikują się ze sobą to muszą mieć pewność, że porozumiewają się z właściwym partnerem. Przykładowo kiedy wykonujemy transakcje bankową w internecie, chcemy mieć pewność, że jesteśmy na stronie naszego banku a nie na innej stronie która podszywa się pod stronę naszego banku. Chcemy wiedzieć również, że komunikacja jest bezpieczna. Dla aplikacji sieciowych istnieją dwa protokoły które rozwiązują ten problem: Transport Layer Security (TLS) i Secure Socket Layer (SSL). Oba te protokoły szyfrują dane i zapewniają autentyczność danych. Dla autentyczności używają Public Key Infrastructure (PKI), która jest niezbędna do obsługi certyfikatów cyfrowych. PKI używa notacji nazywanej Certificate Authority (CA). CA jest to jednostka która wystawia certyfikaty cyfrowe. Certyfikaty cyfrowe wiąże klucz publiczny z tożsamością. Dzięki temu, kiedy dwie strony chcą się komunikować i nadawca chce się upewnić, że komunikuje się z odpowiednim odbiorcą, nadawca może użyć PKI do zweryfikowania tożsamości odbiorcy.

Zasada działania jest prosta. Można albo wybrać bezpośrednio, że ufamy drugiej stronie albo zaufać trzeciej stronie która weryfikuje tożsamość innych podmiotów. Druga opcja jest hierarchiczna, co oznacza, że liczba jednostek którym zdecydujesz się zaufać jest ograniczona. Lecz te jednostki mogą weryfikować tożsamość innych podmiotów co czyni je również podmiotami zaufanymi itd.

Certyfikaty najwyższego poziomu, którym zdecydujesz się zaufać nazywane są certyfikatami głównymi (ang. root certificates). Normalnie nie dodajemy żadnego certyfikatu głównego. Przychodzą one wraz z instalacją systemu operacyjnego lub jego aktualizacjami. Certyfikaty najwyższego poziomu którym ufa nasz komputer można podejrzeć w panelu sterowania w opcjach internetowych. W zakładce Content należy kliknąć guzik Certyficates i wybrać zakładkę Trusted Root Certification Authorities. Okno powinno być podobne do poniższego:

jeżeli strona chce aby jej tożsamość była gwarantowana, musi jedynie zweryfikować jej tożsamość w jednym z podmiotów które darzysz zaufaniem. Jednym z przykładów jest Microsoft. Na komputerze istnieje Root Certificate Authority zwane GTE CyberTrust Global Root. jeżeli wprowadzimy do przeglądarki adres https://www.microsoft.com i podejrzymy certyfikat strony to zobaczymy dialog podobny do poniższego:

Standard który jest używany przez PKI to X.509, który określa format PKIs, Certificate Revocation List (CLR), atrybuty certyfikatów i sposób walidacji ścieżek certyfikatów.
.NET Framework implementuje standard X.509. Wszystkie klasy które są potrzebne do zarządzania certyfikatami znajdują się w przestrzeni nazw System.Security.Cryptography.X509Certificates. Jeżeli posiadamy klucz prywatny który jest zainstalowany lokalnie to możemy odszyfrować dane zapisane odpowiadającym mu kluczem publicznym.

Microsoft oferuje używanie narzędzia Makecert.exe (Certificate Creation Tool), które może być używane do tworzenia certyfikatów.

Do pracy programistycznej z certyfikatami można użyć klasy X509Certificate2.
Certyfikaty używają pojęcia magazynów certyfikatów, które są miejscami, w których certyfikaty są bezpiecznie przechowywane. W .NET magazyny są zaimplementowane w klasie X509Store. System Windows oferuje dwie lokacje dla magazynów, które są reprezentowane przez enumerację StoreLocation.
Wartości enumeracji StoreLocation:

CurrentUser - magazyn certyfikatów aktualnego użytkownika.
LocalMachine - magazyn certyfikatów wspólny dla wszystkich użytkowników na maszynie lokalnej.

System Windows oferuje osiem predefiniowanych magazynów które są reprezentowane przez enumerację StoreName. Możliwe wartości enumeracji StoreName:

AddressBook - magazyn certyfikatów dla innych użytkowników.
AuthRoot - magazyn certyfikatów dla niezależne urzędów certyfikacji CA.
CertificateAuthority - magazyn certyfikatów dla pośrednich CA.
Disallowed - magazyn unieważnionych certyfikatów.
My - magazyn certyfikatów personalnych.
Root - magazyn certyfikatów dla zaufanych głównych urzędów certyfikacji.
TrustedPeople - magazyn certyfikatów dla bezpośrednio zaufanych ludzi i zasobów.
TrustedPublisher - magazyn certyfikatów dla bezpośredniego zaufanych wydawców.

Klasa X509Store posiada właściwość Name, której można użyć jeżeli chcemy stworzyć swój własny magazyn.

Poniższy fragment kodu demonstruje jak użyć klasy X509Store aby pokazać informacje o certyfikatach głównych X509Certificates zainstalowanych na maszynie lokalnej:

classCertificateTest {
staticvoidMain() {
        X509Store store = new X509Store(StoreName.Root,
            StoreLocation.LocalMachine);
        store.Open(OpenFlags.ReadOnly);

        Console.WriteLine("Friendly Name\t\t\t\t\t Expiration date");
foreach (X509Certificate2 certificate in store.Certificates) {
            Console.WriteLine("{0}\t{1}", certificate.FriendlyName
                , certificate.NotAfter);
        }
        store.Close();
    }
}

Zarządzanie kluczami

Czasami chcemy aby nasze dane były po prostu zabezpieczone bez zastanawiania się nad rodzajem algorytmu lub sposobie implementacji. Przykładowo aby algorytm szyfrowania był efektywny trzeba chronić wspólne hasło dla algorytmu symetrycznego i klucz prywatny dla algorytmu asynchronicznego.
Aby rozwiązać tego typu problemy .NET Framework oferuje przestrzeń nazw System.Security.Cryptography i klasę ProtectedData. Ta klasa posiada dwie metody statyczne: Protect i Unprotect. Ich sygnatury są następujące:

publicstaticbyte[] Protect(
byte[] userData,
byte[] optionalEntropy,
    DataProtectionScope scope
)

publicstaticbyte[] Unprotect(
byte[] encryptedData,
byte[] optionalEntropy,
    DataProtectionScope scope
)

Pierwszym parametrem są dane do zaszyfrowania lub odszyfrowania. Drugim parametrem jest optionalEntropy używany do zwiększenia złożoności zaszyfrowanych danych. trzecim jest DataProtectionScope, określa on, kto może odszyfrować dane. Jego wartości toDataProtectionScope.CurrentUser lub DataProtectionScope.LocalMachine.

Poniższy fragment kodu demonstruje użycie klasy ProtectedData do zaszyfrowania ciągu znaków, które odszyfrować może tylko aktualny użytkownik.

byte[] ProtectString(string data)
{
byte[] userData = System.Text.Encoding.Default.GetBytes(data);
byte[] encryptedData = ProtectedData.Protect(userData, null,
        DataProtectionScope.CurrentUser);
    return encryptedData;
}

Jaki algorytm wybrać

Firma Microsoft rekomenduje następujące algorytmy do użycia w następujących sytuacjach:

Dla prywatności danych algorytm Aes.
Dla integralności danych algorytm HMACSHA256 lub HMACSHA512.
Do cyfrowego podpisu algorytmy RSA lub ECDsa.
Do wymiany kluczy algorytmy RSA lub ECDiffieHellman.
Do generowania losowych liczb klasa RNGCryptoServiceProvider.
Do generowania klucza z hasła Rfc2898DeriveBytes.

Poniższy fragment kodu zawiera pełny przykład użycia algorytmu asymetrycznego RSA:

using System;
using System.Security.Cryptography;
using System.Text;

namespaceEncryption.Asymmetric
{
publicclassRSASample
    {
publicstaticvoidRun() {

string keyContainerName = "MyKeyContainer";
string clearText = "This is the data we want to encrypt!";
var cspParams = new CspParameters();
            cspParams.KeyContainerName = keyContainerName;

            RSAParameters publicKey;
            RSAParameters privateKey;

using (var rsa = new RSACryptoServiceProvider(cspParams)) {

                rsa.PersistKeyInCsp = true;
                publicKey = rsa.ExportParameters(false);
                privateKey = rsa.ExportParameters(true);

                rsa.Clear();
            }

byte[] encrypted = EncryptUsingRSAParam(clearText, publicKey);
string decrypted = DecryptUsingRSAParam(encrypted, privateKey);

            Console.WriteLine("Asymmetric RSA");
            Console.WriteLine("Asymmetric RSA - Using RSA Params");
            Console.WriteLine("Encrypted:{0}", Convert.ToBase64String(encrypted));
            Console.WriteLine("Decrypted:{0}", decrypted);
            Console.WriteLine();

            Console.WriteLine("Asymmetric RSA - Using Persistent Key Container");
            encrypted = EncryptUsingContainer(clearText, keyContainerName);
            decrypted = DecryptUsingContainer(encrypted, keyContainerName);
            Console.WriteLine("Encrypted:{0}", Convert.ToBase64String(encrypted));
            Console.WriteLine("Decrypted:{0}", decrypted);
            Console.WriteLine();
        }

staticbyte[] EncryptUsingRSAParam(stringvalue, RSAParameters rsaKeyInfo)
        {
using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(rsaKeyInfo);
byte[] encodedData = Encoding.Default.GetBytes(value);
byte[] encryptedData = rsa.Encrypt(encodedData, true);

                rsa.Clear();
return encryptedData;
            }
        }

staticstringDecryptUsingRSAParam(byte[] encryptedData, RSAParameters rsaKeyInfo) {
using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(rsaKeyInfo);
byte[] decryptedData = rsa.Decrypt(encryptedData, true);
string decryptedValue = Encoding.Default.GetString(decryptedData);

                rsa.Clear();
return decryptedValue;
            }
        }

staticbyte[] EncryptUsingContainer(stringvalue, string containerName)
        {
var cspParams = new CspParameters();
            cspParams.KeyContainerName = containerName;
using (var rsa = new RSACryptoServiceProvider(cspParams))
            {
byte[] encodedData = System.Text.Encoding.Default.GetBytes(value);
byte[] encryptedData = rsa.Encrypt(encodedData, true);

                rsa.Clear();
return encryptedData;
            }
        }

staticstringDecryptUsingContainer(byte[] encryptedData, string containerName)
{
var cspParams = new CspParameters();
            cspParams.KeyContainerName = containerName;
using (var rsa = new RSACryptoServiceProvider(cspParams))
            {
byte[] decryptedData = rsa.Decrypt(encryptedData, true);
string decryptedValue = Encoding.Default.GetString(decryptedData);

                rsa.Clear();
return decryptedValue;
            }
        }
    }
}

Zarządzanie assembly

Wynikiem kompilacji projektu są pliki wykonywalne, nazywane assembly. Assembly są blokami budującymi każdą aplikację .NET. Są one podstawową jednostką do wdrożenia, wersjonowania, ponownego użycia i bezpieczeństwa.

Assembly zawiera Intermediate Language (IL), metadane i zasoby. IL jest rezultatem kompilacji kodu źródłowego, który może być zrozumiany przez Common Language Runtime (CLR). CLR posiada komponent kompilatora Just In Time (JIT), który kompiluje kod IL do kodu binarnego który może być uruchomiony na wybranej platformie, np Windows. Assembly może składać się z jednego lub wielu plików. Visual Studio generuje tylko assembly jedno plikowe.

Assembly jest otrzymywane przez kompilację projektu. Wynikiem assembly może być plik procesowy EXE lub plik biblioteki DLL. Różnicą pomiędzy tymi dwoma jest obecność głównego punktu wejścia w plikach procesowych czyli metody która jest uruchamiana kiedy aplikacja startuje np metoda Main.

Wersja Assembly

Oprogramowanie ewoluuje i sposobem na oznaczenie tego jest tworzenie nowych wersji, gdzie każda nowa wersja dodaje nowe funkcje, naprawia błędy lub jest kompletnie przepisana.
Wersja assembly w .NET jest zaimplementowana jako ciąg znaków, zwykle składająca się z czterech części numerycznych odseparowanych kropkami: Major, Minor, Build i Revision. Przykładowo wszystkie assembly w .NET Framework 4.5 posiadają wersję 4.0.30319.17929.
Oznaczenia części z których składa się wersja:

Revision - jest zwykle losowym numerem rozróżniającym wersje o tym samym numerze Build. Zwykle zmienia się ją przy każdym budowaniu projektu.
Build - jest to zwykle numer który wzrasta każdego dnia, kiedy pracujemy nad aktualną wersją produktu. Zwykle numer zmieniany jest każdej nocy przez nocny proces budowania.
Minor - numer ten jest zwiększany z każdym publicznym wydaniem produktu. Zwykle dwie wersje tego samego produktu które są kompatybilne wstecz mają ten sam numer Major lecz różnią się właśnie numerem Minor.
Major - numer zwiększany za każdym razem, gdy masz główne wydanie swojego produktu, albo przez zmianę istniejących funkcji lub przepisywanie całej aplikacji.

Wersję aplikacji można zmieniać na dwa sposoby. Pierwszym jest zmiana wersji w oknie właściwości projektu. W oknie właściwości Assembly naciskamy guzik Assembly Information i pojawia się okno dialogowe w którym mozna ustawić numer wersji podobne do poniższego:

Drugim sposobem jest edycja wersji w pliku AssemblyInfo.cs który znajduje się w folderze Properties każdego projektu. Na końcu pliku można znaleźć linię z wersją projektu przypominającą poniższą linię:

[assembly: AssemblyVersion("2.1.42.15")]

Właściwość Assembly Version jest ignorowana przez CLR, chyba że jest ona używana wraz z silnymi nazwami.

Podpisywanie assembly używając silnych nazw

Problem z plikami DLL pojawia się kiedy wiele aplikacji używa tej samej biblioteki. Jeżeli aplikacje są skompilowane z różnymi wersjami tej samej biblioteki to ta wersja która została zainstalowana najpóźniej nadpisuje pozostałe. Jeżeli występują problemy z kompatybilnością pomiędzy wersjami biblioteki to niektóre aplikacje mogą działać niepoprawnie a nawet nie działać wcale. Biblioteka .NET rozwiązała ten problem wprowadzając nowy koncept nazywany side-by-side versioning. Polega to rozróżnieniu pomiędzy różnymi wersjami tej samej biblioteki, przy jednoczesnym zapewnieniu, że dwie różne wersje pochodzą z tego samego źródła.
W .NET nazwa assembly składa się z czterech części:

Przyjaznej nazwy.
Wersji.
Kultury.
PublicKeyToken

Przyjazna nazwa jest nazwą assembly, zwykle bez rozszerzenia.
Wersja to wersja assembly omówiona w poprzedniej sekcji.
Kultura jest używany, gdy chcemy zlokalizować swoją aplikację na różnych rynkach. Aby zlokalizować aplikację, należy utworzyć jedną assembly zawierającą kod i jedną assembly dla każdego regionu aplikacji. Assembly dla regionów zawierają jedynie zasoby jak np przetłumaczone teksty lub zdjęcia. Assembly wykonywalna posiada zawsze kulturę neutralną.

Aby assembly posiadała silną nazwę należy ją podpisać parą kluczy prywatnego i publicznego. Klucz prywatny jest używany do cyfrowego podpisania assembly a klucz publiczny jest używany do weryfikacji tego podpisu. Public Key Token jest 64 bitowym skrótem klucza publicznego assembly. Skrót jest używany aby zaoszczędzić miejsce, ponieważ klucz jest dużo dłuższy.

Parę kluczy prywatnego i publicznego dla assembly można wygenerować na dwa sposoby. Pierwszym jest użycie Visual Studio. W oknie właściwości wybieramy zakładkę Signing i zaznaczamy pole wyboru Sign the Assembly jak na obrazku poniżej:

Wybieramy <New...> i pokaże się okno dialogowe jak poniższe:

W oknie dialogowym można ustawić nazwę pliku klucza, hasło i algorytm używany do podpisu cyfrowego.

Drugim sposobem generowania kluczy jest użycie programu sn.exe w oknie Developer Command Prompt i użycie komendy:

sn.exe-kmyFile.snk

Utworzy to nowy klucz który należy wybrać opcją <Browse…> w oknie wyboru klucza.

Kiedy assembly będzie wymagała podpisu cyfrowego to kompilator podpiszę assembly używając klucza prywatnego i dołączy klucz publiczny do assembly dla możliwości weryfikacji. następnym krokiem jest utworzenie skrótu dla klucza publicznego aby utworzyć Public Key Token i również dołączyć go do assembly.
Pełna nazwa assembly jest nazywana Fully Qualified Name (FQN). Przykładowo FQN dla assembly System w .NET 4.5 to:

System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Side-by-Side Versioning

Silne nazwy miałyby tylko niewielką wartość gdyby nie potęga uruchamiania różnych wersji tego samego assembly obok siebie.
Wersionowanie obok siebie działa tylko z silnie nazwanymi assembly ponieważ potrzebuje aby były one wdrożone do Global Assembly Cache (GAC).
Kiedy dodajemy referencję do assembly to informacja o referencji jest dodawana do pliku manifestu assembly. Manifest jest osadzony w assembly jako część metadanych. W pliku manifestu każda referencja jest reprezentowana przez blok przypominający poniższy kod:

// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89) // .z\V.4..
.ver 4:0:0:0
}
.assembly extern CommonFunctionality
{
.ver 1:0:0:0
}
.assembly 'Programming CSharp Assembly'
{ … }

Pierwsza linia .assembly extern reprezentuje referencję do assembly mscorlib, która jest dołączana domyślnie przez wszystkie aplikacje .NET ponieważ zawiera definicje wszystkich bazowych typów danych. Wersja assembly to 4:0:0:0 a Public Key Token to (B7 7A 5C 56 19 34 E0 89). Druga .assembly extern reprezentuje referencję do assembly CommonFunctionality w wersji 1.0.0.0, która nie jest podpisana.
Gdyby druga assembly była podpisana to wpis mógłby wyglądać tak:

// Metadata version: v4.0.30319
.assembly extern mscorlib
{
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) // .z\V.4..
.ver 4:0:0:0
}
.assembly extern CommonFunctionality
{
.publickeytoken = (48 27 85 37 58 E3 97 63 ) // H'.7X..c
.ver 1:0:0:0
}
.assembly 'Programming CSharp Assembly'
{ …}

Te informacje można podejrzeć używając narzędzia Intermediate Language Disassembler (ildasm.exe) z linii komend Developer Command Prompt. Uruchamiamy ją podając jako parametr ścieżkę i nazwę pliku assembly. Otwiera to okno aplikacji w którym podglądamy manifest:

Kiedy uruchamiamy aplikację to środowisko uruchomieniowe próbuje zlokalizować wszystkie wymagane assembly.
Jeżeli assembly nie jest podpisane to CLR szuka w lokalnym folderze aplikacji bazując na nazwie assembly ignorując wersję.
Jeżeli assembly jest podpisana to CLR pierw sprawdza czy są jakieś zasady określone dla danego assembly które mogą wskazać, że trzeba użyć innej wersji assembly. Proces zastępowania assembly bez konieczności rekompilacji innych assembly które jej używają nazywa się binding redirection. Kiedy wersja jest ustalona, CLR pierw przeszukuje GAC w poszukiwaniu określonej wersji assembly, jeżeli tam nie znajdzie to szuka w lokalnym folderze aplikacji. Kiedy znajdzie assembly to sprawdza jej podpis cyfrowy. Jeżeli CLR znejdzie assembly ale nie znajdzie odpowiedniej jej wersji lub kiedy podpis się nie zgadza to zgłoszony zostaje wyjątek System.IO.FileLoadException. Jeżeli assembly nie może być znalezione to zgłoszony zostaje wyjątek System.IO.FileNotFoundException.

Od wersji .NET 2.0, Microsoft dodał do nazwy assembly architekturę procesora, lecz jest ona opcjonalna. Oznacza to, że można mieć dwie takie same wersje assembly rozróżnione atrybutem ProcessorArchitecture.
Wartości atrybutu ProcessorArchitecture są opisane enumeracją System.Reflection.ProcessorArchitecture:

None - niewymieniona lub nieznana.
MSIL - niezależne od procesora.
x86 - 32-bitowy procesor Intel.
IA64 - 64-bitowy procesor Intel.
Amd64 - 64-bitowy procesor AMD.
Arm - procesor ARM.

Architektura procesora jest wyświetlana tylko jeżeli jest różna od None.
Przykładowo jeżeli assembly System miałoby ustawiony atrybut ProcessorArchitecture do MSIL to nazwa assembly byłaby następująca:

System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, ProcessorArchitecture=MSIL

Dodawanie assembly do GAC

Jeżeli aplikacja nie jest aplikacją .NET i korzysta z bibliotek dołączanych dynamicznie, to poszukuje ich w folderze instalacji aplikacji lub w folderach określonych w zmiennej środowiskowej PATH.
Zamiast tego aplikacje .NET używają GAC, która jest repozytorium różnych podpisanych assembly i która działa jako pamięć podręczna dla bibliotek współdzielonych. Lokalizacja GAC to < Your Windows Installation Folder>\assembly.
Zaletami GAC są: współdzieleni assembly, wersjonowanie obok siebie, sprawdzanie podpisu assembly przed instalacją w GAC oraz możliwość do prekompilacji assembly dzięki czemu assembly nie musi być kompilowane przez kompilator JIT za każdym razem gdy jest ładowana. Aby dokonać prekompilacji należy użyć narzędzia ngen.exe (Native Image Generator).

Assembly można dodać do GAC na dwa sposoby.
Pierwszym jest użycie instalatora. jest to preferowany sposób. Używając instalatora upewniamy się, że instalacja jest atomowa.
Drugim sposobem jest użycie narzędzia gacutil.exe, które może być użyte w następujący sposób z linii komend:

gacutil.exe[options][assemblyName | assemblyPath | assemblyListFile]

Najczęściej wykorzystywane parametry gacutil.exe:

/i - dodaje assembly do GAC.
/u - usuwa assembly do GAC.
/l [assemblyName] - wyświetla wszystkie assembly w GAC. Dodanie assemblyName filtruje listę do assembly o określonej nazwie.
/r - śledzi referencje do assembly poprzez zwiększanie i zmniejszanie licznika w czasie instalacji i deinstalacji.

Podsumowanie

Wybór algorytmu szyfrowania

Do szyfrowania danych używanych lokalnie lub jeżeli posiadamy bezpieczny sposób przesyłania klucza szyfrowania to używamy szyfrowania symetrycznego.
Jeżeli nie posiadamy bezpiecznego sposobu przesyłania klucza szyfrowania pomiędzy partnerami to rekomendowane jest szyfrowanie asymetryczne.
Jeżeli wymagana jest tylko integralność danych to należy użyć algorytmu skrótu.
Jeżeli wymagana jest integralność danych i autentyczność należy użyć algorytmu MAC.

Szyfrowanie symetryczne

Bazuje na podstawie wspólnego klucza szyfrowania.
Wymaga wektora inicjującego IV, który nie musi być tajny lecz jest używany do szyfrowania pierwszego bloku danych.
Aby go użyć tworzymy instancję obiektu algorytmu symetrycznego po czym wywołujemy metodę CreateEncryptor lub CreateDecryptor.
Obiekt szyfrujący lub deszyfrujący jest potem używany z metodą TransformFinalBlock lub poprzez wysłanie do strumienia CryptoStream.

Szyfrowanie asymetryczne

Bazuje na podstawie pary komplementarnych kluczy. Dane zaszyfrowane jednym z nich mogą być odszyfrowane jedynie drugim.
Jeden z kluczy jest nazywany kluczem prywatnym i jest atjny. Drugi z kluczy nazywany jest kluczem publicznym i jest dostępny dla osób szyfrujących dane lub chcących sprawdzić zaszyfrowane dane.

Funkcja skrótu

Skrót jest procesem mapowania danych binarnych o zmiennej długości na dane binarne określonej długości.
kiedy chcemy mieć pewność, że dane nie zostały zmodyfikowane podczas transportu to możemy strwożyć ich skrót przed wysłaniem i przesłać razem z danymi w celu weryfikacji zgodności.
Dwa powszechnie stosowane algorytmy to SHA256 i SHA512.

Zarządzanie kluczami

klucze symetryczne mogą być wymieniane używając algorytmów asymetrycznych.
Asymetryczne klucze prywatne mogą być zabezpieczone używając certyfikatu lub kontenera Crypto Service Providers.

Wersja assembly

Wersja assembly składa się z czterech części: Major, Minor, Build i Revision.

Silne nazwy

Assembly podpisane cyfrowo jest nazywane assembly o silnej nazwie.
Silna nazwa posiada pięć części: Friendly Name, Version, Culture, Public Key Token i Processor Architecture.

GAC

Rozwinięcie skrótu to Global Assembly Cache.
GAC jest repozytorium współdzielonych assembly w .Net.
Do GAC mogą być wdrażane tylko assembly z silną nazwą.
W GAC może się znajdować więcej niż jedna wersja tej samej assembly.

X. Sprawdzania poprawności danych wejściowych, debugowanie i instrumentacja

Fri, 11 Mar 2016 14:32:25 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Walidacja - sprawdzania poprawności danych wejściowych i użycie wyrażeń regularnych.
Debugowanie aplikacji - tworzenie i użycie dyrektyw procesora, użycie klas Debug i Trace o podgląd niepożądanych wartości.
Diagnostyka - użycie narzędzi takich jak profiler, event log i performance counter.

Sprawdzania poprawności danych wejściowych

Poniższa lista podsumowuje trzy etapy sprawdzania poprawności danych od najczęściej stosowanego i najmniej inwazyjnego do najrzadziej stosowanego i najbardziej inwazyjnego:

Walidacja aktywacji przycisku - program może zignorować każdy przycisk który jest nieodpowiedni lecz pozwala na wszystkie które mogą prowadzić do poprawnych danych np znak “-” może rozpoczynać liczbę “-.123”. Opcjonalnie, można oznaczyć pole zawierające niewłaściwą wartość tak aby nie przerywała pracy użytkownika.
Walidacja pola - Kiedy przechodzimy z zaznaczeniem do innego pola, program może sprawdzić poprawność jego wartości i oznaczyć niewłaściwą wartość. Program powinien wyświetlać informację, że wartość jest niepoprawna lecz nie powinien wymuszać jej natychmiastowego poprawienia na użytkowniku.
Walidacja formularza - kiedy użytkownik próbuje zaakceptować cały formularz, program powinien sprawdzić wszystkie jego wartości i wyświetlić wiadomość informującą o zaistniałych błędach jeżeli istnieją. Jest to jedyne miejsce w którym program powinien wymusić poprawienie błędów na użytkowniku. Jest to również miejsce w którym program może sprawdzić poprawność pomiędzy różnymi zależnymi polami.

Użycie funkcji wbudowanych

Jedną z najprostszych metod walidacji danych jest sprawdzenie czy użytkownik wprowadził żądaną wartość. Jeżeli wartość byłą wprowadzona w polu tekstowym TextBox, to program może sprawdzić jej długość.
Poniższy fragment kodu sprawdza czy zawartość pola tekstowego jest pusta:

if (emailTextBox.Text.Length == 0)
{
// The email field is blank. Display an error message.
//...
}

Dla innych typów kontrolek program musi sprawdzać inne właściwości kontrolki aby dowiedzieć się czy użytkownik dokonał wyboru wartości. Przykładowo dla ListBox lub ComboBox te właściwości to SelectedIndex i SelectedItem. Aby sprawdzić czy użytkownik wybrał wartość należy użyć sprawdzenia SelectedIndex == -1 lub SelectedItem == null.
Kiedy wartość nie jest pusta, program może sprawdzać dodatkowo czy wartość ma sens. Przykładowo wartość test nie jest poprawnym adresem e-mail.

Język C# posiada wbudowane metody służące do sprawdzania poprawności danych wejściowych. Jednymi z najbardziej przydatnych metod są metody TryParse typów wbudowanych. Metody TryParse próbują parsować ciąg znaków i zwracają true jeżeli im się uda.
Poniższy fragment kodu sprawdza czy pole tekstowe zawiera poprawną wartość waluty:

decimal cost;
if (!decimal.TryParse(costTextBox.Text,
    NumberStyles.Currency,
    CultureInfo.CurrentCulture,
out cost))
{
// Cost is not a valid currency value. Display an error message.
//...
}

Enumeracje NumberStyles i CultureInfo znajdują się w przestrzeni nazw System.Globalization.

Użycie metod klasy String

Klasa String posiada kilka metod które mogą być użyteczne przy sprawdzaniu poprawności danych wejściowych.
Poniższa lista przedstawia większość użytecznych metod:

Contains - zwraca true jeżeli ciąg zawiera wybrany podciąg.
EndsWith - zwraca true jeżeli ciąg jest zakończony wybranym podciągiem.
IndexOf - zwraca pozycję wybranego podciągu w ciągu, opcjonalnie mozna rozpocząć przeszukiwanie od określonej pozycji.
IndexOfAny - zwraca pozycję któregokolwiek z wybranych znaków, opcjonalnie mozna rozpocząć przeszukiwanie od określonej pozycji.
IsNullOrEmpty - zwraca true jeżeli ciąg jest pusty lub null.
IsNullOrWhitespace - zwraca true jeżeli ciąg jest null, pusty lub zawiera tylko znaki spacji i tabulacji.
LastIndexOf - zwraca pozycję ostatniej lokalizacji podciągu w ciągu.
LastIndexOfAny - zwraca ostatniąpozycję któregokolwiek z wybranych znaków.
Remove - usuwa znaki z ciągu.
Replace - zastępuje podciąg lub znak innym.
Split - zwraca tablicę podciągów podzieloną wg wybranego zestawu znaków.
StartsWith - zwraca true jeżeli ciąg rozpoczyna się od wybranego podciągu.
Substring - zwraca podciąg na wyznaczonej pozycji.
ToLower - zwraca ciąg z zamienionymi wszystkimi znakami na małe litery.
ToUpper - zwraca ciąg z zamienionymi wszystkimi znakami na duże litery.
Trim - zwraca ciąg z usuniętymi białymi znakami na początku i na końcu ciągu.
TrimEnd - zwraca ciąg z usuniętymi białymi znakami na końcu ciągu.
TrimStart - zwraca ciąg z usuniętymi białymi znakami na początku ciągu.

Użycie wyrażeń regularnych

Wyrażenia regularne są elastycznym językiem służącym do odnajdywania wzorców w tekście. Wyrażenia regularne pozwalają programowi ustalić czy ciąg znaków pasuje do wzorca, znaleźć fragmenty w tekście które pasują do wzorca i zamienić części ciągu na nowe wartości.
Klasa Regex z przestrzeni nazw System.Text.RegularExpressions służy do pracy z wyrażeniami regularnymi.
Najczęściej używane metody klasy Regex:

IsMatch - zwraca true jeśli wyrażenie regularne dopasowuje ciąg.
Match - szuka pierwszego wystąpienia podciągu który pasuje do wyrażenia regularnego.
Matches - zwraca kolekcję z informacjami o wszystkich częściach ciągu które pasują do wyrażenia regularnego.
Replace - zastępuje niektóre lub wszystkie części ciągu które pasują do wyrażenia regularnego.
Split - dzieli ciąg do tablicy podciągów oddzielonych tekstem pasującym do wyrażenia regularnego.

Większość tych metod posiada przeciążone wersje. Większość z nich pobiera ciąg jako parametr i może opcjonalnie pobrać drugi parametr którym jest wyrażenie regularne. Jeżeli nie użyjemy parametru z wyrażeniem regularnym to zostanie użyte wyrażenie które podaliśmy w konstruktorze.
Klasa Regex posiada również statyczną wersję tych metod które zawsze pobierają ciąg i wyrażenie regularne jako parametry.

Wyrażenia regularne są kombinacją literałów i znaków które mają specjalne znaczenie. Przykładowo sekwencja [a-z] oznacza, że obiekt Regex powinien dopasować każdy pojedynczy znak z zakresu od “a” do “z”.
Wyrażenia regularne mogą zawierać również sekwencje znaków specjalnych zwanych escape sequences które reprezentują pewne specjalne wartości. Przykładowo sekwencja \b oznacza granicę wyrazu a \d oznacza jakąkolwiek cyfrę.
Czasami program musi użyć znaku nawet jeżeli wygląda on jak znak specjalny. Przykładowo znak [ zwykle oznacza rozpoczęcie zakresu znaków. Jeżeli chcemy użyć dokładnie znaku [ musimy dołożyć do niego znak ucieczki jaki jest ** czyli użyć sekwencji [**.

Ucieczki znakowe

Lista najczęściej wykorzystywanych znaków ucieczki:

\t - dopasowuje tabulację.
\n - dopasowuje nową linię.
\nnn - dopasowuje znak z kodem ASCII podanym jako dwie lub trzy cyfry ósemkowe nnn.
\xnn - dopasowuje znak z kodem ASCII podanym jako dwie lub trzy cyfry szesnastkowe nnn.
\unnn - dopasowuje znak z kodem ASCII podanym jako cztery cyfry szesnastkowe nnnn.

Klasy znaków

Lista najczęściej wykorzystywanych klas znaków:

[chars] - dopasowuje znak do znaków w nawiasie, np [aeiou] dopasowuje małą pojedynczą samogłoskę.
[^chars] - dopasowuje pojedynczy znak do znaków które nie są w nawiasie.
[first-last] - dopasowuje znak do zakresu znaków w nawiasie, np [a-zA-Z] dopasowuje jakąkolwiek literę.
. - znak wieloznaczny, który dopasowuje dowolny pojedynczy znak z wyjątkiem \n.
\w - ekwiwalent [a-zA-Z_0-9].
\W - ekwiwalent [^a-zA-Z_0-9].
\s - dopasowuje pojedynczy biały znak.
\S - dopasowuje dowolny pojedynczy znak który nie jest białym znakiem.
\d - ekwiwalent [0-9].
\D - ekwiwalent [^0-9].

Kotwice

Kotwice reprezentują stan ciągu znaków. Lista najczęściej wykorzystywanych kotwic:

^ - dopasowuje początek linii lub ciągu znaków.
$ - dopasowuje koniec linii lub ciągu znaków albo przed \n na końcu linii lub ciągu znaków.
\A - dopasowuje początek ciągu znaków.
\z - dopasowuje koniec ciągu znaków.
\Z - dopasowuje koniec ciągu znaków lub przed \n na końcu ciągu znaków.
\G - dopasowuje koniec poprzedniego dopasowania.

Konstrukcje grupujące

Konstrukcje grupujące pozwalają na zdefiniowanie grup dopasowanych fragmentów ciągu. Przykładowo w numerze telefonu 234-567-8901 można zdefiniować grupy przechowujące części 234, 567 i 8901. Program może później użyć tych grup w kodzie lub w tym samym wyrażeniu regularnym.
Najczęściej wykorzystywanymi rodzajami grup są grupy numerowane i nazwane.
Aby utworzyć grupę numerowaną należy zamknąć wyrażenie regularne w nawiasie okrągłym i nadać numer grupie zaczynając od 1, np (\w)\1.
Aby utworzyć grupę nazwaną należy użyć składni (?subexpression), np (?\w).

Kwantyfikatory

Kwantyfikatory pozwalają na dopasowanie poprzedniego elementu określoną ilość razy, np \d{3} dopasowuje jakąkolwiek cyfrę trzy razy. Lista najczęściej wykorzystywanych kwantyfikatorów:

* - dopasowuje poprzedni element 0 lub więcej razy.
+ - dopasowuje poprzedni element 1 lub więcej razy.
? - dopasowuje poprzedni element 0 lub 1 raz.
{n} - dopasowuje poprzedni element n razy.
{n,} - dopasowuje poprzedni element n lub więcej razy.
{n,m} - dopasowuje poprzedni element od n do m razy.

Przemienność

Przemienność pozwala na użycie znaku | aby pozwolić na dopasowanie do jednego z dwóch wyrażeń, np wyrażenie (yes|no) dopasowuje albo yes alno no.

Opcje wyrażeń regularnych

Program może ustawić opcje wyrażeń regularnych na trzy sposoby.
Pierwszym jest użycie dodatkowego parametru w metodzie obiektu klasy Regex. Parametr jest zdefiniowany jako enumerator RegexOptions.
Drugim sposobem jest użycie składni (?options) w wyrażeniu regularnym. Znak - na początku opcji wyłącza wybrane opcje.
Trzecim sposobem jest użycie składni (?options:subexpression) w wyrażeniu regularnym. Fragment subexpression oznacza część wyrażenia do której opcje mają być zastosowane.
Lista możliwych opcji:

i - ignoruj wielkość liter.
m - wielowierszowy, znaki ^ i $ oznaczają początek i koniec linii.
s - jedna linia, znak . dopasowuje wszystkie znaki włącznie z \n.
n - jawne przechwytywanie, nie przechwytuje grup anonimowych.
x - ignoruj białe znaki we wzorcu i pozwala na użycie komentarzy po znaku #.

Poniższy przykład przedstawia wyrażenie regularne testujące czy podany numer jest poprawnym numerem telefonu w USA:

// Perform simple validation for a 7-digits US phone number.
privatevoidphone7TextBox_TextChanged(object sender, EventArgs e)
{
conststring pattern = @"^\d{3}-\d{4}$";
bool valid = false; 
string text = phone7TextBox.Text;

if (text.Length == 0) valid = true;

if (Regex.IsMatch(text, pattern)) valid = true;

if (valid) phone7TextBox.BackColor = SystemColors.Control;
else phone7TextBox.BackColor = Color.Yellow;
}

Integralność Danych

To, że dane przeszły walidację nie zawsze oznacza, że są poprawne. Nawet jeżeli użytkownik wprowadził poprawne dane to mogą one zostać uszkodzone przez niepoprawne kalkulacje wykonywane przez system. Dodatkowymi metodami pozwalającymi na uniknięcie tego typu błędów są asercje i walidacja poprawności danych w bazie danych.

Użycie walidacji w bazie danych

Jeżeli program używa bazy danych to można w niej dodać kontrole i ograniczenia aby nie pozwolić na zapisanie nieprawidłowych danych.
Silniki baz danych potrafią rozpoznać czy wartość jest pusta, posiada odpowiedni format, posiada unikalną wartość oraz potrafią rozpoznać relacje z innymi polami w tym samym lub innym rekordzie.

Użycie asercji

Innym sposobem na sprawdzenie integralności danych są asercje. Asercje są fragmentami kodu które deklarują pewne twierdzenie na temat danych i sprawdzają czy jest ono prawdziwe.
Jednym ze sposobów stworzenia asercji jest użycie klauzuli if aby przetestować dane i zgłoszenie wyjątku jeżeli dane są niepoprawne, np:

if (!Regex.IsMatch(zip, @"^\d{5}$"))
    throw new FormatException("ZIP code has an invalid format.");

Aby tworzyć prościej tego rodzaju asercje .NET Framework posiada klasę System.Diagnostic.Debug. Metoda Assert tej klasy testuje warunek i zgłasza wyjątek jeżeli nie jest prawdziwy. Poniższy fragment kodu jest ekwiwalentem poprzedniego z użyciem klasy Debug:

Debug.Assert(Regex.IsMatch(zip, @"^\d{5}$"));

Metoda Assert jest wykonywana tylko trybie debug programu.

Debugowanie

Środowisko programistyczne Visual Studio posiada narzędzi do interaktywnego debugowania aplikacji. Pułapki oraz podgląd wartości zmiennych za pomocą okna watches oraz zdolność do przechodzenie kodu krok po kroku pozwalają śledzić działanie aplikacji. Pułapki mogą dodatkowo posiadać warunki które musi spełnić kod aby zostały uruchomione, filtry oraz liczniki wykonania.

Dyrektywy procesora

Dyrektywy procesora mówią kompilatorowi języka C# jak ma wykonywać kod. Pozwalają na wykluczenie fragmentu kodu z kompilacji, zdefiniowanie symboli do użycia w zarządzanym kodzie oraz pogrupowanie fragmentów kodu.

Lista dyrektyw procesora:

#define i #undef
Dyrektywa #define definiuje symbol procesora lub warunkowy symbol kompilacji dla modułu który zawiera dyrektywę. Później można użyć dyrektyw #if lub #elif aby sprawdzić czy symbol został zdefiniowany.
Do symbolu nie można przypisać wartości. Można jedynie zdefiniować lub usunąć symbol oraz sprawdzić czy został zdefiniowany.
Można również użyć Visual Studio aby zdefiniowało symbole dla całego projektu. Aby tego dokonać we właściwościach projektu w zakładce Build definiujemy wybrane symbole w polu tekstowym Conditional Compilation Symbols.
Dyrektywa #undef usuwa symbol.
Obie dyrektywy #define i #undef mogą być używane jedynie na początku pliku więc dyrektywa #undef praktycznie służy tylko do usunięcia symboli zdefiniowanych na poziomie projektu.
#if, #elif, #else i #endif
Dyrektywy #if, #elif, #else i #endif działają jak instrukcje if, else i else if języka C# lecz testują istnienie symboli procesora a nie wyrażenia logiczne.
Dyrektywy #if i #elif testują czy symbol został zdefiniowany. Jeżeli tak to kod który zawierają zostaje dołączony do kompilacji, jeżeli symbol nie istnieje to kod zostaje wyłączony z kompilacji.
Kod dyrektywy #else jest włączony do kompilacji jeżeli żaden z symboli z dyrektyw #if i #elif nie został zdefiniowany.
Dyrektywa #endif kończy blok dyrektyw, np:

// Debug levels. Level 2 gives the most information.
#define DEBUG1
//#define DEBUG2
privatevoidVerifyInternetConnections()
{
#if DEBUG2
// Display lots of debugging information.
//...
#elif DEBUG1
// Display some debugging information.
//...
#else
// Display minimal debugging information.
//...
#endif
// Verify the connections.
...
}

Można również testować równoczesne istnienie kilku symboli używając operatorów != i == oraz nawiasów jeżeli konieczna jest kolejność, np:

#if DEBUG1 == DEBUG2

Wartości true oraz false mogą być uzyte do reprezentowania istnienia symboli, poniższe trzy wyrażenia są sobie równoważne:

#if DEBUG1
#if DEBUG1 == true
#if DEBUG1 != false

#warning i #error
Dyrektywa #warning generuje ostrzeżenie które wyświetla się w oknie Error List w Visual Studio. Edytor kodu podkreśla ostrzeżenie falowaną zieloną linią.
Przykładowym użyciem jest oznaczenie kodu który jest przestarzały, np:

#if OLD_METHOD
#warning Using obsolete methodtocalculatefees.
//...
#else
//...
#endif

Dyrektywa #error jest podobna do #warning z tą różnicą, że zamiast ostrzeżenia generuje błąd i nie pozwala na poprawne zbudowanie projektu. Edytor w Visual Studio podkreśla błąd czerwoną falowaną linią.

#line
Dyrektywa #line pozwala zmienić numer linii w programie oraz opcjonalnie nazwę pliku która jest opisana w oknie ostrzeżeń, błędów i stosu.
Poniższy fragment kodu wyświetla śledzenie stosu ze zmienionym numerem linii i nazwą pliku:

#line 10000 "Geometry Methods"
    Console.WriteLine("********** " + Environment.StackTrace);

Dyrektywa #line default przywraca linię zmienioną wcześniej przez dyrektywę #line.
Dyrektywa #line hidden ukrywa linię przed debuggerem.

#region i #endregion
Dyrektywy #region i #endregion tworzą nazwany region w kodzie który może być zwijany i rozwijany. Nazwa regionu nie jest obowiązkowa, np:

#region Sales Routines
// Sales routines go here...
#endregion Sales Routines

#pragma warning
Dyrektywa #pragma daje specjalną instrukcję kompilatorowi, potencjalnie umożliwiając tworzenie nowych instrukcji preprocesora. Język C# pozwala na użycie dyrektyw #pragma warning i #pragma checksum
Dyrektywa #pragma warning może włączyć i wyłączyć konkretne ostrzeżenie. Rozważmy następujący fragment kodu:

privateclass OrderItem
{
publicstring Description;
publicint Quantity = 0;
public decimal UnitPrice = 0;
}

Pole Description nie zostało zainicjowane i Visual Studio w czasie budowania projektu zgłosi następujące ostrzeżenie:

Field ‘Description’ is never assigned to, and will always have its default value null.

Poniższy fragment kodu pozwala na pominięcie tego ostrzeżenia:

privateclass OrderItem
{
#pragmawarning disable 0649
publicstring Description;
#pragmawarning restore 0649
publicint Quantity = 0;
public decimal UnitPrice = 0;
}

#pragma checksum
Dyrektywa #pragma checksum generuje sumę kontrolną dla pliku, np:

#pragma checksum "filename""{guid}""bytes"

Debug i Trace

Klasy Debug i Trace świadczą usługi, które wysyłają wiadomości do obiektów słuchacza. Domyślnie jedynym słuchaczem jest instancja klasy DefaultTraceListener która wysyła wiadomości do okna Output.

Klasa Debug jest ignorowana w wydaniach release. Dzieje się tak ponieważ do budowania projektu w wersji debug dodawany jest symbol DEBUG a w wersjach release nie. To domyślne zachowanie można zmienić we właściwościach budowania projektu. Można również stworzyć własne wersje budowania projektu które mogą również zawierać symbol DEBUG.
Można również użyć dyrektyw #define i #undef aby zdefiniować symbol DEBUG. Przykładowo można zdefiniować symbol DEBUG w wybranym module aby móc użyć metody Debug.Assert.

Klasa Trace która jest również zdefiniowana w przestrzeni nazw System.Diagnostic, jest podobna do klasy Debug z tą różnicą, że jest kontrolowana przez symbol TRACE.

Klasy Debug i Trace posiadają wiele wspólnych metod. Poniżej lista najważniejszych z nich:

Assert - sprawdza warunek logiczny i zgłasza wyjątek jeżeli jest fałszywy.
Fail - emituje wiadomość błędu do obiektów nasłuchujących. Efekt jest podobny wyjątku zgłaszanego przez metodę Assert.
Flush - opróżnia wyjście do słuchaczy.
Indent - zwiększenie poziomu wcięcia o 1. pomaga to formatować wysyłane wiadomości.
Unindent - zmniejsza poziomu wcięcia o 1.
Write - zapisuje wiadomość do obiektów nasłuchujących.
WriteIf - zapisuje wiadomość do obiektów nasłuchujących jeżeli spełniony jest wyznaczony warunek logiczny.
WriteLine - zapisuje wiadomość do obiektów nasłuchujących i dodaje nową linię.
WriteLineIf - jeżeli spełniony jest wyznaczony warunek logiczny to zapisuje wiadomość do obiektów nasłuchujących i dodaje nową linię.

Listeners

Klasy Debug i Trace posiadają kolekcje Listeners w których znajduja się referencje do obiektów nasłuchujących. Domyślnie te kolekcje inicjowane są referencją do obiektu DefaultTraceListener.
Aby skierować wyjście do innych lokalizacji należy dodać obiekt nasłuchu do kolekcji Listeners. Lista niektórych innych klas nasłuchu których można użyć:

ConsoleTraceListener - kieruje wyjście do okna Console.
EventLogTraceListener - kieruje wyjście do dziennika zdarzeń.
TextWriterTraceListener - kieruje wyjście do strumienia np FileStream. Pozwala to na zapis do dowolnego pliku.

Poniższy fragment kodu pokazuje jak stworzyć TextWriterTraceListener aby skierować wyjście do pliku TraceFile.txt:

using System.IO;
using System.Diagnostics;

privatevoidForm1_Load(object sender, EventArgs e)
{
// Create the trace output file.
    Stream traceStream = File.Create("TraceFile.txt");

// Create a TextWriterTraceListener for the trace output file.
    TextWriterTraceListener traceListener =
new TextWriterTraceListener(traceStream);
    Trace.Listeners.Add(traceListener);

// Write a startup note into the trace file.
    Trace.WriteLine("Trace started " + DateTime.Now.ToString());
}

W czasie działania można dodawać wiadomości przez obiekt Trace. Poniższy fragment kodu pokazuje jak dodawać informacje podczas przetwarzania zamówienia:

privatevoid processOrderButton_Click(object sender, EventArgs e)
{
// Log an order processing message.
    Trace.WriteLine("Processing order");

// Log the order's data.
    Trace.Indent();
    Trace.WriteLine("CustomerId: " + CustomerId);
    Trace.WriteLine("OrderId: " + OrderId);
    Trace.WriteLine("OrderItems:");
    Trace.Indent();
    foreach (OrderItem item in OrderItems)
        Trace.WriteLine(item.ToString());
    Trace.Unindent();
    Trace.WriteLine("ShippingAddress: " + ShippingAddress);
    Trace.Unindent();
// Process the order.
//...
}

Kiedy program dobiega końca może opróżnić buforowany tekst do pliku:

privatevoidForm1_FormClosing(object sender, FormClosingEventArgs e)
{
// Flush the trace output.
    Trace.WriteLine("Trace stopped " + DateTime.Now.ToString());
    Trace.Flush();
}

Programowanie plików bazy danych debugowania

Kiedy budujemy projekt w trybie bebug to Visual Studio tworzy plik bazy danych programu zawierający informacje o programie potrzebne do debugowania.
Aby kontrolować ilość informacji którą VS dodaje do pliku PDB należy użyć właściwości projektu. W zakładce Build wybieramy Advanced Build Settings i wybieramy z listy rozwijanej wartość full, pdb-only lub none.
Domyślnie wybrana jest opcja full tworząca w pełni debugowany program. Opcja pdb-only jest domyślna dla trybu release która potrafi wskazać gdzie wystąpiły wyjątki. Opcja none sprawia, że VS nie tworzy pliku bazy danych.

Instrumentacja aplikacji

Instrumentacja aplikacji oznacza dodanie do aplikacji funkcjonalności umożliwiających jej analizowanie. Zwykle jest to dodanie monitorowania wydajności, zapisu błędów i śledzenia wykonywania programu. Dzięki dobrej instrumentacji można zidentyfikować wąskie gardła w aplikacji bez krokowego śledzenia jej przebiegu za pomocą debugera.

Tracing

Tracing jest procesem instrumentacji programu polegającym na śledzeniu co jest wykonywane w aplikacji. Zwykle śledzenie odbywa się z pomocą klas Debug i Trace. Dodatkowo do zapisywanych informacji można dodać czas i datę wykonywania aby można było zbadać jak program zachowuje sie w różnym czasie.

Event Logs

Logowanie jest procesem instrumentacji programu polegającym na zapisywaniu kluczowych zdarzeń do dziennika.
Zapis do dziennika zdarzeń może odbywać się na różne sposoby. Można użyć klas Debug i Trace, choć ich przeznaczeniem jest raczej śledzenie. Można użyć zapisu do plik w odpowiednich sekcjach. Można użyć zewnętrznej biblioteki jak Log4Net lub NLog. Można również zapisywać zdarzenia do dziennikasystemowego.
Poniższy fragment kodu zapisuje zdarzenia do dziennika systemowego:

using System.Diagnostics;
//...
// Write an event log entry.
privatevoidwriteButton_Click(object sender, EventArgs e)
{
string source = sourceTextBox.Text;
stringlog = logTextBox.Text;
string message = eventTextBox.Text;
int id = int.Parse(idTextBox.Text);

// Create the source if necessary. (Requires admin privileges.)
if (!EventLog.SourceExists(source))
        EventLog.CreateEventSource(source, log);

// Write the log entry.
    EventLog.WriteEntry(source, message,
        EventLogEntryType.Information, id);
    MessageBox.Show("OK");
}

Zwykle użyteczna jest możliwość konfiguracji ilości logowanych zdarzeń. Pozwala to na zmniejszenie ilości zapisywanych informacji w środowiskach produkcyjnych aby zapis do dziennika nie wpływał na wydajność aplikacji.

Profiling

Profilowanie jest procesem zbierania informacji o programie służącym do późniejszego studiowania jego szybkości, pamięci, użycia zasobów i innych charakterystyk wydajnościowych. Istnieją dwa sposoby profilowania programu, za pomocą profilera lub poprzez instrumentowanie programu ręcznie.

Użycie profilera

Automatyczne profilery używają kilku podejść do profilowania aplikacji. Niektóre instrumentują kod źródłowy dodając wyrażenia badające czas do niektórych lub wszystkich metod programu. Inne instrumentują kod skompilowany. Jeszcze inne używają próbkowania CPU.
Visual Studio w edycjach Premium i Ultimate posiadają narzędzia służące do badania wydajności aplikacji.

Narzędzia te uruchamiamy wybierając w VS z menu Analyze i Launch Performance Wizard. Okno czarodzieja wygląda tak:

Opcja próbkowanie CPU cyklicznie sprawdza stan programu aby zobaczyć co jest wykonywane. Pozwala to zdiagnozować które procedury są najbardziej obciążające dla CPU.
Opcja instrumentacji może dostarczyć dokładniejszych informacji lecz dodaje instrumentacje do skopmilowanego kodu co może spowolnić działanie aplikacji.
Opcja .NET Memory Allocation używa próbkowania do zbierania informacji o uzyciu pamięci.

Opcja Resource Contention Data jest używana do badania współbieżności w aplikacjach wielowątkowych.

Opcja próbkowania CPU generuje wyniki podobne do poniższych:

Profilowanie ręczne

Program można profilować ręcznie poprzez wstawianie do kodu źródłowego fragmentów kodu zapisujących stan aplikacji oraz aktualny czas i czas wykonania.
Poniższy fragment kodu używa klasy Stopwatch do badania czasu wykonania:

privatevoidPerformCalculations()
{
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();

// Perform the calculations here.
//...

    Console.WriteLine("Time: " +
        stopwatch.Elapsed.TotalSeconds.ToString("0.00") +
" seconds");
}

Innym sposobem ręcznego profilowania jest użycie liczników wydajności.

Performance Counters

Liczniki wydajności śledzą system operacyjny, aby dać wyobrażenie o aktywności komputera.
Przykładowo przypuśćmy, że program procesujący zdjęcia skanuje folder w każdej minucie. Jeżeli odnajdzie w folderze zdjęcie, pobiera je, procesuje w jakiś sposób i przenosi do innego folderu. Można użyć liczników wydajności aby śledzić procesowanie każdego pliku. Później można użyć narzędzia systemowego Performance Monitor do zobrazowania zmian licznika podczas procesowania programu.

Liczniki wydajności można tworzyć za pomocą kodu (więcej na msdn), lub za pomocą Visual Studio.

W VS otwieramy okno Server Explorer, rozwijamy drzewo i wybieramy Performance Counters w którego menu kontekstowym dodajemy nową kategorię poprzez Create New Category.

Aby użyc licznika wydajności w programie należy utworzyć obiekt klasy PerformanceCounter z przestrzeni nazw System.Diagnostics. Poniższy fragment kodu demonstruje użycie utworzonego na zdjęciu licznika:

private PerformanceCounter totalImages, imagesPerSecond;

privatevoidForm1_Load(object sender, EventArgs e)
{
    totalImages = new PerformanceCounter();
    totalImages.CategoryName = "ImageProcessor";
    totalImages.CounterName = "Images processed";
    totalImages.MachineName = ".";
    totalImages.ReadOnly = false;

    imagesPerSecond = new PerformanceCounter();
    imagesPerSecond.CategoryName = "ImageProcessor";
    imagesPerSecond.CounterName = "Images per second";
    imagesPerSecond.MachineName = ".";
    imagesPerSecond.ReadOnly = false;
}

Kiedy mamy już utworzony obiekt licznika to program może inkrementować go kiedy wykonywana jest przez nas pożądana akcja.
Załóżmy, że program procesujący zdjęcia skanuje folder cyklicznie sprawdzając czy zawiera zdjęcia. Kiedy znajdzie plik to wywołuje następującą metodę:

privatevoidProcessImageFile(string filename)
{
// Process the file.
//...

// Increment the performance counters.
    totalImages.Increment();
    imagesPerSecond.Increment();
}

Aby zobaczyć efekt działania należy uruchomić systemowe narzędzie Performance Monitor.

IX. Praca z LINQ

Mon, 29 Feb 2016 23:17:03 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Zapytania LINQ - pisanie zapytań i metod z użyciem LINQ.
Manipulowanie danymi za pomocą LINQ - manipulowanie danymi za pomocą LINQ a w tym użycie projekcji, użycie złączeń, grupowanie kolekcji, metody agregujące, pobieranie określonej ilości wyników i pomijanie określonej liczby wyników.
Użycie LINQ to XML - tworzenie i modyfikacja danych z użyciem LINQ to XML.

Wyrażenia zapytan LINQ

Language Integrated Query (LINQ) jest aspektem języków w .NET Framework który umożliwia użycie ogólnej składni zapytań do wykonywania zapytań na kolekcjach, dokumentach XML, bazach danych oraz wszystkich typach wspierających interfejsy IEnumerable< T > lubIQueryable< T >.
Istnieją dwa rodzaje składni, które wykonują zapytania LINQ. Pierwszym są wyrażenia zapytań. Drugim są zapytania oparte o metody. Dla kompilatora wybór między tymi dwoma metodami jest nieistotny, należy wybrać metodę która bardziej nam odpowiada.

Kompilator konwertuje wyrażenia zapytań na zapytania oparte o metody w czasie kompilowania. Wyrażenia zapytań są czasem łatwiejsze do odczytu lecz istnieją operacje których nie można wykonać za pomocą wyrażeń zapytań.

Wyrażenia zapytań szukają w danych zapisanych w tablicy, kolekcji lub jakimkolwiek typie wspierającym interfejsy IEnumerable< T > lub IQueryable< T >. Składnia wyrażeń zapytań jest podobna do języka SQL.

Zanim powstało LINQ do wyszukiwania danych wykorzystywane były pętle. Poniższy przykład demonstruje wyszukanie parzystych liczb w tablicy za pomocą pętli foreach:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int[] evenNumbers = newint[5];
int evenIndex = 0;

foreach (int i in myArray)
{
if (i % 2 == 0)
    {
        evenNumbers[evenIndex] = i;
        evenIndex++;
    }
}

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Wyrażenia zapytań LINQ pozwalają na wykonanie zapytania na kolekcji z użyciem składni podobnej do SQL z tym wyjątkiem, że w C# kolejność wyrażeń jest inna. Korzyścią z użycia LINQ jest mniejsza ilość kodu i większa jego czytelność.
Poniższy fragment kodu wykonuje zapytanie LINQ na tablicy pobierające liczby parzyste:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var evenNumbers = from i in myArray
    where i % 2 == 0
    select i;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Zmienna evenNumbers została zadeklarowana jako var. Zmienna zdefiniowana jako var jest nazywana zmienną typu niejawnego. Oznacza to, że kompilator określa typ zmiennej bazując na wyrażeniu po prawej stronie instrukcji inicjującej. W tym wypadku kompilator wie, że wartości w zmiennej evenNumbers są typu int.

Klauzula from zawiera i in myArray. Kompilator niejawnie wie jakiego typu jest zmienna i bazując na type myArray. Jest to ekwiwalent instrukcji pętli foreach(int i in myArray). Zmienna i reprezentuje wyliczane wartości w tablicy.

W składni LINQ pierwszą klauzulą jest from, drugą where a ostatnią select. W klauzuli where należy używać operatora równoważności (==).

Klauzula select zwraca zmienną i. W tym wypadku oznacza to, że kod wyliczając tablicę powinien zwrócić wszystkie elementy spełniające warunek klauzuli where. Wykonując kod krokowo można zauważyć, że w momencie wykonywania pętli foreach kod powróci do zapytania LINQ. Dzieje się tak ponieważ zapytanie LINQ nie zostało wykonane do momentu kiedy zmienna evenNumbers została użyta. Nazywa się to wykonaniem odroczonym (ang. deferred execution). Jeżeli podejrzymy zmienną evenNumbers w oknie podglądu w czasie wykonywania to zauważymy, że nie posiada ona wartości i, że jest wykonywana za każdym razem kiedy elementy są wyliczane. Jeżeli źródło danych zostanie zmienione i wyliczymy elementy jeszcze raz to wynik będzie inny, np:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from i in myArray
    where i % 2 == 0
    select i;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

myArray[1] = 12;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Filtrowanie

Filtrowanie danych jest dokonywane z użyciem klauzuli where w zapytaniu. Ponieważ używamy języka C# to do złożonych operacji używamy operatorów and (&&) i or (||). W poprzednim przykładzie klauzula where zawiera wyrażenie i % 2 == 0. Takie wyrażenie nazywane jest predykatem. Predykat jest wyrażeniem porównującym które jest wykonywane dla każdego elementu w sekwencji.
Poniższy fragment kodu zwraca wszystkie liczby parzyste większe niż pięć z tablicy liczb:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from i in myArray
    where i % 2 == 0 && i > 5
    select i;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Można napisać wiele klauzul where w wyrażeniu zapytania. Oznacza to to samo jakbyśmy mieli wiele wyrażeń w klauzuli where złączonych operatorem &&.
Poniższy kod produkuje ten sam wynik co poprzedni:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from i in myArray
    where i % 2 == 0
    where i > 5
    select i;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Dla bardziej skomplikowanych warunków wymagających operatorów pierwszeństwa należy użyć nawiasów okrągłych ().

Należy zwrócić szczególna uwagę na to, że w wyrażeniu zapytania można użyć wywołania metod.
Poniższy fragment kodu wywołuje metodę IsEvenAndGT5 w wyrażeniu zapytania:

staticvoidRetrieveEvenNumberGT5V3()
{
int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    var evenNumbers = from i in myArray
        where IsEvenAndGT5(i)
        select i;
    foreach (int i in evenNumbers)
    {
        Debug.WriteLine(i);
    }
}

staticboolIsEvenAndGT5(int i)
{
return (i % 2 == 0 && i > 5);
}

Sortowanie

Wyniki działania zapytania można sortować za pomocą klauzuli orderby. Można sortować rosnąco i malejąco tak jak w języku SQL.
Poniższy fragment kodu sortuje parzyste wyniki w kolejności malejącej:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from i in myArray
    where i % 2 == 0
    orderby i descending
    select i;

foreach (int i in evenNumbers)
{
    Debug.WriteLine(i);
}

Można również sortować więcej właściwości poprzez oddzielenie ich przecinkiem.
Poniższy fragment kodu sortuje zwracane elementy alfabetycznie wg stanu a potem wg miasta:

classHometown
{
publicstring City { get; set; }
publicstring State { get; set; }
}

staticvoidOrderByStateThenCity()
{
    List<Hometown> hometowns = new List<Hometown>()
    {
new Hometown() { City = "Philadelphia", State = "PA" },
new Hometown() { City = "Ewing", State = "NJ" },
new Hometown() { City = "Havertown", State = "PA" },
new Hometown() { City = "Fort Washington", State = "PA" },
new Hometown() { City = "Trenton", State = "NJ" }
    };

var orderedHometowns = from h in hometowns
orderby h.State ascending, h.City ascending
select h;

foreach (Hometown hometown in orderedHometowns)
    {
        Debug.WriteLine(hometown.City + ", " + hometown.State);
    }
}

Projekcja

Klauzula select zwraca obiekty w sekwencji lub zwraca określoną liczbę właściwości obiektu w sekwencji. Pobranie określonej liczby właściwości lub transformacja wyniku do innego typu nazywana jest projekcją wyniku.
Poniższy fragment kodu demonstruje pobranie nazwisk osób z listy obiektów klasy Person:

classPerson
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicstring Address1 { get; set; }
publicstring City { get; set; }
publicstring State { get; set; }
publicstring Zip { get; set; }
}

privatestaticvoidProjectionV1()
{
    List<Person> people = new List<Person>()
    {
new Person()
            {
                FirstName = "John", 
                LastName = "Smith", 
                Address1 = "First St", 
                City = "Havertown", 
                State = "PA", 
                Zip = "19084"
            }, 
new Person()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                Address1 = "Second St", 
                City = "Ewing", 
                State = "NJ", 
                Zip = "08560"
            }, 
new Person()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                Address1 = "Third St", 
                City = "Ft Washington", 
                State = "PA", 
                Zip = "19034"
            }
    };

var lastNames = from p in people 
select p.LastName;

foreach (string lastName in lastNames)
    {
        Debug.WriteLine(lastName);
    }
}

Klauzula select pobiera p.LastName zamiast całego obiektu p. Kompilator ustala, że wynikiem powinna być lista typu string bazując na typie pobieranej właściwości.

Załóżmy teraz, że potrzebujemy zwrócić imię i nazwisko osób z listy.
Poniższy fragment kodu demonstruje pobranie imion i nazwisk osób z listy obiektów. zapytanie to tworzy typ anonimowy zawierający właściwości FirstName i LastName:

var names = from p in people
selectnew { p.FirstName, p.LastName };

foreach (var name in names)
{
    Debug.WriteLine(name.FirstName + ", " + name.LastName);
}

Właściwości typu anonimowego można jawnie nazwać używając poniższej składni:

var names = from p in people
selectnew { First = p.FirstName, Last = p.LastName };

foreach (var name in names)
{
    Debug.WriteLine(name.First + ", " + name.Last);
}

Złączenia

Do połączenia dwóch lub więcej sekwencji używana jest klauzula join.
Poniższy fragment kodu łączy dwie oddzielne listy po polu StateId:

classEmployee
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicint StateId { get; set; }
}

classState
{
publicint StateId { get; set; }
publicstring StateName { get; set; }
}

staticvoidJoin()
{
    List<Employee> employees = new List<Employee>()
    {
new Employee()
        {
            FirstName = "John",
            LastName = "Smith",
            StateId = 1
        },
new Employee()
        {
            FirstName = "Jane",
            LastName = "Doe",
            StateId = 2
        },
new Employee()
        {
            FirstName = "Jack",
            LastName = "Jones",
            StateId = 1
        }
    };

    List<State> states = new List<State>()
    {
new State()
        {
            StateId = 1,
            StateName = "PA"
        },
new State()
        {
            StateId = 2,
            StateName = "NJ"
        }
    };

var employeeByState = from e in employees
join s in states
            on e.StateId equals s.StateId
selectnew { e.LastName, s.StateName };

foreach (var employee in employeeByState)
    {
        Debug.WriteLine(employee.LastName + ", " + employee.StateName);
    }
}

Klauzula join używa operatora equal zamiast =. Łączone pola mogą być porównywane tylko tym operatorem. Nie można używać operatorów < i > tak jak w języku SQL.

Outer Join

Aby napisać zapytanie LINQ równorzędne z zapytaniem SQL używającym LEFT OUTER JOIN lub RIGHT OUTER JOIN należy użyć słowa kluczowego group join i metody DefaultIfEmpty. Słowo kluczowe group join pozwala połączyć dwie sekwencje i wstawić je do trzeciej sekwencji.

Dodajmy obiekt Employee do listy employees tak aby wartość pola StateId nie istniała w liście states:

new Employee()
{
    FirstName = "Sue",
    LastName = "Smith",
    StateId = 3
}

Poniższy kod demonstruje pobranie wszystkich elementów z listy employees nawet jeżeli nie ma dopasowania na liście states:

var employeeByState = from e in employees
join s in states 
                          on e.StateId equals s.StateId into employeeGroup
from item in
                          employeeGroup.DefaultIfEmpty(
new State { StateId = 0, StateName = string.Empty })
selectnew { e.LastName, item.StateName };

foreach (var employee in employeeByState)
{
    Debug.WriteLine(employee.LastName + ", " + employee.StateName);
}

Kombinacja list jest wstawiana do obiektu nazwanego employeeGroup poprzez użycie słowa kluczowego into. Druga klauzula from tworząca nową instancję obiektu State z wartościami StateId równą 0 i pustym ciągiem StateName kiedy nie istnieje dopasowanie po polu StateId. Kiedy używamy klauzuli into to nie możemy więcej odnieść się do zmiennej po prawej stronie klauzuli on. Zamiast tego używamy zmiennej która wylicza wartości do nowej sekwencji, w przykładzie jest to zmienna item.

Pisząc wyrażenia zapytań możemy wykonywać tylko złączenia lewostronne left join dla których kolejność zapisu jest istotna.

Klucze złożone

Czasami zachodzi sytuacja w której musimy dokonać złączenia sekwencji za pomocą więcej niż jednej właściwości. Aby tego dokonać tworzymy typ anonimowy zawierający właściwości które chcemy porównać w klauzuli join.

Przykładowo zmieńmy klasę Hometown tak aby posiadała właściwość CityCode oraz zmieńmy klasę Employee tak aby posiadała właściwości City i State a nie posiadała StateId:

classHometown
{
publicstring City { get; set; }
publicstring State { get; set; }
publicstring CityCode { get; set; }
}

classEmployee
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicstring City { get; set; }
publicstring State { get; set; }
}

Poniższy fragment kodu złącza dwie sekwencje używając właściwości City i State:

List<Employee> employees = newList<Employee>()
{
new Employee()
        {
            FirstName = "John", 
            LastName = "Smith", 
            City = "Havertown", 
            State = "PA"
        }, 
new Employee()
        {
            FirstName = "Jane", 
            LastName = "Doe", 
            City = "Ewing", 
            State = "NJ"
        }, 
new Employee()
        {
            FirstName = "Jack", 
            LastName = "Jones", 
            City = "Fort Washington", 
            State = "PA"
        }
};

List<Hometown> hometowns = newList<Hometown>()
{
new Hometown()
        {
            City = "Havertown", 
            State = "PA", 
            CityCode = "1234"
        }, 
new Hometown()
        {
            City = "Ewing", 
            State = "NJ", 
            CityCode = "5678"
        }, 
new Hometown()
        {
            City = "Fort Washington", 
            State = "PA", 
            CityCode = "9012"
        }
};

var employeeByState = from e in employees
join h in hometowns 
onnew { City = e.City, State = e.State } equals
new { City = h.City, State = h.State }
selectnew { e.LastName, h.CityCode };

foreach (var employee in employeeByState)
{
    Debug.WriteLine(employee.LastName + ", " + employee.CityCode);
}

W klauzuli join utworzone zostały dwa typy anonimowe z tymi samymi właściwościami. Równoważność jest określana poprzez porównanie wszystkich właściwości typów anonimowych.

Grupowanie

Bardzo często potrzeba nam pogrupować obiekty w celu zliczenia sum dla poszczególnych właściwości. Przykładowo możemy wykonać raport wyświetlający liczbę pracowników w każdym stanie. Aby tego dokonać można użyć klauzuli group w wyrażeniu zapytania.
Poniższy fragment kodu tworzy listę pracowników i grupuje ich wg stanu. Liczba pracowników dla każdego stanu jest wyświetlana w oknie Output:

privatestaticvoidGroup()
{
    List<Employee> employees = new List<Employee>()
                                   {
new Employee()
                                           {
                                               FirstName = "John", 
                                               LastName = "Smith", 
                                               City = "Havertown", 
                                               State = "PA"
                                           }, 
new Employee()
                                           {
                                               FirstName = "Jane", 
                                               LastName = "Doe", 
                                               City = "Ewing", 
                                               State = "NJ"
                                           }, 
new Employee()
                                           {
                                               FirstName = "Jack", 
                                               LastName = "Jones", 
                                               City = "Fort Washington", 
                                               State = "PA"
                                           }
                                   };

var employeesByState = from e in employees 
group e by e.State;

foreach (var employeeGroup in employeesByState)
    {
        Debug.WriteLine(employeeGroup.Key + ": " + employeeGroup.Count());

foreach (var employee in employeeGroup)
        {
            Debug.WriteLine(employee.LastName + ", " + employee.State);
        }
    }
}

W powyższym przykładzie nie ma klauzuli select. Jest to możliwe dlatego, że klauzula group zwraca kolekcję IGrouping<TKey,TElement>. Jest to kolekcja zawierająca właściwość dla klucza po którym sekwencja została pogrupowana.
W powyższym przykładzie są dwie pętle foreach. Pierwsza iteruje po kolekcji IGrouping i wyświetla właściwość Key oraz Count jako liczbę elementów w grupie. Wewnętrzna pętla iteruje po elementach każdej grupy i wyświetla nazwisko i stan dla każdego pracownika w grupie.

W klauzuli group by można dodać logikę grupującą po dowolnych właściwościach.
Poniższy przykład grupuje liczby parzyste i nieparzyste oraz wyświetla ich liczbę:

staticvoidGroupV2()
{
int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    var groupedNumbers = from i in myArray
        group i by(i % 2 == 0 ? "Even" : "Odd");

    foreach (var groupNumber in groupedNumbers)
    {
        Debug.WriteLine(groupNumber.Key + ": " + groupNumber.Sum());
        foreach(var number in groupNumber)
        {
            Debug.WriteLine(number);
        }
    }
}

Grupując sekwencje można również użyć klauzuli select, ale trzeba również użyć słowa kluczowego into w klauzuli group.
Poniższy fragment kodu demonstruje wyświetlenie liczb parzystych i nieparzystych oraz ich liczby:

privatestaticvoidGroupV3()
{
int[] myArray = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    var groupedNumbers = from i in myArray
                         group i by i % 2 == 0 ? "Even" : "Odd"
                         into g select new { Key = g.Key, SumOfNumbers = g.Sum() };

    foreach (var groupNumber in groupedNumbers)
    {
        Debug.WriteLine(groupNumber.Key + ": " + groupNumber.SumOfNumbers);
    }
}

Zapytania oparte o metody

Wszystkie instrukcje które można wyrazić za pomocą wyrażeń zapytań LINQ można również napisać za pomocą zapytań LINQ opartych o metody. Funkcjonalnie są one równoważne lecz posiadają inną składnię.

Zapytania LINQ oparte o metody są metodami rozszerzającymi znajdującymi się w przestrzeni nazw System.Linq. Metody te rozszerzają wszystkie typy implementujące interfejsy IEnumerable lub IQueryable. Metody zapytań jako parametr przyjmują wyrażenia lambda, które reprezentują logikę która ma zostać wykonana w czasie enumeracji sekwencji.
Przypomnijmy prosty przykład wyrażenia zapytania LINQ które zwraca parzyste liczby z tablicy:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = from i in myArray
    where i % 2 == 0
    select i;

Równoważne zapytanie oparte o metody rozszerzające LINQ wygląda następująco:

int[] myArray = newint[10] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var evenNumbers = myArray.Where(i => i % 2 == 0);

Zmienna i reprezentuje element w tablicy a kod po prawej stronie operatora => reprezentuje logike wykonywaną w czasie enumeracji tablicy.

Filtrowanie

Filtrowanie danych odbywa się z użyciem metody Where do której przekazujemy wyrażenie lambda jako parametr które zwraca wartość typu bool a metoda zwraca tylko te elementy sekwencji które spełniają warunek, np:

myArray.Where(i => i % 2 == 0)

W metodzie Where można używać operatorów (&&) lub (||), np:

var evenNumbers = myArray.Where(i => i % 2 == 0 && i > 5);

Jeżeli wymagamy operatora pierwszeństwa operacji to zamiast niego możemy użyć wielu metod Where, np:

var evenNumbers = myArray.Where(i => i % 2 == 0).Where(i => i > 5);

Sortowanie

Sekwencje można sortować używając metod OrderBy lub OrderByDescending, np:

var evenNumbers = myArray.Where(i => i % 2 == 0).OrderByDescending(i => i);

Jeżeli musimy sortować po więcej niż jednej właściwości służą do tego metody ThenBy lub ThenByDescending, np:

staticvoid MethodBasedOrderByStateThenCity()
{
List<Hometown> hometowns = newList<Hometown>()
    {
new Hometown() { City = "Philadelphia", State = "PA" },
new Hometown() { City = "Ewing", State = "NJ" },
new Hometown() { City = "Havertown", State = "PA" },
new Hometown() { City = "Fort Washington", State = "PA" },
new Hometown() { City = "Trenton", State = "NJ" }
    };

var orderedHometowns = hometowns.OrderBy(h => h.State).ThenBy(h => h.City);

    foreach (Hometown hometown in orderedHometowns)
    {
        Debug.WriteLine(hometown.City + ", " + hometown.State);
    }
}

Projekcja

Można dokonywać projekcji obiektów za pomocą metody Select, np:

private static void MethodBasedProjectionV1()
{
    List<Person> people = new List<Person>()
    {
        new Person()
            {
                FirstName = "John", 
                LastName = "Smith", 
                Address1 = "First St", 
                City = "Havertown", 
                State = "PA", 
                Zip = "19084"
            }, 
        new Person()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                Address1 = "Second St", 
                City = "Ewing", 
                State = "NJ", 
                Zip = "08560"
            }, 
        new Person()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                Address1 = "Third St", 
                City = "Ft Washington", 
                State = "PA", 
                Zip = "19034"
            }
    };

    var lastNames = people.Select(p => p.LastName);

    foreach (string lastName in lastNames)
    {
        Debug.WriteLine(lastName);
    }
}

W metodzie Select można tworzyć typy anonimowe tak samo jak w wyrażeniach zapytań. Jedyną różnicą jest konieczność użycia wyrażenia lambda.
Poniższy fragment kodu tworzy typ anonimowy z właściwościami FirstName i LastName:

private static void MethodBasedProjectionV2()
{
    List<Person> people = new List<Person>()
    {
        new Person()
            {
                FirstName = "John", 
                LastName = "Smith", 
                Address1 = "First St", 
                City = "Havertown", 
                State = "PA", 
                Zip = "19084"
            }, 
        new Person()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                Address1 = "Second St", 
                City = "Ewing", 
                State = "NJ", 
                Zip = "08560"
            }, 
        new Person()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                Address1 = "Third St", 
                City = "Ft Washington", 
                State = "PA", 
                Zip = "19034"
            }
    };

    var names = people.Select(p => new { p.FirstName, p.LastName });

    foreach (var name in names)
    {
        Debug.WriteLine(name.FirstName + ", " + name.LastName);
    }
}

Nazwy właściwości typów anonimowych można jawnie określać, np:

var names = people.Select(p => new { First = p.FirstName, Last = p.LastName });

Istnieje również metoda SelectMany którą można wykorzystać do spłaszczenia dwóch sekwencji do jednej sekwencji podobnie do działania join.
Poniższy przykład spłaszcza listy pracowników i stanów i zwraca kombinację tych list:

private staticvoid MethodBasedProjectionV4()
{
List<Employee> employees = newList<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                StateId = 2
            }, 
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }
    };

List<State> states = newList<State>()
    {
new State() { StateId = 1, StateName = "PA" }, 
new State() { StateId = 2, StateName = "NJ" }
    };

var employeeByState =
        employees.SelectMany(
            e => states.Where(s => e.StateId == s.StateId)
                       .Select(s => new { e.LastName, s.StateName }));

    foreach (var employee in employeeByState)
    {
        Debug.WriteLine(employee.LastName + ", " + employee.StateName);
    }
}

Złączenia

Metoda Join pozwala na złączenie dwóch sekwencji używając wspólnej właściwości lub zestawu właściwości.
Poniższy fragment kodu łączy listę pracowników z listą stanów używając właściwości StateId:

private staticvoid MethodBasedJoin()
{
List<Employee> employees = newList<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                StateId = 2
            }, 
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }
    };

List<State> states = newList<State>()
    {
new State() { StateId = 1, StateName = "PA" }, 
new State() { StateId = 2, StateName = "NJ" }
    };

var employeeByState = employees.Join(
        states, 
        e => e.StateId, 
        s => s.StateId, 
        (e, s) => new { e.LastName, s.StateName });

    foreach (var employee in employeeByState)
    {
        Debug.WriteLine(employee.LastName + ", " + employee.StateName);
    }
}

Lista employees jest rozważana jako sekwencja zewnętrzna. Pierwszym parametrem metody Join jest sekwencją którą chcemy złączyć, w przykładzie states, która jest rozważana jako sekwencja wewnętrzna. Drugim parametrem jest klucz złączenia sekwencji zewnętrznej. Trzecim parametrem jest klucz złączenia sekwencji wewnętrznej. Domyślnie użyte zostanie porównanie równoważności sekwencji. Czwartym parametrem jest wyrażenie lambda tworzące wynik złączenia.

Outer Join

Złączenia typu Outer Join są realizowane za pomocą metody GroupJoin.
Poniższy przykład realizuje left join list pracowników i stanów. Jeżeli nie ma połączenia w liście stanów to nazwa stanu będzie pusta:

privatestatic void MethodBasedOuterJoin()
{
List<Employee> employees = newList<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                StateId = 2
            }, 
new Employee()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                StateId = 1
            }, 
new Employee()
            {
                FirstName = "Sue", 
                LastName = "Smith", 
                StateId = 3
            }
    };

List<State> states = newList<State>()
    {
new State() { StateId = 1, StateName = "PA" }, 
new State() { StateId = 2, StateName = "NJ" }
    };

var employeeByState =
        employees.GroupJoin(
            states, 
            e => e.StateId, 
            s => s.StateId, 
            (e, employeeGroup) => employeeGroup.Select(
                s => new { LastName = e.LastName, StateName = s.StateName })
                .DefaultIfEmpty(new { LastName = e.LastName, StateName = string.Empty }))
                .SelectMany(e => e);

foreach (var employee in employeeByState)
    {
        Debug.WriteLine(employee.LastName + ", " + employee.StateName);
    }
}

Pierwsze trzy parametry metody GroupJoin są analogiczne do metody Join.
Czwarty parametr jest wyrażeniem lambda dla sekwencji zewnętrznej i nowej listy utworzonej analogicznie do słowa kluczowego into używanego w wyrażeniach zapytań, którą dowolnie nazywamy, w przykładzie to employeeGroup.
Używamy metody Select do wyliczenia wszystkich wartości w sekwencji employeeGroup i metody DefaultIfEmpty kiedy nie ma dopasowania pomiędzy sekwencjami. Na konie należy wywołać metodę SelectMany aby zwrócić sekwencję obiektów.

Klucze złożone

Klucze złożone tworzymy poprzez typy anonimowe.
Poniższy fragment kodu demonstruje połączenie sekwencji po dwóch właściwościach:

private staticvoid MethodBasedCompositeKey()
{
List<Employee> employees = newList<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                City = "Havertown", 
                State = "PA"
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                City = "Ewing", 
                State = "NJ"
            }, 
new Employee()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                City = "Fort Washington", 
                State = "PA"
            }
    };

List<Hometown> hometowns = newList<Hometown>()
    {
new Hometown()
            {
                City = "Havertown", 
                State = "PA", 
                CityCode = "1234"
            }, 
new Hometown()
            {
                City = "Ewing", 
                State = "NJ", 
                CityCode = "5678"
            }, 
new Hometown()
            {
                City = "Fort Washington", 
                State = "PA", 
                CityCode = "9012"
            }
    };

var employeeByState = employees.Join(
        hometowns, 
        e => new { City = e.City, State = e.State }, 
        h => new { City = h.City, State = h.State }, 
        (e, h) => new { e.LastName, h.CityCode });

    foreach (var employee in employeeByState)
    {
        Debug.WriteLine(employee.LastName + ", " + employee.CityCode);
    }
}

Grupowanie

Metoda GroupBy może zostać użyta do grupowania po jednym lub więcej polu. Jest ona równoważna do uzycia słowa kluczowego group w wyrażeniach zapytań.
Poniższy fragment kodu grupuje listę pracowników wg stanu:

privatestaticvoidMethodBasedGroupV1()
{
    List<Employee> employees = new List<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                City = "Havertown", 
                State = "PA"
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                City = "Ewing", 
                State = "NJ"
            }, 
new Employee()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                City = "Fort Washington", 
                State = "PA"
            }
    };

var employeesByState = employees.GroupBy(e => e.State);

foreach (var employeeGroup in employeesByState)
    {
        Debug.WriteLine(employeeGroup.Key + ": " + employeeGroup.Count());

foreach (var employee in employeeGroup)
        {
            Debug.WriteLine(employee.LastName + ", " + employee.State);
        }
    }
}

Metoda GroupBy zwraca kolekcję IGrouping<TKey, TElement>, która może zostać wyliczana aby wykonać funkcje agregujące na elementach grupy.
Jeżeli chcemy grupować po więcej niż jednym polu należy użyć typu anonimowego jako parametru metody GroupBy.
Poniższy fragment kodu grupuje pracowników wg miasta i stanu:

var employeesByState = employees.GroupBy(e => new { e.City, e.State });

Funkcje agregujące

Funkcje agregujące pozwalają na wykonanie operacji obliczeniowych takich jak average, sum, count, max i min na kolekcjach. Przykładowo mając listę reprezentującą faktury możemy szybko wykonać sumę faktury używając metody Sum. Te funkcje są dostępne jedynie jako metody ale można ich używać również w wyrażeniach zapytań.
Poniższy fragment kodu demonstruje wyrażenie zapytania oraz jego równoważne zapytanie bazujące na metodach dla przykładowych funkcji agregujących:

count

Wyrażenie:

intcount = (from i in myArray
where i % 2 == 0
select i).Count();

Metoda:

intcount = myArray.Where(i => i % 2 == 0).Count();

Można również odroczyć wykonanie zapytania używając następującej składni:

var evenNumbers = from i in myArray
where i % 2 == 0
select i;

int count = evenNumbers.Count();

average

Wyrażenie:

double average = (from i in myArray
where i % 2 == 0
select i).Average();

Metoda:

double average = myArray.Where(i => i % 2 == 0).Average();

sum

Wyrażenie:

intsum = (from i in myArray
where i % 2 == 0
select i).Sum();

Metoda:

intsum = myArray.Where(i => i % 2 == 0).Sum();

min

Wyrażenie:

intsum = (from i in myArray
where i % 2 == 0
select i).Min();

Metoda:

intsum = myArray.Where(i => i % 2 == 0).Min();

max

Wyrażenie:

intsum = (from i in myArray
where i % 2 == 0
select i).Max();

Metoda:

intsum = myArray.Where(i => i % 2 == 0).Max();

Pierwszy i ostatni element

Istnieją dwie dodatkowe funkcje które umożliwiają odnalezienie pierwszego i ostatniego elementu w sekwencji. Dostępne są jako metody ale można ich również użyć w wyrażeniach zapytań. Funkcje te mogą być użyteczne kiedy chcemy znaleźć w sekwencji pierwszy lub ostatni element który spełnia określony warunek, np pierwszy numer parzysty w sekwencji.

first

Wyrażenie:

int first = (from i in myArray
where i % 2 == 0
select i).First();

Metoda:

int first = myArray.Where(i => i % 2 == 0).First();

last

Wyrażenie:

int first = (from i in myArray
where i % 2 == 0
select i).Last();

Metoda:

int first = myArray.Where(i => i % 2 == 0).Last();

Konkatenacja

Metoda Concat pozwala na złączenie dwóch sekwencji w jedną na zasadzie podobnej do operatora UNION w języku SQL.
Poniższy fragment kodu złącza dwie listy pracowników w jedną:

private staticvoid Concat()
{
List<Employee> employees = newList<Employee>()
    {
new Employee() { FirstName = "John", LastName = "Smith" }, 
new Employee() { FirstName = "Jane", LastName = "Doe" }, 
new Employee() { FirstName = "Jack", LastName = "Jones" }
    };

List<Employee> employees2 = newList<Employee>()
    {
new Employee()
            {
                FirstName = "Bill", 
                LastName = "Peters"
            }, 
new Employee()
            {
                FirstName = "Bob", 
                LastName = "Donalds"
            }, 
new Employee()
            {
                FirstName = "Chris", 
                LastName = "Jacobs"
            }
    };

var combinedEmployees = employees.Concat(employees2);

    foreach (var employee in combinedEmployees)
    {
        Debug.WriteLine(employee.LastName);
    }
}

Należy uważać ponieważ typy obu złączanych ze sobą list nie muszą byś takie same. Można kombinować różne typy poprzez wybieranie typu anonimowego z każdej sekwencji.
Poniższy kod tworzy kombinację listy pracowników i listy osób tworząc typ anonimowy który zawiera tylko nazwiska:

private staticvoid ConcatV2()
{
List<Employee> employees = newList<Employee>()
    {
new Employee() { FirstName = "John", LastName = "Smith" }, 
new Employee() { FirstName = "Jane", LastName = "Doe" }, 
new Employee() { FirstName = "Jack", LastName = "Jones" }
    };

List<Person> people = newList<Person>()
    {
new Person() { FirstName = "Bill", LastName = "Peters" }, 
new Person() { FirstName = "Bob", LastName = "Donalds" }, 
new Person() { FirstName = "Chris", LastName = "Jacobs" }
    };

var combinedEmployees =
        employees.Select(e => new { Name = e.LastName })
            .Concat(people.Select(p => new { Name = p.LastName }));

    foreach (var employee in combinedEmployees)
    {
        Debug.WriteLine(employee.Name);
    }
}

Dzielenie sekwencji

Sekwencje można dzielić lub stronicować poprzez użycie metod Skip i Take.

Metoda Skip pobiera jako parametr liczbę całkowitą która określa ilość elementów które ma pominąć w sekwencji.
Poniższy fragment kody demonstruje pominięcie pierwszego elementu z listy pracowników:

var newEmployees = employees.Skip(1);

Metoda Take pobiera jako parametr liczbę całkowitą która określa ilość elementów które ma pobrać z sekwencji.
Poniższy fragment kody demonstruje pobranie dwóch elementów z listy pracowników:

var newEmployees = employees.Take(2);

Obie metody mogą być użyteczne przy stronicowaniu wyników zapytania.
Poniższy fragment kodu demonstruje pobranie trzeciej strony wyników wyświetlanych po 10:

var newEmployees = employees.Skip(20).Take(10);

Usuwanie duplikatów

Metoda Distinct zwraca listę niepowtarzających się wartości z sekwencji.
Poniższy fragment kodu zwraca niepowtarzające się liczby z tablicy:

int[] myArray = newint[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 };

var distinctArray = myArray.Distinct();

foreach (int i in distinctArray)
{
    Debug.WriteLine(i);
}

Aby używać metody Distinct na własnych typach należy implementować w nich interfejs IEquatable ponieważ metoda Distinct używa domyślnego porównywania równości obiektów. Interfejs IEquatable posiada metodę Equals do zaimplementowania która porównuje obiekty. Należy również nadpisać metodę GetHashCode obiektu tak aby zwracała kod skrótu na podstawie właściwości w swoim obiekcie.

Poniższy przykład demonstruje porównanie obiektów niestandardowych:

class State : IEquatable<State>
{
publicint StateId { get; set; }
publicstring StateName { get; set; }

publicboolEquals(State other)
{
if (Object.ReferenceEquals(this, other))
        {
returntrue;
        }
else
        {
if (StateId == other.StateId && StateName == StateName)
            {
returntrue;
            }
else
            {
returnfalse;
            }
        }
    }

public override intGetHashCode()
{
return StateId.GetHashCode() ^ StateName.GetHashCode();
    }
}

staticvoidDistinctCodeLab()
{
    List<State> states = new List<State>()
    {
new State(){ StateId = 1, StateName = "PA"},
new State() { StateId = 2, StateName = "NJ"},
new State() { StateId = 1, StateName = "PA" },
new State() { StateId = 3, StateName = "NY"}
    };

    var distintStates = states.Distinct();

    foreach (State state in distintStates)
    {
        Debug.WriteLine(state.StateName);
    }
}

Wykorzystanie LINQ to XML

LINQ to XML pozwala na łatwą konwersję sekwencji do dokumentu XML.
Poniższy fragment kodu konwertuje listę pracowników do XML:

private static void LINQToXML()
{
List<Employee> employees = newList<Employee>()
    {
new Employee()
            {
                FirstName = "John", 
                LastName = "Smith", 
                StateId = 1
            }, 
new Employee()
            {
                FirstName = "Jane", 
                LastName = "Doe", 
                StateId = 2
            }, 
new Employee()
            {
                FirstName = "Jack", 
                LastName = "Jones", 
                StateId = 1
            }
    };

var xmlEmployees = new XElement(
"Root", 
        from e in employees
select
new XElement(
"Employee", 
new XElement("FirstName", e.FirstName), 
new XElement("LastName", e.LastName)));

    Debug.WriteLine(xmlEmployees);
}

Wynik działania kodu:

<Root>
<Employee>
<FirstName>John</FirstName>
<LastName>Smith</LastName>
</Employee>
<Employee>
<FirstName>Jane</FirstName>
<LastName>Doe</LastName>
</Employee>
<Employee>
<FirstName>Jack</FirstName>
<LastName>Jones</LastName>
</Employee>
</Root>

Klasa XElement znajduje się w przestrzeni nazw System.Xml.Linq. Pierwszym parametrem konstruktora jest nazwa elementu. Drugim parametrem jest tablica parametrów ParamArray, co oznacza, że można przekazać zmienną liczbę argumentów do konstruktora.

Podsumowanie

Language Integrated Query LINQ

Obiekty implementujące interfejsy IEnumerable lub IQueryable mogą myć odpytywane za pomocą LINQ.
Wyniki zapytań LINQ są zwykle zwracane do zmiennej typu var, która jest zmienną typowaną niejawnie.

Wyrażenia zapytań

Wyrażenia zapytań zawierają klauzulę from i mogą zawierać klauzule select, group by, order by, where i join.
Złączenia join używają zawsze równoważności i dlatego używa się słowa kluczowego equals.
Wykonanie zapytania następuje w momencie jego wyliczenia. Można wymusić wykonanie zapytania używając funkcji agregującej.
Wiele operacji where jest równoważne z operatorem and.
Klauzula orderby jest używana do sortowania wyników, można oddzielić właściwości przecinkiem jeżeli chcemy sortować po więcej niż jednej.
W klauzuli select można utworzyć nowy typ dla wyników. Taka operacja nazywana jest projekcją.
Aby utworzyć złączenie zewnętrzne (left join) należy użyć klauzuli into i wywołać metodę DefaultIfEmpty aby ustawić wartości obiektu kiedy nie ma dopasowania w złączeniu.
Klauzula join może używać typów anonimowych aby połączyć sekwencje po więcej niż jednym polu.
Klauzula group by zwraca kolekcję typu IGrouping<TKey, TElement>.

Zapytania LINQ oparte o metody

Zapytania LINQ oparte o metody są równoważne z wyrażeniami zapytań.
Zapytania LINQ oparte o metody używają wyrażeń lambda.
Metoda SelectMany służy do spłaszczenia dwóch sekwencji w jedną.
Aby uzyskać złączenie zewnętrzne należy użyć metod GroupJoin i DefaultIfEmpty.
Dwie sekwencje można złączy za pomocą metody Concat.
Metoda Skip pomija określoną liczbę wierszy wyniku zapytania.
Metoda Take pobiera określoną liczbę wierszy wyniku zapytania.
Metoda Distinct pobiera niepowtarzające się elementy sekwencji.

LINQ to XML

Klasa XElement pozwala na zwrócenie wyniku zapytania LINQ jako dokument XML.

VIII. Praca z danymi

Sat, 20 Feb 2016 19:38:49 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Operacje I/O - zapis i odczyt z plików oraz strumienie.
Konsumpcja danych - pobieranie, dodawanie, aktualizacja i usuwanie danych z bazy danych. Użycie ADO.NET, ADO.NET Entity Framework i WCF Data Services.
Serializacja - serializacja i deserializacja danych używając serializacji binarnej, XML, JSON, Data Contract i niestandardowej.
Kolekcje danych - przechowywanie i odczyt danych w kolekcjach i tablicach.

Praca z kolekcjami

Zrozumienie jak manipulować zbiorami danych jest kluczową umiejętnością dla każdego programisty.
Tablice są najbardziej prymitywnymi typami w C# służącymi do przechowywania zbiorów danych, posiadają one oraniczoną funkcjonalność. Kolekcje są natomiast terminem ogólnym który obejmuje listy, słowniki, kolejki i inne obiekty.

Tablice

Tablica jest najbardziej podstawowym typem używanym do przechowywania zbiorów danych. Tablice posiadają elementy do których odnosimy się za pomocą indeksu używając nawiasów kwadratowych [].
Poniższy kod tworzy jednowymiarową tablicę liczb całkowitych:

int[] mySet = newint[5];

mySet[0] = 1;
mySet[1] = 2;
mySet[2] = 3;
mySet[3] = 4;
mySet[4] = 5;

Tworząc tablicę trzeba określić liczbę elementów które tablica może posiadać. W przykładzie liczba elementów to 5.
Tablice mogą być również wielowymiarowe. Przykład tworzenia tablicy dwuwymiarowej:

int[,] mySet = newint[3, 2];

mySet[0, 0] = 1;
mySet[0, 1] = 2;
mySet[1, 0] = 3;
mySet[1, 1] = 4;
mySet[2, 0] = 5;
mySet[2, 1] = 6;

Tablice mogą posiadać do 2,147,483,647 wymiarów.

Wszystkie tablice dziedziczą z klasy bazowej System.Array. Klasa ta posiada właściwości i metody użyteczne przy pracy z tablicami. Dwie najbardziej przydatne właściwości tablic to Length i Rank. Właściwość Length wskazuje całkowitą liczbę elementów we wszystkich wymiarach tablicy. Właściwość Rank wskazuje liczbę wymiarów tablicy.

Metoda Clone jest używana do wykonywania płytkiej kopii (ang. shallow copy) tablicy. Metoda CopyTo natomiast kopiuje elementy tablicy do innej tablicy.

Płytka kopia klonuje referencje do oryginalnych elementów tablicy więc dla typów referencyjnych są to te same elementy, np:

Person[] orginal = new Person[1];

orginal[0] = new Person() { Name = "John" };

Person[] clone = (Person[])orginal.Clone();

clone[0].Name = "Mary";

Debug.WriteLine("Original name " + orginal[0].Name);
Debug.WriteLine("Clone name " + clone[0].Name);

Wynik działania:

Original name Mary
Clone name Mary

Aby zmienić element tylko w sklonowanej tablicy należy zastąpić go innym a nie zmieniać jego wartość, np:

Person[] orginal = new Person[1];

orginal[0] = new Person() { Name = "John" };

Person[] clone = (Person[])orginal.Clone();

clone[0] = new Person() { Name = "Bob" };

Debug.WriteLine("Original name " + orginal[0].Name);
Debug.WriteLine("Clone name " + clone[0].Name);

Wynik kodu:

Original name John
Clone name Bob

Kolekcje

Kolekcje to ogólny termin dla specjalnych klas które są bardziej elastyczne niż tablice. Te klasy pozwalają na dynamiczne dodawanie i usuwanie elementów po ich zainicjowaniu, łączenie elementów kluczami, automatyczne sortowanie elementów i dodawanie elementów różnych typów.
Najczęściej wykorzystywane kolekcje to List, List, Dictionary, Dictionary, Stack i Queue.
Klasy kolekcji znajdują się w przestrzeniach nazw System.Collections, System.Collections.Generic i System.Collections.Concurrent. Klasy zawarte w przestrzeni nazw System.Collections.Concurrent służą do wykonywania operacji wielowątkowych i nie będą opisane w tej notatce.

System.Collections

Przestrzeń nazw System.Collections zawiera klasy używane kiedy w kolekcji mamy dane różnego typu. Te kolekcje mogą być miksem typów wartości, klas lub struktur.
Lista klas przestrzeni nazw System.Collections:

ArrayList - tworzy kolekcję której wielkość jest dynamiczna i może posiadac elementy różnego typu.
HashTable - tworzy kolekcję par klucz/wartość której wielkość jest dynamiczna i może posiadac elementy różnego typu.
Queue - tworzy kolekcję first-in-first-out.
SortedList - tworzy kolekcję par klucz/wartość której elementy są posortowane.
Stack - tworzy kolekcję last-in-first-out.

ArrayList

Klasa ArrayList pozwala na dynamiczne dodawanie elementów do kolekcji. Klasa ArrayList jest użyteczna kiedy nie znamy liczby elementów w momencie inicjalizacji kolekcji oraz kiedy chcemy przechowywać w kolekcji dane różnego typu. Metoda Add klasy ArrayList pobiera jako parametr typ Object i pozwala w ten sposób na przechowywanie dowolnego typu.
Poniższy kod tworzy obiekt ArrayList i dodaje do niego elementy trzech różnych typów:

ArrayList myList = new ArrayList();

myList.Add(1);
myList.Add("hello world");
myList.Add(new DateTime(2012, 01, 01));

Lista najczęściej wykorzystywanych właściwości klasy ArrayList:

Capacity - pobiera lub ustawia liczbę elementów w kolekcji.
Count - pobiera aktualna liczbę elementów w kolekcji.
Item - pobiera lub ustawia element określony indeksem.

Lista najczęściej wykorzystywanych metod klasy ArrayList:

Add - dodaje element na końcu kolekcji.
AddRange - dodaje wiele elementów na końcu kolekcji.
BinarySearch - przeszukuje kolekcję używając domyślnej klasy porównywania i zwraca indeks elementu.
Clear - usuwa wszystkie elementy kolekcji.
Contains - sprawdza czy element należy do kolekcji.
CopyTo - kopiuje kolekcję do kompatybilnej tablicy jednowymiarowej.
IndexOf - przeszukuje kolekcje i zwraca indeks pierwszego wystąpienia elementu.
Insert - dodaje element na wyznaczonym indeksem miejscu w kolekcji.
Remove - usuwa element z kolekcji.
RemoveAt - usuwa element wyznaczony indeksem z kolekcji.
Reverse - odwraca kolejność elementów w kolekcji.
Sort - sortuje elementy w kolekcji.

Przykład sortowania dla elementów typu wartości:

ArrayList myList = new ArrayList();
myList.Add(4);
myList.Add(1);
myList.Add(5);
myList.Add(3);
myList.Add(2);
myList.Sort();

foreach (int i in myList)
{
    Debug.WriteLine(i.ToString());
}

Wynik działania kodu:

1
2
3
4
5

Co jeżeli chcemy przechowywać obiekty które nie są standardowymi typami w kolekcji? Przykładowo jeżeli utworzymy klasę z właściwością ID która przechowuje identyfikator obiektu, np:

classMyObject
{
publicint ID{ get; set; }
}

Teraz utworzymy kolekcję z pięcioma instancjami naszej klasy i wywołamy metodę Sort:

ArrayList myList = new ArrayList();

myList.Add(new MyObject() { ID = 4 });
myList.Add(new MyObject() { ID = 1 });
myList.Add(new MyObject() { ID = 5 });
myList.Add(new MyObject() { ID = 3 });
myList.Add(new MyObject() { ID = 2 });

myList.Sort();

foreach (MyObject i in myList)
{
    Console.WriteLine(i.ID.ToString());
}

Jeżeli uruchomimy ten kod to w rezultacie otrzymamy wyjątek wyrzucony w metodzie Sort: Failed to Compare Two Elements in the Array. Dzieje się tak ponieważ metoda nie wie jak wykonac sortowanie dla naszej klasy. Aby to naprawić należy zaimplementować interfejs IComparable w utworzonej klasie i zaimplementować metodę CompareTo służącą do porównywania wartości elementów. Metoda ta pobiera jeden argument - obiekt który chcemy porównać i w wyniku zwraca liczbę mniejszą od zera jeżeli aktualna instancja jest wyższa w kolejności sortowania, zero jeżeli aktualna instancja jest równa lub liczbę większą od zera jeżeli aktualna instancja jest mniejsza w kolejności sortowania.

classMyObject : IComparable
{
publicint ID{ get; set; }

publicintCompareTo(object obj)
{
        MyObject obj1 = obj as MyObject;
returnthis.ID.CompareTo(obj1.ID);
    }
}

Innym powszechnym zastosowaniem tablic i kolekcji jest możliwość przeszukiwania tablicy. Można do tego celu uzyć pętli for lub foreach albo użyć dużo szybszej metody jaką jest BinarySearch. Aby użyć metody BinarySearch elementy kolekcji musza być posortowane. MetodaBinarySearch zwraca indeks elementu który odnalazła. Jeżeli nic nie znalazła to wynikiem będzie liczba ujemna, np:

ArrayList myList = new ArrayList();

myList.Add(new MyObject() { ID = 4 });
myList.Add(new MyObject() { ID = 1 });
myList.Add(new MyObject() { ID = 5 });
myList.Add(new MyObject() { ID = 3 });
myList.Add(new MyObject() { ID = 2 });

myList.Sort();

int foundIndex = myList.BinarySearch(new MyObject() { ID = 4 });

if (foundIndex >= 0)
{
    Debug.WriteLine(((MyObject)myList[foundIndex]).ID.ToString());
}
else
{
    Debug.WriteLine("Element not found");
}

Hashtable

Kolekcja Hashtable pozwala na przechowywanie par klucz/wartość dowolnego typu. Dane są zapisywane zgodnie z hashcode klucza i mogą być dostępne za pomocą klucza a nie indeksu elementu.
Poniższy kod tworzy kolekcję Hashtable i wstawia do niej elementy różnego typu:

Hashtable myHashtable = new Hashtable();

myHashtable.Add(1, "one");
myHashtable.Add("two", 2);
myHashtable.Add(3, "three");

Debug.WriteLine(myHashtable[1].ToString());
Debug.WriteLine(myHashtable["two"].ToString());
Debug.WriteLine(myHashtable[3].ToString());

Wynik działania kodu:

one
2
three

Queue

Queue jest kolekcją typu first-in-first-out. Kolekcja Queue może być użyteczna, gdy trzeba przechowywać dane w określonej kolejności, do sekwencyjnego przetwarzania.
Poniższy kod tworzy kolekcję Queue i dodaje do niej trzy elementy, usuwa wszystkie elementy i wyświetla ich wartość:

Queue myQueue = new Queue();

myQueue.Enqueue("first");
myQueue.Enqueue("second");
myQueue.Enqueue("third");

intcount = myQueue.Count;
for (int i = 0; i < count; i++)
{
    Debug.WriteLine(myQueue.Dequeue());
}

Wynik działania:

first
second
third

Zamiast metody Add kolekcja Queue posiada metodę Enqueue, która dodaje element do kolejki. Do usuwania elementu używana jest metoda Dequeue. Nie można dostać się do elementów kolejki ani za pomocą klucza ani indeksu. Zamiast tego można tylko dodać, usunąć lub podejrzeć wartość na sczycie kolejki. Metoda Peek zwraca wartość elementu na szczycie kolejki ale go nie usuwa.

SortedList

Kolekcja SortedList zawiera pary klucz/wartość ale jest inna niż Hashtable ponieważ do elementu możemy odnieść się za pomocą klucza i indeksu, oraz dlatego, że jest posortowana. Elementy kolekcji SortedList są sortowane używając implementacji IComparable dla klucza lub implementacji IComparer kiedy lista jest tworzona.
Poniższy kod tworzy kolekcję SortedList i dodaje do niej trzy elementy oraz wyświetla je:

SortedList mySortedList = new SortedList();

mySortedList.Add(3, "three");
mySortedList.Add(2, "second");
mySortedList.Add(1, "first");

foreach (DictionaryEntry item in mySortedList)
{
    Debug.WriteLine(item.Value);
}

Wynik działania kodu:

first
second
third

Do kolekcji SortedList można dodawać tylko elementy których klucze mogą być ze sobą porównywane.

Stack

Stack jest kolekcją typu last-in-first-out. Kolekcja Stack może być użyteczna, gdy trzeba przechowywać dane w określonej kolejności, do sekwencyjnego przetwarzania. Zamiast metody Add kolekcja Stack posiada metodę Push. Do usuwania elementu używana jest metoda Pop. MetodaPeek zwraca wartość elementu na szczycie kolejki ale go nie usuwa.
Poniższy kod tworzy kolekcję Stack i dodaje do niej trzy elementy, usuwa wszystkie elementy i wyświetla ich wartość:

Stack myStack = new Stack();

myStack.Push("first");
myStack.Push("second");
myStack.Push("third");

intcount = myStack.Count;
for (int i = 0; i < count; i++)
{
    Debug.WriteLine(myStack.Pop());
}

Wynik działania kodu:

third
second
first

System.Collections.Generic

Przestrzeń nazw System.Collections.Generic zawiera klasy używane kiedy znamy typ danych które będziemy przechowywali w kolekcji i chcemy aby cała kolekcja zawierała elementy tylko jednego typu.
Kolekcje w przestrzeni nazw System.Collections.Generic:

Dictionary<TKey, TValue> - kolekcja par klucz/wartość tego samego typu.
List< T > - kolekcja obiektów tego samego typu.
Queue< T > - kolekcja first-in-first-out z elementami tego samego typu.
SortedList<TKey, TValue> - kolekcja par klucz/wartość tego samego typu które są sortowane wg klucza.
Stack< T > - kolekcja last-in-first-out z elementami tego samego typu.

Kolekcje generyczne są bardziej wydajne i powinno się ich używać jeżeli to możliwe.

Dictionary<TKey, TValue>

Kolekcja Dictionary<TKey, TValue> pozwala na przechowywanie zbioru elementów, gdzie każdy element jest skojarzony kluczem. Zamiast indeksu do pobrania elementu z Dictionary używa się klucza. Może to być przydatne np do przechowywania elementów tabeli bazy danych gdzie kluczem może zostać identyfikator.
Poniższy kod tworzy klasę MyRecord reprezentującą rekord w tabeli, która ma trzy kolumny. Kolekcja Dictionary jest użyta do przechowania wielu elementów tej klasy:

class MyRecord
{
publicint ID { get; set; }
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
}

staticvoidSample1()
{
    Dictionary<int, MyRecord> myDictionary = new Dictionary<int, MyRecord>();

    myDictionary.Add(5, new MyRecord() { ID = 5,
        FirstName = "Bob",
        LastName = "Smith" });

    myDictionary.Add(2, new MyRecord() { ID = 2,
        FirstName = "Jane",
        LastName = "Doe" });

    myDictionary.Add(10, new MyRecord() { ID = 10,
        FirstName = "Bill",
        LastName = "Jones" });

    Debug.WriteLine(myDictionary[5].FirstName);
    Debug.WriteLine(myDictionary[2].FirstName);
    Debug.WriteLine(myDictionary[10].FirstName);
}

Wynik działania kodu:

Bob
Jane
Bill

Liczbę elementów kolekcji Dictionary uzyskujemy używając właściwości Count.

Najczęściej używane metody kolekcji Dictionary:

Add - dodaje klucz i wartość do słownika.
Clear - usuwa wszystkie elementy kolekcji.
ContainsKey - zwraca true jeżeli kolekcja zawiera określony klucz.
ContainsValue - zwraca true jeżeli kolekcja zawiera określoną wartość.
Remove - usuwa element określony kluczem.

Jeżeli odwołujemy się do elementy Dictionary wg klucza który nie istnieje to wyrzucony zostaje wyjątek. Dobrą praktyką jest używanie metody ContainsKey zanim pobierzemy element wg klucza.

List< T >

Kolekcja List jest silnie typowaną kolekcją obiektów. Jest podobna do ArrayList z wyjątkiem tego, że wszystkie elementy musza posiadać ten sam typ.

Poniższy kod tworzy listę liczb całkowitych i dodaje do niej trzy elementy:

List<int> myList = new List<int>();

myList.Add(1);
myList.Add(2);
myList.Add(3);

Kolekcje SortedList<TKey, TValue>, Queue< T > i Stack< T > są silnie typowanymi odpowiednikami kolekcji z przestrzeni nazw System.Collections.

Kolekcje niestandardowe

Oprócz standardowych kolekcji dostarczonych przez .NET, można tworzyć własne silnie typowane kolekcje. Silnie typowane kolekcje są użyteczne ponieważ nie ponoszą strat wydajnościowych spowodowanych przez boxing i unboxing. Aby utworzyć własną kolekcję należy dziedziczyć z klasy bazowej CollectionBase.
Najczęściej używane właściwości klasy System.Collections.CollectionBase:

Capacity - pobiera lub ustawia liczbę elementów jaką może posiadać kolekcja.
Count - zwraca liczbę elementów kolekcji.
InnerList - zwraca kolekcję ArrayList elementów w kolekcji.
List - zwraca kolekcję IList elementów w kolekcji.

Najczęściej używane metody klasy System.Collections.CollectionBase:

Clear - czyści elementy z kolekcji.
OnInsert - umożliwia wykonanie niestandardowego przetwarzania przed wstawieniem nowego elementu.
OnRemove - umożliwia wykonanie niestandardowego przetwarzania przed usunięciem elementu.
OnSet - umożliwia wykonanie niestandardowego przetwarzania przed ustawieniem wartości elementu.
RemoveAt - usuwa element na pozycji określonej indeksem.

Przykładowo utworzymy kolekcję niestandardową zawierającą elementy typu Person. Klasa Person wygląda następująco:

classPerson
{
publicint PersonId { get; set; }
publicstring FName { get; set; }
publicstring LName { get; set; }
publicstring Address { get; set; }
publicstring City { get; set; }
publicstring State { get; set; }
publicstring ZipCode { get; set; }
}

Utwórzmy teraz kolekcję niestandardową dziedziczącą z klasy CollectionBase. Poniższa kolekcja będzie posiadała metody Add, Insert i Remove oraz będzie posiadała silnie typowany indexer. Indexer jest używany kiedy chcemy odnieść się do elementów kolekcji używając indeksu:

classPersonCollection : CollectionBase
{
publicvoidAdd(Person person)
{
        List.Add(person);
    }

publicvoidInsert(int index, Person person)
{
        List.Insert(index, person);
    }

publicvoidRemove(Person person)
{
        List.Remove(person);
    }

public Person this[int index]
    {
get
        {
return (Person)List[index];
        }
set
        {
            List[index] = value;
        }
    }
}

Przykład użycia niestandardowej kolekcji PersonCollection:

staticvoidMain(string[] args)
{
    PersonCollection persons = new PersonCollection();

    persons.Add(new Person() {
        PersonId = 1,
        FName = "John",
        LName = "Smith" });

    persons.Add(new Person()
    {
        PersonId = 2,
        FName = "Jane",
        LName = "Doe" });

    persons.Add(new Person()
    {
        PersonId = 3,
        FName = "Bill Jones",
        LName = "Smith" });

    foreach (Person person in persons)
    {
        Debug.WriteLine(person.FName);
    }
}

Konsumowanie danych

Sekcja ta opisuje jak pobierać dane z bazy danych za pomocą ADO.NET, Entity Framework i WCF Data Service.

Praca z ADO.NET

ADO.NET jest zestawem klas w .NET Framework które pozwalaja na połączenie z bazą danych oraz wykonanie na niej operacji.
Klasy ADO.NET są zlokalizowane w przestrzeni nazw System.Data. W przestrzeni te znajduje się wiele klas bazowych i interfejsów które trzeba zaimplementować aby połączyć się z odpowiednim dostawcą danych. Przykładowo przestrzeń nazw System.Data.SqlClient zawiera zestaw klas i interfejsów do połączenia z SQL Server.

Connection

Obiekt Connection jest używany do uzyskania połączenia z bazą danych. Klasa SqlConnection jest używana do połączenia z bazą danych SQL Server. Każda dostarczane przez różnych dostawców muszą dziedziczyć z klasy bazowej Data.Common.DBConnection.

Najczęściej używane właściwości klasy DBConnection:

ConnectionString - pobiera lub ustawia ciąg znaków używany do połączenia z bazą danych.
ConnectionTimeout - pobiera czas w sekundach, który system powinien czekać podczas nawiązywania połączenia z bazą danych przed wygenerowaniem błędu.
Database - pobiera nazwę bazy danych.
DataSource - pobiera nazwę serwera.
ServerVersion - pobiera wersję serwera dla bazy danych.
State - pobiera ciąg znaków reprezentujący stan połączenia z bazą danych np Open lub Closed.

Najważniejszą właściwością jest ConnectionString. Dla bazy danych SQL Server przyjmuje on następującą formę:

Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;

Najczęściej używane metody klasy DBConnection:

BeginTransaction - rozpoczyna transakcję w bazie danych.
Close - zamyka połączenie z bazą danych.
GetSchema - zwraca obiekt DataTable zawierający informacje o schemacie.
Open - otwiera połączenie z bazą danych używając ciągu ConnectionString.

Metoda Open otwiera połączenie z bazą danych. Po uzyskaniu połączenia możemy używać innych obiektów ADO.NET służących do wykonywania operacji na bazie danych.
Poniższy kod tworzy połączenie z bazą danych SQL Server:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

Command

Obiekt Command jest używany do wykonywania operacji na bazie danych. Za pomocą Command można wykonać select, insert, update, delete lub procedurę składowaną. Klasa System.Data.Common.DBCommand jest klasą bazową dla wszystkich klas dostawców. KlasaSystem.Data.SqlClient.SqlCommand jest implementacją Command dla bazy danych SQL Server.

Metoda ExecuteNonQuery

Metoda ExecuteNonQuery jest używana do wykonywania wyrażenia na bazie danych które nie zwraca wyniku. Przykładowo instrukcja insert, update lub delete.
Poniższy kod demonstruje użycie instrukcji insert na tabeli bazy danych:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = "INSERT INTO Person (FirstName, LastName) " +
"VALUES ('Joe', 'Smith')";
cmd.ExecuteNonQuery();

cn.Close();

Przed wykonaniem metody ExecuteNonQuery należy ustawić trzy właściwości obiektu SqlCommand. Pierwszą jest właściwość Connectiod która musi być ustawiona na otwarte połączenie z bazą danych. Właściwość CommandType posiada w tym przykładzie wartośćCommandType.Text ponieważ używamy instrukcji w języku SQL. Właściwość CommandText zawiera kod SQL który chcemy wykonać.

Jeżeli chcemy wykonać procedurę składowaną to należy ustawić właściwość CommandType na CommandType.StoredProcedure oraz ustawić właściwość CommandText na nazwę procedury.

Przykładowo utwórzmy procedurę składowaną w bazie danych w języku T-SQL:

CREATEPROCEDUREPersonInsert
    @FirstNamevarchar(50),
    @LastNamevarchar(50)
AS
BEGIN
INSERTINTOPERSON(FirstName, LastName)VALUES(@FirstName, @LastName)
END

Poniższy kod wykonuje procedurę składowaną i wstawia do niej parametry:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "PersonInsert";
cmd.Parameters.Add(new SqlParameter("@FirstName", "Joe"));
cmd.Parameters.Add(new SqlParameter("@LastName", "Smith"));
cmd.ExecuteNonQuery();

cn.Close();

Obiekt Command posiada właściwość Parameters która jest używana do wstawiania parametrów do procedur składowanych.
Metoda ExecuteNonQuery zwraca w wyniku liczbę wierszy które zostały zmienione przez wykonanie zapytania.

Metoda ExecuteReader

Metody ExecuteReader używa się aby pobrać dane z bazy danych np za pomocą instrukcji select. Metoda ExecuteReader zwraca obiekt DBDataReader. Klasa DBDataReader jest zdefiniowana w ADO.NET i służy do pobierania wyników podczas gdy obiekt jest połączony z bazą danych. Obiekt DBDataReader jest obiektem typu forward-only co oznacza, że możemy przechodzić przez rekord wynikowy raz i nie możemy cofnąć kursora do poprzedniej pozycji.

Poniższy kod wyświetla wszystkie rekordy tabeli Person za pomocą obiektu SqlDataReader który jest implementacją DBDataReader dla bazy SQL Server:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT * FROM Person";
SqlDataReader dr = cmd.ExecuteReader();

if (dr.HasRows)
{
while (dr.Read())
    {
Debug.WriteLine(string.Format("First Name: {0} , Last Name: {1}",
            dr["FirstName"], dr["LastName"]));
    }
}
dr.Close();
cn.Close();

Po zakończeniu odczytu należy zamknąć obiekt DBDataReader a następnie obiekt Connection.
Metoda ExecuteReader posiada przeciążenie z parametrem typu CommandBehavior pozwalające na automatyczne zamykanie połączenia po zakończeniu odczytu.

Drugą metodą zamykania połączenia w C# jest użycie bloku using. Jest to zalecana metoda używania połączeń.
Składnia użycia using z obiektem Connection wygląda następująco:

using (SqlConnection cn = new SqlConnection())
{
}

Najczęściej wykorzystywane właściwości klasy DBDataReader:

FieldCount - zwraca liczbę kolumn aktualnego wiersza.
HasRows - zwraca true jeżeli DBDataReader posiada jakiekolwiek wiersze.
IsClosed - zwraca true jeżeli DBDataReader jest zamknięty.
Item[Int32] - jest to indekser zwracający kolumnę bazując na indeksie.
Item[String] - jest to indekser zwracający kolumnę bazując na jej nazwie.

Nie istnieje właściwość Count dla obiektu DBDataReader. Aby dowiedzieć się ile jest wierszy w wyniku należy przejść przez wszystkie wiersze obiektu DBDataReader.

Ważną rzeczą jest zapamiętanie, że dla kolumny zawierającej null obiekt DBDataReader zwraca wartość typu DBNull.Value a nie null.

Najczęściej wykorzystywane metody klasy DBDataReader:

Close - zamyka obiekt DBDataReader.
GetBoolean - zwraca wynik wybranej kolumny jako typ bool.
GetByte - zwraca wynik wybranej kolumny jako typ byte.
GetChar - zwraca wynik wybranej kolumny jako typ char.
GetDateTime - zwraca wynik wybranej kolumny jako typ DateTime.
GetDecimal - zwraca wynik wybranej kolumny jako typ decimal.
GetDouble - zwraca wynik wybranej kolumny jako typ double.
GetFieldType - zwraca typ danych wybranej kolumny.
GetFieldValue - zwraca wartość wybranej kolumny jako typ T.
GetFloat - zwraca wynik wybranej kolumny jako typ float.
GetGuid - zwraca wynik wybranej kolumny jako typ Guid.
GetInt16 - zwraca wynik wybranej kolumny jako typ Int16.
GetInt32 - zwraca wynik wybranej kolumny jako typ Int32.
GetInt64 - zwraca wynik wybranej kolumny jako typ Int64.
GetName - zwraca nazwę wybranej kolumny.
GetOrdinal - zwraca pozycję wybranej kolumny.
GetSchemaTable - zwraca obiekt DataTable zawierający metadane kolumn.
GetString - zwraca wynik wybranej kolumny jako typ string.
GetValue - zwraca wynik wybranej kolumny jako typ object.
GetValues - wypełnia tablicę obiektów wartościami kolumn.
NextResult - przenosi kursor do następnego wyniku w obiekcie DBDataReader.
IsDBNull - sprawdza czy wynik zawiera wartość null.
Read - przesuwa kursor do następnego rekordu jeżeli rekord istnieje.

Dobrą praktyką jest sprawdzenie właściwości HasRows przed użyciem metody Read ponieważ metoda Read zgłosi wyjątek jeżeli nie będzie następnego rekordu w obiekcie DBDataReader.

Pobierając dane z bazy danych można wykonać kilka instrukcji Select w jednym wywołaniu. Klasa DBDataReader potrafi przechowywać wiele wyników w jednym obiekcie. Aby przenieść się do następnego wyniku używamy metody NextResult.

Metoda GetSchemaTable zwraca obiekt DataTable zawierający metadane kolumn w obiekcie DBDataReader. Zwrócona tabela posiada wiersz dla każdej kolumny i zawiera nazwę kolumny, typ, rozmiar, pozycję porządkową, informację czy jest to kolumna Identity oraz czy zezwala na wartości null. Jeżeli chcemy pobrać tylko metadane dla tabeli to możemy wykonać metodę ExecuteDataReader z parametrem CommandBehavior.SchemaOnly.

Metoda ExecuteScalar

Metody ExecuteScalar używamy kiedy wiemy, że wynik zapytania do bazy danych zwróci tylko jeden wynik tzn jedną kolumnę z jednym wierszem.
Poniższy kod wywołuje metodę ExecuteScalar i zwraca liczbę wierszy w tabeli Person:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT COUNT(*) FROM Person";
object obj = cmd.ExecuteScalar();

Debug.WriteLine(string.Format("Count: {0}", obj.ToString()));

cn.Close();

Metoda ExecuteScalar zawsze zwraca wynik typu object który możemy rzutować do odpowiedniego typu wyniku.

Metoda ExecuteXmlReader

Metoda ExecuteXmlReader zwraca XmlReader, który pozwala zaprezentować dane jako XML.
Poniższy kod zwraca dane z tabeli Person w postaci XmlReader:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlCommand cmd = new SqlCommand();
cmd.Connection = cn;
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT * FROM Person FOR XML AUTO, XMLDATA";
System.Xml.XmlReader xml = cmd.ExecuteXmlReader();

cn.Close();

Wynik zapytania:

<Schema name="Schema1" xmlns="urn:schemas-microsoft-com:xml-data"
 xmlns:dt="urn:schemas-microsoft-com:datatypes">
    <ElementType name="Person" content="empty" model="closed">
        <AttributeType name="PersonId" dt:type="i4"/>
        <AttributeType name="FirstName" dt:type="string"/>
        <AttributeType name="LastName" dt:type="string"/>
        <AttributeType name="Address" dt:type="string"/>
        <AttributeType name="City" dt:type="string"/>
        <AttributeType name="State" dt:type="string"/>
        <AttributeType name="ZipCode" dt:type="string"/>
        <attribute type="PersonId"/>
        <attribute type="FirstName"/>
        <attribute type="LastName"/>
        <attribute type="Address"/>
        <attribute type="City"/>
        <attribute type="State"/>
        <attribute type="ZipCode"/>
    </ElementType>
</Schema>
<Person xmlns="x-schema:#Schema1" PersonId="1" FirstName="John" LastName="Smith"
 Address="123 First Street" City="Philadelphia" State="PA" ZipCode="19111"/>

DataSet, DataTable i DataAdapter

Innym sposobem na pobranie danych z bazy danych jest użycie DataSet i DataTable. Możliwości klasy DataTable są podobne do DBDataReader , poza tym , że DataTable jest odłączona od bazy danych, można poruszać się kursorem w przód i w tył oraz można aktualizować dane, połączyć się ponownie do bazy danych i zapisać zmiany. Klasa DataSet jest kontenerem dla jednego lub wielu DataTable. Można wykonać instrukcję SQL która zwróci wiele wyników i każdy z nich będzie zawarty w DataSet. Można wtedy filtrować, sortować i aktualizować te dane w pamięci. Klasa DataAdapter służy do wypełnienia DataSet lub DataTable oraz ponownego połączenia z bazą danych aby wykonać komendę insert, update lub delete.
Poniższy kod używa DataSet do pobrania danych z tabeli Person i ich wyświetlenia:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM Person", cn);
DataSet ds = new DataSet();
da.Fill(ds, "Person");

cn.Close();

foreach (DataRow row in ds.Tables[0].Rows)
{
    Debug.WriteLine(string.Format("First Name: {0} , Last Name: {1}",
        row["FirstName"], row["LastName"]));
}

Metoda Fill klasy SqlDataAdapter służy do wypełnienia DataSet.
Klasa DataSet posiada właściwość Tables której można uzyć aby odwołać się do obiektów DataTable które zostały zwrócone przez zapytanie. W powyższym przykładzie powstał tylko jeden obiekt DataTable więc można się do niego odwołać poprzez indeks o wartości zero.
Klasa DataTable posiada właściwość Rows, zawierającą kolekcję obiektów DataRow które reprezentują zwrócone rekordy. Do rekordów można odwołać się poprzez indeks lub iterując kolekcję. Kolekcja Rows posiada właściwość Count.

Klasa DataAdapter pozwala na wstawianie, aktualizowanie i usuwanie wierszy po zmianie obiektu DataTable. Poniższy przykład pokazuje jak użyć obiektu DataAdapter do wstawiania rekordów do bazy danych:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM Person", cn);

//Create the insertcommand
SqlCommand insert = new SqlCommand();
insert.Connection = cn;
insert.CommandType = CommandType.Text;
insert.CommandText = "INSERT INTO Person (FirstName, LastName) VALUES (@FirstName,
    @LastName)";

//Create the parameters
insert.Parameters.Add(new SqlParameter("@FirstName", SqlDbType.VarChar, 50,
"FirstName"));
insert.Parameters.Add(new SqlParameter("@LastName", SqlDbType.VarChar, 50,
"LastName"));

//Associate the insertcommand with the DataAdapter.
da.InsertCommand = insert;

//Get the data.
DataSet ds = new DataSet();
da.Fill(ds, "Person");

//Add anew row.
DataRow newRow = ds.Tables[0].NewRow();
newRow["FirstName"] = "Jane";
newRow["LastName"] = "Doe";
ds.Tables[0].Rows.Add(newRow);

//Update the database.
da.Update(ds.Tables[0]);

cn.Close();

Poniższy kod demonstruje jak użyć obiektu DataAdapter do aktualizacji i usuwania rekordów bazy danych:

SqlConnection cn = new SqlConnection();
cn.ConnectionString = "Server=myServerAddress;Database=myDataBase;
    User Id=myUsername;Password=myPassword;";
cn.Open();

SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM Person", cn);

//Create the updatecommand
SqlCommand update = new SqlCommand();
update.Connection = cn;
update.CommandType = CommandType.Text;
update.CommandText = "UPDATE Person SET FirstName = @FirstName, LastName = @LastName
    WHERE PersonId = @PersonId";

//Create the parameters
update.Parameters.Add(new SqlParameter("@FirstName", SqlDbType.VarChar, 50,
"FirstName"));
update.Parameters.Add(new SqlParameter("@LastName", SqlDbType.VarChar, 50,
"LastName"));
update.Parameters.Add(new SqlParameter("@PersonId", SqlDbType.Int, 0, "PersonId"));

//Create the deletecommand
SqlCommand delete = new SqlCommand();
delete.Connection = cn;
delete.CommandType = CommandType.Text;
delete.CommandText = "DELETE FROM Person WHERE PersonId = @PersonId";

//Create the parameters
SqlParameter deleteParameter = new SqlParameter("@PersonId", SqlDbType.Int, 0,
"PersonId");
deleteParameter.SourceVersion = DataRowVersion.Original;
delete.Parameters.Add(deleteParameter);

//Associate the updateanddelete commands with the DataAdapter.
da.UpdateCommand = update;
da.DeleteCommand = delete;

//Get the data.
DataSet ds = new DataSet();
da.Fill(ds, "Person");

//Update the first row
ds.Tables[0].Rows[0]["FirstName"] = "Jack";
ds.Tables[0].Rows[0]["LastName"] = "Johnson";

//Delete the second row.
ds.Tables[0].Rows[1].Delete();

//Updat the database.
da.Update(ds.Tables[0]);

cn.Close();

Praca z Entity Framework

Biblioteka ADO.NET Entity Framework jest zestawem klas który również umożliwia wykonywanie operacji na bazie danych. Ponadto Entity Framework posiada interfejs graficzny pozwalający na przeciąganie i upuszczanie obiektów bazy danych na powierzchnię projektową. BibliotekaADO.NET Entity Framework jest narzędziem zwanym ORM (ang. Object-Relational Mapping).
Przykłady tej sekcji będą używały bazy danych Northwind dostępnej pod adresem http://northwinddatabase.codeplex.com/.

Tworzenie modelu Entity Framework w Visual Studio

Rdzeniem pracy z Entity Framework jest model. Model zawiera wszystkie klasy które reprezentują obiekty w bazie danych.
Aby utworzyć model bazy danych Northwind należy:

Uruchomić Visual Studio.
Utworzyć nowy projekt np typu Console Application i nadać mu nazwę np NorthwindsConsole.
Po utworzeniu dodać nowy element z menu rozwijanego w oknie Solution Explorer.
Dodać ADO.NET Entity Data Model z listy zainstalowanych szablonów i nadać mu nazwę np NorthwindsModel.
Ponieważ baza danych już istnieje wybieramy Generate from Database. Takie podejście tworzenia modelu nazywane jest Database First. Alternatywnym podejściem jest Model First, które pozwala na wygenerowanie bazy danych po utworzeniu klas modelu danych.
W oknie połączenia z bazą danych należy wybrać nowe połączenie z danymi łączącymi z bazą danych Northwind.
Po wybraniu połączenia należy wybrać obiekty które mają być zmapowane w modelu. Wybieramy tabele, widoki i procedury składowane.

Generator Entity Framework wygeneruje model który będzie wyglądał tak:

Do projektu został dodany plik NorthwindsModel.edmx, jest to graficzna reprezentacja modelu. Klikając strzałkę przy nazwie modelu w oknie Solution Explorer możemy zobaczyć wszystkie klasy jakie zostały wygenerowane dla modelu.

Plik NorthwindsModel.tt jest plikiem Text Transformation Template Toolkit zwanym również szablonem T4. Szablony T4 są używane do automatycznego generowania kodu w Visual Studio. Klikając strzałkę obok pliku zobaczymy listę wygenerowanych przez model klas. jak widać dla każdej tabeli, widoku i procedury został wygenerowany osobny plik.
Przykładowo plik Categories.cs jest plikiem klasy wygenerowanej dla tabeli Category i ma następującą postać:

publicpartialclassCategories
{
publicCategories()
{
this.Products = new HashSet<Products>();
    }

publicint CategoryID { get; set; }
publicstring CategoryName { get; set; }
publicstring Description { get; set; }
publicbyte[] Picture { get; set; }

publicvirtual ICollection<Products> Products { get; set; }
}

Dla każdej kolumny została wygenerowana właściwość. Została również wygenerowana inna właściwość ICollection Products która jest wygenerowaną kolekcją dla tabeli połączonej kluczem obcym.

Plik NorthwindsModel.Context.tt jest szablonem T4 dla obiektu Context. Obiekt Context jest obiektem który reprezentuje połączenie z całą bazą danych. Jeżeli rozwiniemy plik to zobaczymy plik NorthwindsModel.Context.cs w którym zdefiniowana jest klasa NorthwindsEntitiesposiadająca właściwości dla każdej tabeli w bazie danych. Właściwości są typu generycznego DbSet, który jest kolekcją dla każdego typu reprezentującego tabelę lub widok np:

public DbSet<Category> Categories { get; set; }

Procedury składowane zostały stworzone jako metody o takiej samej nazwie. Parametry procedur są zmapowane na parametry tych metod. Jeżeli procedura zwraca wynik to metoda posiada typ zwracanej kolekcji ObjectResult. Przykładowo procedura CustOrderHist została zmapowana na następującą metodę:

publicvirtual ObjectResult<CustOrderHist_Result> CustOrderHist(string customerID)
{
var customerIDParameter = customerID != null ?
new ObjectParameter("CustomerID", customerID) :
new ObjectParameter("CustomerID", typeof(string));

return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction
        <CustOrderHist_Result>("CustOrderHist", customerIDParameter);
}

Klasa CustOrderHist_Result jest typem utworzonym dla zwracanych wartości procedury. procedura posiada jeden parametr zmapowany jako customerID. Aby wywołać procedurę wykonywana jest metoda ExecuteFunction która jest zdefiniowana w klasie bazowej DbContext. KlasaDbContext jest zdefiniowana w przestrzeni nazw System.Data.Entity.

Pobieranie rekordów

Posiadając model możemy pobrać dane nie znając języka SQL i posługując się jedynie obiektami.
Poniższy fragment kodu pobiera rekordy z tabeli Category i wyświetla je:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
var categories = from c in db.Categories select c;

foreach (Categories category in categories)
    {
        Debug.WriteLine(
string.Format("CategoryId: {0}, CategoryName: {1}", 
            category.CategoryID, category.CategoryName));
    }
}

Wynik działania zapytania:

CategoryId: 1, CategoryName: Beverages
CategoryId: 2, CategoryName: Condiments
CategoryId: 3, CategoryName: Confections
CategoryId: 4, CategoryName: Dairy Products
CategoryId: 5, CategoryName: Grains/Cereals
CategoryId: 6, CategoryName: Meat/Poultry
CategoryId: 7, CategoryName: Produce
CategoryId: 8, CategoryName: Seafood

Do pobierania danych z użyciem Entity Framework używane są zapytania LINQ.

Poniższy kod demonstruje pobieranie danych z wielu tabel połączonych kluczem obcym:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
var products = from c in db.Categories
join p in db.Products on c.CategoryID equals p.CategoryID
select p;

foreach (Products product in products)
    {
        Debug.WriteLine(
string.Format(
"ProductName: {0}, CategorName: {1}", 
                product.ProductName, 
                product.Categories.CategoryName));
    }
}

Wstawianie rekordów

Poniższy fragment kodu demonstruje wstawianie rekordu do tabeli Category za pomocą Entity Framework:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
    Categories category = new Categories() { 
        CategoryName = "Alcohol", 
        Description = "Happy Beverages"
    };

    db.Categories.Add(category);
    db.SaveChanges();
}

Po utworzeniu instancji klasy Categories została ona dodana do kolekcji db.Categories za pomocą metody Add. Zmiany w bazie danych zostały zapisane za pomocą metody SaveChanges.

Aktualizacja rekordów

Poniższy fragment kodu demonstruje aktualizację rekordu z tabeli Category za pomocą Entity Framework:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
Categories category = db.Categories.First(c => c.CategoryName == "Alcohol");
    category.Description = "Happy People";
    db.SaveChanges();
}

Usuwanie rekordów

Poniższy fragment kodu demonstruje usuwanie rekordu z tabeli Category za pomocą Entity Framework:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
    Categories category = db.Categories.First(c => c.CategoryName == "Alcohol");
db.Categories.Remove(category);
db.SaveChanges();
}

W wersjach wcześniejszych niż Entity Framework 5.0 usuwanie rekordów odbywało się z użyciem metody DeleteObject.

Wywołanie procedury składowanej

Ponieważ procedury składowane są wygenerowane przez EF jako metody to ich wywołanie oznacza proste wywołanie metody np:

using (NORTHWNDEntities db = new NORTHWNDEntities())
{
var custOrderHist = db.CustOrderHist("ALFKI");

    foreach (CustOrderHist_Resultresultin custOrderHist)
    {
Debug.WriteLine(
string.Format("ProductName: {0}, Total: {1}", 
result.ProductName, 
result.Total));
    }
}

WCF Data Services

WCF Data Services są komponentami .NET Framework które umożliwiają dostęp do bazy danych poprzez użycie URI. W poprzednich wersjach usługa ta nazywała się ADO.NET Data Services. Używając URI i ich parametrów można pobierać, filtrować, aktualizować a nawet usuwać dane. WCF Data Services używają Open Data Protocol (OData), który jest protokołem sieciowym używającym HTTP.
Przykładowo poniższy adres może być użyty do pobrania przefiltrowanych kategorii z bazy danych Northwind:

http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/Categories?$filter=CategoryName eq ‘Beverages’

W powyższym przykładzie Categories to encja która ma być zwrócona a parametr filter jest użyty do znalezienia kategorii które mają pole CategoryName równe ‘Beverages’. Dane mogą być zwracane w formacie XML (OData ATOM Format) lub JSON.
Powyższe zapytanie zwraca wynik w postaci XML:

<?xml version="1.0" encoding="utf-8" ?>
<feedxml:base="http://localhost:5000/WcfDataService1.svc/"
xmlns=http://www.w3.org/2005/Atom
xmlns:d=http://schemas.microsoft.com/ado/2007/08/dataservices
xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata">
<id>http://localhost:5000/WcfDataService1.svc/Categories</id>
<titletype="text">Categories</title>
<updated>2013-01-01T23:54:24Z</updated>
<linkrel="self"title="Categories"href="Categories" />
<entry>
<id>http://localhost:5000/WcfDataService1.svc/Categories(1)</id>
<categoryterm="NorthwindsModel.Category"
scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme" />
<linkrel="edit"title="Category"href="Categories(1)" />
<title />
<updated>2013-01-10T23:54:24Z</updated>
<author>
<name />
</author>
<contenttype="application/xml">
<m:properties>
<d:CategoryIDm:type="Edm.Int32">1</d:CategoryID>
<d:CategoryName>Beverages</d:CategoryName>
<d:Description>Soft drinks, coffees, teas, beers, and ales</d:Description>
<d:Picturem:type="Edm.Binary">FRwvA…</d:Picture>
</m:properties>
</content>
</entry>
</feed>

Tworzenie WCF Data Service

Utworzenie serwisu WCF Data Service polega na utworzeniu aplikacji WEB, utworzeniu modelu Entity Framework i wyeksponowanie tego modelu dodając WCF Data Service:

Dodaj pusty projekt ASP.NET Web Application w Visual Studio i nazwij go NorthwindsWCFDataService.
Dodaj do projektu model ADO.NET Entity Data Model dla bazy Northwind z nazwą NorthwindsModel.
Dodaj do projektu serwis WCF Data Service i nazwij go NorthwindsService.svc. Spowoduje to wygenerowanie następującej klasy dziedziczącej z DataService:

public class WCF_Data_Service : DataService< /* TODO: put your data source class name here */ >
{
    // Thismethodis called only once to initialize service-wide policies.
    public staticvoidInitializeService(DataServiceConfiguration config)
    {
        // TODO: set rules to indicate which entity sets and service operations are visible, updatable, etc.
        // Examples:
        // config.SetEntitySetAccessRule("MyEntityset", EntitySetRights.AllRead);
        // config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
        config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
    }
}

Zamień tekst TODO na nazwę modelu Entity Data Model czyli NorthwindsEntities.
Dodaj poniższą linię kodu do metody InitializeService:

config.SetEntitySetAccessRule("Categories", EntitySetRights.AllRead );

Uruchom projekt i otwórz adres w przeglądarce: http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/Categories

Serwisy WCF Data Service pozwalają na używanie następujących opcji zapytań:

$orderby - ustawia sortowanie np
$orderby=CategoryName,CategoryId
$top - ustawia limit pobierania danych np
$top=10
$skip - ustawia liczbę rekordów wynikowych do pominięcia np
$skip=10
$filter - definiuje wyrażenie filtrujące dane np
?$filter=CategoryName eq ‘Beverages’
$expand - określa które powiązane encje mają być zawarte w wyniku np
$expand=Products
$select - określa kolumny zwracane w wyniku np:
$select=CategoryName,CategoryId
$inlinecount - zwraca liczbę wierszy wyniku

Lista operatorów używanych w opcji $filter:

Eq - równe
Ne - nierówne
Gt - większe niż
Ge - większe lub równe
Lt - mniejsze niż
Le - mniejsze lub równe
And - logiczne And
Or - logiczne Or
Not - logiczne Not
() - nawias matematyczny określający pierwszeństwo
Add - dodawanie
Sub - odejmowanie
Mul - mnożenie
Div - dzielenie
Mod - reszta

W opcji $filter można również używać następujących funkcji dla ciągów znaków:

bool substring(string p0, string p1) - zwraca true jeżeli p0 jest w p1.
bool endswith(string p0, string p1) - zwraca true jeżeli p0 zakończone jest ciągiem p1.
bool startswith(string p0, string p1) - zwraca true jeżeli p0 zaczyna sie od p1.
int length(string p0) - zwraca długość ciągu.
int indexof(string p0, string p1) - zwraca pozycję p0 w p1.
string replace(string p0, string p1, string replace) - wyszukuje p1 w p0 i zastępuje przez replace.
string substring(string p0, int pos) - zwraca podciąg p0 od pozycji pos.
string substring(string p0, int pospos, int length) - zwraca podciąg p0 od pozycji pos o długości length.
string tolower(string p0) - zwraca ciąg jako małe znaki.
string toupper(string p0) - zwraca ciąg jako duże znaki.
string trim(string p0) - zwraca ciąg bez białych znaków.
string concat(string p0, string p1) - łączy ciągi.

W opcji $filter można również używać następujących funkcji dla dat:

int day(DateTime p0) - zwraca dzień z daty.
int hour(DateTime p0) - zwraca godzinę z daty.
int minute(DateTime p0) - zwraca minuty z daty.
int month(DateTime p0) - zwraca miesiącz daty.
int second(DateTime p0) - zwraca sekundy z daty.
int year(DateTime p0) - zwraca rokz daty.

W opcji $filter można również używać następujących funkcji matematycznych:

double round(double p0) - zaokraglenie.
decimal round(double p0) - zaokrąglenie.
double floor(double p0) - podłoga.
decimal floor(double p0) - podłoga.
double ceiling(double p0) - powała.
decimal ceiling(double p0) - powała.

W opcji $filter można również używać następujących funkcji typów:

bool isOf(type p0) - zwraca true jeżeli encja jest typu p0.
bool IsOf(expression p0, type p0) - zwraca true jeżeli p0 jest typu p1.

Poza używaniem $filter można również pobierać encje używając klucza głównego w nawiasie okrągłym () np

http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/Categories(1)

Poniższy adres URI zwraca CategoryName tabeli Category z wartością klucza głównego równą 1:

http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/Categories(1)/CategoryName

Tworzenie aplikacji klienckiej używającej Uses WCF Data Services

W tej sekcji utworzymy aplikację konsolową która będzie odnosić się do Northwinds WCF Data Service i wykonywać operacje CRUD na danych:

Dodaj nowy projekt Console Application w Visual Studio o nazwie NorthwindsClient.
W oknie Solution Explorer kliknij prawym przyciskiem myszy na References i dodaj referencje do serwisu wybierając opcję Add Service Reference.
Używając guzika Discover wybierz serwisy zawarte w solucji. Zmień przestrzeń nazw na NorthwindsServiceReference.
Do klasy Program dodaj następujące klauzule using:

using NorthwindsClient.NorthwindsServiceReference;
usingSystem.Diagnostics;
usingSystem.Data.Services.Client;
usingSystem.Net;

Dodaj do metody Main następujący kod:

NorthwndEntities db =
new NorthwndEntities(new Uri("http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/"));

var categories = from c in db.Categories select c;
foreach (Categories category in categories)
{
    Debug.WriteLine(
string.Format("CategoryId: {0}, CategoryName: {1}", category.CategoryID, category.CategoryName));
}

Ustaw aplikacje konsolową jako startową i uruchom projekt.

Kod odpytujący baz danych jest taki sam jak dla modelu ADO.NET Entity Framework. Jedyną różnicą jest utworzenie obiektu NorthwindsEntities który tworzymy podając adres URI do serwisu WCF Data Service.

Dodawanie rekordów za pomocą WCF Data Services

Poniższy kod dodaje nowy rekord do tabeli Categories:

NorthwndEntities db =
new NorthwndEntities(new Uri("http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/"));

// Create a category
Categories category = new Categories() { 
    CategoryName = "Alcohol", 
Description = "Happy Beverages"
};

db.AddToCategories(category);
DataServiceResponse response = db.SaveChanges();
if (response.First().StatusCode == (int)HttpStatusCode.Created)
{
    Debug.WriteLine("New CategoryId: {0}", category.CategoryID);
}
else
{
    Debug.WriteLine("Error: {0}", response.First().Error.Message);
}

Istnieje tutaj kilka różnic w porównaniu do dodawania rekordów za pomocą ADO.NET Entity Framework.
Po pierwsze w klasie NorthwindsEntities została wygenerowana metoda AddToCategories.
Po drugie metoda SaveChanges zwraca obiekt DataServiceResponse który zawiera listę odpowiedzi z serwera. W powyższym przykładzie używamy właściwości StatusCode aby sprawdzić czy rekord został dodany.
Jeżeli uruchomimy ten kod to zwrócony zostanie nam błąd “An Error Occurred While Processing This Request.”. Dzieje się tak ponieważ nie zezwoliliśmy na tworzenie rekordów w czasie ustawiania zabezpieczeń serwisu. Aby to zmienić należy dodać następujący wpis do metodyInitializeService serwisu:

config.SetEntitySetAccessRule("Categories", EntitySetRights.AllRead | 
    EntitySetRights.AllWrite);

lub

config.SetEntitySetAccessRule("Categories", EntitySetRights.All);

Aktualizacja rekordów za pomocą WCF Data Services

Poniższy kod aktualizuje rekord z tabeli Categories:

NorthwndEntities db =
new NorthwndEntities(newUri("http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/"));

Categories category = db.Categories
    .Where(c => c.CategoryName == "Alcohol")
    .FirstOrDefault();

category.Description = "Happy People";

db.UpdateObject(category);

db.SaveChanges();

Metoda UpdateObject powoduje, że obiekt będzie zaktualizowany po wywołaniu metody SaveChanges.

Usuwanie rekordów za pomocą WCF Data Services

Poniższy kod usuwa rekord z tabeli Categories:

NorthwndEntities db =
new NorthwndEntities(newUri("http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/"));

Categories category = db.Categories
    .Where(c => c.CategoryName == "Alcohol")
    .FirstOrDefault();

db.DeleteObject(category);

db.SaveChanges();

Metoda DeleteObject usuwa rekord po wywołaniu metody SaveChanges.

Pobranie danych w formacie JSON

Domyślnie dane są zwracane w formacie XML. Aby otrzymać dane w formacie JSON należy dołączyć nagłówek do żądania HTTP o następującej treści:

“Accept: application/json;odata=verbose”

Poniższy kod tworzy żądanie używając obiektu WebRequest pobierające dane w postaci JSON:

HttpWebRequest req =
    (HttpWebRequest)
    WebRequest.Create(
        "http://localhost/NorthwindsWCFDataService/NorthwindsService.svc/Categories(1)?$select=CategoryID,CategoryName,Description");

req.Accept = "application/json;odata=verbose";

using (HttpWebResponse resp = (HttpWebResponse)req.GetResponse())
{
    Stream s = resp.GetResponseStream();
    StreamReader readStream = new StreamReader(s);

    string jsonString = readStream.ReadToEnd();

    Debug.WriteLine(jsonString);

    resp.Close();
    readStream.Close();
}

Wynik działania kodu:

{
    "d":
{
        "__metadata":
{
            "id":"http://localhost:8999/NorthwindsService.svc/Categories(1)",
            "uri":"http://localhost:8999/NorthwindsService.svc/Categories(1)",
            "type":"NorthwindsModel.Category"
},
        "CategoryID":1,
        "CategoryName":"Beverages",
        "Description":"Soft drinks, coffees, teas, beers, and ales"
}
}

Operacje I/O

Operacje I/O są operacjami odczytu i zapisu plików. Pliki są przechowywane w katalogach a .NET Framework zapewnia zestaw klas służących do kopiowania, przenoszenia, usuwania i sprawdzania czy plik lub katalog istnieje. Plik jest uporządkowaną i nazwaną kolekcją bajtów które zostały zapisane do magazynu danych. Kiedy pracujemy z plikami używamy strumieni. Strumień jest obiektem w pamięci używanym do reprezentowania sekwencji bajtów w pliku. Specjalne klasy odczytujące i zapisujące służą do pracy z zakodowanymi strumieniami. Wszystkie typy służące do pracy z operacjami I/O znajdują się w przestrzeni nazw System.IO.

Pliki i foldery

Lista klas służących do pracy z plikami i folderami:

File - klasa statyczna posiadająca metody do tworzenia, kopiowania, usuwania, przenoszenia i otwierania plików.
FileInfo - klasa instancyjna posiadająca metody do tworzenia, kopiowania, usuwania, przenoszenia i otwierania plików.
Directory - klasa statyczna posiadająca metody do tworzenia, kopiowania, usuwania, przenoszenia i enumerowania przez pliki w katalogu.
DirectoryInfo - klasa instancyjna posiadająca metody do tworzenia, kopiowania, usuwania, przenoszenia i enumerowania przez pliki w katalogu.
Path - klasa statyczna która dostarcza sposobów uzyskiwania informacji lub manipulowania plikami lub katalogami używając ciągu znaków.

Klasy File i FileInfo są podobne z wyjątkiem tego, że File jest klasą statyczną i nie posiada właściwości.
Właściwości klasy FileInfo:

Directory - pobiera instancję obiektu DirectoryInfo dla katalogu nadrzędnego.
DirectoryName - pobiera ciąg znaków dla pełnej ścieżki katalogu.
Exists - zwraca true jeżeli plik istnieje.
IsReadOnly - zwraca true jeżeli plik jest tylko do odczytu.
Length - zwraca rozmiar pliku w bajtach.
Name - zwraca nazwę pliku.

Klasa FileInfo dziedziczy z klasy System.IO.FileSystemInfo która zawiera właściwości dla atrybutów, czasu utworzenia, pełnej nazwy, ostatniego czasu dostępu i ostatniego czasu zapisu do pliku.
Konstruktor klasy FileInfo pobiera ciąg znaków ze ścieżką i nazwą pliku, np:

FileInfo fileInfo = new FileInfo(@”c:\Samples\HelloWorld.txt”);
Debug.WriteLine(fileInfo.Name);

Lista metod klas File i FileInfo jest taka sama ale ich parametry różnią się od siebie. Metody klasy File wymagają podania ścieżki pliku.
Lista najczęściej wykorzystywanych metod klas File i FileInfo:

AppendAllText - tworzy obiekt klasy StreamWriter który może być użyty do dodania tekstu do pliku.
CopyTo (FileInfo) - kopiuje plik.
Copy (File) - kopiuje plik.
Create - tworzy plik.
Decrypt - odszyfrowuje plik który został zaszyfrowany przez aktualne konto.
Delete - usuwa plik.
Encrypt - szyfruje plik.
MoveTo - przenosi plik.
Open - zwraca obiekt klasy FileStream umożliwiający odczyt i zapis.
Replace - zastępuje treść pliku treścią innego pliku.
SetAccessControl - stosuje listę kontroli dostępu za pomocą obiektu FileSecurity.

Klasy Directory i DirectoryInfo są podobne do klas File i FileInfo z tym, że operują na folderach a nie na plikach.
Właściwości klasy DirectoryInfo:

Exists - zwraca true jeżeli plik istnieje.
Name - zwraca nazwę pliku.
Parent - zwraca obiekt klasy DirectoryInfo dla folderu nadrzędnego.
Root - zwraca obiekt klasy DirectoryInfo dla folderu głównego.

Lista najczęściej wykorzystywanych metod klas Directory i DirectoryInfo:

Create (DirectoryInfo) - tworzy folder.
CreateDirectory (Directory) - tworzy folder.
Delete - usuwa folder.
GetAccessControl - zwraca obiekt DirectorySecurity zawierający listę kontroli dostępu.
GetDirectories - zwraca tablicę obiektów DirectoryInfo dla podkatalogów.
GetFiles - zwraca tablicę obiektów FileInfo dla plików w katalogu.
GetFileSystemInfos - zwraca tablicę obiektów FileSystemInfo dla plików i katalogów w danym katalogu.
MoveTo (DirectoryInfo) - przenosi folder.
MoveTo (Directory) - przenosi folder.
SetAccessControl - stosuje listę kontroli dostępu za pomocą obiektu DirectorySecurity.

Poniższy przykład wyświetla listę plików i katalogów na dysku C:

//DirectoryInfo
DirectoryInfo directoryInfo = new DirectoryInfo(@"c:\");

//Directories
Debug.WriteLine("Directories");
foreach (FileInfo fileInfo in directoryInfo.GetFiles())
{
    Debug.WriteLine(fileInfo.Name);
}

//Files
Debug.WriteLine("Files");
foreach (DirectoryInfo diin directoryInfo.GetDirectories())
{
    Debug.WriteLine(di.Name);
}

Strumienie

Strumienie są klasami wykorzystywane do przechowywania zawartości pliku.
Lista strumieni dostępnych w .NET Framework:

FileStream - odczytują i zapisują pliki.
IsolatedStorageFileStream - odczytują i zapisują pliki w odizolowanych magazynach.
MemoryStream - odczytują i zapisują w pamięci.
BufferedStream - używane do przechowywania bloków bajtów w pamięci.
NetworkStream - zapisują i odczytują dane w sieci używając gniazd (ang. socket).
PipeStream - zapisują i odczytują dane w sieci za pomocą kanałów zwanych pipe.
CryptoStream - używane do łączenia danych z transformacjami kryptograficznymi.

Klasa FileStream może by użyta do odczytu, zapisu, otwarcia i zamknięcia plików. Poniższy przykład tworzy nowy plik, zapisuje w nim numery i zamyka plik:

FileStream fileStream = new FileStream(
    @"d:\Samples\Numbers.txt", 
    FileMode.Truncate, 
    FileAccess.Write, 
    FileShare.None);
for (int i = 0; i < 10; i++)
{
    byte[] number = new UTF8Encoding(true).GetBytes(i.ToString());
    fileStream.Write(number, 0, number.Length);
}

fileStream.Close();

Konstruktor FileStream pobiera cztery parametry, ścieżkę do pliku, tryb pliku, dostęp do pliku i udostępnienie pliku.
Enumerator FileMode określa czy tworzymy, otwieramy czy czyścimy plik.
Wartości enumeratora FileMode:

Append - otwiera plik jeżeli istnieje i szuka na koncu pliku lub tworzy nowy plik jeżeli nie istnieje. Może być używany tylko z dostępem FileAccess.Write.
CreateNew - tworzy nowy plik, jeżeli plik istnieje to zgłasza wyjątek.
Create - tworzy nowy plik, jeżeli plik istnieje to go nadpisuje. Jeżeli plik istnieje ale jest ukryty to zgłoszony zostaje wyjątek.
Open - otwiera plik lub zgłasza wyjątek jeżeli plik nie istnieje.
OpenOrCreate - otwiera plik lub tworzy nowy jeżeli nie istnieje.
Truncate - otwiera plik i czyści jego dane. Jeżeli plik nie istnieje to zgłasza wyjątek.

Enumerator FileAccess określa co robimy ze strumieniem po jego utworzeniu.
Wartości enumeratora FileAccess:

Read - odczyt pliku.
Write - zapis do pliku.
ReadWrite - odczyt i zapis do pliku.

Enumerator FileShare określa typ dostępu do pliku dla innych strumieni w czasie kiedy jest on otwarty.
Wartości enumeratora FileShare:

None - blokuje dostęp do pliku.
Read - pozwala na odczyt.
Write - pozwala na zapis.
ReadWrite - pozwala na odczyt i zapis.
Delete - pozwala na usuwanie.
Inheritable - sprawia, że uchwyt pliku jest dziedziczony przez procesy.

Kiedy tworzymy lub otwieramy plik to proces musi mieć odpowiednie uprawnienia do pliku lub katalogu aby mógł wykonać określone operacje. typy uprawnień są opisane w enumeracji System.Security.Permissions.FileIOPermissionAccess:

NoAccess - brak dostępu.
Read - pozwala na odczyt.
Write - pozwala na zapis.
Append - pozwala na dodanie danych a w tym na tworzenie nowych plików i folderów.
PathDiscovery - dostęp do informacji o ścieżce.
AllAccess - wszystkie powyższe uprawnienia.

Klasy odczytujące i zapisujące

Klasy odczytujące i zapisujące (ang. readers i writers) są klasami przestrzeni nazw System.IO które odczytują lub zapisują zakodowane znaki ze strumieni.
Typy klas odczytujących i zapisujących w przestrzeni nazw System.IO:

BinaryReader, BinaryWriter - używany do odczytu i zapisu danych binarnych.
StreamReader, StreamWriter - używany do odczytu i zapisu znaków używając zakodowanej wartości do konwertowania znaków do i z bajtów.
StringReader, StringWriter - używany do odczytu i zapisu znaków do i z ciągów znaków.
TextReader, TextWriter - klasy abstrakcyjne dla innych klas odczytujących lub zapisujących.

Klasy StreamReader i StringReader dziedziczą z klasy abstrakcyjnej TextReader.
Klasy StreamWriter i StringWriter dziedziczą z klasy abstrakcyjnej TextWriter.

Klasa StreamReader jest używana do odczytu znaków w danym kodowaniu. Domyślnym kodowaniem jest UTF-8. Klasy StreamReader można użyć do odczytania standardowego pliku tekstowego.
Najczęściej wykorzystywane metody klasy StreamReader:

Close - zamyka czytnik strumienia i strumień.
Peek - zwraca następny znak ze strumienia ale nie przechodzi do jego pozycji.
Read() - zwraca następny znak ze strumienia i przechodzi do jego pozycji.
Read(Char[], Int32, Int32) - odczytuje określoną liczbę znaków do tablicy bajtowej.
ReadBlock(Char[], Int32, Int32) - odczytuje określoną liczbę znaków do tablicy bajtowej.
ReadLine - odczytuje linię tekstu i zwraca ciąg znaków.
ReadToEnd - odczytuje wszystkie znaki od aktualnej pozycji do końca pliku i zwraca ciąg znaków.

Poniższy kod wyświetla treść pliku znak po znaku, linię po linii oraz całą zawartość naraz za pomocą klasy StreamReader:

StreamReader streamReader = new StreamReader(@"d:\Samples\Numbers.txt");
Debug.WriteLine("Char by Char");
while (!streamReader.EndOfStream)
{
    Debug.WriteLine((char)streamReader.Read());
}
streamReader.Close();

streamReader = new StreamReader(@"d:\Samples\Numbers.txt");
Debug.WriteLine("Line by line");
while (!streamReader.EndOfStream)
{
    Debug.WriteLine(streamReader.ReadLine());
}
streamReader.Close();

streamReader = new StreamReader(@"d:\Samples\Numbers.txt");
Debug.WriteLine("Entire file");
Debug.WriteLine(streamReader.ReadToEnd());

Klasa StringReader jest podobna do klasy StreamReader z wyjątkiem tego, że zamiast odczytywać plik odczytujemy ciąg znaków. Konstruktor klasy StringReader pobiera ciąg znaków jako parametr.
Poniższy kod wyświetla treść pliku znak po znaku za pomocą klasy StringReader:

StringReader stringReader = new StringReader("Hello\nGoodbye");
int pos = stringReader.Read();

while (pos != -1)
{
    Debug.WriteLine("{0}", (char)pos);
    pos = stringReader.Read();
}

stringReader.Close();

Klasa StreamWriter jest podobna do klasy Stream z wyjątkiem tego, że klasa StreamWriter odczytuje znaki w określonym kodowaniu a klasa Stream jest zaprojektowana do bajtowego wejścia i wyjścia. Klasy StreamWriter można użyć do zapisu danych do pliku. Klasa StreamWriterposiada metody Write i WriteLine służące do zapisu strumienia do pamięci. Klasa StreamWriter posiada właściwość AutoFlush która kiedy jest ustawiona na true to powoduje, że zapis do zasobu jest wykonywany po wywołaniu metody Write a kiedy jest ustawiona na false to zapis do zasobu jest wykonywany po wywołaniu metody Flush lub kiedy StreamWriter jest zamykany.
Poniższy kod zapisuje wartości do pliku:

StreamWriter streamWriter = new
    StreamWriter(@"d:\Samples\StreamWriter.txt");

streamWriter.WriteLine("ABC");
streamWriter.Write(true);
streamWriter.Write(1);

streamWriter.Close();

Parametr konstruktora przyjmuje ścieżkę do pliku. jeżeli plik istnieje to jest nadpisywany lub jest tworzony jeżeli nie istnieje. Do konstruktora można również przekazać strumień.

Klasy BinaryWriter używamy do zapisu typów prostych binarnie lub jako ciągów znaków w wybranym kodowaniu.
Poniższy kod zapisuje dane w formacie binarnym:

FileStream fileStream = new FileStream(@"d:\Samples\BinaryWriter.txt",
    FileMode.Create);
BinaryWriter binaryWriter = new BinaryWriter(fileStream);

binaryWriter.Write("ABC");
binaryWriter.Write(true);
binaryWriter.Write(1);

binaryWriter.Close();

Klasa BinaryWriter potrzebuje obiektu Stream przekazanego do konstruktora.

Aby odczytać dane binarne należy użyć klasy BinaryReader.
Poniższy kod odczytuje plik utworzony poprzednio:

FileStream fileStream = new FileStream(@"d:\Samples\BinaryWriter.txt",
    FileMode.Open);
BinaryReader binaryReader = new BinaryReader(fileStream);

string abs = binaryReader.ReadString();
bool b = binaryReader.ReadBoolean();
int i = binaryReader.ReadInt32();

binaryReader.Close();

Asynchroniczne Operacje I/O

Klasy Stream, Reader i Writer zapewniają możliwość odczytu i zapisu plików asynchronicznie.
Wykonanie asynchroniczne odbywa się z użyciem słów kluczowych async i await.

Poniższy fragment kodu demonstruje asynchroniczne przeszukiwanie plików w folderze które zawierają określony ciąg znaków. Jeżeli plik zawiera szukaną frazę to jego nazwa jest wyświetlana:

privateasyncvoidbutton1_Click(object sender, EventArgs e)
{
this.Text = "Searching...";

string outputFileName = @"d:\Samples\FoundFiles.txt";

await SearchDirectory(@"d:\Samples", "A", outputFileName);

this.Text = "Finished";

    Process.Start(outputFileName);
}

privatestaticasync Task SearchDirectory(string searchPath, string searchString,
string outputFileName)
{
    StreamWriter streamWriter = File.CreateText(outputFileName);

string[] fileNames = Directory.GetFiles(searchPath);
await FindTextInFilesAsync(fileNames, searchString, streamWriter);

    streamWriter.Close();
}

privatestaticasync Task FindTextInFilesAsync(string[] fileNames, string
    searchString, StreamWriter outputFile)
{
foreach (string fileName in fileNames)
        {
if (fileName.ToLower().EndsWith(".txt"))
            {
                StreamReader streamReader = new StreamReader(fileName);

string textOfFile = await streamReader.ReadToEndAsync();
                streamReader.Close();

if (textOfFile.Contains(searchString))
                {
await outputFile.WriteLineAsync(fileName);
                }
        }
    }
}

Serializacja

Serializacja jest procesem transformacji obiektu do innej formy która może być przechowywana w magazynie danych lub przesyłana z jednej domeny aplikacji do innej. Proces odwrotny do serializacji to deserializacja. Obiekty można serializować do zapisu na dysku, do strumienia, do pamięci lub do przesłania przez sieć. Najbardziej popularnymi formatami serializacji są XML i JSON. .NET Framework posiada klasy które wspierają serializację binarną, XML i JSON. Można również utworzyć własny sposób serializacji.

Serializacja binarna

Klasa BinaryFormatter jest używana do binarnej serializacji obiektów. Można ją znaleźć w przestrzeni nazw System.Runtime.Serialization.Formatters.Binary. Dwie najważniejsze metody tej klasy to Serialize i Deserialize.
Klasy BinaryFormatter można użyć ze strumieniem FileStream do odczytu i zapisu obiektów na dysk. Klasa która ma być serializowana musi posiadać atrybut [Serializable].
Poniższy fragment kodu tworzy klasę Person i czyni ją serializowalną:

[Serializable]
classPerson
{
privateint _id;
publicstring FirstName;
publicstring LastName;

publicvoidSetId(int id)
{
        _id = id;
    }
}

Jeżeli chcemy zapisać obiekt do magazynu danych to możemy utworzyć instancję klasy BinaryFormatter i wywołać metodę Serialize:

Person person = new Person();
person.SetId(1);
person.FirstName = "Joe";
person.LastName = "Smith";

IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream("Person.bin", FileMode.Create, FileAccess.Write,
    FileShare.None);
formatter.Serialize(stream, person);
stream.Close();

Należy zauważyć, że nawet prywatne zmienne są zapisywane na dysk.

Aby odtworzyć obiekt z pliku Person.bin należy użyć metody Deserialize:

stream = new FileStream("Person.bin",FileMode.Open,FileAccess.Read,FileShare.Read);
Person person2 = (Person)formatter.Deserialize(stream);
stream.Close();

Aby zapobiec serializacji pola klasy należy użyć atrybutu [NonSerialized], np:

[Serializable]
classPerson
{
    [NonSerialized]
privateint _id;
publicstring FirstName;
publicstring LastName;
publicvoidSetId(int id)
{
        _id = id;
    }
}

Serializacja XML

Do serializacji XML używamy klasy XmlSerializer z przestrzeni nazw System.Xml.Serialization. Klasa XmlSerializer serializuje jedynie klasy publiczne i ich publiczne właściwości i pola oraz nie wymaga użycia atrybutu [Serializable].
Poniższy fragment kodu serializuje obiekt klasy Person:

Personperson = new Person();
person.SetId(1);
person.FirstName = "Joe";
person.LastName = "Smith";

XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
StreamWriter streamWriter = new StreamWriter("Person.xml");
xmlSerializer.Serialize(streamWriter, person);

Wynik działania kodu:

<?xml version="1.0" encoding="utf-8"?>
<Personxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<FirstName>Joe</FirstName>
<LastName>Smith</LastName>
</Person>

Aby pole było ignorowane podczas serializacji należy użyć atrybutu [XmlIgnore], np:

[XmlIgnore]
publicstring FirstName;

Aby odtworzyć obiekt z pliku XML należy użyć metody Deserialize:

XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
FileStream fs = new FileStream("Person.xml", FileMode.Open);
Personperson = (Person)xmlSerializer.Deserialize(fs);

Atrybuty używane przez XmlSerializer:

XmlIgnore - ignoruje pole w czasie serializacji.
XmlAttribute - mapuje pole jako atrybut.
XmlElement - mapuje pole jako węzeł.
XmlArray - używany przy serializacji kolekcji.
XmlArrayItem - używany przy serializacji kolekcji.

Przykład atrybutów serializacji kolekcji:

[Serializable]
publicclassOrder
{
 [XmlAttribute]
 publicint ID { get; set; }

 [XmlIgnore]
 publicbool IsDirty { get; set; }

 [XmlArray(“Lines”)]
 [XmlArrayItem(“OrderLine”)]
 public List<OrderLine> OrderLines { get; set; }
}

Serializacja JSON

JSON jest podobny do XML z tym, że jest mniej obszerny. Aby serializować do postaci JSON trzeba jawnie wstawić atrybut przed każdą właściwością która ma być serializowana. Ponadto trzeba użyć atrybutu klasy [DataContract].
Poniższy fragment kodu pokazuje jak należy zmodyfikować klasę Person aby możliwa była serializacja JSON:

[DataContract]
publicclassPerson
{
    [DataMember]
privateint _id;
    [DataMember]
publicstring FirstName;
    [DataMember]
publicstring LastName;

publicvoidSetId(int id)
{
        _id = id;
    }
}

Aby zignorować pole należy nie umieszczać atrybutu [DataMember] przed jego deklaracją.
Poniższy fragment kodu demonstruje serializację obiektu klasy Person do JSON:
Person person = new Person();

person.SetId(1);
person.FirstName = "Joe";
person.LastName = "Smith";

Stream stream = new FileStream("Person.json", FileMode.Create);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
ser.WriteObject(stream, person);
stream.Close();

Zamiast metody Serialize używamy metody WriteObject.
Wynik działania kodu:

{
    "FirstName":"Joe",
    "LastName":"Smith",
    "_id":1
}

Aby odczytać obiekt z postaci JSON należy użyć metody ReadObject:

Personperson = new Person();

Stream stream = new FileStream("Person.json", FileMode.Open);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
person = (Person)ser.ReadObject(stream);
stream.Close();

Serializacja niestandardowa

Istnieją dwa sposoby dostosowywania procesu serializacji. Pierwszym jest dodanie metody z odpowiednim atrybutem która będzie manipulowała danymi obiektu w czasie serializacji i deserializacji obiektu. Atrybuty których można użyć to OnDeserializedAttribute,OnDeserializingAttribute, OnSerializedAttribute i OnSerializingAttribute. Dodanie tych atrybutów przed metodami powoduje ich uruchomienie w wybranej fazie procesu serializacji lub deserializacji.
Poniższy fragment kodu dostosowuje logikę serializacji klasy Person:

[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context)
{
    FirstName = "Bob";
}

[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context)
{
    FirstName = "Serialize Complete";
}

[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context)
{
    FirstName = "John";
}

[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context)
{
    FirstName = "Deserialize Complete";
}

Drugim sposobem dostosowania serializacji jest implementacja interfejsu ISerializable. Interfejs ten posiada jedną metodę którą trzeba zaimplementować GetObjectData. Metoda ta jest wywoływana kiedy obiekt jest serializowany. Należy zaimplementować również specjalny konstruktor który będzie wywołany podczas deserializacji.
Poniższy fragment kodu zmienia klasę Person tak aby implementowała interfejs ISerializable:

[Serializable]
publicclassPerson : ISerializable
{
privateint _id;
publicstring FirstName;
publicstring LastName;

publicvoidSetId(int id)
{
        _id = id;
    }

publicPerson() { }

publicPerson(SerializationInfo info, StreamingContext context)
{
        FirstName = info.GetString("custom field 1");
        LastName = info.GetString("custom field 2");
    }

publicvoidGetObjectData(SerializationInfo info, StreamingContext context)
{
        info.AddValue("custom field 1", FirstName);
        info.AddValue("custom field 2", LastName);
    }
}

Metoda GetObjectData pobiera parametr typu SerializationInfo która pozwala dostosować nazwę i dane, które zostaną zapisane do strumienia.
Wynik serializacji do JSON będzie następujący:

{
    "custom_x0020_field_x0020_1":"Joe",
    "custom_x0020_field_x0020_2":"Smith"
}

Kiedy obiekt jest deserializowany to wywoływany jest konstruktor z parametrem typu SerializationInfo. Można go użyć do odtworzenia obiektu za pomocą użytych nazw niestandardowych.

W większości przypadków zalecane jest użycie atrybutów zamiast implementowania interfejsu ISerializable.

Podsumowanie

Tablice i kolekcje

Tablice dziedziczą z typu System.Array.
Kolekcje ArrayList, HashTable, Queue, SortedList, i Stack znajdują się w przestrzeni nazw System.Collections.
Kolekcje Dictionary<TKey, TValue>, List, Queue, SortedList<TKey, TValue> i Stack znajdują się w przestrzeni nazw System.Collections.Generic.
Kolekcja Queue jest typu first-in-first-out.
Kolekcja Stack jest typu last-in-first-out.
Aby porównywać obiekty należy zaimplementować interfejs IComparable.
Kolekcja Dictionary przechowuje pary klucz/wartość.
Kolekcje niestandardowe dziedziczą z klasy bazowej CollectionBase.

ADO.NET

ADO.NET jest zestawem klas używanych do wykonywania komend na bazie danych.
Obiekt Command jest używany do wykonywania procedur składowanych lub instrukcji SQL.
Metoda ExecuteNonQuery jest używana do wykonywania instrukcji które nie zwracają wyników jak np INSERT lub UPDATE.
Metoda ExecuteScalar jest używana do pobierania tylko jednej wartości z bazy danych.
Obiekt DBDataReader jest kursorem tylko do odczytu połączonym z bazą danych który odczytuje dane tylko w przód.
Metoda ExecuteXMLReader zwraca dane w postaci XML. Aby pobrać dane w postaci XML z bazy SQL Server należy użyć klauzuli FOR XML.
Obiekt DataSet jest odłączonym od bazy zbiorem wyników i może posiadać jedną lub więcej tabel wynikowych DataTables. Klasa DataAdapter jest używana do wypełnienia DataSet.
Klasa DataAdapter może być użyta z DataSet do dodawania, aktualizacji lub usuwania rekordów z bazy danych.

ADO.NET Entity Framework

Entity Framework jest narzędziem typu ORM które używa ADO.NET do komunikacji z baza danych.
Entity Framework Model zawiera klasy reprezentujące obiekty w bazie danych.
W Entity Framework Model procedury składowane są zmapowane jako metody.

WCF Data Services

WCF Data Services pozwalają na dostęp do bazy danych przez sieć.
WCF Data Services używają protokołu OData.
WCF Data Services domyslnie zwracają dane w formacie OData ATOM ale mogą również zwracać je jako JSON.
Dane w bazie danych można odpytywać za pomocą ciągów zapytań w adresie URL.

I\O

Klasy File i FileInfo sa używane do uzyskiwania właściwości plików oraz wykonywania operacji na plikach.
Obiekt strumienia Stream jest używany jako reprezentacja pliku w pamięci i może być używany do zapisu i odczytu danych w pliku.
Klasy BinaryReader i BinaryWriter są używane do zapisu i odczytu plików w postaci binarnej.
Klasy StreamReader i StreamWriter są używane do zapisu i odczytu znaków poprzez użycie kodowanej wartości do konwertowania znaków do i z postaci binarnej. Domyślnym kodowaniem jest UTF-8.
Za pomocą obiektu StreamReader można odczytywać plik znak po znaku, linia po linii lub cały na raz.
Klasy StringReader i StringWriter odczytują i zapisują ciągi znaków.

Serializacja

Serializacja jest procesem transformacji obiektu do innej formy która może być przechowywana w magazynie danych lub przesyłana z jednej domeny aplikacji do innej.
Klasa BinaryFormatter służy do serializacji binarnej.
Klasa XmlSerializer służy do serializacji XML.
Klasa DataContractJsonSerializer służy do serializacji JSON.
Serializację można modyfikować używając atrybutów lub implementując interfejs ISerializable.

VII. Użycie refleksji, niestandardowych atrybutów, CodeDOM i wyrażeń Lambda

Sat, 23 Jan 2016 21:39:23 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Refleksja - znajdywanie, wykonywanie i tworzenie typów w czasie wykonania.
Atrybuty - tworzenie, stosowanie i odczyt atrybutów które mogą być używane do zmiany zachowania klas.
CodeDOM - tworzenie generatorów kodu.
Wyrażenia Lambda - skrócona składnia tworzenia metod bez ich deklaracji.

Użycie przestrzeni nazw System.Reflection

Refleksja odnosi się do zdolności do zbadania kodu i dynamicznego odczytu, modyfikacji lub wywołania zachowania dla assembly, modułu lub typu. Typ jest tutaj rozumiany jako klasa, interfejs, tablica, typ wartości, enumeracja, parametr lub typ generyczny. Można użyć klas w przestrzeni nazw System.Reflection lub klasy System.Type aby dowiedzieć się jaka jest nazwa assembly, przestrzeń nazw, właściwości, metody, klasa bazowa i wiele innych metadanych o klasie lub zmiennej.

Przestrzeń nazw System.Reflection zawiera wiele klas służących do odczytu metadanych lub dynamicznego wywołania zachowania dla typu. Najczęściej wykorzystywane klasy to:

Assembly - reprezentuje plik DLL lub EXE i zawiera właściwości dla nazwy assembly, klas, modułów i innych metadanych czasu wykonania.
EventInfo - reprezentuje zdarzenia zdefiniowane w klasie i zawiera właściwości takie jak nazwa zdarzenia.
FieldInfo - reprezentuje pole zdefiniowane w klasie i zawiera właściwości takie jak to czy pole jest publiczne czy prywatne.
MemberInfo - abstrahuje metadane o klasie i może reprezentować zdarzenie, pole itd.
MethodInfo - reprezentuje metodę zdefiniowaną w klasie i może być użyta do wywołania metody.
Module - moduł jest plikiem który tworzy assembly, zwykle plik DLL lub EXE.
ParameterInfo - reprezentuje deklarację parametru dla metody lub konstruktora. Pozwala na określenie typu parametru, nazwy itp.
PropertyInfo - reprezentuje właściwość zdefiniowaną w klasie i zawiera właściwości takie jak nazwa i typ.

Refleksja jest bardzo potężnym narzędziem i może być użyta z niektórymi wzorcami projektowymi takimi jak Factory lub Inversion of Control.

Klasa Assembly

Assembly jest zasadniczo skompilowanym kawałkiem kodu, który jest zazwyczaj plikiem DLL lub EXE. Można użyć klasy Assembly aby załadować assembly, odczytać metadane o assembly a nawet utworzyć instancje typów które sa zawarte w assembly.
Lista najważniejszych właściwości klasy Assembly:

CodeBase - zwraca ścieżkę do assembly.
DefinedTypes - zwraca kolekcję typów zdefiniowanych w assembly.
ExportedTypes - zwraca kolekcję publicznych typów zdefiniowanych w assembly.
FullName - zwraca nazwę assembly.
GlobalAssemblyCache - zwraca true jeżeli assembly została załadowana z global assembly cache.
ImageRuntimeVersion - zwraca wersję CLR dla assembly.
Location - zwraca ścieżkę lub lokalizację UNC dla assembly.
Modules - zwraca kolekcję zawierającą moduły w assembly.
SecurityRuleSet - zwraca wartość która wskazuje, który zestaw reguł bezpieczeństwa jest zastosowany dla assembly przez CLR.

Przykład kodu ładującego assembly System.Data i wypisującego niektóre właściwości assembly:

Assembly myAssembly = Assembly.Load("System.Data, Version=4.0.0.0, Culture=neutral,
    PublicKeyToken=b77a5c561934e089");

Debug.WriteLine("CodeBase: {0}", myAssembly.CodeBase);
Debug.WriteLine("FullName: {0}", myAssembly.FullName);
Debug.WriteLine("GlobalAssemblyCache: {0}", myAssembly.GlobalAssemblyCache);
Debug.WriteLine("ImageRuntimeVersion: {0}", myAssembly.ImageRuntimeVersion);
Debug.WriteLine("Location: {0}", myAssembly.Location);

Wynik działania kodu:

CodeBase: file:///C:/Windows/Microsoft.Net/assembly/GAC_32/System.Data/
v4.0_4.0.0.0__b77a5c561934e089/System.Data.dll
FullName: System.Data, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
GlobalAssemblyCache: True
ImageRuntimeVersion: v4.0.30319
Location: C:\Windows\Microsoft.Net\assembly\GAC_32\System.Data\
v4.0_4.0.0.0__b77a5c561934e089\System.Data.dll

Lista najczęściej używanych metod klasy Assembly:

CreateInstance(String) - tworzy instancję klasy poprzez przeszukanie assembly dla nazwy klasy.
GetCustomAttributes(Boolean) - zwraca tablicę obiektów reprezentujących niestandardowe atrybuty dla tego assembly.
GetExecutingAssembly - zwraca obiekt klasy Assembly dla aktualnie wykonywanego programu.
GetExportedTypes - zwraca klasy publiczne zawarte w assembly.
GetModule - zwraca wyszczególniony moduł zawarty w assembly.
GetModules() - zwraca wszystkie moduły z assembly.
GetName() - zwraca AssemblyName.
GetReferencedAssemblies - zwraca tablicę obiektówAssemblyName reprezentującą wszystkie assembly do których odwołuje się to assembly.
GetTypes - zwraca tablicę obiektów Type zdefiniowanych w tym assembly.
Load(String) - ładuje assembly wg długiej nazwy.
LoadFile(String) - ładuje zawartość pliku assembly wg ścieżki pliku.
LoadFrom(String) - ładuje assembly wg nazwy lub ścieżki.
ReflectionOnlyLoad(String) - ładuje assembly, ale można wykonać na jej typach tylko refleksję.
UnsafeLoadFrom - ładuje assembly pomijając pewne kroki bezpieczeństwa.

Metoda statyczna GetExecutingAssembly pozwalająca na pobranie referencji do aktualnie wykonywanego kodu. Metody GetExportedTypes i GetTypes są używane do pobierania referencji do typów zdefiniowanych w assembly.
Poniższy fragment kodu wyświetla wszystkie typy zdefiniowane w aktualnie wykonywanym assembly:

Assembly myAssembly = Assembly.GetExecutingAssembly();

Type[] myAssemblysTypes = myAssembly.GetTypes();

foreach (Type myType in myAssemblysTypes)
{
Debug.WriteLine(string.Format("myType Name: {0}", myType.Name));
}

Właściwość Modules lub metody GetLoadedModules, GetModules i GetModule zwracają listę modułów ()lub wybrany moduł) zdefiniowanych w assembly. Moduł jest plikiem który wchodzi w skład assembly. Jest to zwykle jeden plik DLL lub EXE.
Poniższy fragment kodu wyświetla wszystkie moduły zdefiniowane w assembly System.Data:

Assembly myAssembly = Assembly.Load("System.Data, Version=4.0.0.0, Culture=neutral,
    PublicKeyToken=b77a5c561934e089");

Module[] myAssemblysModules = myAssembly.GetModules();

foreach (Module myModule in myAssemblysModules)
{
Debug.WriteLine(string.Format("Module Name: {0}", myModule.Name));
}

Wynik działania fragmentu kodu:

Module Name: System.Data.dll

Poprzedni fragment kodu użył metody Load aby załadować assembly System.Data do pamięci. Ponieważ assembly została załadowana używając metody Load to można wykonywać kod należący do assembly. Jeżeli nie potrzebujemy wykonywać kodu to możemy użyć metodyReflectionOnlyLoad.
Assembly możemy także załadować za pomocą metod LoadFrom lub LoadFile które pobierają ścieżkę jako parametr. Różnica pomiędzy tymi metodami polega na różnych typach kontekstów w jakich refleksja wyszukuje assembly. Assembly może być w jednym z trzech kontekstów lub w żadnym z nich:

load context - zawiera assembly odnalezione poprzez wykrywanie w GAC, host assembly store, folderze assembly lub w folderze prywatnym bin.
load-from context - zawiera assembly zlokalizowane w ścieżce podanej jako parametr.
reflection-only context - zawiera assembly załadowane przez metody ReflectionOnlyLoad lub ReflectionOnlyLoadFrom.

Rekomendowaną metodą jest użycie metody Load. Użycie metody LoadFrom wymaga praw dostępu oraz mogą w nim wystąpić konflikty nazw i identyfikatorów. Metody LoadFile możemy użyć jeżeli istnieją dwie assembly z tym samym identyfikatorem w różnych folderach na komputerze.

Kiedy mamy już załadowane assembly to możemy utworzyć instancje klas zdefiniowanych w tym assembly. Aby utworzyć instancję klasy używamy metody CreateInstance.
Poniższy fragment kodu tworzy instancję klasy DataTable i wypisuje liczbę wierszy w tabeli:

Assembly myAssembly = Assembly.Load("System.Data, Version=4.0.0.0, Culture=neutral,
    PublicKeyToken=b77a5c561934e089");

DataTable dt = (DataTable)myAssembly.CreateInstance("System.Data.DataTable");

Debug.Print("Number of rows: {0}", dt.Rows.Count);

Jeżeli jako parametr metody CreateInstance podamy nieistniejącą nazwę klasy to zwrócona zostanie wartość null i nie zostanie zgłoszony żaden wyjątek.

Metoda GetReferencesAssemblies jest używana do odkrywania referencji w assembly. Może to być przydatne podczas rozwiązywania problemów wdrażania.
Poniższy kod wypisuje wszystkie referencje dla assembly System.Data:

Assembly myAssembly = Assembly.Load("System.Data, Version=4.0.0.0, Culture=neutral,
    PublicKeyToken=b77a5c561934e089");

AssemblyName[] referencedAssemblyNames = myAssembly.GetReferencedAssemblies();

foreach (AssemblyName assemblyName in referencedAssemblyNames)
{
    Debug.WriteLine("Assembly Name: {0}", assemblyName.Name);
    Debug.WriteLine("Assembly Version: {0}", assemblyName.Version);
}

Wynik działania kodu:

Assembly Name: mscorlib
Assembly Version: 4.0.0.0
Assembly Name: System
Assembly Version: 4.0.0.0
Assembly Name: System.Xml
Assembly Version: 4.0.0.0
Assembly Name: System.Configuration
Assembly Version: 4.0.0.0
Assembly Name: System.Transactions
Assembly Version: 4.0.0.0
Assembly Name: System.Numerics
Assembly Version: 4.0.0.0
Assembly Name: System.EnterpriseServices
Assembly Version: 4.0.0.0
Assembly Name: System.Core
Assembly Version: 4.0.0.0

Klasa System.Type

Klasa System.Type reprezentuje klasę, interfejs, tablicę, typ wartości, enumerację, parametr i typ generyczny. Najczęściej jest używana do pobrania informacji o klasie zawartej w assembly. Możesz uzyskać odwołanie do typu na dwa sposoby.
Można użyć słowa kluczowego typeof(), np:

System.Type myType = typeof(int);

Można również użyć metody GetType() na instancji typu, np:

int myIntVariable = 0;
System.Type myType = myIntVariable.GetType();

Kiedy posiadamy referencję do typu to możemy zbadać jego właściwości. Lista najczęściej używanych właściwości dla klasy System.Type:

Assembly - zwraca Assembly w którym typ jest zadeklarowany.
AssemblyQualifiedName - zwraca ciąg znaków, który jest kompletną nazwą tego typu, i który zawiera nazwę assembly, z którego typ został załadowany.
BaseType - zwraca typ z którego dany typ dziedziczy.
FullName - zwraca ciąg znaków, który jest kompletną nazwą tego typu z przestrzenią nazw.
IsAbstract - zwraca true jeżeli typ jest abstrakcyjny.
IsArry - zwraca true jeżeli typ jest tablicą.
IsClass - zwraca true jeżeli typ jest klasą a nie interfejsem ani typem wartości.
IsEnum - zwraca true jeżeli typ jest enumeracją.
IsInterface - zwraca true jeżeli typ jest interfejsem.
IsNotPublic - zwraca true jeżeli typ nie jest zadeklarowany jako publiczny.
IsPublic - zwraca true jeżeli typ jest zadeklarowany jako publiczny.
IsSerializable - zwraca true jeżeli typ jest serializowany.
IsValueType - zwraca true jeżeli typ jest typem wartości.
Name - zwraca nazwę typu.
Namespace - zwraca przestrzeń nazw typu.

Przykład wyświetlający niektóre właściwości typu int:

int myIntVariable = 0;
System.Type myType = myIntVariable.GetType();

Debug.WriteLine("AssmeblyQualifiedName: {0}", myType.AssemblyQualifiedName);
Debug.WriteLine("FullName: {0}", myType.FullName);
Debug.WriteLine("IsValueType: {0}", myType.IsValueType);
Debug.WriteLine("Name: {0}", myType.Name);
Debug.WriteLine("Namespace: {0}", myType.Namespace);

Wynik działania kodu:

AssmeblyQualifiedName: System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
FullName: System.Int32
IsValueType: True
Name: Int32
Namespace: System

Klasa System.Type posiada również metody których można użyć do pobrania metadanych typu.
Lista najczęściej wykorzystywanych metod klasy System.Type:

GetArrayRank - jeżeli typ jest tablicą, to metoda zwraca liczbę wymiarów w tablicy.
GetConstructor(Type[]) - szuka publicznych wystąpień konstruktora którego parametry pasują do typów określonych w tablicy i zwraca obiekt klasy ConstructorInfo.
GetConstructors() - zwraca tablicę obiektów ConstructorInfo dla wszystkich publicznych konstruktorów zdefiniowanych dla danego typu.
GetEnumName - jeżeli typ jest enumeracją to metoda zwraca nazwę elementu który posiada określoną wartość.
GetEnumNames - jeżeli typ jest enumeracją to metoda zwraca wszystkie nazwy członków enumeracji.
GetEnumValues - jeżeli typ jest enumeracją to metoda zwraca tablicę wartości enumeracji.
GetField(String) - szuka publicznego pola o określonej nazwie.
GetFields() - zwraca wszystkie publiczne pola.
GetInterface(String) - zwraca interfejs o określonej nazwie.
GetMember(String) - zwraca publiczny element o określonej nazwie.
GetMembers - zwraca wszystkie publiczne element typu.
GetMethod(String) - zwraca publiczną metodę o określonej nazwie.
GetMethods() - zwraca wszystkie metody publiczne typu.
GetProperty(String) - zwraca publiczną właściwość o określonej nazwie.
GetProperties() - zwraca wszystkie publiczne właściwości typu.
GetTypeArray - zwraca wszystkie typy obiektów w wybranej tablicy.
InvokeMember(String, BindingFlags, Binder, Object, Object[]) - wykonuje metodę używając określonych powiązan i dopasowując listę argumentów.

GetArrayRank

Jeżeli typ jest tablicą, to metoda zwraca liczbę wymiarów w tablicy. Poniższy kod tworzy trzy-wymiarową tablicę i wyświetla liczbę wymiarów tablicy:

int[,,] myIntArray = new int[5,6,7];
Type myIntArrayType = myIntArray.GetType();
Debug.Print("Array Rank: {0}", myIntArrayType.GetArrayRank());

Wynik:

3

GetConstructors

Metoda zwraca tablicę obiektów ConstructorInfo dla wszystkich publicznych konstruktorów zdefiniowanych dla danego typu. Poniższy kod wyświetla konstruktory publiczne dla klasy System.DataTable:

DataTable myDataTable = new DataTable();
Type myDataTableType = myDataTable.GetType();
ConstructorInfo[] myDataTableConstructors = myDataTableType.GetConstructors();

for(int i = 0; i <= myDataTableConstructors.Length - 1; i++)
{
    ConstructorInfo constructorInfo = myDataTableConstructors[i];
    Debug.Print("\nConstructor #{0}", i + 1);

    ParameterInfo[] parameters = constructorInfo.GetParameters();
    Debug.Print("Number Of Parameters: {0}", parameters.Length);

    foreach (ParameterInfo parameterin parameters)
    {
        Debug.Print("Parameter Name: {0}", parameter.Name);
        Debug.Print("Parameter Type: {0}",
parameter.ParameterType.Name);
    }
}

Wynik:

Constructor #1
Number Of Parameters: 0
Constructor #2
Number Of Parameters: 1
Parameter Name: tableName
Parameter Type: String
Constructor #3
Number Of Parameters: 2
Parameter Name: tableName
Parameter Type: String
Parameter Name: tableNamespace
Parameter Type: String

GetEnumName, GetEnumNames i GetEnumValues

Jeżeli typ jest enumeracją to metody GetEnum… pozwalają na pobranie wszystkich nazw i wartości enumeracji.
Przykładowa enumeracja:

privateenumMyCustomEnum
{
Red = 1,
White = 2,
Blue = 3
}

Kod wyświetlający wszystkie nazwy enumeracji:

Type myCustomEnumType = typeof(MyCustomEnum);
string[] enumNames = myCustomEnumType.GetEnumNames();

foreach (string enumName in enumNames)
{
    Debug.Print(string.Format("Name: {0}", enumName));
}

Wynik:

Name: Red
Name: White
Name: Blue

Wartości enumeracji można pobrać za pomocą metody GetEnumValues. Poniższa metoda wyświetla wszystkie wartości enumeracji:

Type myCustomEnumType = typeof(MyCustomEnum);
Array enumValues = myCustomEnumType.GetEnumValues();

foreach (object enumValue in enumValues)
{
    Debug.Print(string.Format("Enum Value: {0}", enumValue.ToString()));
}

Wynik:

Enum Value: Red
Enum Value: White
Enum Value: Blue

Zauważmy, że wartości są takie same jak nazwy.

Można również użyć metody GetEnumName aby pobrać nazwę. Poniższy kod wyświetla wszystkich członków używając wartości enumeracji:

Type myCustomEnumType = typeof(MyCustomEnum);

for (int i = 1; i <= 3; i++)
{
    string enumName = myCustomEnumType.GetEnumName(i);
    Debug.Print(string.Format("{0}: {1}", enumName, i));
}

Wynik:

Red: 1
White: 2
Blue: 3

GetField i GetFields

Pole jest zmienną zdefiniowaną w klasie lub strukturze. Metoda GetField jest używana do pobrania obiektu klasy FieldInfo dla pola. Metoda GetFields pobiera tablicę obiektów FieldInfo. Metoda GetFields może również zwrócić pola z odziedziczonych klas. Kiedy ją wywołujemy to wstawiamy enumerację BindingFlags aby wybrać zakres pól które chcemy pobrać.
Poniższa klasa zawiera pięć pól z różnych zakresów:

classReflectionExample
{
privatestring _privateField = "Hello";
publicstring _publicField = "Goodbye";
internalstring _internalfield = "Hola";
protectedstring _protectedField = "Adios";
staticstring _staticField = "Bonjour";
}

Możemy użyć metody GetFields aby pobrać wartości tych zmiennych w zależności od zakresu, np:

ReflectionExample reflectionExample = new ReflectionExample();
Type reflectionExampleType = typeof(ReflectionExample);

FieldInfo[] fields = reflectionExampleType.GetFields(BindingFlags.Public |
    BindingFlags.Instance |
    BindingFlags.Static |
    BindingFlags.NonPublic |
    BindingFlags.FlattenHierarchy);

foreach (FieldInfo field in fields)
{
object fieldValue = field.GetValue(reflectionExample);

    Debug.WriteLine(string.Format("Field Name: {0}, Value: {1}", field.Name,
        fieldValue.ToString()));
}

Wynik:

Field Name: _privateField, Value: Hello
Field Name: _publicField, Value: Goodbye
Field Name: _internalfield, Value: Hola
Field Name: _protectedField, Value: Adios
Field Name: _staticField, Value: Bonjour

Wywołując metodę GetFieldsmożemy użyć operatora bitowego aby wybrać więcej niż jedną wartość enumeracji BindingFlags.

Dzięki refleksji można odczytać także zmienne prywatne więc trzeba mieć na uwadze co zapisujemy w tych zmiennych.

Obiekt FieldInfo posiada także metodę SetValue która pozwala zmienić wartość zmiennej, nawet jeżeli jest prywatna lub chroniona.
Przykładowo dodajmy do klasy ReflectionExample właściwość:

publicstring PrivateField
{
get { return privateField; }
}

Poniższy kod zmienia wartość zmiennej privateField i ją wyświetla:

ReflectionExample reflectionExample = new ReflectionExample();
Type reflectionExampleType = typeof(ReflectionExample);

reflectionExampleType.GetField("privateField", BindingFlags.NonPublic |
    BindingFlags.Instance).SetValue(reflectionExample, "My New Value");

Debug.Print("Private Field Value: {0}",
    reflectionExample.PrivateField);

Wynik:

Private Field Value: My New Value

GetProperty i GetProperties

Metody GetProperty i GetProperties są podobne do GetField i GetFields ponieważ pozwalają na pobranie właściwości, pobranie ich wartości i ustawienie ich wartości. Metody zwracają obiekty klasy PropertyInfo zamiast FieldInfo.

GetMethod i GetMethods

Metody GetMethod i GetMethods pozwalają na pobranie informacji o metodach danego typu. Po pobraniu referencji do metody możemy ją wykonać za pomocą metody Invoke obiektu klasy MethodInfo. Wybraną metodę można również wykonać za pomocą metody InvokeMember klasySystem.Type.
Dodajmy poniższą metodę do klasy ReflectionExample:

publicdoubleMultiply(double x, double y)
{
return x * y;
}

Poniższy kod wykonuje metodę Multiply i wyświetla jej wynik:

ReflectionExample reflectionExample = new ReflectionExample();
Type reflectionExampleType = typeof(ReflectionExample);

MethodInfo methodInfo = reflectionExampleType.GetMethod("Multiply");
double returnValue = (double)methodInfo.Invoke(reflectionExample,
new object[] { 4, 5 });

Debug.Print("Return Value: {0}", returnValue);

Parametry metody wstawiamy używając tablicy obiektów jako drugiego parametru metody Invoke.
Wynik:

Return Value: 20

Używając metody InvokeMember składnia jest następująca:

ReflectionExample reflectionExample = new ReflectionExample();
Type reflectionExampleType = typeof(ReflectionExample);

double returnValue = (double)reflectionExampleType.InvokeMember("Multiply",
    BindingFlags.InvokeMethod,
null,
    reflectionExample,
newobject[] { 4, 5 });

Debug.Print(string.Format("Return Value: {0}", returnValue));

Drugim parametrem jest BindingFlags.InvokeMethod, która wywołuje metodę InvokeMember.

Odczyt i tworzenie atrybutów niestandardowych

Atrybuty pozwalają definiować metadane dla klas, właściwości lub metod. Klasa, właściwość lub metoda są określane jako cel atrybutu. Refleksja może być użyta do odczytu tych atrybutów dynamicznie i zmiany zachowania celu. Atrybuty są zawarte w nawiasy kwadratowe “[ ]” powyżej celu i mogą być układane jeden po drugim gdy potrzebnych jest wiele atrybutów do definiowania celu. Przykładowo jeżeli chcemy aby klasa była serializowalna to musimy dodać atrybut [Serializable()] do definicji klasy, np:

[Serializable()]
publicclassMyClass
{
//…
}

Atrybut Serializable jest klasą zdefiniowaną w .NET Framework’u która dziedziczy z klasy System.Attribute. Klasa System.Attribute jest klasą abstrakcyjną która jest klasą bazową dla wszystkich atrybutów niestandardowych.

Odczyt atrybutów

Przestrzen nazw System.Reflection posiada wiele klas pozwalających na odczyt metadanych klas wewnątrz assembly. Assembly posiada metodę GetCustomAttributes która pozwala na odczyt wszystkich klas atrybutów niestandardowych zdefiniowanych w assembly lub odfiltrowanie konkretnego typu atrybutu.
Poniższy kod iteruje przez wszystkie assembly do których odnosi się aktualna assembly i wyświetla nazwy klas niestandardowych atrybutów:

Assembly assembly = Assembly.GetExecutingAssembly();
AssemblyName[] assemblyNames = assembly.GetReferencedAssemblies();

foreach (AssemblyName assemblyName in assemblyNames)
{
    Debug.WriteLine("\nAssembly Name: {0}", assemblyName.FullName);

    Assembly referencedAssembly = Assembly.Load(assemblyName.FullName);

    object[] attributes = referencedAssembly.GetCustomAttributes(false);

foreach (object attribute in attributes)
    {
        Debug.WriteLine(\nAttribute Name: {0}",
            attribute.GetType().Name);

//Get the properties of this attribute
        PropertyInfo[] properties = attribute.GetType().GetProperties();
foreach (PropertyInfo property in properties)
        {
            Debug.WriteLine("{0} : {1}", property.Name,
                property.GetValue(attribute));
        }
    }
}

Aktualnie wykonywane assembly posiada referencje do: mscorlib, System.Data i System. Wynik działania kodu:

Assembly Name: mscorlib, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
Attribute Name: StringFreezingAttribute
TypeId : System.Runtime.CompilerServices.StringFreezingAttribute
…
Assembly Name: System, Version=4.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089
Attribute Name: ComVisibleAttribute
Value : False
TypeId : System.Runtime.InteropServices.ComVisibleAttribute

Tworzenie atrybutów

Aby utworzyć własny atrybut niestandardowy należy utworzyć klasę dziedziczącą z klasy abstrakcyjnej System.Attribute, np:

classMyCustomAttribute : System.Attribute
{
}

Nazywając klasę atrybutu należy dodać do nazwy sufiks Attribute. Kiedy korzystamy z atrybutów możemy odwoływać się do nich pomijając sufiks.

Po zadeklarowaniu klasy można dodać do niej właściwości i enumeracje tak samo jak do każdej innej klasy.
Przykładowo dodajmy enumerację i trzy właściwości:

classMyCustomAttribute : System.Attribute
{
publicenum MyCustomAttributeEnum
    {
        Red,
        White,
        Blue
    }

publicbool Property1 { get; set; }
publicstring Property2 { get; set; }
public MyCustomAttributeEnum Property3 { get; set; }
}

Kolejnym krokiem jest zdefiniowanie zakresu atrybutu. Przykładowo ograniczymy zakres atrybutu do klas i struktur. Aby tego dokonać używamy atrybutu System.AttributeUsage, np:

[System.AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
classMyCustomAttribute : System.Attribute
{
//…
}

Teraz możemy użyć tego atrybutu definiując klasę, np:

[MyCustom(Property1 = true, Property2 = "Hello World", Property3 =
MyCustomAttribute.MyCustomAttributeEnum.Red)]
class MyTestClass()
{
}

Zauważmy, że użyliśmy nazwy atrybutu MyCustom a nie MyCustomAttribute.
Aby ustawić wartości właściwości wstawiliśmy ich wartości jako parametry nazwane. Można również dodać konstruktor do klasy atrybutu i w nim ustawić wartości.

Teraz gdy mamy klasę z atrybutami to możemy odczytać wartośi właściwości atrybutów za pomocą refleksji:

Type myTestClassType = typeof(MyTestClass);
MyCustomAttribute attribute =
    (MyCustomAttribute)myTestClassType.GetCustomAttribute
        (
            typeof(MyCustomAttribute),
false
        );

Debug.WriteLine("Property1: {0}", attribute.Property1);
Debug.WriteLine("Property2: {0}", attribute.Property2);
Debug.WriteLine("Property3: {0}", attribute.Property3);

Wynik:

Property1: True
Property2: Hello World
Property3: Red

Generowanie kodu za pomocą CodeDOM

The Code Document Object Model, CodeDOM jest zestawem klas w .NET Framework który umożliwia tworzenie generatorów kodu. CodeDOM zawiera klasy reprezentujące właściwości, metody, klasy, logikę, parametry i inne typy kodu.

Można użyć klas CodeDOM do wygenerowania kodu w C#, VB.NET lub JScript. Kod wygenerowany przez CodeDOM jest bardzo dobry do automatyzacji powtarzalnych zadań lub egzekwowania wzorców w projekcie.

W tej sekcji zademonstrujemy jak utworzyć klasę która posiada pola, właściwości i metody, używając CodeDOM.
Typowa struktura klasy w C# posiada następujące elementy:

Plik tekstowy w którym znajduje się kod klasy.
Zestaw wyrażeń using.
Deklarację przestrzeni nazw.
Deklarację nazwy klasy.
Zestaw pól, właściwości i metod. Metody mogą posiadać logikę z pętlami, wyrażeniami itp.

Przestrzeń nazw CodeDOM posiada klasy które umożliwiają utworzenie struktóry nazywanej grafem CodeDOM Graph, który modeluje te elementy.

Lista najczęściej używanych klas przestrzeni CodeDOM:

CodeArgumentReferenceExpression - reprezentuje referencję do wartości argumentu wstawianego do metody.
CodeAssignStatement - instrukcja przypisania.
CodeBinaryOperatorExpression - wyrażenie zawierające operację binarną.
CodeCastExpression - wyrażenie rzutowania typów.
CodeComment - komentarz.
CodeCompileUnit - kontener dla CodeDOM, zawierający deklaracje, przestrzeń nazw, klasy i komponenty klasy.
CodeConditionStatement - instrukcja warunkowa np if.
CodeConstructor - konstruktor.
CodeFieldReferenceExpression - referencja do pola.
CodeIterationStatement - pętla np for.
CodeMemberEvent - deklaracja zdarzenia.
CodeMemberField - deklaracja pola.
CodeMemberMethod - deklaracja metody.
CodeMemberProperty - deklaracja waściwości.
CodeMethodInvokeExpression - wyrażenie wywołujące metodę.
CodeMethodReturnStatement - instrukcja return.
CodeNamespace - deklaracja przestrzeni nazw.
CodeNamespaceImport - dyrektywa importu przestrzeni nazw.
CodeObjectCreateExpression - wyrażenie tworzące nową instancję typu.
CodeParameterDeclarationExpression - deklaracja parametru dla metody, właściwości lub konstruktora.
CodePropertyReferenceExpression - referencja do wartości właściwości.
CodePropertySetValueReferenceExpression - argument wartości dla metody set właściwości.
CodeRegionDirective - nazwa i tryb regionu kodu.
CodeSnippetCompileUnit - reprezentuje tekstowy fragment kodu który może być skompilowany.
CodeSnippetStatement - reprezentuje tekstowy fragment kodu.
CodeThisReferenceExpression - referencja do instancji klasy lokalnej.
CodeThrowExceptionStatement - wyrażenie wyrzucania wyjątku.
CodeTryCatchFinallyStatement - blok try-catch-finally.
CodeTypeConstructor - statyczny konstruktor klasy.
CodeTypeDeclaration - deklaracja klasy, struktury, interfejsu lub enumeracji.
CodeTypeDelegate - deklaracja delegaty.
CodeVariableDeclarationStatement - deklaracja zmiennej.
CodeVariableReferenceExpression - referencja do zmiennej lokalnej.

Przestrzeń nazw CodeDOM posiada klasę dla każdego typu wyrażenia które można utworzyć w .NET Framework.
Kod klasy który wygenerujemy za pomocą CodeDOM:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespaceReflection
{
publicclassCalculator
    {
publicdouble X { get; set; }

publicdouble Y { get; set; }

publicdoubleDivide()
{
if (this.Y == 0)
            {
return0;
            }
else
            {
returnthis.X / this.Y;
            }
        }

publicdoubleExponent(double power)
{
return Math.Pow(this.X, power);
        }
    }
}

Jest to prosta klasa nazwana Calculator znajdująca się w przestrzeni nazw Reflection, zawierająca dwa pola, dwie właściwości i dwie metody. poniższe sekcje zademonstrują jak wygenerować taką klasę dynamicznie za pomocą CodeDOM.

CodeCompileUnit

Klasa CodeCompileUnit jest kontenerem dla wszystkich obiektów które chcemy wygenerować. Mozna myśleć o niej jak o pliku który ma zawierać cały wygenerowany kod.
Poniższy kod służy do utworzenia instancji tej klasy:

CodeCompileUnit codeCompileUnit = new CodeCompileUnit();

CodeNamespace i CodeNamespaceImport

Klasa CodeNamespace jest używana do deklarowania przestrzenii nazw. Konstruktor tej klasy pobiera nazwę przestrzeni nazw jako parametr:

CodeNamespace codeNamespace = new CodeNamespace("Reflection");

Klasa CodeNamespaceImport dodaje instrukcje using:

codeNamespace.Imports.Add(newCodeNamespaceImport("System"));
codeNamespace.Imports.Add(newCodeNamespaceImport("System.Collections.Generic"));
codeNamespace.Imports.Add(newCodeNamespaceImport("System.Linq"));
codeNamespace.Imports.Add(newCodeNamespaceImport("System.Text"));
codeNamespace.Imports.Add(newCodeNamespaceImport("System.Threading.Tasks"));

CodeTypeDeclaration

Klasa CodeTypeDeclaration służy do deklaracji klasy:

CodeTypeDeclaration targetClass = new CodeTypeDeclaration("Calculator");
targetClass.IsClass = true;
targetClass.TypeAttributes = TypeAttributes.Public;
//Add the class to the namespace.
codeNamespace.Types.Add(targetClass);

Ustawienie wartości właściwości IsClass na true mówi .NET Framework’owi, że ma wygenerować deklarację klasy. Właściwość TypeAttributes pozwala deklarować atrybuty public, private i static. Można je kombinować za pomocą operatora bitowego (|). Po zadeklarowaniu klasy należy ją dodać do kolekcji Types przestrzeni nazw.

CodeMemberField

Za pomocą klasy CodeMemberField deklarujemy pola klasy:

CodeMemberField xField = new CodeMemberField();
xField.Name = "x";
xField.Type = new CodeTypeReference(typeof(double));
targetClass.Members.Add(xField);

CodeMemberField yField = new CodeMemberField();
yField.Name = "y";
yField.Type = new CodeTypeReference(typeof(double));
targetClass.Members.Add(yField);

CodeMemberProperty

Za pomocą klasy CodeMemberProperty deklarujemy właściwości klasy:

//X Property
CodeMemberProperty xProperty = new CodeMemberProperty();
xProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
xProperty.Name = "X";
xProperty.HasGet = true;
xProperty.HasSet = true;
xProperty.Type = new CodeTypeReference(typeof(System.Double));

xProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "x")));

xProperty.SetStatements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "x"),
new CodePropertySetValueReferenceExpression()));

targetClass.Members.Add(xProperty);

//Y Property
CodeMemberProperty yProperty = new CodeMemberProperty();
yProperty.Attributes = MemberAttributes.Public | MemberAttributes.Final;
yProperty.Name = "Y";
yProperty.HasGet = true;
yProperty.HasSet = true;
yProperty.Type = new CodeTypeReference(typeof(System.Double));

yProperty.GetStatements.Add(new CodeMethodReturnStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "y")));

yProperty.SetStatements.Add(new CodeAssignStatement(
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "y"),
new CodePropertySetValueReferenceExpression()));

targetClass.Members.Add(yProperty);

Klasa CodeMemberProperty posiada dwie właściwości HasGet i HasSet które trzeba ustawić aby wygenerować akcesory Get i Set.
Kolekcja GetStatements jest używana aby dodać kod do akcesora Get. W tym przypadku metoda Get zwraca pole this.x. Aby wygenerować referencję this używamy klasy CodeThisReferenceExpression.
Kolekcja SetStatements zawiera kod ustawiający pole this.x. Aby ustawić wartość trzeba użyć klasy CodeAssignStatement.

CodeMemberMethod

Klasa CodeMemberMethod służy do tworzenia metod. poniższy kod tworzy metodę o nazwie Divide która zwraca double i ustawia metodę jako final i public:

CodeMemberMethod divideMethod = new CodeMemberMethod();
divideMethod.Name = "Divide";
divideMethod.ReturnType = new CodeTypeReference(typeof(double));
divideMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;

Kiedy mamy już sygnaturę metody to należy utworzyć jej ciało. Metoda Divide sprawdza czy właściwość Y jest równa 0, jeżeli tak to zwraca 0, w przeciwnym wypadku iloraz. Logika If jest utworzona za pomocą klasy CodeConditonStatement:

CodeConditionStatement ifLogic = new CodeConditionStatement();

ifLogic.Condition = new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), yProperty.Name),
    CodeBinaryOperatorType.ValueEquality,
new CodePrimitiveExpression(0));

ifLogic.TrueStatements.Add(new CodeMethodReturnStatement(
new CodePrimitiveExpression(0)));

ifLogic.FalseStatements.Add(new CodeMethodReturnStatement(
new CodeBinaryOperatorExpression(
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), xProperty.Name),
        CodeBinaryOperatorType.Divide,
new CodeFieldReferenceExpression(
new CodeThisReferenceExpression(), yProperty.Name))));

divideMethod.Statements.Add(ifLogic);

CodeParameterDeclarationExpression i CodeMethodInvokeExpression

Następnym krokiem jest utworzenie metody Exponent. Metoda ta pobiera parametr o nazwie power i zwraca this.Y podniesione do potęgi o wartości power.

CodeMemberMethod exponentMethod = new CodeMemberMethod();

exponentMethod.Name = "Exponent";
exponentMethod.ReturnType = new CodeTypeReference(typeof(double));
exponentMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;

CodeParameterDeclarationExpression powerParameter =
new CodeParameterDeclarationExpression(typeof(double), "power");
exponentMethod.Parameters.Add(powerParameter);

CodeMethodInvokeExpression callToMath = new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression("System.Math"),
"Pow",
new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
        xProperty.Name), new CodeArgumentReferenceExpression("power"));

exponentMethod.Statements.Add(new CodeMethodReturnStatement(callToMath));

targetClass.Members.Add(exponentMethod);

Parametr power tworzymy za pomocą klasy CodeParameterDeclarationExpression.
Wywołanie metody i wstawienie do niej parametrów jest realizowane za pomocą klasy CodeMethodInvokeExpression.

CodeDOMProvider

Ostatnim krokiem jest wygenerowanie pliku klasy. Do utworzenia pliku klasy używamy klasy CodeDOMProvider. Klasa ta posiada metodę GenerateCodeFromCompileUnit która pobiera jako parametry obiekty klas CodeCompileUnit, TextWriter i CodeGeneratorOptions. KlasaCodeGeneratorOptions posiada właściwości pozwalające na kontrole formatowania kodu. Poniższy przykład mówi kompilatorowi aby użył interlinii pomiędzy deklaracjami. Ustawia właściwość BracingStyle na wartość “C”, która mówi, że nawiasy mają być w osobnych liniach.

CodeDOMProvider provider = CodeDOMProvider.CreateProvider("CSharp");

CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = false;
options.BracingStyle = "C";

using (StreamWriter sourceWriter = new StreamWriter(@"c:\CodeDOM\Calculator." +
    provider.FileExtension))
{
    provider.GenerateCodeFromCompileUnit(codeCompileUnit, sourceWriter, options);
}

Lampda Expressions

Wyrażenia Lambda są skróconą składnią pisania metod anonimowych. Wyrażenia Lambda są bardzo często używane w LINQ więc ich zrozumienie jest bardzo ważne.

Delegaty

Delegata jest typem który przechowuje referencje do metod. Kiedy deklarujemy delegatę, określamy sygnaturę metod jakie maja być przechowywane przez delegatę.
Przykładowo utwórzmy metodę WriteToConsoleForward:

staticvoidWriteToConsoleForward(string stringToWrite)
{
    Console.WriteLine("This is my string: {0}", stringToWrite);
}

Jeżeli chcielibyśmy zapisać referencję do tej metody to musielibyśmy utworzyć delegatę o takiej samej sygnaturze, np:

delegatevoidMyFirstDelegate(string s);

Teraz możemy powiązać zmienną utworzonego typu z metodą:

MyFirstDelegate myFirstDelegate = new
    MyFirstDelegate(LambdaExpressions.WriteToConsoleForward);

Teraz zmienna myFirstDelegate zasadniczo posiada odniesienie do metody.
Teraz możemy wywołać metodę używając zmiennej myFirstDelegate i wstawiając do niej parametr:

myFirstDelegate("Hello World");

Utwórzmy teraz kolejną metodę o takiej samej sygnaturze:

staticvoidWriteToConsoleBackwards(string stringToWrite)
{
char[] charArray = stringToWrite.ToCharArray();
    Array.Reverse(charArray);

    Console.WriteLine("This is my string backwards: {0}",
newstring(charArray));
}

Ponieważ metoda posiada taką samą sygnaturę to referencja do niej może być przechowywane przez tą samą delegatę.

Stwórzmy metodę która przyjmuje delegatę jako parametr i wywołuje metodę:

staticvoidWriteToConsole(MyFirstDelegate myDelegate, string stringToWrite)
{
    myDelegate(stringToWrite);
}

Teraz możemy wywołać metodę WriteToConsole i wstawić metodę jako parametr:

WriteToConsole(LambdaExpressionExample.WriteToConsoleForward, "Hello World");

WriteToConsole(LambdaExpressionExample.WriteToConsoleBackwards, "Hello World");

Wynik działania kodu:

This is my string: Hello World
This is my string backwards: dlroW olleH

Ważną rzeczą dotyczącą delegat jest koncept kowariancji i kontrawariancji.
Kowariancja pozwala na posiadanie metod z typem zwracanym który jest odziedziczony z typu który jest zadeklarowany w delegacie. Więc typ delegaty może być klasą bazową a typ zwracany przez metody może dziedziczyć z tego typu bazowego.
Kontrawariancja pozwala na posiadanie parametrów typu który jest klasą bazową dla typu zdefiniowanego w delegacie. Więc typ parametru metody może być klasa bazową pod warunkiem, że parametr delegaty jest typu dziedziczącego z tej klasy bazowej.

Metody anonimowe

Metody anonimowe pozwalają na deklarację delegaty i bezpośrednie przypisanie do niej metody w tej samej linii kodu, np:

MyFirstDelegate forward = delegate(string s2)
{
    Console.WriteLine("This is my string: {0}", s2);
};
forward("Hello World");

Jedną z różnic między metodą anonimową a delegata jest to, że można w niej odnosić się do zmiennych lokalnych które nie zostały przekazane jako parametr.
Poniższy kod demonstruje utworzenie delegaty bez parametrów i użycie zmiennej lokalnej w metodzie anonimowej:

delegate voidMyAnonymousMethod();

staticvoidMain(string[] args)
{
string myLocalString = "Hello World";

    //Create an anonymous methodusing the local variable.
MyAnonymousMethod forward = delegate()
    {
Console.WriteLine(string.Format("This is my string: {0}", myLocalString));
    };

    forward();
}

Lambda Expressions

Wyrażenia lambda pozwalają na tworzenie metod anonimowych używając skróconej notacji, np:

delegate doublesquare(double x);

staticvoidMain(string[] args)
{
    square myLambdaExpression = x => x * x;
    Console.WriteLine("X squared is {0}", myLambdaExpression(5));
}

Wyrażeniem lambda z przykładu jest x => x x*. Operator => nazywany jest operatorem goes to. Lewa strona operatora zawiera parametry wejściowe metody. Ciało metody zapisywane jest po prawej stronie operatora. Jeżeli używamy kilku parametrów to zapisujemy je w nawiasie oddzielając je przecinkami, np:

delegate boolGreaterThan(double x, double y);
staticvoidMain(string[] args)
{
    GreaterThan gt = (x, y) => x > y;
    Console.WriteLine("Is 6 greater than 5. {0}", gt(6, 5));
}

Jeżeli metoda zawiera tylko jedno wyrażenie to nazywamy takie wyrażenie wyrażeniem lambda (ang. expression lambda).
Jeżeli metoda wymaga użycia wielu wyrażeń w swoim ciele to takie nazywamy ją deklaracją lambda (ang. statement lambdas) i otaczamy nawiasem klamrowym { }, np:

s =>
    {
char[] charArray = s.ToCharArray();
Array.Reverse(charArray);
Console.WriteLine("This is my string to write backwards: {0}",
            new string(charArray));
    };

Można użyć wyrażenia lambda aby wstawić funkcję do metody. poniższy przykład używa wyrażenia lambda do wywołania metody WriteToConsole:

WriteToConsole(x => Console.WriteLine("This is my string {0}", x), "Hello World");

Podsumowanie

Refleksja(ang. Reflection)

Istnieja dwa sposoby aby pobrać referencję do typu Type obiektu. Używając na obiekcie metod typeof() lub .GetType().
Można uzyć klasy System.Reflection.Assembly aby zbadać typy w pliku EXE lub DLL.
Metoda Assembly.Load pobiera assembly do pamięci i pozwala na wykonanie jej kodu.
Metoda Assembly.ReflectionOnlyLoad pobiera assembly do pamięci ale nie pozwala na wykonanie jej kodu.
Metoda Assembly.CreateInstance tworzy instancję typu.
Klasa System.Type reprezentuje klasę, interfejs, tablicę, typ wartości, enumerację, parametr i typ generyczny.
Metoda Type.GetProperty zwraca obiekt PropertyInfo i pozwala na pobranie i ustawianie wartości właściwości.

Atrybuty

Atrybuty służą do tworzenia metadanych dla klas, właściwości i metod.
Atrybuty definiuje się w nawiasach kwadratowych [].
Atrybuty niestandardowe muszą dziedziczyć z klasy System.Attribute.

Code Document Object Model (CodeDOM)

Przestrzeń nazw CodeDOM zawiera klasy które pozwalają tworzyć generatory kodu.
Klasa System.CodeDom.CodeCompileUnit jest kontenerem dla kodu który chcemy wygenerować.
Klasa System.CodeDom.CodeDOMProvider generuje plik klasy w wybranym z języków: C#, VB lub JScript.

Lambda expressions

Wyrażenie lambda są skróconą notacją dla metod anonimowych.
Delegata jest typem który przechowuje referencje do metod.
Kowariancja pozwala na posiadanie metod z typem zwracanym który jest odziedziczony z typu który jest zadeklarowany w delegacie.
Kontrawariancja pozwala na posiadanie parametrów typu który jest klasą bazową dla typu zdefiniowanego w delegacie.
Operator => jest odczytywany jako “goes to”.

VI. Wielowątkowość i przetwarzanie asynchroniczne

Thu, 07 Jan 2016 17:03:07 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Task Parallel Library (ParallelFor, Plinq, Tasks).
Użycie ThreadPool i obiektów Thread.
Odblokowywanie UI przy użyciu klasy BackgroundWorker.
Użycie słów kluczowych async i await.
Zarządzanie danymi za pomocą równoległych kolekcji. Użycie klas z przestrzeni nazw System.Concurrent.Collections.
Synchronizacja zasobów za pomocą klas ManualResetEvent i AutoResetEvent.
Implementacja blokowania za pomocą klas Monitor, Mutex i Semaphore.
Przerywanie długich zadań za pomocą klas CancellationTokenSource i CancellationToken.

Tworzenie responsywnych aplikacji

Pierwsze komputery zostały stworzone w architekturze nazywanej architekturą von Newmann’a. Komputry te posiadały jedną jednostkę przetwarzania, moduł sterujący, pamięć i system wejścia i wyjścia (IO). Ponieważ posiadały tylko jedną jednostkę przetwarzania to programy pisane na tą architekturę musiały być bisane tak aby były wykonywane sekwencyjnie. taki rodzaj programowania jest używany do dzisiaj. Największą wadą takiego podejścia jest to, że ilekroć aplikacja musi czekać aż coś się wykona to cały system zostaje zatrzymany, tworząc bardzo nieprzyjemne doświadczenie użytkownika. Wątki zostały wprowadzone aby zminimalizować tego rodzaju problemy.

Praca z wątkami

Kiedy aplikacja pobiera dane z I/O to CPU czeka na dane które maja być odebrane nie wykonując w tym czasie żadnych obliczeń. Aby polepszyć responsywność aplikacji została wprowadzona wielowątkowość. W aplikacjach wielowątkowych jeden wątek tworzy następny wątek który pobiera dane I/O i czeka aż ojczysty wątek powróci aby wykonywać dalszą pracę. Kiedy dane są potrzebne to ojczysty wątek jest zablokowany czekając aż utworzony wątek zakończy pracę. Ten wzorzec jest nazywany fork-join.
Jeżeli mamy do dyspozycji jeden procesor to oznacza, że tylko jeden wątek może być wykonywany w danym punkcie czasu. Może to być osiągnięte na dwa różne sposoby:

Grupowo - każdy wątek musi zrezygnować z kontroli, tak aby inny wątek mógł być wykonany.
Zapobiegawczo - system operacyjny posiada komponent zwany scheduler który sprawdza czy żaden wątek nie monopolizuje CPU. Windows jest zbudowany w ten sposób.

Algorytm działania harmonogramu Windows:

Każdy wątek posiada priorytet nadany przy jego tworzeniu. Tworzony wątek nie jest startowany automatycznie, trzeba go uruchomić.
Kiedy wątek jest wystartowany, zostaje dodany do kolejki wszystkich wątków które mogą być uruchomione.
Harmonogram pobiera wątek z najwyższym priorytetem w kolejce i uruchamia go.
Jeżeli kilka wątków posiada ten sam priorytet to harmonogram rozkłady je w kołowym porządku (round robin).
Kiedy upływa przeznaczony czas, harmonogram wstrzymuje wątek i dodaje go na koniec kolejki. Po tym pobiera kolejny wątek z kolejki i uruchamia go.
Jeżeli nie ma innego wątku z wyższym priorytetem niż ten wstrzymany, to ten wątek zostaje wykonywany ponownie.
Kiedy wątek jest blokowany i czeka na operację I/O lub jest blokowany z innego powodu to wątek ten jest usuwany z kolejki i następny wątek jest uruchamiany.
Kiedy zablokowany wątek zostaje odblokowany to wraca z powrotem do kolejki.
Kiedy wątek zostaje zakończony to harmonogram pobiera kolejny wątek do uruchomienia.

Istnieje jeden wątek nazywany System idle process (Proces bezczynności systemu), który nie robi nic oprócz trzymania procesora jako zajętego kiedy ten nie posiada żadnych innych wątków do uruchomienia.
W .NET wszystkie aplikacje posiadają kilka wątków. Oto lista niektórych z nich:

Garbage Collector thread - wątek czyszczenia pamięci.
Finalizer thread - uruchamia metodę Finalize w obiektach.
Main thread - uruchamia metody główne aplikacji.
UI thread - aktualizuje interfejs użytkownika.
Poza wątkiem Main wszystkie pozostałe wymienione watki są wątkami wykonywanymi w tle. Tworząc nowy wątek masz możliwość określenia, czy wątek powinien być wątkiem wykonywanym w tle.
Kiedy wątek główny i wszystkie wątki które nie są wątkami tła zostają zakończone to aplikacja również zostaje zakończona.

Wielowątkowe aplikacje posiadają również wady, oto najważniejsze z nich:

Wszystkie wątki używają zasobów. Potrzebują do pracy dużo pamięci (standardowo 1MB) i za każdym razem kiedy harmonogram przełącza sie pomiędzy wątkami, procesor jest zajęty zapisywaniem kontekstu wstrzymywanego wątku oraz przywróceniem kontekstu wątku uruchamianego.
Jeżeli aplikacja tworzy za dużo wątków to przełączenie kontekstu pochłania dużo czasu.
Ponieważ wątki potrzebują dużo pamięci to zwykle ich tworzenie i usuwanie zajmuje sporo czasu dla systemu.

W .NET wątki są zaimplementowane w klasie System.Threading.Thread.
Praca z tworzeniem wątków odbywa sie w następujący sposób:

Utworzenie obiektu wątku.
Uruchomienie wątku.
Wykonanie większej ilości pracy w metodzie wywołującego.
Czekanie aż wątek się zakończy.
Kontynuacja pracy metody wywołującej.

Przykład aplikacji symulującej wykonywanie dwóch rzeczy: czytania I/O i wykonywania intensywnych obliczeń:

class Program {
staticvoidMain(string[] args) {
        // We are usingStopwatch to time the code
Stopwatch sw = Stopwatch.StartNew();

        // Here we call different methods
        // for different ways of running our application.
RunSequencial();

        // Print the time it took to run the application.
Console.WriteLine("We're done sequencial in {0}ms!", sw.ElapsedMilliseconds);

        // We are usingStopwatch to time the code
        sw = Stopwatch.StartNew();

        // Here we call different methods
        // for different ways of running our application.
RunWithThreads();

        // Print the time it took to run the application.
Console.WriteLine("We're done with threads in {0}ms!", sw.ElapsedMilliseconds);

if (Debugger.IsAttached) {
Console.Write("Press any key to continue . . .");
Console.ReadKey(true);
        }
    }
staticvoidRunSequencial() {
        double result = 0d;

        // Call the function to read data from I/O
result += ReadDataFromIO();
        // Add the resultof the second calculation
result += DoIntensiveCalculations();

        // Print the result
Console.WriteLine("The result is {0}", result);
    }

staticvoidRunWithThreads() {
        double result = 0d;

        // Create the thread to read from I/O
var thread = new Thread(() => result = ReadDataFromIO());

        // Start the thread
        thread.Start();

        // Save the resultof the calculation into another variable
        double result2 = DoIntensiveCalculations();

        // Waitfor the thread to finish
        thread.Join();

        // Calculate the endresult
result += result2;

        // Print the result
Console.WriteLine("The result is {0}", result);
    }

static double ReadDataFromIO() {
        // We are simulating an I/O by putting the current thread to sleep.
Thread.Sleep(5000);
return10d;
    }

static double DoIntensiveCalculations(){
        // We are simulating intensive calculations
        // by doing nonsens divisions
        double result = 100000000d;
var maxValue = Int32.MaxValue;
for(int i=1; i < maxValue; i++){
result /= i;
        }
returnresult + 10d;
    }
}

Wynik działania:

The result is 20
We’re done sequencial in 16489ms!
The result is 20
We’re done with threads in 11388ms!

Użycie ThreadPool

Ponieważ wątki są zasobami drogimi w utrzymaniu to aby ulepszyć wydajność aplikacji, można wybrać wątki już utworzone przez .NET które są dostępne w puli wątków. Służy do tego klasa System.Threading.ThreadPool. Klasa ta posada tylko etody statyczne, najważniejsze z nich to:

GetAvailableThreads - zwraca liczbę wątków dostępnych w puli wątków.
GetMaxThreads - zwraca maksymalną liczbę wątków jaką może utworzyć pula wątków.
GetMinThreads - zwraca minimalną liczbę wątków jaką może utworzyć pula wątków.
QueueUserWorkItem - dodaje żądanie o wykonanie do kolejki puli wątków. jJeżeli istnieją wolne wątki w puli to żądanie zostanie wykonane natychmiast.
RegisterWaitForSingleObject - rejestruje metodę do wywołania, gdy albo określony, jako pierwszy parametr WaitHandle zostanie zasygnalizowany lub gdy limit czasu określony jako czwarty parametr upłynie.
SetMaxThreads - ustawia maksymalną liczbę wątków które mogą być utworzone w puli.
SetMinThreads - ustawia minimalną liczbę wątków dostępnych w puli w określonym czasie.

Powyższa lista nie jest kompletna. Najważniejsza z tej listy metoda to QueueUserWorkItem.
Pula wątków działa w następujący sposób. Kiedy potrzebujesz odseparowanego wątku na wykonanie długotrwałej metody, to zamiast tworzyć nowy wątek, wywołujesz metodę QueueUserWorkItem w celu umieszczenie nowego elementu pracy w kolejce zarządzanej przez pulę wątków. Jeżeli w kolejce jest bezczynny wątek to startuje element pracy i wykonuje go tak samo jak każdy inny wątek. Jeżeli nie ma dostępnego wolnego wątku i liczba wątków w puli jest mniejsza niż MaxThreads, to pula tworzy nowy wątek który uruchomi element pracy. W przeciwnym wypadku element pracy czeka w kolejce na wolny wątek.
Metoda SetMinThread jest używana aby poprawić wydajność pracy aplikacji jeżeli wiemy, że będziemy używać puli wątków.
Metoda QueueUserWorkItem posiada dwa przeciążenia:

publicstaticbool QueueUserWorkItem(WaitCallback callBack)
publicstaticbool QueueUserWorkItem(WaitCallback callBack, Object state)

Parametr System.Threading.WaitCallback jest delegatą zdefiniowaną następująco:

public delegate void WaitCallback(Object state)

Istnieją pewne różnice pomiędzy wątkami utworzonymi manualnie a wątkami z puli ThreadPool, są to:

Wszystkie wątki z puli wątków są wątkami wykonywanymi w tle, natomiast wątki utworzone manualnie są domyślnie wątkami pierwszoplanowymi ale mogą być ustawione jako watki wykonywane w tle.
Nie można przerwać lub anulować wątku z puli wątków.
Nie możesz dołączyć wątku z puli wątków.
Wątki z puli po zakończeniu pracy trafiają z powrotem do kolejki i mogą być użyte ponownie natomiast wątki utworzone manualnie są niszczone po zakończeniu pracy.
Nie można kontrolować priorytetu wątków z puli wątków.

Maksymalna liczba wątków w puli jest różna dla różnych wersji .NET i powinna być traktowana jako detal implementacyjny. W .NET 2.0 jest 25 wątków na rdzeń, w .NET 3.5 jest 250 a w .NET 4 jest 1023 dla 32 bitowych aplikacji i 32,767 dla 64 bitowych.
Przykład metody z poprzedniej sekcji wykonującej odczyt z I/O w osobnym wątku napisanej za pomącą puli wątków:

staticvoidRunInThreadPool() {
    double result = 0d;
    // Create a work item to read from I/O
ThreadPool.QueueUserWorkItem((x) => result += ReadDataFromIO());
    // Save the resultof the calculation into another variable
    double result2 = DoIntensiveCalculations();
    // Waitfor the thread to finish

    // TODO: We will need a way to indicate
    // when the thread pool thread finished the execution
    // Calculate the endresult
result += result2;

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Wywołanie metody ThreadPool.QueueUserWorkItem wstawia jednostkę pracy do kolejki zarządzanej przez pulę wątków. kiedy wątek z puli jest dostępny to pobiera jednostkę i wykonuje ją aż do jej zakończenia. Jedynym problemem jest to, że nie wiadomo kiedy wątek zakończy swoją pracę. Nie istnieje metoda Join ani nic podobnego. Aby rozwiązać ten problem nalerzy użyć jakiegoś mechanizmu sygnalizującego koniec pracy.
Bardzo często nie chcemy używać klasy ThreadPool bezpośrednio. Zamiast tego można użyć innych technologii zbudowanych na jej podstawie jak Task Parallel Library (TPL), Asynchronous Pattern Model (APM), Eventbased Asynchronous Pattern (EAP), Task-based Asynchronous Pattern Model (TAP), lub nowych słów kluczowych async i await.

Odblokowywanie interfejsu użytkownika

Jednym z największych problemów aplikacji jest to, że mogą przestać odpowiadać. Aby temu zapobiec można przetwarzać czasochłonne operacje w osobnych wątkach. Istnieje wiele wzorców programowania asynchronicznego które stosuje się aby tego dokonać.
Aplikacje od wersji .NET 4.5 posiadają nowy model programowania async/await. Jeżeli aplikacja napisana jest w niższej wersji .NET Frameworka to niestety trzeba samemu zadbać o asynchroniczność.

Klasa BackgroundWorker

.NET 2.0 prowadził klasę System.ComponentModel.BackgroundWorker która abstrahuje tworzenie wątku i wykorzystanie puli wątków.
Przydatne metody tej klasy to:

RunWorkerAsync - rejestruje żądanie wystartowania operacji w tle.
ReportProgress - zgłasza zdarzenie ProgressChanged.
CancelAsync - rejestruje żądanie anulowania operacji w tle.

Przydatne właściwości tej klasy to:

CancellationPending - ustawione na true jeżeli wywołana została metoda CancelAsync.
IsBusy - zwraca true jeżeli metoda RunAsync została uruchomiona i operacja nie została jeszcze ukończona.
WorkerReportsProgress - ustawienie na true powoduje raportowanie postępu przez operację wykonywaną w tle.
WorkerSupportsCancellation - ustawienie na true umożliwia wsparcie dla anulowania operacji.

Przydatne zdarzenia tej klasy to:

DoWork - wyzwalane kiedy RunWorkerAsync jest wywoływany. tutaj wykonuje się długotrwałe operacje.
ProgressChanged - wyzwalane kiedy ReportProgress jest wywoływany.
RunWorkerCompleted - wyzwalane kiedy operacja jest zakończona, również przez anulowanie lub wyjątek.

Algorytm pracy z BackgroundWorker jest następujący:

Tworzymy metodę o sygnaturze DoWorkEventHandler.
W tej metodzie wywołujemy długotrwałą operację. Kiedy metoda się zakonczy to przypisujemy wynik operacji do właściwości Result parametru DoWorkEventArgs.
Tworzymy instancję klasy BackgroundWorker.
Zapisujemy utworzoną metodę do zdarzenia DoWork.
Tworzymy metodę o sygnaturze RunWorkerCompletedEventHandler.
W tej metodzie pobieramy wynik długotrwałej operacji i aktualizujemy UI.
Zapisujemy tę metodę do zdarzenia RunWorkerCompleted. Jeżeli operacja wyrzuciła wyjątek to znajdziemy go we właściwości Error parametru RunWorkerCompletedEventArgs, w przeciwnym wypadku właściwość ta ma wartość null.
Jeżeli chcemy śledzić postęp wykonania operacji to tworzymy metodę o sygnaturze ProgressChangedEventHandler i zapisujemy ją do zdarzenia ProgressChanged.
Startujemy proces w tle poprzez uruchomienie metody RunWorkerAsync.
Możemy użyć metody CancelAsync do anulowania zadania.

Załóżmy, że mamy aplikację Windows Forms która posiada formularz z etykietą o nazwie lblResult i guzikiem btnRun. Przykładowo długotrwałe zadanie z użyciem klasy BackgroundWorker może wyglądać tak:

public partial class Form1 : Form {
    private BackgroundWorker worker;

    public Form1() {
InitializeComponent();
        worker = new BackgroundWorker();
        worker.DoWork += worker_DoWork;
        worker.RunWorkerCompleted += worker_RunWorkerCompleted;
    }

void worker_DoWork(object sender, DoWorkEventArgs e) {
        e.Result = DoIntensiveCalculations();
    }

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
        lblResult.Text = e.Result.ToString());
    }

    private void btnRun_Click(object sender, EventArgs e) {
if (!worker.IsBusy) {
            worker.RunWorkerAsync();
        }
    }

static double DoIntensiveCalculations() {
        // We are simulating intensive calculations
        // by doing nonsens divisions
        double result = 100000000d;
var maxValue = Int32.MaxValue;
for (int i = 1; i < maxValue; i++) {
result /= i;
        }
returnresult + 10d;
    }
}

Wielowątkowe aplikacje Windows Forms

Aplikacje Windows Forms i WPF posiadają dedykowany wątek do aktualizacji interfejsu użytkownika. Zapobiega on sytuacjom w których więcej niż jeden wątek próbuje dostać się do tego samego wspólnego zasobu. Taka sytuacja nazywana jest race conditions. Jeżeli próbujemy aktualizować UI z innego wątku to .NET Framework wyrzuci wyjątek InvalidOperationException z informacją “Cross-thread operation not valid: Control ‘ctrlName’ accessed from a thread other than the thread it was created on.”
Kod z poprzedniej sekcji działał ponieważ BackgroundWorker został uruchomiony z wątku UI. Jeżeli zostałby uruchomiony z innego wątku to otrzymalibyśmy wyjątek. Aby rozwiązać ten problem należy zmodyfikować metodę worker_RunWorkerCompleted:

voidworker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
if (this.InvokeRequired) {
this.Invoke(
new Action<string>(UpdateLabel),
            e.Result.ToString());
    }
else {
        UpdateLabel(e.Result.ToString());
    }
}
privatevoidUpdateLabel(string text) {
    lblResult.Text = text;
}

Właściwość InvokeRequired jest zdefiniowana w klasie Control i zwraca true jeżeli jest sprawdzana w innym wątku niż wątek UI.
Metoda Invoke również należy do klasy Control i przyjmuje jako pierwszy parametr delegatę. metoda Invoke umieszcza metodę w kolejce wątku UI.

Wielowątkowe aplikacje WPF

Aplikacje WPF tak jak aplikacje Windows Forms posiadają wątek odpowiedzialny za aktualizację UI. Dodatkowo aplikacje WPF posiadają prywatny wątek renderowania UI.
Przykładowa aplikacja WPF wykonująca metodę DoIntensiveCalculation:

public partial class MainWindow : Window {
    private BackgroundWorker worker;

    public MainWindow() {
InitializeComponent();
        worker = new BackgroundWorker();
        worker.DoWork += worker_DoWork;
        worker.RunWorkerCompleted += worker_RunWorkerCompleted;
    }

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
        lblResult.Content = e.Result;
    }

void worker_DoWork(object sender, DoWorkEventArgs e) {
        e.Result = DoIntensiveCalculations();
    }

    private void btnRun_Click(object sender, EventArgs e) {
if (!worker.IsBusy) {
            worker.RunWorkerAsync();
        }
    }
static double DoIntensiveCalculations() {
        // We are simulating intensive calculations
        // by doing nonsens divisions
        double result = 100000000d;
var maxValue = Int32.MaxValue;
for (int i = 1; i < maxValue; i++) {
result /= i;
        }
returnresult + 10d;
    }
}

Jedyną różnicą jest sposób aktualizacji etykiety. Zamiast aktualizacji właściwości Text aktualizujemy właściwość Content. Niestety aplikacja WPF również wyrzuca wyjątek InvalidOperationException z informacją “The calling thread cannot access this object because a different thread owns it.” jeżeli aktualizujemy wątek UI z innego wątku. Rozwiązanie wygląda następująco:

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
this.Dispatcher.Invoke(()=> lblResult.Content = e.Result);
}

Praca z Task Parallel Library

W .NET 4 została wprowadzona klasa Task która reprezentuje operację asynchroniczną. Klasa ta została wprowadzona w celu abstrahowania programisty od wątków. Używa ona wątków z puli wątków ale oferuje dużą kontrolę i elastyczność w tym jak zadania są tworzone. Klasa Task znajduje się w przestrzeni nazw System.Treading.Tasks. Istnieją dwie klasy zadań: Task i Task<TResult>. Pierwsza z nich jest używana kiedy wykonujemy w zadaniu metodę i nie potrzebujemy zwracanej wartości, drugą używamy kiedy metoda zwraca wynik.

Najczęściej używane metody klasy Task:

ContinueWith - tworzy nowe zadanie które będzie uruchomione asynchroniczne kiedy aktualne zadanie się zakończy.
Delay - metoda statyczna tworząca zadanie które jest oznaczone jako zakończone po wyznaczonym opóźnieniu.
Run - metoda statyczna wysyłająca żądanie do puli wątków i zwracająca obiekt klasy Task.
Start - startuje zadanie reprezentowane przez tą instancję klasy.
Wait - czeka na zakończenie zadania wykonywanego przez tą instancję klasy.
WaitAll - metoda statyczna czekająca na wykonanie wszystkich zadań wysłanych jako parametr.
WaitAny - metoda statyczna czekająca na wykonanie któregokolwiek z zadań wysłanych jako parametr.
WhenAll - metoda statyczna tworząca zadanie oznaczone jako zakończone kiedy wszystkie zadania wysłane jako parametr zostaną zakończone.
WhenAny - metoda statyczna tworząca zadanie oznaczone jako zakończone kiedy którekolwiek zadanie wysłane jako parametr zostanie zakończone.

Najczęściej używane właściwości klasy Task:

CurrentId - statyczna właściwość tylko do odczytu, identyfikator wykonywanego zadania.
Exception - właściwość tylko do odczytu zawierająca nieobsługiwany wyjątek AggregateException, jeśli
wystąpił wyjątek który spowodował zakończenie zadania.
Factory - statyczna właściwość tylko do odczytu zwraca obiekt fabryki który może być użyty do utworzenia nowych zadań.
ID - właściwość tylko do odczytu zwracająca identyfikator instancji klasy Task.
IsCanceled - właściwość tylko do odczytu posiadająca wartość true jeżeli zadanie zostało zakończone poprzez anulowanie.
IsCompleted - właściwość tylko do odczytu posiadająca wartość true jeżeli zadanie zostało zakończone.
IsFaulted - właściwość tylko do odczytu posiadająca wartość true jeżeli zadanie zostało zakończone przez nieobsłużony wyjątek.
Status - właściwość tylko do odczytu zwracająca status zadania.
Result - właściwość tylko do odczytu zwraca wartość zwracaną przez operację asynchroniczną reprezentowaną poprzez to zadanie.

Statyczna właściwość Factory jest typu TaskFactory i jest używana do tworzenia nowych zadań. Najczęściej wykorzystywane metody tej klasy to:

ContinueWhenAll - tworzy nowe zadanie które startuje kiedy wszystkie zadania przesłane jako parametr zostaną zakończone.
ContinueWhenAny - tworzy nowe zadanie które startuje kiedy jakiekolwiek zadanie przesłane jako parametr zostanie zakończone.
FromAsync - metoda używana do przeniesienia kodu starego modelu asynchronicznego do modelu TAP poprzez opakowanie wywołania asynchronicznego przez zadanie.
StartNew - metoda tworząca nowe zadanie i startująca je.

Tworzenie zadań

Zadania możemy tworzyć na kilka sposobów:

Można utworzyć instancję obiektu Task. Instancja nie jest automatycznie uruchamiana więc trzeba wywołać metodę Start.
Można użyć jednego z przeciążeń metody TaskFactory.StartNew. Ta metoda tworzy i startuje zadanie.
Można użyć jednego z przeciążeń statycznej metody Task.Run. Jest to uproszczona wersja metody TaskFactory.StartNew.
Można wywołać jedną z metod kontynuacji jak np Task.WhenAll, Task.WhenAny, TaskFactory.ContinueWhenAll, TaskFactory.ContinueWhenAny.

Metoda TaskFactory.StartNew oferuje dużą elastyczność. Kiedy tworzymy zadanie musimy przynajmniej określić metodę lub funkcję którą chcemy uruchomić jako zadanie. Ponadto, można określić opcje dotyczące tworzenia zadania, token anulowania i harmonogram kolejki zadań w wątkach.
Enumerator TaskCreationOptions opisuje opcje tworzenia zadania:

None - domyślne zachowanie.
PreferFairness - Zadania powinny być zaplanowane w sposób uczciwy. Jest to tylko podpowiedź i oczekiwanym jej rezultatem jest to, że zadania zaplanowane wcześniej będą wykonywane wcześniej.
LongRunning - Oznacza, że zadanie zajmuje dużo czasu. jest to tylko podpowiedź i oczekiwanym jej rezultatem jest to, że zadania mogą być wykonywane w większej ilości wątków niż dostępna liczba wątków sprzętowych.
AttachedToParent - Nowe zadanie jest przypięte do zadania rodzica w hierarchii.
DenyChildAttach - Oznacza, że żadne podzadania nie mogą być przypięte do tego zadania.
HideScheduler - Oznacza, że aktualny harmonogram nie powinien być używany przy tworzeniu zadania z tego nowo utworzonego zadania.

Enumerator posiada również atrybut FlagsAttribute oznaczający, że opcje mogą być kombinowane.

Przykład programu wywołującego metodę obliczeniową 32 razy:

class Program {
constintNUMBER_OF_ITERATIONS = 32;

staticvoidMain(string[] args) {
        // We are usingStopwatch to time the code
Stopwatch sw = Stopwatch.StartNew();
        // Run the method
RunSequential();
        // Print the time it took to run the application.
Console.WriteLine("We're done in {0}ms!", sw.ElapsedMilliseconds);
    }

staticvoidRunSequential() {
        double result = 0d;
        // Here we call same method several times.
for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
result += DoIntensiveCalculations();
        }
        // Print the result
Console.WriteLine("The result is {0}", result);
    }

static double DoIntensiveCalculations() {
        // We are simulating intensive calculations
        // by doing nonsens divisions and multiplications
        double result = 10000d;
var maxValue = Int32.MaxValue >> 4;
for (int i = 1; i < maxValue; i++) {
if (i % 2 == 0) {
result /= i;
            }
else {
result *= i;
            }
        }
returnresult;
    }
}

Wynik działania programu to:

The result is 22.0386557304958
We’re done in 41860ms!

jak widać wykonanie tego programu trwało 42s. Ulepszmy wydajność tego zadania używając zadań. Aby tego dokonać zastąpimy metodę RunSequential za pomocą metody RunTasks:

staticvoidRunTasks() {
    double result = 0d;
Task[] tasks = new Task[NUMBER_OF_ITERATIONS];
    // We create one task per iteration.
for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
        tasks[i] = Task.Run(() => result += DoIntensiveCalculations());
    }
    // Print the result
Console.WriteLine("The result is {0}", result);
}

Wynik działania programu to:

The result is 2.75483196631197
We’re done in 10115ms!
Jak widać wynik jest niepoprawny. Aplikacja nie jest 8 razy szybsza jak się tego można spodziewać.
Powodem dla którego aplikacja nie jest 8 razy szybsza jest to, że używamy nowoczesnego procesora Intel Core I7. Jest to czterordzeniowy procesor z funkcją hyper-threading. Hyperthreading oznacza, że każdy rdzeń ma dwa potoki instrukcji, ale tylko jeden silnik wykonania. System operacyjny widzi to jako 8 różnych procesorów. Hyperthreading poprawia wydajność o około 30%.
Wynik aplikacji jest niepoprawny ponieważ występuje tu zjawisko race conditions i zamiast sumowania wyniku każdy wątek go nadpisuje. poprawna wersja metody to:

staticvoidRunTasksCorrected() {
    double result = 0d;
Task<double>[] tasks = new Task<double>[NUMBER_OF_ITERATIONS];
    // We create one task per iteration.
for (int i = 0; i < NUMBER_OF_ITERATIONS; i++) {
        tasks[i] = Task.Run(() => DoIntensiveCalculations());
    }

    // We wait for the tasks to finish
Task.WaitAll(tasks);

    // We collect the results
    foreach (var task in tasks) {
result += task.Result;
    }

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Wynik działania programu to:

The result is 22.0386557304958
We’re done in 10369ms!

Wywołanie Task.WaitAll(tasks) nie jest konieczne ponieważ task.Result zablokuje pętlę wywołującą jeżeli kalkulacja jeszcze nie została zakończona.

Praca z harmonogramem zadań

Kolejkowanie zadań w wątkach jest wykonywane przez komponent zwany harmonogramem zadań (ang. task scheduler), zaimplementowanym w klasie TaskScheduler. Normalnie nie używa się go bezpośrednio. Startując zadanie bez wyznaczenia harmonogramu używany jest domyślny.
W aplikacjach Windows Forms lub WPF używa się harmonogramu zadań bezpośrednio. Ponieważ UI może być zaktualizowane tylko przez wątek UI to żeby zadanie mogło aktualizować UI musi używać tego wątku. Aby to osiągnąć używa się metody StartNew lub ContinueWith pobierającej jako parametr obiekt TaskScheduler i wstawia się jako wartość TaskScheduler.FromCurrentSynchronizationContext().
Przykład użycia metody UpdateLabel jako zadania w aplikacji Windows Forms w wątku UI:

Task.Factory.StartNew(
UpdateLabel,
CancellationToken.None,
TaskCreationOptions.None,
TaskScheduler.FromCurrentSynchronizationContext()
);

Użycie klasy Parallel

Klasa Task jest abstrakcją reprezentującą operacje asynchroniczne wykonywane przez wątki. Mimo, że są lżejsze niż wątki, czasami po prostu trzeba lepszej abstrakcji przy pracy wielozadaniowej. Dlatego Microsoft stworzył klasę Parallel. Jest ona częścią przestrzeni nazw System.Threading.Tasks. Klasa ta posiada trzy metody statyczne opisane poniżej:

For - Metoda podobna do pętli for lecz wykonywana równolegle. Posiada 12 przeciążeń akceptujących jako parametry min ParallelOptions i ParallelLoopState.
ForEach - Podobna do pętli foreach ale wykonywana równolegle. Posiada 20 przeciążeń z parametrami podobnymi do metody For.
Invoke - Metoda ta będzie próbować uruchomić dostarczonych akcji równolegle. Posiada dwa przeciążenia. Oba przyjmują delegatę Action do wykonania. Jedno przeciążenie przyjmuje parametr ParallelOptions.

Wszystkie trzy metody wspominają o możliwości uruchomienia równoległego ale żadna z nich tego nie gwarantuje.
Klasa ParallelLoopState jest używana jako parametr wejściowy dla niektórych metod For i ForEach. Posiada ona dwie metody: Stop i Break których można użyć, aby przedwcześnie przerwać pętlę.

Przykład użycia Parallel.For:

staticvoidRunParallelFor() {
    double result = 0d;

    // Here we call same method several times in parallel.
Parallel.For(0, NUMBER_OF_ITERATIONS, i => {
result += DoIntensiveCalculations();
    });

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Wynik działania aplikacji:

The result is 2.06612397473398
We’re done in 10186ms!

Tak jak w poprzednim przypadku wynik jest błędny.
Poprawne użycie wymaga uzycia przeciążonej metody Parallel.For:

public static ParallelLoopResult For<TLocal>(
int fromInclusive,
int toExclusive,
Func<TLocal> localInit,
Func<int, ParallelLoopState, TLocal, TLocal> body,
    Action<TLocal> localFinally
)

Przykład:

staticvoidRunParallelForCorrected() {
    double result = 0d;

    // Here we call same method several times.
    //for (int i = 0; i < NUMBER_OF_ITERATIONS; i++)
Parallel.For(0, NUMBER_OF_ITERATIONS,
        // Func<TLocal> localInit,
        () => 0d,

        // Func<int, ParallelLoopState, TLocal, TLocal> body,
        (i, state, interimResult) => interimResult + DoIntensiveCalculations(),

        // Final step after the calculations
        // we add the result to the final result
        // Action<TLocal> localFinally
        (lastInterimResult) => result += lastInterimResult
    );

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Wynik działania aplikacji:

The result is 22.0386557304958
We’re done in 10370ms!

Praca z kontynuacjami

W niektórych sytuacjach nie można przekształcić wszystkiego w zadania bez łamania algorytmu naszej aplikacji. Musimy dbać o zależności wynikające z algorytmu. Jeżeli z zależności w algorytmie wynika, że nie można wykonać kroku 3 przed zakończeniem kroku 1 i kroku 2 to można użyć pewnych mechanizmów kontynuacji dostępnych w TPL. Załóżmy, że mamy w aplikacji trzy metody nazwane Step1, Step2 i Step3 np:

classProgram {
staticvoidMain(string[] args) {
        Step1();
        Step2();
        Step3();
    }

staticvoidStep1() {
        Console.WriteLine("Step1");
    }

staticvoidStep2() {
        Console.WriteLine("Step2");
    }

staticvoidStep3() {
        Console.WriteLine("Step3");
    }
}

Zaimplementujmy funkcjonalność opartą o zadania dla różnych scenariuszy:

Jeżeli metody są niezależne od pozostałych to możemy użyć np:

staticvoidMain(string[] args){
    Parallel.Invoke(Step1, Step2, Step3);
}

Metody step1 i Step2 są niezależne lecz metoda Step3 może być wykonana po zakończeniu metody Step1 np:

static void Main(string[] args) {
Task step1Task = Task.Run(() => Step1());
Task step2Task = Task.Run(() => Step2());
Task step3Task = step1Task.ContinueWith( (previousTask) => Step3());

Task.WaitAll(step2Task, step3Task);
}

Metoda Task.WaitAll(step2Task, step3Task); gwarantuje, że poczekamy na wyniki wszystkich kroków.

Metody step1 i Step2 są niezależne lecz metoda Step3 może być wykonana po zakończeniu metod Step1 i Step2 np:

static void Main(string[] args) {
Task step1Task = Task.Run(() => Step1());
Task step2Task = Task.Run(() => Step2());
Task step3Task = Task.Factory.ContinueWhenAll(
        new Task[] { step1Task, step2Task },
        (previousTasks) => Step3()
    );

    step3Task.Wait();
}

Metoda ContinueWhenAll pobiera jako pierwszy parametr tablicę zadań które mają być wykonane i delegatę do uruchomienia kiedy zadania się zakończa. Delegata pobiera jako parametr tablicę zadań na których wykonanie oczekuje.

Metody step1 i Step2 są niezależne lecz metoda Step3 może być wykonana po zakończeniu metod Step1 lub Step2 np:

static void Main(string[] args) {
Task step1Task = Task.Run(() => Step1());
Task step2Task = Task.Run(() => Step2());
Task step3Task = Task.Factory.ContinueWhenAny(
        new Task[] { step1Task, step2Task },
        (previousTask) => Step3()
    );

    step3Task.Wait();
}

Asynchroniczne Aplikacje w C # 5.0

W C# 5.0Microsoft wprowadził dwa nowe słowa kluczowe do języka: async i await.
Słowa kluczowego async możemy użyć aby oznaczyć metodę jako asynchroniczną i aby powiadomić kompilator, że metoda będzie miała co najmniej jedno wyrażenie await. Jeżeli kod nie posiada wyrażenia await to kompilator wygeneruje ostrzeżenie.
Operator await stosuje się do zadania w metodzie asynchronicznej aby zawiesić wykonanie metody aż do momentu kiedy zawieszone zadanie zostanie wykonane.
Wiele klas w bibliotece .NET Framework używających I/O zostało zmodyfikowanych poprzez dodanie do nich metod asynchronicznych wspierających wzorzec async/await.
Przykład metody synchronicznej symulującej odczyt z I/O:

publicstaticdoubleReadDataFromIO(){
// We are simulating an I/O by putting the current thread to sleep.
    Thread.Sleep(2000);
return10d;
}

Wariant asynchroniczny metody może wyglądać tak:

publicstaticTask<double> ReadDataFromIOAsync() {
returnTask.Run(new Func<double>(ReadDataFromIO));
}

Aby metoda była asynchroniczna musi zwracać obiekt Task lub Task i posiadać sufiks Async w nazwie.

Kiedy metoda jest oznaczona modyfikatorem async to musi zwracać jako wynik void, Task lub Task. Jeżeli metoda synchroniczna zwraca void to można wybrać pomiędzy void i Task. Jeżeli metoda nie jest obsługą zdarzenia to zaleca się aby zwracała Task dzięki czemu jest nie tylko metodą asynchroniczną ale również można oczekiwać na jej wykonanie za pomocą słowa kluczowego await. Kiedy metoda synchroniczna zwraca wynik jakiegokolwiek typu to należy zwracać Task w metodzie asynchronicznej.

Wracając do aplikacji WPF z poprzedniej sekcji zamieńmy metodę ReadDataFromIO na jej wersję asynchroniczną:

publicpartialclassMainWindow : Window {
publicMainWindow() {
        InitializeComponent();
    }
privateasyncvoidbtnRun_Click(object sender, EventArgs e) {
        lblResult.Content = await ReadDataFromIOAsync();
    }
}

kod napisany w ten sposób powoduje, że aplikacja nie zamarza i zwraca ten sam rezultat. Przeanalizujmy jak to działa:

Dodajemy słowo kluczowe async aby oznaczyć metodę jako asynchroniczną. Zwracany typ metody nie ulega zmianie ponieważ musimy użyć sygnatury delegaty EventHandler.
Zastępujemy wywołanie metody ReadDataFromIO poprzez await ReadDataFromIOAsync. Jest to równe wyrażeniu:

Task<double> task = ReadDataFromIOAsync();
lblResult.Content = task.Result;

Kiedy wywołujemy ReadDataFromIOAsync to .NET Framework wykonuje kod do momentu kiedy zostaje on zablokowany przez operację I/O. W tym momencie stan metody zostaje zapisany, otoczony w zadanie i zwrócony do metody wywołującej.
Metoda wywołująca kontynuuje wykonanie do momentu kiedy potrzebuje wyniku. W tym wypadku wynik otrzymuje od razu ale możliwe jest, że zapisuje zadanie, wykonuje więcej pracy synchronicznej i dopiero później wywołuje await blokując metodę wywołującą.

Rozpatrzmy przykład w którym wywołujemy metodę ReadDataFromIO kilkukrotnie z wnętrza kodu a nie z obsługi zdarzeń i aktualizujemy w ten sposób kilka etykiet np:

publicpartialclassMainWindow : Window {
publicMainWindow() {
        InitializeComponent();
    }
privatevoidbtnRun_Click(object sender, EventArgs e) {
        GetData();
    }
privatevoidGetData() {
        lblResult.Content = ReadDataFromIO();
        lblResult2.Content = ReadDataFromIO();
    }
}

Aby zmienić kod w asynchroniczny musimy najpierw zmienić metodę GetData np:

privateasync Task GetDataAsync() {
    lblResult.Content = await ReadDataFromIOAsync();
    lblResult2.Content = await ReadDataFromIOAsync();
}

Dodaliśmy modyfikator async do metody i zmieniliśmy jej nazwę poprzez dodanie sufiksu Assync. Zwracany typ został zmieniony do typu Task i użyliśmy asynchronicznej wersji metody ReadDataFromIOAsync wraz ze słowek kluczowym await.
Kiedy uruchomimy aplikacje to nie zostanie ona zamrożona po wciśnięciu guzika. po kilku sekundach otrzymamy pierwszy wynik a po kolejnych kilku następny. Dzieje się tak ponieważ blokujemy wywołującą metodę pierwszym wywołaniem await i druga metoda czeka na jego ukończenie.
Można to ulepszyć poprzez przepisanie metody GetDataAsync np:

privateasync Task GetDataAsync() {
var task1 = ReadDataFromIOAsync();
var task2 = ReadDataFromIOAsync();

// Here we can do more processing
// that doesn't need the data from the previous calls.
// Now we need the data so we have to wait
await Task.WhenAll(task1, task2);

// Now we have data to show.
    lblResult.Content = task1.Result;
    lblResult2.Content = task2.Result;
}

Zaawansowane zagadnienia dotyczące wielowątkowości

Programowanie wielowątkowe jest o wiele trudniejsze niż programowanie jednowątkowe z kilku przyczyn:

Kilka wątków może próbować zaktualizować ten sam fragment danych w tym samym czasie.
Nie zawsze gwarantuje jednakowe wyniki.
Jest trudne do śledzenia, rozumienia i odnajdywania błędów.
Jest trudne do testowania.

Jednym z najczęściej spotykanych problemów jest tzw race condition. Dzieje się to gdy co najmniej dwa wątki próbują zaktualizować ten sam zasób. Przeanalizujmy przykład takiej sytuacji. Załóżmy, że posiadamy zmienną nazwaną sharedData i dwa wątki które próbują wykonać instrukcję sharedData++, która jest wykonywana przez CPU w następujący sposób:

Odczyt sharedData w rejestrze.
Dodanie 1 do wartości w rejestrze.
Zapis nowej wartości z rejestru z powrotem do zmiennej sharedData.

Dlaczego jest to tak ważne? Ponieważ jeśli byłaby to tylko jedna instrukcja, CPU mógłby wykonać to raz i żaden błąd nie może być tutaj wprowadzony. nazywane jest to operacja atomową. Jeżeli mamy aplikację wielowątkową to obiekt harmonogramu może przerwać aktualny wątek w każdej chwili i może to doprowadzić do błędu, np:

Zmienna sharedData posiada wartość 0.
Pierwszy wątek uruchamia pierwszą instrukcję, odczytując wartość 0.
Drugi wątek uruchamia pierwszą instrukcję, odczytując wartość 0. Na maszynie z pojedynczym rdzeniem może to się wydarzyć kiedy harmonogram przerwie pierwszy wątek i uruchomi drugi. Na maszynach wielordzeniowych jest to normalna sytuacja ponieważ wątki mogą być uruchamiane na różnych rdzeniach.
Pierwszy wątek inkrementuje wartość do 1.
Pierwszy wątek zapsuje wartość 1 do zmiennej sharedData.
Drugi wątek inkrementuje wartość do 1. W tej sytuacji wartość powinna być równa 2 lecz wartość początkowa która jest zapisana dla wątku drugiego posiada jest “stara” i wynosi 0.
Drugi wątek zapisuje wartoś 1 do zmiennej sharedData.

Tak jak wyjaśniono taka sytuacja może zajść nawet w sytuacji kiedy aplikacja jest uruchamiana na maszynie z jednym rdzeniem lecz występuje dużo częściej na maszynach wielordzeniowych. Aby zapobiec takiej sytuacji należy upewnić się, że tylko jeden wątek ma dostęp do zmiennych współdzielonych w danym momencie czasu.
Najlepszą metodą jest nie współdzielenie danych. Jeżeli musimy współdzielić dane to sprawmy aby były tylko do odczytu. Czasami jest to niemożliwe ze względu na rozmiar danych. Jeżeli tak jest to należy wyizolować dane i mieć pewność, że są używane w kontrolowany sposób. Jeżeli nie jest to możliwe to należy użyć mechanizmów synchronizacji danych. Podsumowując, kolejność rozważania na temat danych współdzielonych jest następująca:

Nie współdziel.
Spraw aby dane były tylko do odczytu.
Izoluj dane w mniejszych modułach.
Użyj mechanizmów synchronizacji danych.

Synchronizacja zasobów

Microsoft zapewnia kilka klas pozwalających na synchronizację zasobów. Istnieją klasy umożliwiające sygnalizację, wzajemne wykluczenie, anulowanie i klasy obsługujące kolekcja współbieżne.

Sygnalizacja jest używana jako mechanizm komunikacji pomiędzy watkami. W .NET istnieją dwa rodzaje sygnalizacji: zdarzenia synchronizacji i bariery.

Zdarzenia synchronizacji

Zdarzenia synchronizacji są obiektami które mogą się znajdować w dwóch stanach: sygnalizowany i niesygnalizowany. Jeżeli wątek potrzebuje aby coś było wykonane w innym wątku to może użyć zdarzenia sygnalizacji i badać stan zdarzenia jako mechanizm komunikacji. jeżeli jest w stanie sygnalizowanym to znaczy, że kontynuuje wykonywanie, jeżeli nie to znaczy, że blokuje wykonywanie, oczekując na zdarzenie, aż będzie sygnalizowane. Kiedy inne wątki zakończa swoją pracę, to sygnalizuje zdarzenie odblokowując oczekujące wątki. Zdarzenia synchronizacji są zaimplementowane w duch klasach: EventWaitHandle i CountdownEvent.

Klasa EventWaitHandle reprezentuje zdarzenie synchronizacji i jest zdefiniowana w przestrzeni nazw System.Threading. najczęściej wykorzystywane metody tej klasy to:

EventWaitHandle - Konstruktor z czterema przeciążeniami. Trzeba określić co najmniej czy zdarzenie powinno być sygnalizowane i czy zdarzenie powinno być resetowane manualnie czy automatycznie z użyciem enumeratora EventResetMode.
Dispose - implementacja interfejsu IDisposable. Metoda oczyszczająca niepotrzebne zasoby kiedy obiekt nie jest już potrzebny.
Reset - ustawia stan zdarzenia na niesygnalizowany powodując blokowanie wątków.
Set - ustawia stan zdarzenia na sygnalizowany. oczekujące wątki będą w stanie kontynuować. Jeżeli zdarzenie zostało utworzone jako AutoReset to tylko jeden wątek może wywołać WaitOne bez bycia zablokowanym lub jeżeli istnieją blokowane wątki jako wynik działania metodyWaitOne to tylko jeden wątek zostanie odblokowany i zdarzenie będzie w stanie niesygnalizowanym do momętu wywołania metody Set. Jeżeli zdarzenie było utworzone jako ManualReset to zdarzenie będzie sygnalizowane do momentu uzycia na nim metody Reset.
WaitOne - Blokuje aktualny wątek jeżeli jest niesygnalizowany. jeżeli zdarzenie jest sygnalizowane i zostało utworzone jako AutoReset to odblokowuje zdarzenie i resetuje je do stanu niesygnalizowanego.

Przykład użycia tych klas pokazujący jak zyskać pewność, że nie odczytujemy wyniku obliczeń przed ich zakończeniem. Oryginalna metoda wygląda tak:

staticvoidRunInThreadPool() {
    double result = 0d;

    // Create a work item to read from I/O
ThreadPool.QueueUserWorkItem((x) => result += ReadDataFromIO());

    // Save the resultof the calculation into another variable
    double result2 = DoIntensiveCalculations();

    // Waitfor the thread to finish
    // TODO: We will need a way to indicate
    // when the thread pool thread finished the execution
    // Calculate the endresult
result += result2;

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Przykład rozwiązania za pomocą sygnalizacji:

staticvoidRunInThreadPoolWithEvents() {
    double result = 0d;

    // We use this event to signal when the thread is don executing.
EventWaitHandle calculationDone =
        new EventWaitHandle(false, EventResetMode.ManualReset);

    // Create a work item to read from I/O
ThreadPool.QueueUserWorkItem((x) => {
result += ReadDataFromIO();
        calculationDone.Set();
    });

    // Save the resultof the calculation into another variable
    double result2 = DoIntensiveCalculations();

    // Waitfor the thread to finish
    calculationDone.WaitOne();

    // Calculate the endresult
result += result2;

    // Print the result
Console.WriteLine("The result is {0}", result);
}

Kod działa następująco:

Tworzymy obiekt klasy EventWaitHandle w stanie niesygnalizowanym.
Dodajemy do kolejki nowe zadanie. po otrzymaniu pierwszego wyniku sygnalizujemy zdarzenie aby wskazać, że obliczenia są zakończone.
Wywołujemy drugą metodę w wątku głównym.
Po otrzymaniu wyniku drugiej metody, czekamy na zakonczenie kalkulacji pierwszej metody poprzez oczekiwanie na to kiedy zdarzenie będzie w stanie sygnalizowanym.
kiedy otrzymamy stan sygnalizowany wiemy, że posiadamy wynik więc możemy obliczyć wartość finalną i ją pokazać.

.NET posiada dwie klasy dziedziczące z EventWaitHandle, są to: AutoResetEvent i ManualResetEvent. obie posiadają tylko jeden konstruktor i nie posiadają żadnych metod ani właściwości. Ich konstruktor przyjmuje wartość logiczną oznaczającą czy zdarzenie jest w stanie sygnalizowanym czy nie.

Klasa CoundownEvent jest zdefiniowana w przestrzeni nazw System.Threading i została wprowadzona w .NET 4. Scenariusz użycia klasy jest prosty: czekamy, aż zdefiniowana liczba wątków zostanie zakończona. najczęściej wykorzystywane metody i właściwości klasyCoundownEvent:

CountdownEvent - konstruktor przyjmujący ilość oczekiwanych sygnałów zanim zmieni stan na sygnalizowany.
AddCount - inkrementuje aktualną liczbę zdarzeń. Jeżeli zdarzenie jest ustawione to zgłasza wyjątek InvalidOperationException.
Dispose - implementacja interfejsu IDisposable. Metoda oczyszczająca niepotrzebne zasoby kiedy obiekt nie jest już potrzebny.
Reset - resetuje właściwość InitialCount.
Signal - Rejestruje sygnał dekrementując właściwość CurrentCount o określoną wartość.
TryAddCount - inkrementuje aktualną liczbę zdarzeń i nie zgłasza wyjątku jak metoda AddCount lecz zwraca true lub false.
Wait - Blokuje aktualny wątek dopóki zdarzenie CountdownEvent jest ustawione.
CurrentCount - właściwość tylko do odczytu zwracająca aktualna wartość wymaganych sygnałów brakujących do ustawienia zdarzenia.
InitialCount - właściwość tylko do odczytu, wartość początkowa wymaganych sygnałów brakujących do ustawienia zdarzenia.
IsSet - właściwość tylko do odczytu, zwraca true jeżeli zdarzenie jest ustawione.
WaitHandle - właściwość tylko do odczytu zwracająca WaitHandle uzyty do oczekiwania na zdarzenie do ustawienia.

Klasa CoundownEvent nie dziedziczy z klasy WaitHandle jek większość klas synchronizacji dlatego posiada właściwość WaitHandle zwracającą instancję używanego obiektu WaitHandle.

Bariery

W scenariuszach wielowątkowych istnieją sytuacje w których wywołujemy kilka wątków i chcemy mieć pewność, że wszystkie dotrą do pewnego punktu, zanim będzie można kontynuować wykonywanie kodu.
Przykładem takiego scenariusza możne być np sytuacja w której grupa przyjaciół decyduje się podróżować samochodem z punktu A do punktu C przez punk B. Wszyscy startują z punktu A i zatrzymują się w B; potem planują wystartować wspólnie jeszcze raz i spotkać sie w punkcie C. Niektórzy z nich mogą nawet zdecydować się, że nie chcą już podróżować i wrócić do domu.
.NET 4 wprowadził nową klasę System.Threading.Barrier która dotyczy dokładnie takich sytuacji.
Najczęściej uzywane metody i właściwości klasy Barrier:

Barrier - konstruktor z dwoma przeciążeniami przyjmującymi jako parametr liczbę uczestników. Drugie przeciążenie pobiera dodatkowy parametr typu Action który będzie uruchomiony po przybyciu wszystkich uczestników do bariery w jednej fazie.
AddParticipant - wysyła informację do bariery o tym, że będzie jeszcze jeden uczestnik.
AddParticipants - wysyła informację do bariery o tym, że będzie jeszcze kilku uczestników.
Dispose - implementacja interfejsu IDisposable. Metoda oczyszczająca niepotrzebne zasoby kiedy obiekt nie jest już potrzebny.
RemoveParticipant - wysyła informację do bariery o tym, że będzie o jednego z uczestników mniej.
RemoveParticipants - wysyła informację do bariery o tym, że będzie o kilku uczestników mniej.
SignalAndWait - sześć przeciążeń. Sygnalizuje, że uczestnik dotarł do bariery i oczekuje na dotarcie innych uczestników. Przeciążenia służą do wywołania metody z tokenem anulującym i/lub limitem czasu.
CurrentPhaseNumber - właściwość tylko do odczytu zwracająca aktualną fazę bariery.
ParticipantCount - właściwość tylko do odczytu zwracająca całkowitą liczbę uczestników bariery.
ParticipantsRemaining - właściwość tylko do odczytu zwracająca liczbę uczestników którzy jeszcze nie dotarli do bariery.

Przykład użycia klasy Barrier:

staticvoidMain(string[] args){
    var participants = 5;

    Barrier barrier = new Barrier(participants + 1,
// We add one for the main thread.
        b => { // This method is only called when all the paricipants arrived.
            Console.WriteLine("{0} paricipants are at rendez-vous point {1}.",
                b.ParticipantCount -1, // We substract the main thread.
                b.CurrentPhaseNumber);
        });

for (int i = 0; i < participants; i++) {
        var localCopy = i;
        Task.Run(() => {
            Console.WriteLine("Task {0} left point A!", localCopy);
            Thread.Sleep(1000 * localCopy + 1); // Do some "work"
if (localCopy % 2 == 0) {
                Console.WriteLine("Task {0} arrived at point B!", localCopy);
                barrier.SignalAndWait();
            }
else {
                Console.WriteLine("Task {0} changed its mind and went back!",
                    localCopy);
                barrier.RemoveParticipant();
return;
            }
            Thread.Sleep(1000 * (participants - localCopy)); // Do some "more work"
            Console.WriteLine("Task {0} arrived at point C!", localCopy);
            barrier.SignalAndWait();
        });
    }

    Console.WriteLine("Main thread is waiting for {0} tasks!",
        barrier.ParticipantCount - 1);
    barrier.SignalAndWait(); // Waiting at the first phase
    barrier.SignalAndWait(); // Waiting at the second phase
    Console.WriteLine("Main thread is done!");
}

Wynik działania kodu

Main thread is waiting for 5 tasks!
Task 4 left point A!
Task 2 left point A!
Task 0 left point A!
Task 3 left point A!
Task 1 left point A!
Task 0 arrived at point B!
Task 1 changed its mind and went back!
Task 2 arrived at point B!
Task 3 changed its mind and went back!
Task 4 arrived at point B!
3 paricipants are at rendez-vous point 0.
Task 4 arrived at point C!
Task 2 arrived at point C!
Task 0 arrived at point C!
3 paricipants are at rendez-vous point 1.
Main thread is done!

Użycie mechanizmów blokowania

Jednym ze sposobów radzenia sobie z udostępniania danych jest wzajemne wykluczanie (ang mutual exclusion). Wzajemne wykluczanie zapewnia, że tylko jeden wątek ma dostęp do udostępnianego zasobu w danym czasie. jeżeli inny wątek próbuje dostać się do zasobu to zostaje zablokowany do czasu aż pierwszy z wątków nie zwolni dostępu do zasobu. Zamiast kontrolować wszystkie ścieżki kodu które kierują się do określonego regionu danych kontrolujemy regiony kodu które próbują otrzymać dostęp do części danych. Wzajemne wykluczanie jest zaimplementowane w .NET na kilka sposobów: monitory, muteksy, semafory, blokady odczytu i zapisu oraz kilka implementacji nieblokujących.

Monitory

Monitory są prymitywnymi synchronizatorami używanymi do synchronizacji dostępu do obiektów. Monitor jest zaimplementowany w klasie System.Threading.Monitor. Klasa Monitor jest używana w połączeniu z typami referencyjnymi aby upewnić się, że tylko jeden wątek ma dostęp do obiektu w danej chwili. Klasa udostępnia tylko metody statyczne które pobierają jako pierwszy parametr obiekt który ma być blokowany. W każdym momencie najwyżej jeden wątek może zablokować obiekt za pomocą wywołania metody statycznej Monitor.Enter. Jeżeli inny wątek wywoła metodę Monitor.Enter zanim pierwszy wątek wywoła metodę Monitor.Exit to drugi wątek będzie blokowany do czasu aż pierwszy wywoła metodę Monitor.Exit. W .NET wszystkie typy referencyjne posiadają pole które przechowuje referencję do wątku który nałożył blokadę na obiekt oraz listę wątków gotowych które czekają na nałożenie blokady oraz listę obiektów oczekujących na powiadomienie poprzez metodę Pulse lub PulseAll.
Najczęściej wykorzystywane metody klasy Monitor:

Enter - zakłada wyłączną blokadę na obiekcie.
Exit - zwalnia blokadę na obiekcie.
IsEntered - zwraca true jeżeli na obiekcie nałożona jest blokada. (Metoda została wprowadzona w .NET 4.5).
Pulse - powiadamia wątek na liście oczekujących o zmianie stanu obiektu, w efekcie przenosząc wątek z listy oczekujących na listę gotowych.
PulseAll - powiadamia wszystkie wątki na liście oczekujących o zmianie stanu obiektu, w efekcie przenosząc wątki z listy oczekujących na listę gotowych.
TryEnter - próbuje założyć wyłączną blokadę na obiekcie. metoda posiada sześć przeciążeń.
Wait - zwalnia blokadę na obiekcie i blokuje aktualny wątek do czasu aż będzie potrzebował blokady. Aktualny wątek zostanie umieszczony na liście oczekujących i będzie czekał na wywołanie metody Pulse lub PulseAll aby mógł kontynuować wykonywanie.

Metody Wait, Pulsei PulseAll mogą być wywoływane tylko przez wątek który jest właścicielem blokady.
Prosty przykład użycia monitora:

objectsyncObject =newobject();
Monitor.Enter(syncObject);
// Code updating some shared data
Monitor.Exit(syncObject);

Kod ten nie sprawdza czy w czasie wykonywania nie został zgłoszony wyjątek. Jeżeli wyjątek został zgłoszony to blokada nie zostanie zwolniona prowadząc do zakleszczenia. Aby rozwiązać ten problem można użyć bloku try-catch-finally np:

objectsyncObject =newobject();
Monitor.Enter(syncObject);
try {
// Code updating some shared data
}
finally {
Monitor.Exit(syncObject);
}

Język C# posiada skrót do tego wyrażenia nazwany lock np:

objectsyncObject =newobject();
lock (syncObject) {
// Code updating some shared data
}

Alternatywy Lock-free

Blokady są niebezpieczne i konsumują wiele zasobów. Czasem potrzebujemy wykonać proste operacje i chcemy być pewni, że są one atomowe. Aby rozwiązać tego typu problemy .NET oferuje klasę Interlocked zdefiniowaną w przestrzeni nazw System.Threading. Klasa ta posiada jedynie metody statyczne, które reprezentują wyłącznie operacje atomowe co oznacza, że zostaną wykonane bez przerywania przez harmonogram.
lista metod klasy Interlocked:

Add - dodaje dwie liczby 32-bitowe lub 64-bitowe i zastępuje pierwszą liczbę całkowitą z sumą, jako operacja atomowa.
CompareExchange - porównuje pierwszy i trzeci parametr dla równości i jeżeli są równe, zastępuje pierwszy parametr wartością drugiego.
Decrement - dekrementuje wybraną zmienną i zapisuje wynik, jako operacja atomowa.
Exchange - ustawia obiekt do określonej wartości i zwraca odwołanie do oryginalnego obiektu, jako operacja atomowa.
Increment - inkrementuje wybraną zmienną i zapisuje wynik, jako operacja atomowa.
Read - Ładuje wartość 64-bitową jako operacja atomowa i zwraca ją do wywołującego. Jest to konieczne tylko na platformach 32-bitowych.

Kolekcje współbieżne

Kolekcje zaimplementowane w przestrzeniach nazw System.Collections i System.Collections.Generic nie zostały zaimplementowane jako thread-safe. Zostały zaimplementowane tak aby były szybkie. Przed .NET 4.0 jeżeli potrzebowaliśmy kolekcji współbieżnej to musieliśmy zaimplementować ją sami. Od .NET 4.0Microsoft wprowadził kolekcje współbieżne. Wszystkie są zdefiniowane w przestrzeni nazw System.Collections.Concurrent. Wszystkie kolekcje współbieżne, z wyjątkiem klasy ConcurrentDictionary, implementują interfejsIProducerConsumerCollection. Ten interfejs wprowadza następujące metody:

CopyTo - kopiuje elementy obiektu IProducerConsumerCollection do tablicy Array, startując od wybranej pozycji.
ToArray - zwraca nową tablicę zawierającą wszystkie elementy obiektu IProducerConsumerCollection.
TryAdd - próbuje dodać obiekt do obiektu IProducerConsumerCollection.
TryTake - próbuje usunąć i zwrócić obiekt z obiektu IProducerConsumerCollection.

Lista klas implementujących interfejs IProducerConsumerCollection:

BlockingCollection - implementuje interfejs IProducerConsumerCollection, zapewniając blokowanie i ograniczenia możliwości.
ConcurrentBag - reprezentuje bezpieczną dla wątków kolekcję obiektów.
ConcurrentDictionary <TKey, TValue> - reprezentuje bezpieczną dla wątków wersję klasy Dictionary <TKey, TValue>.
ConcurrentQueue - reprezentuje bezpieczną dla wątków wersję klasy Queue.
ConcurrentStack - reprezentuje bezpieczną dla wątków wersję klasy Stack.

Praca z anulacjami (ang. Cancellations)

Przed .NET 4.0 każde anulowanie operacji było niebezpieczne. Aby anulować operację należało przerwać wątek lub porzucić operację. Pomimo, że to dziłało w większości przypadków to było źródłem wielu błędów.
.NET 4.0 wprowadził anulacje jako obywateli pierwszej klasy biblioteki .NET. Anulacje są odwołaniami kooperacyjnymi, co oznacza, że można wysłać żądanie unieważnienia do innego wątku, lub zadania, ale to ich wybór, aby uhonorować to żądanie.
Możliwości anulacji są implementowane przy użyciu jednej klasy CancellationTokenSource i jednej struktury CancellationToken działających w następujący sposób:

Jeśli wątek chce mieć możliwość odwołania kolejnej operacji, tworzy obiekt CancellationTokenSource.
Kiedy odwoływalna asynchroniczna operacja startuje, wątek wywołujący podaje CancellationToken uzyskany poprzez właściwość Token obiektu CancellationTokenSource. Odwoływalna asynchroniczna operacja oznacza, albo operację wspierającą anulowanie albo nowy watek lub, że zostanie utworzona poprzez aktualny wątek. To jest zwykle wyrażone w postaci jednej lub kilku metod przeciążonych akceptujących parametr CancellationToken. Wysyłając CancellationToken chcemy pozwolić operacji na zainicjowanie anulowania. Może to być wykonane jedynie przez obiekt CancellationTokenSource.
Jeśli wątek rodzic chce, aby anulować trwające odwoływalne operacje, wywołuje Cancel na obiekcie CancellationTokenSource.
Wszystkie bieżące operacje mogą używać CancelationToken wysłany jako parametr, aby sprawdzić, czy odwołanie jest w toku i odpowiednio na nie reagować.

Przykład użyty w sekcji z barierami przerobiony w taki sposób aby anulował trasy:

staticvoidMain(string[] args){
    var participants = 5;

// We create a CancellationTokenSource to be able to initiate the cancellation
    var tokenSource = new CancellationTokenSource();

// We create a barrier object to use it for the rendez-vous points
    var barrier = new Barrier(participants,
        b => {
            Console.WriteLine("{0} paricipants are at rendez-vous point {1}.",
            b.ParticipantCount,
            b.CurrentPhaseNumber);
        });
for (int i = 0; i < participants; i++) {
        var localCopy = i;
        Task.Run(() => {
            Console.WriteLine("Task {0} left point A!", localCopy);
            Thread.Sleep(1000 * localCopy + 1); // Do some "work"           
if (localCopy % 2 == 0) {
                Console.WriteLine("Task {0} arrived at point B!", localCopy);
                barrier.SignalAndWait(tokenSource.Token);
            }
else {
                Console.WriteLine("Task {0} changed its mind and went back!",
                    localCopy);
                barrier.RemoveParticipant();
return;
            }           
            Thread.Sleep(1000 * localCopy + 1);
            Console.WriteLine("Task {0} arrived at point C!", localCopy);
            barrier.SignalAndWait(tokenSource.Token);
        });
    }
    Console.WriteLine("Main thread is waiting for {0} tasks!",
        barrier.ParticipantsRemaining - 1);
    Console.WriteLine("Press enter to cancel!");
    Console.ReadLine();
if(barrier.CurrentPhaseNumber < 2){
        tokenSource.Cancel();
        Console.WriteLine("We canceled the operation!");
    }
else{
        Console.WriteLine("Too late to cancel!");
    }
    Console.WriteLine("Main thread is done!");
}

Kod startuje od utworzenia obiektów CancellationTokenSource i Barrier. Liczba uczestników bariery jest taka sama jak liczba wszystkich uczestników ponieważ chcemy użyć głównego wątku do anulowania.
Następnie w kodzie dla każdego uczestnika tworzone jest zadanie. Tak jak poprzednio, każde zadanie które zmieniło zdanie zostaje usunięte z bariery.
Następnie kod wywołuje SignalAndWait, co wysyła token anulowania z CancellationTokenSource.
Główny wątek wywołuje Console.ReadLine czekając na komendę użytkownika. Kiedy użytkownik naciśnie Enter, kod sprawdza czy wszyscy dotarli do celu. Kiedy się tego dowie poprzez zapytanie o wartość CurrentPhaseNumber obiektu bariery. Jeżeli wartość wynosi 2 to oznacza, że wszyscy przeszli przez dwie fazy, więc nie trzeba anulować operacji.
Finalnie, kod wywołuje tokenSource.Cancel, co wysyła sygnał anulowania do wszystkich obiektów czekających w obiekcie bariery, co odblokowuje je i anuluje pozostałą część operacji.

Podsumowanie

Wątki (ang. Threads)

Wątek tworzymy poprzez wysłanie do konstruktora delegaty która będzie główną metodą wątku.
Wątek startujemy poprzez bezpośrednie wywołanie metody Start na jego obiekcie.
Aby użyć puli wątków wywołujemy ThreadPool.QueueUserWorkItem lub ThreadPool.RegisterWaitForSingleObject.

Zadania (ang. Tasks)

Zadanie tworzymy poprzez wysłanie do konstruktora delegaty która będzie główną metodą zadania. Zadanie startujemy poprzez bezpośrednie wywołanie metody Start na jego obiekcie.
Wywołanie metody statycznej Task.Run z delegatą jako parametrem która będzie główną metodą zadania, tworzymy zadanie które jest startowane automatycznie.
Wywołanie metody statycznej Task.Factory.StartNew z delegatą jako parametrem która będzie główną metodą zadania, tworzymy zadanie które jest startowane automatycznie.

Blokady (ang. Locks)

Używamy metod Monitor.Enter lub Monitor.TryEnter aby założyć blokadę. Używamy Monitor.Exit aby zwolnić blokadę.
W języku C# można użyć wyrażenia lock, które jest skrótem dla utworzenia i zwolnienia blokady w bloku try-finally.

Anulowanie (ang. Cancellations)

Używamy obiektu CancellationTokenSource do kontrolowania operacji anulowalnych.
Używamy obiektu CancellationToken uzyskanego z CancellationTokenSource za pomocą właściwości Token aby wystartować operację anulowalną.
Aby anulować operację wywołujemy metodę Cancel obiektu CancellationTokenSource.

async/await

Są to dwa nowe słowa kluczowe wprowadzone w języku C# 5.0.
Słowo kluczowe async oznacza metodę jako asynchroniczną, mówiąc kompilatorowi, że metoda posiada instrukcję await w swoim ciele. Jeżeli w ciele metody nie ma instrukcji await to kompilator zwróci ostrzeżenie.
Słowo kluczowe await blokuje wykonanie aktualnej metody, czekając na wykonanie oczekiwanej operacji.

BackgroundWorker

Wykonuje długotrwałe operacje które trzeba wykonać jako zdarzenie DoWork.
Operację startujemy poprzez wywołanie RunWorkerAsync.
Aby dowiedzieć się kiedy długotrwała operacja została wykonana należy subskrybować zdarzenie RunWorkerCompleted.
Aby dowiedzieć się o postępie operacji należy subskrybować zdarzenie ProgressChanged.

Kontynuacje zadań (ang. Task continuation)

Kontynuuje zadanie za pomocą metod ContinueWith, WhenAll lub WhenAny.

V. Delegaty, zdarzenia i wyjątki

Thu, 26 Nov 2015 20:09:33 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Tworzenie i implementacja zdarzeń i wywołań zwrotnych.
Użycie wyrażeń lambda.
Użycie metod anonimowych.
Implementacja obsługi wyjątków.
Blok try-catch-finally.
Wyrzucanie wyjątków.

Praca z delegatami

Poniższy kod pokazuje jak tworzymy delegat:

[accessibility] delegate returnType DelegateName([parameters]);

Elementy tworzenia delegat:

accessibility - modyfikator dostępu do delegat np. private lub public.
delegate - wymagane słowo kluczowe.
returnType - typ danych zwracany przez metody tego delegaty np int lub string.
DelegateName - nazwa typu delegaty.
parameters - lista parametrów które metody tego typu delegaty powinny przyjmować na wejściu.
Przykładowy delegat:

privatedelegatefloatFunctionDelegate(float x);

Ten typ reprezentuje metody które przyjmują liczbę typu float jako parametr i zwracają typ int jako wynik.
Po zdefiniowaniu typu delegaty można utworzyć zmienną tego typu. Poniższy kod deklaruje zmienną TheFunction typu FunctionDelegate:

private FunctionDelegate TheFunction;

Później można ustawić zmienną na metodę która ma odpowiednie parametry i zwraca odpowiedni typ. Poniższy kod definiuje metodę Function1 i ustawia zmienną TheFunction na zadeklarowaną metodę:

// y = 12 * Sin(3 * x) / (1 + |x|)
privatestaticfloatFunction1(float x)
{
return (float)(12 * Math.Sin(3 * x) / (1 + Math.Abs(x)));
}
// Initialize TheFunction.
privatevoidForm1_Load(object sender, EventArgs e)
{
TheFunction = Function1;
}

Po inicjalizacji zmiennej TheFunction program może użyć jej jakby to była sama metoda. Przykładowo poniższy kod ustawia zmienną y równą wartości zwracanej przez TheFunction z parametrem o wartości 1.23.

float y = TheFunction(1.23f);

W tym momencie nie wiadomo do jakiej metody odnosi się zmienna TheFunction. Zmienna może odnosić się do metody Function1 lub innej metody która posiada sygnaturę pasującą do typu FunctionDelegate.

Zaleca się aby delegaty przechowywać w zmiennych. Delegaty można przechowywać jak każdy inny typ wartości w strukturze, tablicy czy liście. Przykładowo poniższy kod tworzy listę z która może zawierać referencje do metod które pasują do typu FunctionDelegate:

List<FunctionDelegate> functions = newList<FunctionDelegate>();

Szczegóły delegaty

Użycie delegat jest podobne do użycia innych typów danych. Wartościami delegat są referencje do metod. Delegaty mają również zdefiniowane operacje takie jak dodawanie czy odejmowanie. Załóżmy, że metody Method1 i Method2 nie pobierają żadnych parametrów i zwracają typ void to poniższy kod jest poprawny:

Action del1 = Method1;
Action del2 = Method2;
Action del3 = del1 + del2 + del1;

Delegata del3 zawiera serię zmiennych. Jeżeli ją wywołamy to program wykona po kolei Method1, Method2 i Method1.
Istnieje również kilka cech które są unikalne dla delegat.

Metody statyczne i metody instancji

Jeżeli ustawimy zmienną delegaty do statycznej metody to jest jasne co stanie się po wywołaniu tej metody. Istnieje tylko jedna taka metoda współdzielona przez wszystkie instancje klasy która ją definiuje, więc to jest zawsze ta metoda która jest wywoływana.
Jeżeli ustawimy wartość zmiennej delegaty do metody instancji to wynik może być bardziej zagmatwany. Kiedy wykonamy metodę przypisaną do zmiennej to wykonana zostanie metoda tej instancji klasy która została przypisana do zmiennej.
Przykład kodu z metodą statyczną i metodą instancji:

class Person
{
    public stringName;
    // A method that returns a string.
    public delegate stringGetStringDelegate();
    // A staticmethod.
    public staticstringStaticName()
    {
return"Static";
    }
    // Return this instance's Name.
    public stringGetName()
    {
returnName;
    }
    // Variables to hold GetStringDelegates.
    public GetStringDelegateStaticMethod;
    public GetStringDelegateInstanceMethod;
}
//...
private voidForm1_Load(object sender, EventArgs e)
{
    // Make some Persons.
Person alice = new Person() { Name = "Alice" };
Person bob = new Person() { Name = "Bob" };
    // MakeAlice's InstanceMethod variable refer to her own GetNamemethod.
    alice.InstanceMethod = alice.GetName;
    alice.StaticMethod = Person.StaticName;
    // MakeBob's InstanceMethod variable refer to Alice's GetNamemethod.
    bob.InstanceMethod = alice.GetName;
    bob.StaticMethod = Person.StaticName;
    // Demonstrate the methods.
stringresult = "";
result += "Alice's InstanceMethod returns: " + alice.InstanceMethod() +
Environment.NewLine;
result += "Bob's InstanceMethod returns: " + bob.InstanceMethod() +
Environment.NewLine;
result += "Alice's StaticMethod returns: " + alice.StaticMethod() +
Environment.NewLine;
result += "Bob's StaticMethod returns: " + bob.StaticMethod();
    resultsTextBox.Text = result;
    resultsTextBox.Select(0, 0);
}

Kowariancja i kontrawariancja

Kowariancja i kontrawariancja dają pewną elastyczność podczas przypisywania metod do zmiennych delegat. Przede wszystkim pozwalają traktować zwracany typ i parametry delegaty polimorficznie.
Kowariancja pozwala metodzie zwracać wartości z podklas oczekiwanego przez delegatę wyniku. Przykładowo jeżeli klasa Employee dziedziczy z klasy Person i delegata typu ReturnPersonDelegate reprezentuje metodę która zwraca obiekt typu Person to można do zmiennejReturnPersonDelegate przypisać metodę która zwraca typ Employee ponieważ jest on podtypem klasy Person.
Kontrawariancja pozwala metodom pobierać parametry które są typu klasy nadrzędnej do oczekiwanego typu. Przykładowo załużmy, że delegat typu EmployeeParameterDelegate reprezentuje metodę która oczekuje obiektu klasy Employee jako parametru to można do zmiennej typuEmployeeParameterDelegate przypisać metodę która przyjmuje parametr typu Person.
Przykład kodu wykorzystującego kowariancję i kontrawariancję:

// A delegate that returns a Person.
privatedelegate Person ReturnPersonDelegate();
private ReturnPersonDelegate ReturnPersonMethod;
// A method that returns an Employee.
private Employee ReturnEmployee()
{
returnnew Employee();
}
// A delegate that takes an Employee as a parameter.
privatedelegatevoidEmployeeParameterDelegate(Employee employee);
private EmployeeParameterDelegate EmployeeParameterMethod;
// A method that takes a Person as a parameter.
privatevoidPersonParameter(Person person)
{
}
// Initialize delegate variables.
privatevoidForm1_Load(object sender, EventArgs e)
{
// Use covariance to set ReturnPersonMethod = ReturnEmployee.
    ReturnPersonMethod = ReturnEmployee;
// Use contravariance to set EmployeeParameterMethod = PersonParameter.
    EmployeeParameterMethod = PersonParameter;
}

Wbudowane delegaty

Delegata Action

Generyczna delegata Action reprezentuje metodę zwracającą typ void. Różne wersje delegaty Action pobieraja od 1 do 18 parametrów wejściowych. Poniższy kod pokazuje definicję delegaty Action pobierającej dwa parametry wejściowe:

publicdelegatevoid Action<in T1, in T2>(T1 arg1, T2 arg2)

Słowo kluczowe in z parametrami generycznymi oznacza, że parametry T1 i T2 są kontrawariantami.
jeżeli potrzebujemy zdefiniować delegat który pobiera mniej niż 18 parametrów wejściowych to możemy użyć Action zamiast tworzyć swój własny typ. Przykładowe porównanie tworzenia:

// Method 1.
privatedelegatevoidEmployeeParameterDelegate(Employee employee);
private EmployeeParameterDelegate EmployeeParameterMethod1;
// Method 2.
private Action<Employee> EmployeeParameterMethod2;

Delegata Func

Generyczna delegata Func reprezentuje metodę zwracającą wartość i pobiera od 1 do 18 parametrów wejściowych. Przykład delegaty Func pobierającej dwa parametry wejściowe:

publicdelegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2)

Trzy typy zdefiniowane przez generyczną delegatę to dwa typy parametrów wejściowych i typ zwracany. Przykładowe porównanie tworzenia:

// Method 1.
privatedelegate Person ReturnPersonDelegate();
private ReturnPersonDelegate ReturnPersonMethod1;
// Method 2.
private Func<Person> ReturnPersonMethod2;

Metody anonimowe

Metody anonimowe to metody które nie posiadają nazwy. Zamiast tworzyć metodę w normalny sposób tworzy się delegatę która odnosi się do metody anonimowej. Składnia tworzenia delegaty z metodą anonimową:

delegate([parameters]) { code... }

Przykład metody anonimowej:

private Func<float, float> Function = delegate(float x) { return x * x; };

Nie można wywołać takiej metody po nazwie ale można użyć zmiennej Function aby wywołać metodę.
Zwykle używa się metod anonimowych kiedy program kiedy program potrzebuje relatywnie prostego fragmentu kodu wywoływanego w jednym miejscu.
Dwa inne miejsca gdzie często wykorzystuje się metody anonimowe to definiowanie prostej obsługi zdarzeń i wykonywanie prostych zadań w osobnych wątkach.
Poniższy kod dodaje obsługę zdarzenia Paint:

privatevoidForm1_Load(object sender, EventArgs e)
{
this.Paint += delegate(object obj, PaintEventArgs args)
    {
        args.Graphics.DrawEllipse(Pens.Red, 10, 10, 200, 100);
    };
}

Poniższy kod wykonuje metodę anonimową w osobnym wątku:

privatevoid Form1_Load(object sender, EventArgs e)
{
    System.Threading.Threadthread=new System.Threading.Thread(
        delegate() { MessageBox.Show("Hello World"); }
    );
thread.Start();
}

Wyrażenia Lambda

Metody anonimowe pozwalaja na tworzenie krótkich metod wykonywanych tylko w jednym miejscu. Wyrażenia lambda są skróconą notacją tworzącą metody anonimowe.
Wyrażenia lambda mogą być zapisywane w kilku formatach i kilku wariantach:

Expression Lambdas

Składnia wyrażenia lambda:

() => expression;

Wyrażenie expression w kodzie jest pojedynczą deklaracją języka C# która powinna być wykonana przez delegatę. Fakt, że to wyrażenie lambda posiada pojedyncze wyrażenie po prawej stronie sprawia, że jest to wyrażenie lambda.
Pusty nawias reprezentuje pustą listę parametrów metody anonimowej. Znaki => oznaczają, że jest to deklaracja lambda.
Przykład użycia:

Action note = () => MessageBox.Show("Hi");

Przykład użycia z parametrami:

Action<string> note = (message) => MessageBox.Show(message);

Kiedy wyrażenie lambda posiada jeden parametr to można ominąć nawias np:

Action<string> note = message => MessageBox.Show(message);

Zwykle Visual Studio potrafi wywnioskować typy danych parametrów wyrażenia lambda. Jeżeli nie lub jeżeli chcemy zapisać kod bardziej jawnie to można zawrzeć typ danych parametrów np:

Action<string> note = (stringmessage) => MessageBox.Show(message);

Przykład z czterema parametrami wejściowymi:

Action<string, string, MessageBoxButtons, MessageBoxIcon> note;
note = (message, caption, buttons, icon) =>
    MessageBox.Show(message, caption, buttons, icon);
note("Invalid input", "Alert", MessageBoxButtons.OK,
    MessageBoxIcon.Asterisk);

Wyrażenie lambda może również zwracać wartość np:

Func<float, float> square = (float x) => x * x;
float y = square(13);

Statement Lambdas

Deklaracja lambda różni się tym, że jej kod zawarty jest w nawiasie klamrowym oraz musi posiadać deklarację return zwracającą jakiś wynik. Pozwala to na zapis bardziej skomplikowanych wyrażeń składających się z więcej niż jednego wyrażenia.
Przykład deklaracji lambda:

TheFunction = (float x) =>
    {
constfloat A = -0.0003f;
constfloat B = -0.0024f;
constfloat C = 0.02f;
constfloat D = 0.09f;
constfloat E = -0.5f;
constfloat F = 0.3f;
constfloat G = 3f;
return (((((A * x + B) * x + C) * x + D) * x + E) * x + F) * x + G;
    };

Async Lambdas

Asynchroniczne wyrażenia lambda pozwalają na użycie słowa kluczowego async sprawiającego, że metoda może być wykonywana asynchronicznie. Można wtedy użyć słowa kluczowego await aby fragment kodu wywołał asynchroniczną metodę i poczekał na zwracaną wartość. Przykład kodu wykorzystującego asynchroniczne wyrażenie lambda:

// The number of times we have run DoSomethingAsync.
privateint Trials = 0;
// Create an event handler for the button.
privatevoidForm1_Load(object sender, EventArgs e)
{
    runAsyncButton.Click += async (button, buttonArgs) =>
        {
int trial = ++Trials;
            statusLabel.Text = "Running trial " + trial.ToString() + "...";
await DoSomethingAsync();
            statusLabel.Text = "Done with trial " + trial.ToString();
        };
}
// Do something time consuming.
async Task DoSomethingAsync()
{
// In this example, just waste some time.
await Task.Delay(3000);
}

Praca ze zdarzeniami

Zdarzenia pozwalają obiektom na komunikowanie programowi, że coś ciekawego zaszło. Przykładowo obiekt skrzynki email może wywołać zdarzenie aby powiedzieć programowi, że otrzymał nową wiadomość, guzik może wywołać zdarzenie mówiące programowi, że użytkownik nacisnął reprezentację graficzną guzika na ekranie. Obiekt, który wywołuje zdarzenie nazywa wydawca tego zdarzenia (event’s publisher). Klasa która przechwytuje zdarzenia nazywana jest subskrybentem (subscriber).

Publikowanie zdarzeń

Zanim obiekt zgłosi zdarzenie, musi najpierw je zadeklarować aby subskrybenci wiedzieli jakie zdarzenie jest zgłaszane i jakie parametry zawiera. Składnia deklaracji zdarzenia:

accessibility eventdelegate EventName;

Przykładowo klasa BankAccount może używać poniższego kodu do definiowania zdarzenia Overdrawn:

publicdelegatevoidOverdrawnEventHandler();
publicevent OverdrawnEventHandler Overdrawn;

Pierwsza linijka deklaruje delegatę OverdrawnEventHandler, która reprezentuje metodę nie pobierającą żadnych parametrów wejściowych i zwracającą void.
Druga linijka deklaruje zdarzenie o nazwie Overdrawn typu OverdrawnEventHandler. Oznacza to, że subskrybenci muszą użyć metod pasujących do delegaty OverdrawnEventHandler aby obsłużyć to zdarzenie.
Później obiekt BankAccount może zgłosić to zdarzenie w razie potrzeby. Przykład klasy BankAccount:

classBankAccount
{
publicdelegatevoidOverdrawnEventHandler();
publicevent OverdrawnEventHandler Overdrawn;
// The account balance.
publicdecimal Balance { get; set; }
// Add money to the account.
publicvoidCredit(decimal amount)
{
        Balance += amount;
    }
// Remove money from the account.
publicvoidDebit(decimal amount)
{
// See if there is this much money in the account.
if (Balance >= amount)
        {
// Remove the money.
            Balance -= amount;
        }
else
        {
// Raise the Overdrawn event.
if (Overdrawn != null) Overdrawn();
        }
    }
}

Predefiniowane typy zdarzeń

Zdarzenie zdefiniowane powyżej, które nie pobiera parametrów i nic nie zwraca można uprościć za pomocą predefiniowanej delegaty Action:

publicevent Action Overdrawn;

Najlepsze praktyki używania zdarzeń

Microsoft zaleca aby wszystkie zdarzenia posiadały dwa parametry: obiekt zgłaszający zdarzenie i obiekt z argumentami które są wymagane do obsługi zdarzenia. Drugi obiekt powinien dziedziczyć z klasy EventArgs.
Przykładowo obiekt klasy BankAccount opisany w poprzedniej sekcji powinien być pierwszym argumentem zdarzenia tak aby można było stwierdzić które konto zgłosiło zdarzenie Overdrawn.
Fakt, że zdarzenie zostało zgłoszone mówi nam o tym, że konto nie posiada wystarczającej ilości środków ale nie mówi nam jak duży jest debet. Można zmodyfikować program tak aby jako drugi parametr przesyłał nam tę informację.
Klasa z informacjami powinna dziedziczyć z klasy EventArgs i wg konwencji jej nazwa powinna składać się z nawy zdarzenia i przyrostka EventArgs np:

classOverdrawnEventArgs : EventArgs
{
publicdecimal CurrentBalance, DebitAmount;
publicOverdrawnEventArgs(decimal currentBalance, decimal debitAmount)
{
        CurrentBalance = currentBalance;
        DebitAmount = debitAmount;
    }
}

Ponieważ obsługa zdarzenia wymaga teraz dwóch parametrów, to trzeba zmienić deklarację zdarzenia. Można stworzyć nową delegatę ale .NET Framework posiada już predefiniowaną delegatę generyczną o nazwie EventHandler. Deklaracja zdarzenia po zamianie:

publicevent EventHandler<OverdrawnEventArgs> Overdrawn;

Metoda Debit wywołująca nowy typ zdarzenia:

// Remove money from the account.
publicvoidDebit(decimal amount)
{
// See if there is this much money in the account.
if (Balance >= amount)
    {
// Remove the money.
        Balance -= amount;
    }
else
    {
// Raise the Overdrawn event.
if (Overdrawn != null)
        Overdrawn(this, new OverdrawnEventArgs(Balance, amount));
    }
}

Dziedziczenie zdarzeń

Zdarzenie może być wywoływane jedynie z klasy która je deklaruje więc podklasy nie mogą zgłaszać zdarzeń zadeklarowanych w klasie bazowej.
Rozwiązaniem zaproponowanym przez Microsoft jest dodanie do klasy bazowej metody chronionej która wywołuje zdarzenie. Klasa która dziedziczy może wywołać tę metodę aby zgłosić zdarzenie. Wg konwencji metody takie zaczynają się przedrostkiem On i kończą nazwą zdarzenia npOnOverdrawn.
Wg wzorca obsługi metoda wywołująca zdarzenie Overdrawn klasy BankAccount powinna przenieść wywołanie zdarzenia do nowej metody OnOverdrawn, np:

// Raise the Overdrawn event.
protectedvirtualvoidOnOverdrawn(OverdrawnEventArgs args)
{
if (Overdrawn != null) Overdrawn(this, args);
}
// Remove money from the account.
publicvoidDebit(decimal amount)
{
// See if there is this much money in the account.
if (Balance >= amount)
    {
// Remove the money.
        Balance -= amount;
    }
else
    {
// Raise the Overdrawn event.
        OnOverdrawn(new OverdrawnEventArgs(Balance, amount));
    }
}

Przypuśćmy, że chcemy dodać klasę MoneyMarketAccount dziedziczącą z klasy BankAccount. Kiedy chcemy zgłosić zdarzenie Overdrawn to wywołujemy metodę rodzica OnOverdrawn:

classMoneyMarketAccount : BankAccount
{
publicvoidDebitFee(decimal amount)
{
// See if there is this much money in the account.
if (Balance >= amount)
        {
// Remove the money.
            Balance -= amount;
        }
else
        {
// Raise the Overdrawn event.
            OnOverdrawn(new OverdrawnEventArgs(Balance, amount));
        }
    }
}

Subskrybowanie i anulowanie subskrypcji do zdarzeń

Aby dodać subskrypcję zdarzenia można użyć kodu podobnego do tego poniżej:

processOrderButton.Click += processOrderButton_Click;

Kod ten dodaje metodę processOrderButton_Click jako obsługę zdarzenia Click guzika processOrderButton.
Alternatywnie ten sam kod można napisać tak:

processOrderButton.Click += new System.EventHandler(processOrderButton_Click);

Przykładowa pusta metoda obsługująca zdarzenie processOrderButton_Click:

voidprocessOrderButton_Click(object sender, EventArgs e)
{
thrownew NotImplementedException();
}

Anulowanie subskrypcji dokonywane jest za pomocą poniższego kodu:

processOrderButton.Click -= processOrderButton_Click;

Jeżeli dokonamy subskrypcji zdarzenia więcej niż raz to obsługa tego zdarzenia będzie wywołana więcej niż raz.
Za każdym razem jak anulujemy subskrypcję zdarzenia to usuwana jest jedna subskrypcja z listy subskrybentów.
Jeżeli anulujemy subskrypcję obsługi zdarzenia które nie jest subskrybowane do zdarzenia to nic się nie wydarzy i nie będzie zgłoszony żaden błąd ani wyjątek.
Subskrybowanie zdarzeń może się również odbyć z okna Designer w Visual Studio.

Obsługa wyjątków

Bez względu na to, jak dobrze zaprojektujemy aplikację, pewne problemy są nieuniknione. Użytkownicy wpiszą nieprawidłowe wartości, niezbędne pliki zostaną usunięte a krytyczne połączenia sieciowe nie powiodą się. Aby uniknąć tego rodzaju problemów, program musi obsługiwać sprawdzanie błędów i obsługę wyjątków.

Sprawdzanie błędów i obsługa wyjątków

Sprawdzanie błędów to proces przewidywania błędów, sprawdzając, czy będą występować, i pracy wokół nich. Na przykład, jeśli użytkownik musi wprowadzić liczbę całkowitą w polu tekstowym to w końcu ktoś wprowadzi wartość nienumeryczną. Jeśli program próbuje analizować wprowadzone wartości, jak gdyby były liczbą całkowitą, to ulegnie awarii.
Zamiast awarii, program powinien walidować wprowadzany tekst aby sprawdzić czy ma on sens przed konwertowaniem jego wartości. Przykładowo metoda int.TryParse wykonuje obie te czynności.
W przeciwieństwie do sprawdzania błędów, obsługa wyjątków jest procesem zabezpieczania aplikacji, gdy wystąpi nieoczekiwany błąd. Przykładowo kiedy program zacznie pobierać plik z sieci i w pewnym momencie utracone zostanie połączenie sieciowe. Nie ma możliwości aby program przewidział taki problem ponieważ sieć była dostępna kiedy program rozpoczynał pobieranie.
Nawet jeśli sprawdzimy każdą wartość wprowadzoną przez użytkownika i sprawdzimy każdą możliwą sytuację, mogą pojawić się nieoczekiwane wyjątki. Pliki mogą zostać uszkodzone, połączenie sieciowe, które było obecne może zostać zerwane, w systemie może zabraknąć pamięci lub biblioteki, których używasz i nad którymi nie masz kontroli mogą wyrzucić wyjątek.

Blok try-catch-finally

Blok try-catch-finally pozwala programowi na przechwycenie niepożądanych błędów i ich obsługę. Zawiera on trzy sekcje: jeden blok try, jeden lub wiele bloków catch i blok finally. Sekcja try jest wymagana i musi posiadać przynajmniej jedną sekcję catch lub finally.
Sekcja try zawiera kod który może zgłosić wyjątek. W tej sekcji można zamieścić dowolną ilość deklaracji. Można również zagnieżdżać bloki try-catch-finally. Składnia sekcji try i catch:

try
{
    // Statements that might throw an exception.
    //...
}
catch [(ExceptionType [variable])]
{
    //Statements to execute...
}

Jeżeli w sekcji try wystąpi wyjątek to program przegląda jego wszystkie sekcje catch w kolejności w jakiej zostały napisane w programie w poszukiwaniu obsługi typu wyjątku zgodnego ze zgłoszonym wyjątkiem. typ wyjątku jest zgodny jeżeli jest jednym z typów klasy typu wyjątkuExceptionType. Przykładowo klasa DivideByZeroException dziedziczy z klasy ArithmeticException która dziedziczy z klasy SystemException a at z kolei dziedzczy z klasy Exception. Jeżeli program wyrzuci wyjątek DivideByZeroException to obsłużyć go można w bloku catchobsługującym którykolwiek z tych typów wyjątków. Każdy wyjątek dziedziczy z klasy Exception, więc blok catch z typem wyjątku Exception przechwyci każdy zgłoszony wyjątek.
Kiedy program znajdzie dopasowanie typu wyjątku w sekcji catch to wykona kod znajdujący się w odnalezionej sekcji i przeskoczy wszystkie pozostałe sekcje catch.
Ponieważ program przeszukuje sekcje catch w kolejności w jakiej zostały napisane w kodzie to należy tak pisać kod aby lista sekcji catch rozpoczynała się od najbardziej szczegółowych wyjątków a kończyła się najbardziej ogólnymi. Przykładowo klasa FormatException dziedziczy zSystemException a ta dziedziczy z Exception więc blok try-catch powinien wyglądać tak:

try
{
//Statements...
}
catch (SystemException ex)
{
//Statements...
}
catch (FormatException ex)
{
//Statements...
}
catch (Exception ex)
{
//Statements...
}

Jeżeli w sekcji catch nie podamy typu wyjątku to blok ten przechwyci wszystkie rodzaje wyjątków np:

int quantity;
try
{
    quantity = int.Parse(quantityTextBox.Text);
}
catch
{
    MessageBox.Show("The quantity must be an integer.");
}

Jeżeli blok catch zawiera typ wyjątku i zmienną to zmienna jest typu tego wyjątku i posiada informacje na temat zgłaszanego wyjątku. Wszystkie klasy dziedziczące z Exception posiadają właściwość Message która zawiera informację tekstową o zgłaszanym wyjątku.
Jeżeli blok catch zawiera typ wyjątku ale nie zawiera zmiennej to sekcja przechwyci wyjątek który pasuje do danego typu ale nie posiada szczegółowych informacji które byłyby zawarte w zmiennej.
Sekcja finally jest wykonywana po zakończeniu wykonywania sekcji try i catch. jest ona wykonywana zawsze, nawet jeżeli program opuści sekcje try i catch z niżej wymienionych powodów:

Sekcja try zakończyła się sukcesem i żadna sekcja catch nie została wykonana.
Sekcja try wyrzuciła wyjątek i sekcja catch go obsłużyła.
Sekcja try wyrzuciła wyjątek i żadna sekcja catch go nie obsłużyła.
Sekcja try użyła wyrażenia return służącego do wyjścia z metody.
Sekcja catch użyła wyrażenia return służącego do wyjścia z metody.
Kod w sekcji catch wyrzucił wyjątek.
Jedynie kod w sekcji try jest chroniony przez blok try-catch-finally. jeżeli wyjątek zostanie zgłoszony w sekcji catch lub sekcji finally to nie zostanie obsłużony w tym bloku try-catch-finally. Dlatego bloki try-catch-finally mogą być zagnieżdżone.

Użycie wyrażenia using

Wyrażenie using zachowuje się jak sekwencja try-finally wywołująca metodę Dispose obiektu w sekcji finally np:

using (Pen pen = new Pen(Color.Red, 10))
{
// Use the pen to draw...
}

Jest ekwiwalentem kodu:

Pen pen;
try
{
    pen = new Pen(Color.Red, 10);
// Use the pen to draw...
}
finally
{
if (pen != null) pen.Dispose();
}

Wyjątki nieobsłużone

Wyjątki nieobsłużone występują wtedy gdy program wyrzuci wyjątek i nie jest on obsłużony w żadnym bloku try-catch-finally. Może się to wydarzyć na dwa sposoby. Pierwszym jest gdy wyjątek zostaje wyrzucony we fragmencie kodu który nie znajduje się w bloku try-catch-finally. Drugi przypadek jest wtedy gdy wyjątek zostaje wyrzucony w sekcji try ale żadna sekcja catch nie obsłuży tego wyjątku.
Kiedy program napotka na nieobsłużony wyjątek to kontrola przechodzi do góry stosu wywołań do metody która wywołała kod który wywołał wyjątek. Jeżeli metoda ta znajduje się w sekcji try bloku try-catch-finally to jego sekcja catch spróbuje obsłużyć wyjątek. W przeciwnym wypadku kontrola przechodzi o poziom wyżej w stosie wywołań. Kontrola przechodzi wyżej aż znajdzie sekcję catch która obsłuży zgłoszony wyjątek. W tym wypadku kod zostaje wywoływany dalej od tego momentu w którym wyjątek został obsłużony. Jeżeli wyjątek nie zostanie obsłużony w żadnym bloku try-catch-finally to program ulegnie awarii i pojawi się okno mówiące o awarii a w tym o wyjątku który został zgłoszony i stosie wywołań w programie prowadzącym do tego wyjątku. Okno posiada guziki umożliwiające zakończenie programu lub podjęcie próby kontynuacji działania programu. Przykład okna zgłaszającego nieobsłużony wyjątek.

Aby chronić program przed możliwymi wyjątkami, należy cały kod zawrzeć w bloku try-catch-finally.

Powszechnie stosowane wyjątki

.NET Framework definiuje setki klas wyjątków reprezentujących różne błędy. Poniżej rysunek przedstawiający najczęściej wykorzystywane wyjątki zdefiniowane w przestrzeni nazw System:

Użyteczne klasy wyjątków:

System.Exception - Klasa bazowa wszystkich innych klas wyjątków. Reprezentuje wyjątki na wysokim poziomie.
SystemException - Klasa bazowa wyjątków zdefiniowanych w przestrzeni nazw System.
ArgumentException - Jeden z argumentów metody jest niepoprawny.
ArgumentNullException - Jeden z argumentów ma niedozwolona wartość null.
ArgumentOutOfRangeException - Argument jest poza dozwolonym zakresem.
ArithmeticException - Błąd arytmetyczny lub błąd przy konwertowaniu lub rzutowaniu typów.
DivideByZeroException - Błąd dzielenia przez zero.
OverflowException - Operacja arytmetyczna, konwersja lub rzutowanie wykonane w bloku checked zwraca błąd przepełnienia.
NotFiniteNumberException - Operacja zmiennoprzecinkowa zwraca błąd, że wynik jest nieskończonością lub NaN.
ArrayTypeMismatchException - Program próbuje wstawić zły typ do tablicy.
FormatException - Argument ma niepoprawny format.
IndexOutOfRangeException - indeks tablicy z poza jej zakresu.
InvalidCastException - Niepoprawne rzutowanie lub konwersja.
InvalidOperationException - Wywołanie metody jest nieprawidłowe dla obecnego stanu obiektu.
IO.IOException - Błąd wejścia/wyjścia.
IO.DirectoryNotFoundException - Cześć ścieżki nie została odnaleziona.
IO.DriveNotFoundException - Dysk lub zasób sieciowy niedostępny.
IO.EndOfStreamException - Program próbował odczytać poza końcem strumienia.
IO.FileLoadException - Program próbował załadować plik który istnieje ale jest niedostępny.
IO.FileNotFoundException - Plik nie został odnaleziony.
IO.PathTooLongException - Ścieżka lub nazwa pliku jest za długa.
NotImplementedException - Funkcja niezaimplementowana.
NotSupportedException - Program próbował wywołać metodę, która nie jest wspierana. Możesz wyrzucić ten wyjątek, aby wskazać metodę, która została usunięta w ostatnich wersjach biblioteki.
NullReferenceException - Program próbował dostać się do obiektu który ma wartość null.
OutOfMemoryException - Za mało pamięci aby program mógł kontynuować.
RankException - Program wstawił do metody tablicę z niewłaściwą liczbą wymiarów.
Security.SecurityException - Błąd bezpieczeństwa.
Security.VerificationException - Polityka bezpieczeństwa wymaga kodu by używał typów bezpiecznych, a kod nie może być zweryfikowany jako bezpiecznego typu.
UnauthorizedAccessException - Dostęp zabroniony z powodu błędu wejścia/wyjścia lub bezpieczeństwa.

Wyjątki SQL

SQL Server używa klasy System.Data.SqlClient.SqlException reprezentującej wszyskie błędy i wyjątki. Można użyć właściwości tej klasy aby dowiedzieć się co dokładnie się wydarzyło. Najbardziej użyteczne właściwości klasy SqlException:

Class - Numer od 0 do 25 oznaczający typ błędu. Błędy powyżej 20 są fatalne i oznaczają zamknięcie połączenia do bazy danych. Błędy poniżej 10 są klasy informacyjnej. Błędy z zakresu 11-16 mogą być naprawione przez użytkownika. Błąd 17 oznacza, że serwer korzysta z zasobów które nie są konfigurowalne i błąd może rozwiązać administrator. 18 to błąd niefatalny wewnątrz oprogramowania. 19 oznacza, że SQL Server przekroczył limit zasobów. 20: problem w wyrażeniu wywołanym przez aktualny proces. 21: problem dotyczący wszystkich procesów bazy danych. 22: indeks lub tabela są uszkodzone. 23: baza danych jest uznana za uszkodzoną. 24: problem sprzętowy. 25: błąd systemowy.
LineNumber - numer błędnej linii w komendzie T-SQL lub procedurze składowanej.
Message - Informacja opisująca problem.
Number - Numer błędu.
Procedure - Nazwa procedury wywołującej błąd.
Klasa System.Data.Common.DbException jest klasa bazową klasy SqlException i jeszcze trzech innych klas reprezentujących błędy dla innych typów baz danych, są to:
System.Data.Odbc.OdbcException - Klasa błędów baz ODBC.
System.Data.OleDb.OleDbException - Klasa błędów baz OleDb.
System.Data.OracleClient.OracleException - Klasa błędów baz danych Oracle.
Wszystkie te klasy zawierają właściwość message która zawiera informacja opisująca problem.

Overflow Exception

Domyślnie program nie wyrzuca wyjątku jeżeli operacja arytmetyczna powoduje przepełnienie zakresu liczby całkowitej. Jeżeli operandy są całkowite lub dziesiętne to program obcina wartość wynikową.
Aby program zwrócił wyjątek OverflowException należy użyć bloku checked lub ustawić zaawansowaną opcję budowania.
Program nie wyrzuca wyjątku również dla operacji zmiennoprzecinkowej która powoduje przepełnienie lub zwraca specialną wartość NaN (not a number).
Typy zmiennoprzecinkowe posiadają właściwości statyczne PositiveInfinity, NegativeInfinity i NaN. Można porównać wartość z PositiveInfinity lub NegativeInfinity ale nie można porównać z NaN.
Zamiast porównywania można użyć specjalnych metod sprawdzających:

IsInfinity - zwraca true jeżeli wartość jest PositiveInfinity lub NegativeInfinity.
IsNegativeInfinity - zwraca true jeżeli wartość jest NegativeInfinity.
IsPositiveInfinity - zwraca true jeżeli wartość jest PositiveInfinity.
IsNaN - zwraca true jeżeli wartość jest NaN.

Właściwości wyjątków

Klasa System.Exception jest przodkiem wszystkich klas wyjątków i definiuje kilka właściwości mówiących programowi o tym co się wydarzyło i jaki problem wystąpił, są to właściwości:

Data - Kolekcja par klucz/wartość dająca dodatkowe informacje o wyjątku.
HelpLink - Łącze do pliku pomocy powiązanego z wyjątkiem.
HResult - Numeryczny kod wyjątku.
InnerException - Wyjątek wewnętrzny posiadający więcej informacji o błędzie który wystąpił.
Message - Wiadomość opisująca wyjątek.
Source - Nazwa aplikacji lub obiektu zgłaszającego wyjątek.
StackTrace - Tekstowa reprezentacja stosu wywołań prowadzącego do wystąpienia wyjątku.
TargetSite - Informacje o metodzie zgłaszającej wyjątek.
Właściwość Message klasy Exception nie zawiera wystarczająco dokładnych informacji aby wyświetlić je użytkownikowi lecz czasem jest wystarczająca dla programisty w czasie usuwania błędów. Metoda ToString klasy Exception posiada więcej użytecznych dla programisty informacji. Zawiera nazwę klasy wyjątku, właściwość Message oraz stos wywołań. Przykładowo metoda ToString klasy OverflowException może zwrócić następujący tekst:

System.OverflowException: Arithmetic operation resulted in an overflow.
    at OrderProcessor.OrderForm.CalculateSubtotal() in
        d:\Support\Apps\OrderProcessor\OrderForm.cs:line 166

Wyrzucanie i ponowne wyrzucanie wyjątków

Metoda może używać bloku try-catch-finally do przechwytywania wyjątków. Jeżeli ta metoda posiada interakcję z użytkownikiem to prawdopodobnie wyświetli wiadomość o wystąpieniu błędu.
Jednakże bardzo często metody nie powinny mieć interakcji z użytkownikiem. Zamiast tego powinny wyrzucać wyjątki do ich właścicieli aby powiedzieć wywołującemu kodowi, że wydarzył się błąd. Ten kod może wyświetlić informację użytkownikowi lub może poradzić sobie z problemem, nie przeszkadzając użytkownikowi.

Użycie wyjątków i zwracanie wartości

Metoda może wykonywać jakąś akcję po czym zwrócić informację do wywołującego ją kodu poprzez wartość zwracaną lub parametr wyjściowy. Wyjątek daje metodzie kolejną możliwość komunikacji z wywołującym ją kodem. Wyjątek mówi programowi, że coś wyjątkowego się wydarzyło i, że metoda mogła nie zakończyć powierzonego jej zadania.
Zdania na temat tego, kiedy metody powinny zwracać wartość za pomocą wartości lub parametru oraz kiedy powinny zwracać informacje za pomocą wyjątków, są podzielone. Większość programistów zgadza się z tym, że informacje o normalnym statusie powinny być zwracane za pomocą wartości a wyjątki powinny być używane dla błędów.
Najlepszą metodą aby zdecydować czy użyć wyjątku jest zadanie pytania czy wywołujący kod może pozwolić na ignorowanie zwracanego przez metodę statusu. Jeżeli metoda zwraca informację za pomocą wartości to wywołujący kod może ją zignorować. Jeżeli metoda zwraca wyjątek to wywołujący kod musi zawierać blok try-catch aby obsłużyć jawnie wyjątek. Na przykład, rozważmy następującą metodę, która zwraca silnię liczby:

// Calculate a number's factorial.
private long Factorial(long n)
{
    // Make sure n >= 0.
if (n < 0) return0;
    checked
    {
try
        {
            long result = 1;
for (long i = 2; i <= n; i++) result *= i;
returnresult;
        }
        catch
        {
return0;
        }
    }
}

Jeśli parametr jest mniejszy niż zero lub jeśli obliczenie powoduje przepełnienie liczby całkowitej to metoda zwraca wartość 0.
Istnieją dwa problemy z takim podejściem. Po pierwsze, kod wywołujący może zignorować błąd i traktować wartość 0 jako wartość silni dając nieprawidłowe wyniki. Jeżeli wartość jest używana w złożonych obliczeniach to błąd może wystąpić w trakcie obliczeń co może być trudne do zlokalizowania i naprawienia. Drugim problemem jest to, że kod wywołujący nie może powiedzieć, co poszło nie tak. Można zwracać różne wartości, np 0 dla przepełnienia zakresu liczby całkowitej i -1 dla wartości parametru mniejszego od 0, lecz nawet używając różnych kodów zwracających status nie możemy sprawdzić czy kod nie został zignorowany. Lepszym rozwiązaniem jest wyrzucenie odpowiedniego wyjątku. poniższa wersja metody jest lepszym rozwiązaniem:

// Calculate a number's factorial.
private long Factorial(long n)
{
    // Make sure n >= 0.
if (n < 0) throw new ArgumentOutOfRangeException(
"n", "The number n must be at least 0 to calculate n!");
    checked
    {
        long result = 1;
for (long i = 2; i <= n; i++) result *= i;
returnresult;
    }
}

Jeżeli parametr jest mniejszy niż zero to kod wyrzuci wyjątek ArgumentOutOfRangeException. Ponieważ obliczenia są zagnieżdżone w bloku checked to jeżeli nastąpi przepełnienie zakresu liczby całkowitej to zostanie wyrzucony wyjątek OverflowException..

Przechwytywanie, wyrzucanie i ponowne wyrzucanie wyjątków

Jeżeli metoda wyjaśnia dlaczego wyjątek wystąpił a nie raportuje, że wystąpił lub jeżeli dodaje dodatkowe informacje sprawiając, że wyjątek jest bardziej specyficzny to metoda powinna przechwycić wyjątek i wyrzucić nowy zawierający nowe informacje.
Jeżeli wyrzucamy wyjątek w ten sposób to dobrą praktyką jest zawarcie oryginalnego wyjątku we właściwości InnerException wyrzucanego wyjątku.
Jeżeli metoda dodaje nowe informacje do wyjątku to zwykle nie powinna go przechwytywać lecz pozwolić na przejście wyżej w drzewie wywołań. Czasami chcemy jednak przechwycić taki wyjątek w celu wykonania pewnej “prywatnej” akcji jak np logowanie. W takim przypadku można wykonać prywatny kod obsługujący wyjątek i ponownie go wyrzucić tak aby mógł zostać przechwycony wyżej w drzewie wywołań.
Ponowne wyrzucenie aktualnego wyjątku polega na użyciu deklaracji throw bez podania wyjątku. Poniższy kod demonstruje tą technikę:

try
{
    // Do something dangerous.
    //...
}
catch (Exception)
{
    // Log the error.
    //...
    // Re-throw the exception.
    throw;
}

Można też wyrzucić ponownie wyjątek z jawą jego deklaracją lecz powoduje to zresetowanie drzewa wywołań do aktualnej lokalizacji co może zmylić programistę który próbuje naprawić błąd. Poniższy kod demonstruje tą technikę:

try
{
    // Do something dangerous.
    //...
}
catch (Exception ex)
{
    // Log the error.
    //...
    // Re-throw the exception.
    throw ex;
}

Istnieją jednak powody dla których chcemy ponownie wyrzucać wyjątki i resetować drzewo wywołań, np kiedy nie chcemy pokazywać detali zamkniętej biblioteki i jej prywatnych metod. W takim wypadku powinniśmy obsłużyć wyjątek w metodzie publicznej i wtedy wyrzucić go ponownie tak aby drzewo wywołań zaczynało się w tej metodzie publicznej.

Tworzenie niestandardowych wyjątków

Czasami nie możemy znaleźć w .NET Framework odpowiedniej klasy wyjątku która odpowiada naszym potrzebom. W takim wypadku możemy utworzyć własną klasę wyjątku.
Klasa wyjątku powinna dziedziczyć z klasy Exception i jej nazwa powinna być zakończona słowem Exception.
Aby klasa była jak najbardziej użyteczna powinniśmy nadać jej konstruktor pasujący do zdefiniowanego w klasie Exception. Poniższy kod prezentuje klasę InvalidException napisaną wg powyższych zaleceń:

[Serializable]
class InvalidProjectionException : Exception
{
    public InvalidProjectionException()
        : base() { }
    public InvalidProjectionException(string message)
        : base(message) { }
    public InvalidProjectionException(string message,
    Exception innerException)
        : base(message, innerException) { }
    protected InvalidProjectionException(SerializationInfo info, 
        StreamingContext context)
        : base(info, context) { }
}

Każdy z konstruktorów przekazuje parametry do konstruktora klasy bazowej. Typy SerializationInfo i StreamingContext są zdefiniowane w przestrzeni nazw System.Runtime.Serialization.
Aby wyjątki mogły być przekazywane poza granice domeny aplikacji należy umożliwić im serializację poprzez dodanie atrybutu Serialize.

Użycie Debug.Assert

Klasa System.Diagnostics.Debug wprowadza metodę Assert która jest często używana do sprawdzania poprawności danych wstawianych do metody. Metoda Assert pobiera wartość bool jako pierwszy parametr i wyrzuca wyjątek jeżeli ta wartość to false. Inne parametry pozwalaja na określenie i wyświetlenie informacji gdzie metoda zawiodła.
W kompilacji debug metoda Assert zatrzymuje wykonywanie i wyświetla drzewo wywołań. W kompilacji release program pomija wywołanie tej metody.
Metody Assert można użyć do zweryfikowania czy wprowadzone dane mają sens. Przykładowo metoda PrintInvoice pobiera na wejściu tablicę obiektów klasy OrderItem nazwaną items i wyświetla faktury dla tych obiektów. Metoda ta może zaczynać się od użycia metody Assertsprawdzającej czy tablica wejściowa jest mniejsza niż 100:

Debug.Assert(items.Length <= 100)

Podsumowanie

Delegaty

Delegata jest tpem reprezentującym rodzaj metody. Definiuje parametry metody i typ zwracany.
Zazwyczaj nazwa delegaty nazywana jest z końcówką Delegate lub Callback.
Można użyć operatorów + i - do kombinowania zmiennych delegat np del3 = del1 + del2 to delegata del3 wykona metody z obu delegat.
Jeżeli zmienna delegaty odwołuje się do metody instancji obiektu to wykonuje się na obiekcie do którego została przypisana.
Kowariancja pozwala metodzie zwrócić wartość z podklasy typu który został zadeklarowany jako zwracany przez delegatę.
Kontrawariancja pozwala metodzie przyjąć parametr z klasy bazowej typu który był oczekiwany przez delegatę.
.NET Framework definiuje dwa wbudowane typy delegat Action i Func np:

publicdelegatevoid Action<in T1, in T2>(T1 arg1, T2 arg2)
publicdelegate TResult Func<in T1, in T2, out TResult>
(T1 arg1, T2 arg2)

Metoda anonimowa to metoda bez nazwy np:

Func<float, float> function = delegate(float x) { return x * x; };

Wyrażenia lambda pozwalają na tworzenie metod anonimowych w zwięzły sposób np:

Action note1 = () => MessageBox.Show("Hi");
Action<string> note2 = message => MessageBox.Show(message);
Action<string> note3 = (message) => MessageBox.Show(message);
Action<string> note4 = (string message) => MessageBox.Show(message);
Func<float, float> square = (float x) => x * x;

Zdarzenia

Zdarzenia posiadają wydawców i subskrybentów.
Do definicji zdarzeń używamy delegat w następujący sposób:

publicdelegatevoidOverdrawnEventHandler();
publicevent OverdrawnEventHandler Overdrawn;

Można użyć zdefiniowanej delegaty Action do utworzenia zdarzenia np:

publicevent Action Overdrawn;

Zaleca się aby pierwszym parametrem zdarzenia był obiekt nadawcy a następne parametry dające więcej informacji o zdarzeniu. Obiekt nadawcy powinien dziedziczyć z klasy EventArgs i mieć nazwę zakończona Args.
Można użyć zdefiniowanej delegaty EventHandler aby zdefiniować zdarzenie pobierające obiekt nazwany sender jako pierwszy argument i obiekt danych zdarzenia jako drugi np:

publicevent EventHandler<OverdrawnEventArgs> Overdrawn;

Zgłaszaj zdarzenia jak w poniższym kodzie:

if (EventName != null) EventName(arguments...);

Klasy nie mogą dziedziczyć zdarzen. Aby klasy mogły zgłaszać zdarzenia klas bazowych używa się metod nazywanych w stylu OnEventName zgłaszających zdarzenie.
Program używa operatorów += i -= do zapisywania się i wypisywania z subskrypcji zdarzeń.
Jeżeli program zapiszę się na subskrypcję zdarzenia więcej niż raz to obsługa zdarzenia zostanie wykonana wiele razy.
Jeżeli program wypisze się z subskrypcji zdarzenia nawet jeżeli nie był na nią wcześniej zapisany to nic się nie wydarzy.

Wyjątki

Obsługa wyjątków jest procesem ochrony programu od nieoczekiwanych błędów.
Blok try-catch-finally musi mieć co najmniej jedną sekcję catch lub finally.
Sekcja finally jest zawsze wykonywana.
Najbardziej specyficzna sekcja catch powinna pojawić się jako pierwsza w bloku try-catch-finally.
Jeżeli nie chcemy robić nic ze zgłoszonym wyjątkiem to możemy ominąć zmienną wyjątku pozostawiając tylko jego typ w sekcji catch.
Klasa Exception jest klasą bazową wszystkich wyjątków i przechwytuje wszystkie rodzaje wyjątków.
Sekcja catch bez zdefiniowanego typu wyjątku przechwytuje wszystkie wyjątki.
Wyrażenie using jest równoważne z blokiem try-catch-finally w którym w sekcji finally obiekt jest zbyty.
Wyjątek przechodzi w górę drzewa wywołan aż napotka blok catch który go obsłuży.
Właściwość Message wyjątku posiada informacje o wyjatku. Metoda ToString zawiera właściwość Message oraz dodatkowe opcję wraz z drzewem wywołań.
Klasa SqlException reprezentuje wyjątki serwera SQL Server.
Ponowne wyrzucenie wyjątku polega na użyciu instrukcji throw bez podania obiektu wyjątku. Można również wyrzucić ponownie wyjątek z obiektem lecz powoduje to zresetowania drzewa wywołań.

IV. Tworzenie i implementacja hierarchii klas

Sun, 01 Nov 2015 17:20:23 Z

Zagadnienia egzaminu 70-483 opisane w tej notatce:

Dziedziczenie z klasy bazowej.
Wywoływanie konstruktorów klasy potomnej lub tej samej klasy.
Tworzenie i implementacja interfejsów.
Użycie standardowych interfejsów jak IComparable, IEquatable i IEnumerable.
Implementacja interfejsu IDisposable i destruktor.
Użycie wyrażenia using.

Dziedziczenie z klasy bazowej

Poniższy kod definiuje klasę Person:

publicclassPerson
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicPerson(string firstName, string lastName)
{
// Validate the first and last names.
if ((firstName == null) || (firstName.Length < 1))
thrownew ArgumentOutOfRangeException(
"firstName", firstName,
"FirstName must not be null or blank.");
if ((lastName == null) || (lastName.Length < 1))
thrownew ArgumentOutOfRangeException(
"lastName", lastName,
"LastName must not be null or blank.");
// Save the first and last names.
        FirstName = firstName;
        LastName = lastName;
    }
}

Klasa Person posiada dwie właściwości typu tekstowego: FirstName i LastName. jej konstruktor pobiera imię i nazwisko jako parametry, wykonuje ich walidację i zapisuje jako właściwości FirstName i LastName.
Załóżmy, że chcemy utworzyć klasę Employee posiadającą właściwości FirstName, LastName i DepartmentName. Możemy zbudować tą klasę w całości lecz potrzebuje ona tych samych właściwości co klasa Person i może potrzebować również takiej samej walidacji więc budowanie jej w całości byłoby powtórzeniem pracy. Lepszym rozwiązaniem jest dziedziczenie klasy Employee z klasy Person w taki sposób aby odziedziczyła pola, właściwości, metody i zdarzenia. Logicznie pracownik jest pewnym rodzajem osoby więc sensowne jest stwierdzenie, że klasa Employee jest rodzajem klasy Person.
Dziedziczenie klasy z innej jest zapisywane w postaci nazwy klasy, dwukropka i nazwy klasy z której dziedziczy. Poniższy kod przedstawia dziedziczenie klasy Employee z klasy Person:

publicclassEmployee : Person
{
publicstring DepartmentName { get; set; }
}

Klasa Employee dziedziczy z klasy Person wszystkie pola,właściwości, metody i zdarzenia. W ciele klasy dodana jest nowa właściwość DepartmentName.
Pomimo dziedziczenia większości kodu ciała klasy rodzica, potomek nie dziedziczy konstruktorów.
W tym momencie utworzenie obiektu klasy Employee bez inicjalizacji właściwości wygląda tak:

Employee employee = newEmployee();

Ponieważ kod nie inicjuje właściwości to właściwości FirstName i LastName mają wartość null co jest sprzeczne z walidacją w konstruktorze klasy Person. Rozwiązaniem tego problemu jest wywołanie konstruktora rodzica przez konstruktor klasy potomka.

Wywołanie konstruktora klasy rodzica

Aby być pewnym, że konstruktor klasy Person jest wywoływany i sprawdza poprawność imienia i nazwiska, należy nadać klasie potomnej Employee konstruktor zawierający parametry klasy rodzica oraz dodać po dwukropku słowo kluczowe base które sprawi, że zostanie wywołany odpowiedni konstruktor klasy rodzica. Przykład klasy Employee wywołującej konstruktor klasy bazowej Person:

publicclassEmployee : Person
{
publicstring DepartmentName { get; set; }
publicEmployee(string firstName, string lastName,
string departmentName)
            : base(firstName, lastName)
{
// Validate the department name.
if ((departmentName == null) || (departmentName.Length < 1))
thrownew ArgumentOutOfRangeException(
"departmentName", departmentName,
"DepartmentName must not be null or blank.");
// Save the department name.
        DepartmentName = departmentName;
    }
}

Konstruktor klasy bazowej jest wywoływany przed ciałem konstruktora klasy potomka. Jeżeli kasa bazowa ma wiele konstruktorów to można użyć każdego z nich. program decyduje którego konstruktora użyć na podstawie parametrów w nawiasie po słowie kluczowym base.
Jeżeli obie klasy bazowa i potomka posiadają konstruktory to konstruktor potomka musi wywoływać jeden z konstruktorów klasy rodzica co oznacza, że użycie klauzuli ze słowem kluczowym base jest wtedy wymagane. W przeciwnym wypadku VisualStudio wygeneruje błąd: “PersonHierarchy.Person Does Not Contain a Constructor That Takes 0 Arguments”.
Jeżeli klasa potomka nie posiada konstruktora to nie musi wywoływać konstruktora klasy bazowej tzn, że taka deklaracja jest poprawna:

publicclassEmployee : Person
{
publicstring DepartmentName { get; set; }
}

Wywołanie konstruktora tej samej klasy

bardzo często klasy posiadają wiele konstruktorów wykonujących różne rodzaje inicjalizacji w zależności od wprowadzonych parametrów wejściowych. Czasem wiele konstruktorów musi wykonywać te same zadania.
Przykładowo klasa Person posiadająca właściwości FirstName i LastName może być inicjowana poprzez podanie imienia lub imienia i nazwiska:

classPerson
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
// Constructor with first name.
publicPerson(string firstName)
{
        FirstName = firstName;
    }
// Constructor with first and last name.
publicPerson(string firstName, string lastName)
{
        FirstName = firstName;
        LastName = lastName;
    }
}

Drugi konstruktor klasy wykonuje tę samą czynność co pierwszy konstruktor czyli inicjuje właściwość FirstName. W tym przykładzie to nie jest duży problem ale w bardziej skomplikowanym przykładzie mogłoby być to wiele powtarzającego się kodu.
Aby temu zapobiec można pozwolić konstruktorowi wywoływać inny konstruktor. Wykonuje się to tak samo jak wywoływanie konstruktora bazowego tylko, że przy użyciu słowa kluczowego this. Przykład konstruktora wywołującego inny konstruktor:

// Constructor with first and last name.
publicPerson(string firstName, string lastName)
: this(firstName)
{
    LastName = lastName;
}

Konstruktor wskazany słowem kluczowym this jest wykonywany przed ciałem konstruktora który go wywołuje.

Interfejsy

Kiedy wiemy już jak dziedziczyć pomiędzy klasami to możemy budować diagramy używające strzałek pokazujących relacje pomiędzy klasami. Język C# pozwala na posiadanie jednej klasy rodzica więc rezultatem takiego diagramu jest drzewiasta hierarchia.
Hierarchie klasowe są wystarczające dla wielu różnych problemów modelowania, ale od czasu do czasu byłoby wygodne, aby umożliwić klasom dziedziczenie z wielu klas bazowych. Przykładowo pisząc program zarzadzający studentami i pracownikami uniwersytetu. Dwie ważne klasy to klasa Student reprezentująca osobę studiującą i klasa Facultyreprezentująca osobę nauczającą. Problem pojawia się kiedy chcemy dodać klasę TeachingAssistant reprezentującą asystenta wykładowcy który jest jednocześnie studentem. Idealnym rozwiązaniem byłoby użycie wielokrotnego dziedziczenia tak aby klasa mogła dziedziczyc jednocześnie z klas Student i Faculty. Niestety w języku C# jest to niemożliwe.
Zamiast użycia wielokrotnego dziedziczenia w języku C# można użyć interfejsów aby zasymulować takie dziedziczenie.
Interfejs wymaga klasy aby zapewnić pewne funkcje tak samo jak klasa bazowa lecz w przeciwieństwie do klasy bazowej interfejs nie posiada implementacji. Ponieważ używanie interfejsu jest podobne do dziedziczenia bez implementacji to nazywane jest dziedziczeniem interfejsu. Każda klasa może dziedziczyć tylko z jednej klasy bazowej ale może implementować dowolną liczbę interfejsów.

Definiowanie interfejsów

Interfejs tak samo jak klasa posiada właściwości, metody i zdarzenia ale nie posiada kodu który je implementuje. Jest formą kontraktu określającego cechy jakie inna klasa powinna implementować.
Jeżeli klasa implementuje interfejs to musi implementować cechy zdefiniowane w interfejsie. Mówi to programowi, że ta klasa ma te cechy więc kod może je wywoływać.
Wprowadza to rodzaj polimorfizmu podobny do tego w jaki klasy mogą być traktowane przez program jako obiekty innych klas kompatybilnych. Przykładowo klasa Employee dziedziczy z klasy Person i implementuje interfejs ICloneable. Program może traktować obiekt klasy Employee jako Employee, Person lub ICloneable.
Przykład interfejsu IStudent:

publicinterfaceIStudent
{
// The student's list of current courses.
    List<string> Courses { get; set; }
// Print the student's current grades.
voidPrintGrades();
}

Wg konwencji nazwy interfejsów rozpoczynamy od dużej litery I np IStudent.
Klasa Student implementująca interfejs IStudent i dziedzicząca z klasy Person:

publicclassStudent : Person, IStudent
{
// Implement IStudent.Courses.
// The student's list of current courses.
public List<string> Courses { get; set; }
// Implement IStudent.PrintGrades.
// Print the student's current grades.
publicvoid PrintGrades()
    {
// Do whatever is necessary...
    }
}

Klasa TeachingAssistant dziedzicząca z klasy Faculty i implementująca interfejs IStudent:

publicclassTeachingAssistant : Faculty, IStudent
{
// Implement IStudent.Courses.
// The student's list of current courses.
public List<string> Courses { get; set; }
// Implement IStudent.PrintGrades.
// Print the student's current grades.
publicvoid PrintGrades()
    {
// Do whatever is necessary...
    }
}

Implementacja interfejsów

Czasami implementacja wszystkich metod zdefiniowanych przez interfejs może być dużą ilością pracy. Na szczęście VisualStudio posiada narzędzia ułatwiające implementację interfejsów. Deklarując interfejs do implementacji w VisualStudio klikamy prawym przyciskiem myszy na nazwie interfejsu i z menu kontekstowego wybieramy opcję Implement Interfacelub Implement Interface Explicitly. Przykład kodu wygenerowanego przez VisualStudio:

// Explicit implementation.
publicclassTeachingAssistant : Faculty, IStudent
{
    List<string> IStudent.Courses
    {
get
        {
thrownew NotImplementedException();
        }
set
        {
thrownew NotImplementedException();
        }
    }
void IStudent.PrintGrades()
    {
thrownew NotImplementedException();
    }
}

Opcja Explicitly powoduje, że przed każdą metodą i właściwością dodane jest cześć z której jest implementowana czyli IStudent.. Wygenerowane części kodu wyrzucają wyjątek NotImplementedException kiedy zostaną wywołane. Tę część kodu należy zamienić na odpowiedni kod logiki aplikacji.
Oprócz różnic w składni istnieje funkcjonalna różnica pomiędzy niejawną i jawną implementacją interfejsu. Jeśli klasa implementuje interfejs jawnie to program nie może odnieść się do członków interfejsu za pośrednictwem instancji klasy. Zamiast tego musi użyć instancji interfejsu.
Przykładowo klasa TeachingAssistant implementuje jawnie interfejs IStudent:

TeachingAssistant ta = new TeachingAssistant();
// The following causes a design time error.
ta.PrintGrades();
// The following code works.
IStudent student = ta;
student.PrintGrades();

Jeżeli klasa implementuje interfejs niejawnie to program ma dostęp do członków interfejsu z instancji klasy i z instancji interfejsu.

Delegowanie interfejsów

Obie klasy Student i TeachingAssistant implementuja interfejs IStudent, więc obie zawierają kod zapewniający cechy interfejsu. Kod ten jest zduplikowany.
Aby uniknąć duplikowania kodu w klasie TeachingAssistant można użyć delegacji do klasy Student w której ten kod jest już zaimplementowany. Delegowanie odbywa się poprzez umieszczenie obiektu klasy Student w ciele klasy TeachingAssistant.
Ilekroć klasa TeachingAssistant będzie musiała wykonać pewną czynność wyspecyfikowaną w interfejsie IStudent użyje obiektu klasy Student np:

// Delegate IStudent to a Student object.
publicclassTeachingAssistant : Faculty, IStudent
{
// A Student object to handle IStudent.
private Student MyStudent = new Student();
public List<string> Courses
    {
get
        {
return MyStudent.Courses;
        }
set
        {
            MyStudent.Courses = value;
        }
    }
publicvoid PrintGrades()
    {
        MyStudent.PrintGrades();
    }
}

Implementacja popularnych interfejsów

.NET Framework zawiera wiele interfejsów które wspomagają pracę klas. Poniżej opisane zostaną najważniejsze z nich.

IComparable

Interfejs IComparable wprowadza metodę CompareTo która umożliwia programowi porównanie dwóch instancji klas i zdecydowanie który z obiektów jest pierwszy w kolejności sortowania. Przykładowo klasa Car służy do przechowywania modeli samochodów i chcemy aby obiekty tej klasy były sortowane wg nazwy. Możemy stworzyć klasę Car tak aby implementowała interfejs IComparable i użyć metody Array.Sort do sortowania tablicy z obiektami klasy Car.
Interfejs IComparable posiada dwie wersje: zwykłą i generyczną. Wersja zwykła interfejsu istnieje dla zgodności z poprzednimi wersjami .NET rameworka. Zaleca się używanie wersji generycznej.
Jeżeli użyjemy zwykłej wersji to metoda CompareTo pobierze dwa niespecyfikowane obiekty jako parametry po czym w kodzie trzeba je skonwertować na obiekty klasy Car przed porównaniem ich nazw np:

classCar : IComparable
{
publicstring Name { get; set; }
publicint MaxMph { get; set; }
publicint Horsepower { get; set; }
publicdecimal Price { get; set; }
// Compare Cars alphabetically by Name.
publicintCompareTo(object obj)
{
if (!(obj is Car))
thrownew ArgumentException("Object is not a Car");
        Car other = obj as Car;
return Name.CompareTo(other.Name);
    }
}

Wersja generyczna implementacji interfejsu IComparable dla klasy Car:

class Car : IComparable<Car>
{
public string Name { get; set; }
publicint MaxMph { get; set; }
publicint Horsepower { get; set; }
public decimal Price { get; set; }
// Compare Cars alphabetically by Name.
publicint CompareTo(Car other)
    {
returnthis.Name.CompareTo(other.Name);
    }
}

IComparer

Interfejs IComparer pozwala na porównywanie obiektów po wielu różnych właściwościach. Klasa implementująca ten interfejs musi posiadać metodę Compare która porównuje obiekty. Przykładowo można utworzyć klasę CarPriceComparer która implementuje interfejs IComparer i posiada metodę Compare która porównuje obiekty klasy Car po właściwościPrice. Można użyć obiektu klasy CarPriceComparer jako parametru metody Array.Sort aby posortować samochody w tablicy wg ceny.
Interfejs IComparer posiada dwie wersje: zwykłą i generyczną. Wersja zwykła interfejsu istnieje dla zgodności z poprzednimi wersjami .NET rameworka. Zaleca się używanie wersji generycznej.
Klasa CarPriceComparer pozwala na sortowanie wg ceny ale ciągle nie pozwala na sortowanie wg maksymalnej prędkości czy też innych właściwości samochodu. Można utworzyć kilka różnych klas implementujących interfejs IComparer, ale istnieje prostsze rozwiązanie. jest nim utworzenie jednej klasy implementującej interfejs IComparer z polem które mówi po jakim polu ma odbywać się porównywanie. Poniższy kod przedstawia klasę CarComparer demosntrującą to rozwiązanie:

class CarComparer : IComparer<Car>
{
// The field to compare.
public enum CompareField
    {
        Name,
        MaxMph,
        Horsepower,
        Price,
    }
public CompareField SortBy = CompareField.Name;

publicint Compare(Car x, Car y)
    {
switch (SortBy)
        {
case CompareField.Name:
return x.Name.CompareTo(y.Name);
case CompareField.MaxMph:
return x.MaxMph.CompareTo(y.MaxMph);
case CompareField.Horsepower:
return x.Horsepower.CompareTo(y.Horsepower);
case CompareField.Price:
return x.Price.CompareTo(y.Price);
        }
return x.Name.CompareTo(y.Name);
    }
}

IEquatable

Interfejs IEquatable wprowadza metodę Equals która pozwala na sprawdzenie czy obiekty są sobie równe.
Przykład programu wykorzystującego interfejs:

class Person : IEquatable<Person>
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicboolEquals(Person other)
{
return ((FirstName == other.FirstName) &&
            (LastName == other.LastName));
    }
}

Program dodający obiekt klasy Person do listy unikalnych osób:

// The List of Persons.
private List<Person> People = new List<Person>();
// Add a Person to the List.
privatevoidbtnAdd_Click(object sender, EventArgs e)
{
// Make the new Person.
    Person person = new Person()
    {
        FirstName = firstNameTextBox.Text,
        LastName = lastNameTextBox.Text
    };
if (People.Contains(person))
    {
        MessageBox.Show("The list already contains this person.");
    }
else
    {
        People.Add(person);
        firstNameTextBox.Clear();
        lastNameTextBox.Clear();
        firstNameTextBox.Focus();
    }
}

Metoda Contains listy używa faktu, że klasa Person implementuje interfejs IEquatable do zdecydowania czy obiekt istnieje już w liście.
Jeżeli klasa Person nie implementowałaby interfejsu IEquatable to metoda Contains traktowałaby każdy inny obiekt jako nowy bez względu na to czy miały by takie same wartości pól.
Zaleca się aby każda klasa której obiekty mogą być gromadzone w kolekcjach implementowała interfejs IEquatable.

ICloneable

Klasa implementująca interfejs ICloneable musi posiadać metodę Clone która zwraca kopię obiektu dla którego jest wywoływana np:

classPerson : ICloneable
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
public Person Manager { get; set; }
// Return a clone of this person.
publicobjectClone()
{
        Person person = new Person();
        person.FirstName = FirstName;
        person.LastName = LastName;
        person.Manager = Manager;
return person;
    }
}

Metoda Clone zwraca niespecyfikowany obiekt więc kod wywołujący musi rzutować wynik na klasę Person. Przykład użycia:

Person ann = new Person()
{
FirstName ="Ann",
LastName ="Archer",
Manager =null
};
Person bob = new Person()
{
FirstName ="Bob",
LastName ="Baker",
Manager = ann
};
Person bob2 = (Person)bob.Clone();

IEnumerable

Interfejs IEnumerable wprowadza metody pozwalające na wyliczenia elementów które klasa posiada. Metoda GetEnumerator zwraca obiekt implementujący interfejs IEnumerator.
Obiekt IEnumerator wprowadza właściwość Current która zwraca aktualny obiekt w wyliczaniu. Wprowadza także metodę MoveNext która przesuwa wyliczenie do następnego elementu i metodę Reset która resetuje enumerator do stanu sprzed wyliczania. Wprowadza także metodę Dispose która czyści wszystkie użyte zasoby kiedy nie są już potrzebne.
Program poniżej przechowuje informacje o węźle w drzewie:

class TreeNode : IEnumerable<TreeNode>
{
publicint Depth = 0;
publicstring Text = "";
public List<TreeNode> Children = new List<TreeNode>();
publicTreeNode(string text)
{
        Text = text;
    }
// Add and create children.
public TreeNode AddChild(string text)
{
        TreeNode child = new TreeNode(text);
        child.Depth = Depth + 1;
        Children.Add(child);
return child;
    }
// Return the tree's nodes in an preorder traversal.
public List<TreeNode> Preorder()
    {
// Make the result list.
        List<TreeNode> nodes = new List<TreeNode>();
// Traverse this node's subtree.
        TraversePreorder(nodes);
// Return the result.
return nodes;
    }
privatevoidTraversePreorder(List<TreeNode> nodes)
{
// Traverse this node.
        nodes.Add(this);
// Traverse the children.
        foreach (TreeNode child in Children)
        child.TraversePreorder(nodes);
    }
public IEnumerator<TreeNode> GetEnumerator()
    {
returnnew TreeEnumerator(this);
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
returnnew TreeEnumerator(this);
    }
}

Klasa TreeEnumerator definiująca obiekty które potrafią enumerować drzewo stworzone z obiektów klasy TreeNode:

class TreeEnumerator : IEnumerator<TreeNode>
{
// The tree's nodes in their proper order.
private List<TreeNode> Nodes;
// The index of the current node.
privateint CurrentIndex;
// Constructor.
publicTreeEnumerator(TreeNode root)
{
        Nodes = root.Preorder();
        Reset();
    }
public TreeNode Current
    {
        get { return GetCurrent(); }
    }
    object IEnumerator.Current
    {
        get { return GetCurrent(); }
    }
private TreeNode GetCurrent()
{
if (CurrentIndex < 0)
thrownew InvalidOperationException();
if (CurrentIndex >= Nodes.Count)
thrownew InvalidOperationException();
return Nodes[CurrentIndex];
    }
publicboolMoveNext()
{
        CurrentIndex++;
return (CurrentIndex < Nodes.Count);
    }
publicvoidReset()
{
        CurrentIndex = -1;
    }
publicvoidDispose()
{
    }
}

Ponieważ klasa TreeNode implementuje interfejs IEnumerable a klasa TreeEnumerator implementuje interfejs IEnumerator to program ich używający może enumerować po drzewie złożonym z obiektów TreeNode np:

// Build and display a tree.
privatevoid Form1_Load(object sender, EventArgs e)
{
// Build the tree.
    TreeNode president = new TreeNode("President");
    TreeNode sales = president.AddChild("VP Sales");
    sales.AddChild("Domestic Sales");
    sales.AddChild("International Sales");
// Other tree-building code omitted.
    ...
// Display the tree.
    string text = "";
    IEnumerator<TreeNode> enumerator = president.GetEnumerator();
while (enumerator.MoveNext())
text += new string(' ', 4 * enumerator.Current.Depth) +
            enumerator.Current.Text +
            Environment.NewLine;
text = text.Substring(0, text.Length - Environment.NewLine.Length);
    treeTextBox.Text = text;
    treeTextBox.Select(0, 0);
}

Implementacja interfejsu IEnumerable wymaga dużo pracy w tym zaimplementowanie kilku metod oraz dodanie klasy pomocniczej implementującej interfejs IEnumerator. Jeżeli program wymaga tylko wykonywania pętli na zbiorze obiektów to istnieje łatwiejsza metoda.
Należy dodać do klasy metodę zwracającą obiekt typu IEnumerable, gdzie class jest klasą z którą pracujemy. Niech metoda znajdzie wszystkie obiekty które mają być wyliczane i niech wywoła dla każdego z nich yield return. Na koniec wyliczania metoda musi wywołać yield break.
Poniższy kod pokazuje klasę TreeNode:

// Return an enumerator.
public IEnumerable<TreeNode> GetTraversal()
{
// Get the preorder traversal.
    List<TreeNode> traversal = Preorder();
// Yield the nodes in the traversal.
foreach (TreeNode node in traversal) yieldreturn node;
yieldbreak;
}

Kod wywołuje metodę Preorder opisaną wcześniej aby pobrać listę węzłów drzewa.
Przykładowe użycie enumeracji:

string text = "";
foreach (TreeNode node in president.GetTraversal())
{
    text += newstring(' ', 4 * node.Depth) +
        node.Text +
        Environment.NewLine;
}

Użycie słowa kluczowego yield jest dużo łatwiejsze niż implementacja interfejsu IEnumerable a rezultat programu jest taki sam.

Zarządzanie cyklem życia obiektów

Kiedy program w języku C# tworzy instancję klasy to powstaje obiekt. Program używa tego obiektu przez pewien czas, lecz od pewnego momentu obiekt może już nie byc potrzebny. Kiedy program traci ostatnią referencję do obiektu, albo poprzez ustawienie wszystkich referencji na null albo wyszły z zakresu (scope), to obiekt przestaje być dostępny dla programu i staje się kandydatem do usunięcia (garbage collection).
W pewnym momencie garbage collector (GC) może zdecydować, że programowi zaczyna brakować pamięci i czas rozpocząć usuwanie śmieci. GC zaznacza całą pamięć, która była używana przez program, jako obecnie nieosiągalną (unreachable). Następnie przechodzi przez wszystkie referencje dostępne dla programu i oznacza je jako osiągalne (reachable). Jeżeli referencja odwołuje się do obiektu to GC podąża za nią dopóki nie odwiedzi wszystkich obiektów do których program może się dostać.
Kiedy GC sprawdzi referencje to bada wszystkie obiekty oznaczone jako nieosiągalne. Jeżeli obiekt posiada metodę Finalize to GC ją wywołuje w celu wykonania wymaganych porządków. Po wykonaniu metody Finalize, GC czyści pamięć zajętą przez obiekt w celu późniejszego jej użycia.
Proces wywoływania metody Finalize jest nazywany finalizacją. Ponieważ nie można powiedzieć GC aby uruchomił finalizację obiektu to proces ten nazywa się finalizacją niedeterministyczną.
Proces ten jest prosty dla prostych obiektów ale może być bardziej skomplikowany dla obiektów która mają dostęp do zasobów które uszą być w jakiś sposób oczyszczone. Przykładowo program tworzy obiekt który blokuje plik do zapisu, przykładowo do rejestrowania zdarzeń. Kiedy obiekt przestaje być w zakresie to staje się kandydatem do czyszczenia dlaGC, lecz nie można powiedzieć GC kiedy ma sfinalizować ten obiekt a tymczasem plik pozostaje zablokowany pomimo, że nie jest używany przez program.
Można wykonać dwa kroki aby pomóc obiektowi zwolnić jego zasoby: zaimplementować interfejs IDisposable i użyć destruktorów.

Implementacja interfejsu IDisposable

Klasa implementująca interfejs IDisposable musi posiadać metodę Dispose która służy do czyszczenia zasobów używanych przez klasę. Program powinien wywoływać metodę Dispose lub używać deklaracji using kiedy obiekt nie jest już potrzebny i można wykonać czyszczenie jego zasobów.
Głównym zadaniem metody Dispose jest czyszczenie zasobów niezarządzanych (nie kontrolowanych przez CLR np. pliki), ale może również czyścić zasoby zarządzane. jeżeli obiekt używa referencji do innych obiektów implementujących interfejs IDisposable, to może wywołać ich metodę Dispose.
Przykładowo obiekt klasy Shape reprezentuje kształt rysunku i posiada właściwości które są referencjami do obiektów klas Brush i Pen. Klasy Brush i Pen są klasami zarządzanymi implementującymi interfejs IDisposable, więc wywołanie metody Dispose klasy Shape czyści jej zasoby.
Innym przykładem może być klasa ImageTransformer która używa kodu niezarządzanego do manipulacji bitmapami. Używa wywołań API aby otrzymać uchwyt do bitmapy (HBITMAP), innych wywołań API aby otrzymać kontekst urządzenia (DC) i innych do manipulacji bitmapami. Wywołania API są kodem niezarządzanym. Jeżeli obiekt ImageTransformer jest niszczony bez użycia wywołania API do usunięcia jego uchwytów, to zajmowana przez nie pamięć jest stracona. Metoda Dispose klasy ImageTransformer powinna użyć odpowiednich metod API do zwolnienia tych zasobów.
Wg konwencji wywołanie metody Dispose więcej niż jeden raz powinno być bezpieczne dlatego stosuje się zmienną binarną sprawdzającą czy metoda ta była już wywołana na obiekcie, jeżeli tak to metoda nie powinna robić nic więcej.
Microsoft dla obiektów które mogą być używane wielokrotnie zaleca używanie metod Open i Close.

Destruktory

Metoda Dispose zwalnia zasoby jeżeli program ją wywoła, ale jeżeli program jej nie wywoła to zasoby nie zostaną zwolnione. Kiedy GC niszczy niepotrzebne obiekty to oczyszcza zasoby zarządzane ale zasoby niezarządzane nie zostają zwolnione. Aby zapobiec takiej sytuacji można dodać klasie konstruktor który zwalnia zasoby kiedy obiekt jest niszczony.
Destruktor jest metodą która nie ma typu zwracanego a nazwa jest taka sama jak nazwa klasy z prefiksem ~. GC wykonuje konstruktor przed zniszczeniem obiektu.
Destruktory posiadają pewne zasady które nie są stosowane do innych metod:

Destruktory mogą być definiowane tylko w klasach, nie w strukturach.
Klasa może posiadać tylko jeden destruktor.
Destruktor nie może być odziedziczony lub przeciążony.
Destruktor nie może być wywołany bezpośrednio.
Destruktor nie może posiadać modyfikatorów ani parametrów.
GC wywołuje finalizację obiektu a nie destruktor. Destruktor jest konwertowany na nadpisaną metodę Finalize która wykonuje kod destruktora po czym wywołuje metodę Finalize klasy bazowej.
Przykładowo klasa Person posiada taki destruktor:

~Person()
{
    // Free unmanaged resources here.
    //...
}

Destruktor jest konwertowany na metodę Finalize:

protected override void Finalize()
{
try
    {
    // Free unmanaged resources here.
    //...
    }
    finally
    {
        base.Finalize();
    }
}

Nie można bezpośrednio nadpisać metody Finalize w kodzie C# oraz nie można jej bezpośrednio wywołać.
Kiedy wykonywany jest destruktor to GC jest prawdopodobnie w czasie usuwania innych obiektów więc kod destruktora nie może zależeć od istnienia innych obiektów. Przykładowo klasa Person posiada referencję do klasy Company. Destruktor klasy Person nie może zakładać, że obiekt klasy Company nadal istnieje ponieważ mógł być wcześniej zniszczony przez GC. Oznacza to, że destruktor klasy Person nie może wywoływać metody Dispose klasy Company.

Istnieje jeszcze jeden haczyk w zarządzaniu zasobami. jeżeli obiekt posiada destruktor to musi przejść przez kolejkę finalizacji (finalization queue) zanim zostanie zniszczony a to zajmuje dodatkowy czas. Jeżeli metoda Dispose zwolniła zasoby obiektu wcześniej to nie ma potrzeby aby uruchamiać destruktor obiektu. W tym wypadku metoda Dispose może wywołać GC.SuppressFinalize aby GC nie wywoływał finalizacji obiektu i przeskoczył kolejkę finalizacji przy niszczeniu obiektu.
Podsumowanie zasad i konceptów zarządzania zasobami:

Jeżeli klasa nie posiada zasobów zarządzanych i niezarządzanych to nie potrzebuje implementować interfejsu IDisposable ani posiadać destruktora.
Jeżeli klasa posiada tylko zasoby zarządzane to powinna implementować IDisposable ale nie potrzebuje destruktora.
Jeżeli klasa posiada zasoby niezarządzane to powinna implementować IDisposable oraz destruktor w wypadku gdy metoda Dispose nie zostanie wywołana przez program.
Metoda Dispose musi być zabezpieczona przed jej wielokrotnym wywołaniem.
Metoda Dispose powinna zwalniać zasoby zarządzane i niezarządzane.
Destruktor powinien zwalniać tylko zasoby niezarządzane.
Po zwolnieniu zasobów metoda Dispose powinna wywoływać GC.SuppressFinalize aby przeskoczyć kolejkę finalizacji.
Przykład programu z implementacją IDisposable i destruktorem:

classDisposableClass : IDisposable
{
// A name to keep track of the object.
publicstring Name = "";
// Free managed and unmanaged resources.
publicvoidDispose()
{
        FreeResources(true);
    }
// Destructor to clean up unmanaged resources
// but not managed resources.
    ~DisposableClass()
    {
        FreeResources(false);
    }
// Keep track if whether resources are already freed.
privatebool ResourcesAreFreed = false;
// Free resources.
privatevoidFreeResources(bool freeManagedResources)
{
        Console.WriteLine(Name + ": FreeResources");
if (!ResourcesAreFreed)
        {
// Dispose of managed resources if appropriate.
if (freeManagedResources)
            {
// Dispose of managed resources here.
                Console.WriteLine(Name + ": Dispose of managed resources");
            }
// Dispose of unmanaged resources here.
            Console.WriteLine(Name + ": Dispose of unmanaged resources");
// Remember that we have disposed of resources.
            ResourcesAreFreed = true;
// We don't need the destructor because
// our resources are already freed.
            GC.SuppressFinalize(this);
        }
    }
}

GC posiada metodę Collect wymuszająca uruchomienie oczyszczania śmieci przez GC ale używanie jej jest niezalecane ponieważ zaburza normalny cykl algorytmu oczyszczania GC co może mieć wpływ na wydajność programu.

Użycie deklaracji using

Jeżeli obiekt posiada metodę Dispose, to program który go uzywa powinien ją wywołać po wykonaniu przcy obiektu aby zwolnić jego zasoby. Jest to bardzo ważne ale bardzo łatwe do zapomnienia. Aby można było łatwiej to wywoływać w języku C# wprowadzono deklarację using.
Deklaracja using rozpoczyna blok kodu który jest związany z obiektem implementującym interfejs IDisposable. Kiedy blok jest zakończony to program automatycznie wywołuje metodę Dispose.
Przykład użycia:

using (DisposableClass obj = newDisposableClass())
{
    obj.Name = "CreateAndDispose " + ObjectNumber.ToString();
ObjectNumber++;
}

Blok using wywołuje metodę Dispose kiedy jest zakończony, nawet jeżeli kod w środku wyrzuci wyjątek. Poprzedni kod jest ekwiwalentem to poniższego kodu:

{
    DisposableClass obj = new DisposableClass();
    try
{
        obj.Name = "CreateAndDispose " + ObjectNumber.ToString();
        ObjectNumber++;
    }
    finally
{
        if (obj != null) obj.Dispose();
    }
}

Deklaracja using posiada trzy formy:

// Version 1.
using (DisposableClass obj1 = new DisposableClass())
{
}

// Version 2.
DisposableClass obj2 = new DisposableClass();
using (obj2)
{
}

// Version 3.
DisposableClass obj3;
using (obj3 = new DisposableClass())
{
}

Pierwsza z metod jest zalecana ponieważ obiekt jest inicjowany w nawiasie i jego zasięg ogranicza się do bloku using.
W pozostałych metodach pomimo, że obiekt uruchomił już metodę Dispose to jest nadal dostępny w zakresie poza blokiem using.

Podsumowanie

Dziedziczenie

Język C# nie zezwala na wielokotne dziedziczenie.
Słowo kluczowe base pozwala wywołać konstruktor klasy rodzica w następujący sposób:

public class Employee : Person
    {
        public Employee(string firstName, string lastName)
            : base(firstName, lastName)
        {
            //...
        }
    }

Słowo kluczowe this pozwala wywołać inny konstruktor tej samej klasy w następujący sposób:

publicclassPerson
{
publicstring FirstName { get; set; }
publicstring LastName { get; set; }
publicPerson(string firstName)
{
        FirstName = firstName;
    }
publicPerson(string firstName, string lastName)
        : this(firstName)
{
        LastName = lastName;
    }
}

Konstruktor może wywołać tylko jeden konstruktor klasy bazowej lub jeden konstruktor tej samej klasy.
Jeżeli klasa bazowa ma konstruktory to konstruktory klasy potomka muszą wywoływać jeden z nich pośrednio lub bezpośrednio.

Interfejsy

Zgodnie z konwencją nazwy interfejsów rozpoczyna się od dużej litery I np: IComparable.
Klasa może implementować wiele interfejsów jednocześnie.
Jeżeli klasa implementuje interfejs jawnie to kod nie może dostać się do członków interfejsu poprzez instancję obiektu. Zamiast tego musi użyć instancji interfejsu.
jeżeli klasa implementuje interfejs niejawnie to kod może dostać się do członków interfejsu poprzez instancję obiektu jak i interfejsu.
Interfejs IComparable wprowadza metodę CompareTo która określa kolejność obiektów.
Interfejs IComparer wprowadza metodę Compare która porównuje dwa obiekty i określa ich kolejność.
Interfejs IEquatable wprowadza metodę Equals która sprawdza czy obiekty są sobie równe.
Interfejs ICloneable wprowadza metodę Clone która tworzy kopię obiektu.
Interfejs IEnumerable wprowadza metodę GetEnumerator która zwraca obiekt interfejsu IEnumerator który pozwala na użycie metod MoveNext i Reset które umożliwiają przechodzenie przez listę obiektów.
Metoda może użyć deklaracji yield return aby dodac obiekt do wyniku IEnumerator.

Destruktory

Destruktory mogą być definiowane jedynie w klasach.
Klasa może posiadać tylko jeden destruktor.
Destruktor nie może być dziedziczony ani przeciążony.
Destruktor nie może być bezpośrednio wywołany.
Destruktor nie może posiadać modyfikatorów ani parametrów.
Destruktor jest konwertowany na nadpisaną wersję metody Finalize. Metody Finalize nie można nadpisać bezpośrednio ani wywołać.

Zarządzanie zasobami

Jeżeli klasa nie posiada zasobów zarządzanych i niezarządzanych to nie potrzebuje implementować interfejsu IDisposable ani posiadać destruktora.
Jeżeli klasa posiada tylko zasoby zarządzane to powinna implementować IDisposable ale nie potrzebuje destruktora.
Jeżeli klasa posiada zasoby niezarządzane to powinna implementować IDisposable oraz destruktor w wypadku gdy metoda Dispose nie zostanie wywołana przez program.
Metoda Dispose musi być zabezpieczona przed jej wielokrotnym wywołaniem.
Metoda Dispose powinna zwalniać zasoby zarządzane i niezarządzane.
Destruktor powinien zwalniać tylko zasoby niezarządzane.
Po zwolnieniu zasobów metoda Dispose powinna wywoływać GC.SuppressFinalize aby przeskoczyć kolejkę finalizacji.
Deklaracja using pozwala programowi na automatyczne wywoływanie metody Dispose po wykonaniu bloku kodu.