Slajd 1

Język C#

• Najważniejszy język programowania dla platformy .NET

• Obiektowy, prosty, nowoczesny i bezpieczny

• Najbardziej wszechstronny, pozwala korzystać ze wszystkich możliwości
platformy

• Łatwy do nauki – bardzo duże podobieństwo do Javy

• Główny architekt – Anders Hejlsberg

• Obecna wersja 2.0 ukazała się w październiku 2005

• W przygotowaniu wersja 3.0

System operacyjny (Win 32)

Message

Queueing

COM+

IIS

WMI

Common Language Runtime (CLR)

.NET Framework Class Library

ADO.NET i XML

Web Forms

Windows Forms

Web Services

VB.NET

C++

PERL, Python, ...

Co na początek warto wiedzieć o Console

• Podstawowy strumień wejścia-wyjścia w aplikacjach konsolowych

• Obsługuje czytanie i pisane, przemieszczanie kursora po konsoli, zmianę
ustawień klawiatury a nawet ustawienie koloru tła i obsługę głośniczka
systemowego

• Pozwala na formatowanie wyprowadzanego tekstu:

Console.WriteLine(

„

Liczba {0:F2} z dwiema cyframi po

przecinku

”

, 12.34556");

• Formaty:

• C – format walutowy
• D – notacja dziesiętna, pozwala określić liczbę wyświetlanych cyfr
• E – notacja wykładnicza
• F – notacja zmiennoprzecinkowa z ustaloną liczbą miejsc po przecinku
• N – format liczbowy określony w Ustawieniach regionalnych
• X – format szesnastkowy

Program w C#

• Aplikacja w C# to zbiór klas, struktur, interfejsów i wyliczeń

• Podstawowe elementy programu to klasy, zasady ich budowy bardzo
podobne do C++ i Javy

• Punktem startowym aplikacji jest statyczna metoda Main()

• Klasa składa się z pól, metod i właściwości, oznakowanych
modyfikatorami dostępu znanymi z innych języków

• Aplikacja w C# może składać się z wielu plików

• Klasa w C# może być podzielona na wiele plików, jeden plik może
zawierać wiele klas

• Nazwa pliku nie musi być taka sama jak nazwa klasy

Przestrzenie nazw

• Klasy .NET Framework Class Library są pogrupowane w przestrzenie
nazw (namespaces)

• Namespace dla naszej aplikacji tworzymy umieszczając odpowiednie
klasy w blokach namespace Nazwa { … }
• Odwołania do klasy:

• z podaniem pełnej „ścieżki” w przestrzeni nazw:

System.Console.WriteLine();
• użycie using w nagłówku pliku:

using System;

………

Console.WriteLine();

Podział typów danych

Typy bezpośrednie

• Wyliczenia i struktury

• Zmienne danego typu umieszczane na stosie

• Bezpośrednio zawierają swoje dane
• Każda ma własną kopię swoich danych
• Operacje na jednej nie mają wpływu na drugą

Typy referencyjne

• Obiekty umieszczane na stercie

• Zmienne zawierają referencje do swoich danych (do obiektu)
• Dwie zmienne mogą odnosić się do tego samego obiektu
• Operacje na jednej zmiennej mogą mieć wpływ na drugą

Typy C# a typy CLS

Typ C#

Rozmiar

Typ CLS

bool

System.Boolean

byte

System.Byte

sbyte

System.SByte

short

System.Int16

ushort

System.UInt16

char

System.Char

int

System.Int32

uint

System.UInt32

float

System.Single

double

System.Double

long

System.Int64

ulong

System.UInt64

decimal

System.Decimal

object

System.Object

string

System.String

Uwagi na temat typów bezpośrednich

• Zmienne tworzymy w standardowy sposób:

int a = 18;

• Przed pierwszym użyciem zmiennej trzeba jej przypisać wartość (nie
dotyczy to pól klasy, którym są automatycznie inicjowane)

• Deklaracje stałych poprzedzamy słowem kluczowym const,
readonly – zmienna, której tylko raz można przypisać wartość

• Konwersje do liczbowych typów „pojemniejszych” dokonują się
automatycznie, w pozostałych przypadkach należy użyć operatora
rzutowania

int i =10; short s =(int)x;

• Brak niejawnej konwersji do typu logicznego jak w C

int i = 1; if (i) {…} //BŁĄD
if (i = 2) {…}

//BŁĄD

Klasa Object

• W C# wszystko (a nie tylko prawie wszystko) jest obiektem

• Niektóre metody klasy Object:

Equals() GetType() ToString() MemberwiseClone()

• Wszystkie typy (w tym typy bezpośrednie) wywodzą się z Object,
posiadają ponadto wiele własnych metod, poprawne są zatem konstrukcje:

int x = int.ParseInt(”12”);

25.ToString();

• Istnieje mechanizm automatycznego opakowywania wartości skalarnych
do obiektów

int x =14; object o = x;

//OK

Operatory uporządkowane względem priorytetu

( )

grupowanie lub wywołania metody

. ->

operatory dostępu do składowych

[]

operator indeksowania

++ --

operatory inkrementacji i dekrementacji

new

tworzenie nowego obiektu w pamięci

typeof, sizeof

typ obiektu, rozmiar

! ~

negacja logiczna ( ! ) lub bitowa ( ~ )

operator dereferencji

operator pobrania adresu

(typ)

operator rzutowania typu

* / %

operatory mnożenia, dzielenia oraz modulo

+ -

operatory dodawania i odejmowania

>> <<

przesunięcie bitowe w prawo lub w lewo

> < >= <=

operatory relacji

operator zgodności typów

operator rzutowania w dół hierarchii klas

== !=

operatory równości i nierówności

| & ^

operatory logiczne bitowe.

|| &&

operatory logicznej alternatywy oraz koniunkcji

trójargumentowy operator warunku

= *= += -= %= &= ... operatory przypisania

Uwagi do operatorów

• Gdy operatory mają ten sam priorytet o ich kolejności decyduje łączność

• Operatory przypisań oraz jednoargumentowe łączą od prawej strony,
natomiast operatory dwuargumentowe (z wyjątkiem przypisań) od lewej

• Ponadto istnieją operatory checked i unchecked służące do sprawdzania
przepełnienia, np.

int a = checked( b * c ) ;

Instrukcje warunkowe

if ( Boolean-expression )

first-statement

else

second-statement

switch ( expression )
{
case value1:

instr; break;

case value2:

instr; break;

…
default:

instr; break;

}

Pętle

while (Boolean-expression )

{ blok instrukcji }

do
{ blok instrukcji }
while (Boolean-expression )

for (int i=0;i<10;i++)

{ blok instrukcji }

ArrayList<int> numbers = new ArrayList <int>();
foreach (int number in numbers)
Console.WriteLine(number);

Preprocesor

• Dyrektywy w C# podobnie jak w C pozwalają na preprocessing

• W porównaniu do C preprocesor C# ma mniejsze możliwości, nie
obsługuje makr

• Zestaw dyrektyw obejmuje

#define #undef #if #else #elif #endif

#pragma #warning #error #line #region

• Dyrektywa #region pozwala narzędziom takim jak Visual Studio na

ukrywanie kodu w edytorze

Wyliczenia

• Bardzo proste typy definiujące zbiór możliwych wartości

• Wartości są synonimami dla wartości całkowitych

• Definicja:

enum Color { Red, Green, Blue };

• Użycie:

Color myBest = Color.Green;

Tworzenie klasy

class BankAccount
{
private decimal _balance;

//pola klasy

private string _name;

public BankAccount(string name)

//konstruktor

{ _name = name; }

public void Withdraw(decimal amount)

//metody

  { ... }
  public void Deposit(decimal amount)
  { ... }

public string Name {

//właściwości

get { return _name; }
set { _name = value; } }

}

Modyfikatory dostępu

• public : składowa lub typ zadeklarowany jako publiczny są dostępne z
dowolnego miejsca. Ten rodzaj dostępu jest domyślny dla interfejsów

• private : składowa zadeklarowana jako prywatna jest dostępna tylko z
wnętrza typu, w którym została zadeklarowana. Ten rodzaj dostępu jest
domyślny dla składowych klas i struktur

• protected : składowa zadeklarowana jako chroniona jest dostępna z
wnętrza klasy, w której została zadeklarowana lub z wnętrza klasy
pochodnej

• internal : typ lub składowa typu są dostępne tylko z wnętrza pakietu, w
którym nastąpiła ich deklaracja

• protected internal : składowa zadeklarowana z takim rodzajem dostępu
jest widoczna z wnętrza klasy, w której została zadeklarowana (lub klasy
pochodnej od niej) oraz z wnętrza pakietu, w którym się znajduje

Metody

• Metody mogą być statyczne tj. wykonywane na rzecz klasy, w C# w
przeciwieństwie do Javy nie można wywołać statycznej metody na obiekcie

• Klasa może posiadać przeciążone metody – o tej samej nazwie, różniące
się sygnaturą (na sygnaturę nie mają wpływu nazwy parametrów a tylko ich
typy, ani typ zwracany przez procedurę)

• Argumenty procedury mogą być przekazywane przez wartość, przez
referencję lub jako parametry wyjściowe:

public static void DoSomething(string param1,

ref string param2, out string param3);

Właściwości (properties)

• Popularny sposób enkapsulacji w C#, właściwości zapewniają podobny
dostęp jak pola

• get dostęp do odczytu

• set dostęp do zapisu

• Właściwości to „logiczne pola” – wartość zwracana przez accessor get
może być obliczana

• Properties to nie wartości; nie mają adresu

• Properties nie mogą być użyte jako parametry ref lub out metod

• Semantycznie są podobne do metod, mogą być virtual, abstract lub
override, ale nie mogą być typu void ani posiadać parametrów

Tworzenie obiektu

• Każda klasa posiada metodę tworzącą nowy egzemplarz klasy –
konstruktor. Nazwa konstruktora jest taka sama jak nazwa klasy.

• Klasa może posiadać wiele konstruktorów różniących się typem i liczbą
parametrów. Brak konstruktora w definicji klasy powoduje utworzenie przez
kompilator domyślnego bezparametrowego konstruktora

• Jeżeli napiszesz swój własny konstruktor, kompilator nie stworzy
konstruktora domyślnego

• Tworzenie obiektu – operator new zwraca referencję do obiektu

utworzonego przez konstruktor

BankAccount yours = new BankAccount(” Kowalski” );

Zmienne referencyjne

• Do obiektów odwołujemy się zawsze przez referencje

• Wiele referencji może wskazywać na ten sam obiekt, po utracie ostatniej
referencji obiekt zostanie po pewnym czasie skasowany przez GC

• W przypadku zmiennych referencyjnych operatory działają na
referencjach a nie wartościach obiektów

• Aby porównać zawartość obiektów zamiast == należy użyć metody
Equals()

• Tworzenie płytkiej kopii – metoda MemberwiseClone()

• Gdy w skład naszego obiektu wchodzą inne zmienne referencyjne dla
prawidłowego działania tych i innych metod klasy Object, musimy je
najczęściej w naszej klasie przedefiniować

Operator as

• Działa dla typów referencyjnych jak rzutowanie

• W przypadku błędu

• zwraca null

• nie wyrzuca wyjątku

Bird b = a as Bird; // Convert

if (b == null)

Console.WriteLine("Not a bird");

Statyczne klasy i konstruktory

• Oznaczenie klasy jako statyczną zabrania tworzenia obiektów tej klasy

• Klasy statyczne nie mogą zawierać niestatycznych składników ani
konstruktora

• Konstruktor statyczny może zostać umieszczony w dowolnej klasie,
zostanie wywołany przed wywołaniem właściwego konstruktora

• Konstruktor statyczny nie może posiadać modyfikatorów dostępu

Destruktory

• Destruktor to metoda, która zostanie wywołana tuż przed usunięciem
obiektu z pamięci

• Sam destruktor nie zajmuje się zwalnianiem pamięci, ale może np.
zamknąć otwarte pliki

• O momencie wywołania destruktora decyduje Garbage Collector

• Definicja destruktora:

~NazwaKlasy { … }

• Brak modyfikatorów dostępu

Wcześniejsze zwalnianie zasobów

• Możemy zażądać wcześniejszego zwolnienia zasobów implementując
interfejs IDisposable – umieścić w klasie definicję metody Dispose()

• Należy wtedy wyłączyć mechanizm automatycznego odzyskiwania
pamięci metodą GC.SuppressFinalize(this) w ciele metody Dispose()

• Instrukcja using – automatyczne wywołanie Dispose() po bloku instrukcji

using ( Font f = new Font(„Arial”) )
{

…

}

//tu wykona się f.Dispose()

Dziedziczenie w C#

• Składnia:

class KlasaOgolniejsza
{
...
}
class KlasaSzegolowa: KlasaOgolniejsza

{
...
}

• Klasa dziedzicząca nie może być bardziej dostępna niż podstawowa

• Brak wielodziedziczenia, rozwiązanie: interfejsy

Zasady nadpisywania

• Trzeba dopasować metodę nadpisaną do jej metody wirtualnej

• Można nadpisać nadpisaną metodę

• Nie wolno deklarować metody override jako virtual

• Nie wolno deklarować metody override jako static lub private

class Token
{   ...
    public int LineNumber( )  { ... }
    public virtual string Name( ) { ... }
}
class CommentToken: Token
{   ...
    public override int LineNumber( ) { ... }

//BLAD

public override string Name( ) { ... }

//OK

private override string Name( ) { ... }

//BLAD

public override string Name(int k) { ... }

//BLAD

}

Zagadka

• Co wyświetli program?

class A {
   public virtual void M() { Console.Write("A"); }
}
class B: A {
   public override void M() { Console.Write("B"); }
}
class C: B {
   new public virtual void M() { Console.Write("C"); }
}
class D: C {
   public override void M() { Console.Write("D"); }
   static void Main() {
       D d = new D(); C c = d; B b = c; A a = b;
       d.M(); c.M(); b.M(); a.M();
   }
}

Metody abstrakcyjne

• Sygnatura metody poprzedzona słowem abstract
• Metody abstrakcyjne nie posiadają ciała

• Tylko klasy abstrakcyjne mogą deklarować abstrakcyjne metody

• Metody abstrakcyjne są wirtualne

• Metody nadpisane mogą nadpisywać metody abstrakcyjne na kolejnych
poziomach dziedziczenia

Klasy abstrakcyjne i zamknięte

• Jeżeli klasę oznaczymy modyfikatorem abstract nie będzie możliwe

tworzenie obiektów tej klasy

• Klasy abstrakcyjne mogą zawierać metod zwykłe lub abstrakcyjne

• Klasy zamknięte (sealed) uniemożliwiają dziedziczenia
• Wiele klas .NET Framework jest sealed: String, StringBuilder itd.

Interfejsy

• Interfejs to „klasa”, która zawiera tylko deklaracje metod

• Metody nie posiadają modyfikatorów dostępu, nie mają ciała

• Klasa może implementować wiele interfejsów

• Konwencja: nazwa rozpoczyna się od ‘I’

• Przykład:

interface IToken
{
int LineNumber( );
string Name( );
}
class Token: IToken
{
int LineNumber( ) { cialo_metody }
... }

Klasy abstrakcyjne a interfejsy

Podobieństwa

• Nie mogą mieć instancji

• Nie mogą być sealed

Różnice

• Interfejsy nie mogą zawierać implementacji

• Interfejsy nie mogą mieć składowych niepublicznych

• Interfejsy nie mogą rozszerzać nie-interfejsów

Struktury

• Typy bardzo podobne do klas, mogą zawierać pola, metody, właściwości,
konstruktory, tworzone za pomocą new

• Zmienne tych typów są bezpośrednie a nie referencyjne, zalecany w
przypadku małych typów

• Nie umożliwiają dziedziczenia, nie mogą zawierać bezparametrowych
konstruktorów (jeśli konstruktora brak nastąpi inicjalizacja wszystkich pól
wartościami domyślnymi)

struct Point {
int x, y;
public Point(x, y) {

this.x=x;
this.y=y;
}

}

Obsługa wyjątków

• Znana konstrukcja „try … catch … finally”

try

{

Console.WriteLine(„Podaj pierwszą liczbę");
int i = int.Parse(Console.ReadLine());
Console.WriteLine(„Podaj drugą liczbę");
int j = int.Parse(Console.ReadLine());
int k = i / j;

}

catch (OverflowException caught)

{Console.WriteLine(caught.Message);}

catch (DivideByZeroException caught.Message)

{Console.WriteLine(caught.Message);}

catch (Exception caught.Message)

{Console.WriteLine(caught.Message);}

finally
{

Console.WriteLine(„Ten kod wykona się zawsze”);
Console.ReadLine();

}

Wyrzucanie wyjątków

• Użytkownik może wyrzucić wyjątek za pomocą instrukcji:

• throw new <klasa wyjątku>
•throw new OutOfMemoryException();

• Użytkownik może zdefiniować swój własny wyjątek. Klasa wyjątku musi
dziedziczyć w sposób bezpośredni lub pośredni z klasy System.Exception

• Brak słowa kluczowego throws do umieszczenia w sygnaturze metody

Tablice

• Każdy typ tablicowy jest typem referencyjnym wywodzącym się z
System.Array

• Tworzenie prostych tablic

int[] tablInt = new int[ 100 ] ;
int[ ] tabl = { 1, 2 , 3 } ;

• Tworzenie tablic typów referencyjnych wymaga inicjalizacji wartości tablicy

• Możliwe jest tworzenie tablic wielowymiarowych oraz nieregularnych

int [,] tabl3D = new int[5,10]; //Regularna tablica
int [][] tabl2D = new int[10][] ; //Tablica nieregularna

Metody dostępne dla tablic

• Rank – zwraca ilość wymiarów tablicy

• Length – zwraca ilość pól tablicy

• GetLenght() – zwraca liczbę pól danego wymiaru

• Sort() – sortuje tablice

• BinarySearch() – szybkie wyszukiwanie w posortowanych tablicach

• Clear() – ustawia wartości elementów tablicy na zero lub null

• Clone() – klonuje daną tablice

• IndexOf() – zwraca indeks pierwszego wystąpienia danej wartości w
tablicy

Tablice argumentów

• Słowo kluczowe params pozwala przekazać do metody dowolną liczbę
argumentów bez konieczności jawnego tworzenia tablicy

public void DisplayParams(params int[] vals)
{

foreach (int i in vals)

Console.WriteLine(i);

}
...

DisplayParams(1,2,3,4,5);

Mechanizm indeksowania

• Pozwala na dostęp do obiektu tak, jakby był on tablicą

• Przypuśćmy, że stworzyliśmy graficzną kontrolkę MyComboBox,
przechowującą tablice stringów:

class MyComboBox
{

private string[] strings;
...
public string this[int index]
{
get { return strings[index]; }

// OBSLUZYC

set { strings[index] = value; } }

// WYJATKI!

}
...
MyComboBox box = new MyComboBox();
...
string s = box[2];

Kolekcje

• C# i .NET Framework dostarczają wielu standardowych kolekcji:

• List<T>

• Queue<T>

• Stack<T>

• Dictonary<T,K>

• typ T kolekcji może być dowolnym typem referencyjnym lub bezpośrednim

• po kolekcjach możemy w wygodny sposób iterować instrukcją foreach

lub skorzystać z enumeratorów

Interfejsy kolekcji

• Możemy tworzyć własne typy kolekcji implementując w naszej klasie
interfejsy kolekcji:

ICollection<T> IEnumerable<T> IComparable<T>

IList<T> IDictonary<T>

class IterowanaKlasa :IEnumerable<int>
{

private int[] tab = new int[10];
public IEnumerator<int> GetEnumerator()
{

foreach (int i in tab)

yield return i;

}

}
...
IterowanaKlasa klasa = new IterowanaKlasa();
foreach (int i in klasa)

Console.WriteLine(i);

Łańcuchy znaków

• Łańcuchami nazywamy literały znakowe umieszczone w cudzysłowach
oraz obiekty klasy string

• W zapisie literałów możemy używać znanych z C sekwencji sterujących

• Znak ‘@’ przed łańcuchem powoduje traktowanie dosłowne wszystkich
znaków

• Obiekty klasy string są niezmienne

• Klasa string oferuje wiele użytecznych metod narzędziowych:

Compare() Concat() Join() CompareTo() Insert()

LastIndexOf() Remove() Split() Substring()

ToCharArray() ToLower() ToUpper() Trim()

Manipulowanie łańcuchami

• Operatory (np. +=) i metody manipulujące łańcuchami zwracają zawsze

nowy łańcuch, gdyż obiekty string są niezmienne

• Tworzenie obiektów jest czasochłonne, więc jeśli chcemy często
manipulować łańcuchem dobrze jest użyć klasy StringBuilder, oferującej
metody: Append(), AppendFormat(), Insert(), Remove(), Replace()

String ala = „Ala ma kota”;
StringBuilder builder = new StringBuilder();
foreach (string s in ala.Split(‘ ‘))

builder.AppendFormat(

”

Wyraz: {0}\n”, s);

Console.WriteLine(builder.ToString());

Wyrażenia regularne

• C# obsługuje wyrażenia regularne o składni regexp z Perla 5

• Podstawową klasą do obsługi wyrażeń regularnych jest Regex

• Prosty przykład:

String ciag = "gk4435g52hjvj4hv";
Regex reg = new Regex("[0-9]+");
MatchCollection maches = reg.Matches(ciag);
foreach (Match mach in maches)
Console.WriteLine(mach.ToString());
if (reg.IsMatch("15454621"))
Console.WriteLine("Goal");

A to jeszcze nie koniec

• Atrybuty

• Przeciążanie operatorów

• Nullable types

• Wątki i mechanizmy synchronizacji

• Domeny aplikacji

• Refleksja typów

• Delegaty i zdarzenia

• Wskaźniki i praca z kodem niezarządzanym