C Sharp/Wersja do druku

Programowanie w C

Aktualna, edytowalna wersja tego podręcznika jest dostępna w Wikibooks, bibliotece wolnych podręczników pod adresem
https://pl.wikibooks.org/wiki/Programowanie_w_C

Całość tekstu jest objęta licencją CC-BY-SA 3.0 i jednocześnie GNU FDL.

Udziela się zezwolenia na kopiowanie, rozpowszechnianie lub modyfikację tego dokumentu zgodnie z zasadami Licencji Creative Commons Uznanie autorstwa-Na tych samych warunkach 3.0 Unported lub dowolnej późniejszej wersji licencji opublikowanej przez Creative Commons, która zawiera te same elementy co niniejsza licencja. Treść licencji dostępna jest pod adresem http://creativecommons.org/licenses/by-sa/3.0/legalcode.

Udziela się zezwolenia na kopiowanie, rozpowszechnianie lub modyfikację tego dokumentu zgodnie z zasadami Licencji wolnej dokumentacji GNU (niewersjonowanej, bez części nienaruszalnych oraz tekstów przedniej i tylnej okładki)

C Sharp/Spis treści

Wstęp

O podręczniku

O czym mówi ten podręcznik?

W tym podręczniku mam zamiar poruszyć podstawy języka C#. Jest to język obiektowy, wysokiej kultury kodu. Jest to język niezwykle prosty, warto zaczynać się uczyć programowania właśnie od tego języka, gdyż składnia i bugogenność C++ jest wręcz olbrzymia. Innym wyborem jest Java.

Co trzeba wiedzieć, żeby skorzystać z niniejszego podręcznika?

Ten podręcznik jest przeznaczony dla początkujących programistów. Nie znajdą tutaj za wiele ludzie, którzy kochają C++'owe wskaźniki i tym podobne. Aby zrozumieć główną ideę języka warto przeczytać artykuł na Wiki: programowanie obiektowe

Czy mogę pomóc?

Oczywiście że możesz. Mało tego, będziemy zadowoleni z każdej pomocy - możesz pisać rozdziały lub tłumaczyć je na inny język. Nie musisz pytać się nikogo o zgodę - jeśli chcesz, możesz zacząć już teraz. Prosimy jedynie o zapoznanie się ze stylem podręcznika, użytymi w nim szablonami i zachowanie układu rozdziałów. Propozycje zmiany spisu treści należy zgłaszać na stronie dyskusji.

Jeśli znalazłeś jakiś błąd a nie umiesz go poprawić koniecznie powiadom o tym fakcie autorów tego podręcznika za pomocą strony dyskusji danego modułu książki. Dzięki temu przyczyniasz się do rozwoju tego podręcznika.

Autorzy

• Codern
• jarek
• SwordPL

Potrzebne narzędzia

Potrzebne narzędzia

Potrzebne narzędzia

Do programowania w języku C# wymagane są biblioteki. Są one dostępne w paczkach, które nazywa sie frameworkami. Są trzy najpopularniejsze frameworki:

• .NET Framework - stworzone przez Microsoft, najszybciej aktualizowane. Aktualna wersja: 4.5.2
• Mono - open-sourcowy framework wspomagany przez koncern Novell, który pozwala odpalić nasze aplikacje w Linuxie bądź MacOSie. Niestety rozwój tego frameworka jest znacznie wolniejszy, niż rozwój oryginalnego rozwiązania MS.
• DotGNU - projekt, który ma na celu uruchomienie programu na niemal każdej platformie, chociażby na Xboksie 360 bądź PlayStation 3.

Po ściągnięciu pakietu framework potrzebujemy albo edytora tekstu i dodatkowego kompilatora, albo IDE - zintegrowanego środowiska programistycznego. Ściągając IDE automatycznie ściągamy także kompilator, nie musimy martwić się o dodatkowe szukanie. Każdy z tych frameworków posiada własne profilowane środowisko. Dla MS .NET Framework

• Visual Studio ostatnia wersja 2019 (16)
• Visual Studio Community
• Visual Studio Code
• SharpDevelop
• MonoDevelop ostatnia wersja 2018
• Xamarin Studio - platforma wielosystemowa ( obecnie jako Xamarin for VisualStudio i VisualStudio for OS X )

Dla Mono

• MonoDevelop (działa również na .NET Framework 3.5, jednak trzeba doinstalować bibliotekę Gtk#)

Dla DotGNU takowe środowisko nie istnieje, lecz jest udostępniony kompilator na oficjalnej stronie tego projektu.

Edytory i kompilatory online

• https://dotnetfiddle.net/
• https://repl.it/

Używanie kompilatora

Używanie kompilatora

Jak skompilować kod?

Opiszę tu użycie kompilatora csc.exe z .NET Framework.

Aby skompilować kod¹ należy wpisać w linię poleceń:

csc.exe program.cs

W Linuksie konieczna jest z kolei komenda:

mcs program.cs

Oczywiście niezbędne jest uprzednie zainstalowanie pakietu mono i mono-mcs z repozytoriów (Ubuntu i Debian). Kompilatory C Sharp'a jest zależne od wersji. Dla wersji starszych używa się np. kompilatora dmcs. Wszystkie starsze kompilatory C Sharp'a zostały połączone w jeden o nazwie mcs. Program uruchamiamy jak zwykle poprzez:

./a.out

Parametry kompilatora

Wybrane opcje kompilatora

Nazwa opcji	Skrócona forma	Parametry	Znaczenie
/out:	-	nazwa pliku	Określa jaką ma mieć nazwę plik wynikowy
/target	/t	Do wyboru: exe winexe library	Określa co kompilator ma stworzyć: exe - aplikacja konsolowa, winexe - aplikacja okienkowa, library - biblioteka

Przypisy

1 - Zakładam, że albo jesteśmy już w folderze z kompilatorem i kodem albo ścieżka ta znajduje się w zmiennej systemowej PATH

Część 1
Podstawy języka

Pierwszy program

Tworzymy pierwszy program

Zaczniemy od czegoś zupełnie prostego i poniekąd znanego. Prawie każdy kurs programowania zaczyna się od tego programu. Kochany program Hello World!

using System;

public class Klasa {
  public static void Main (string[] args)
  {
   Console.WriteLine("Witaj świecie!");
  }
}

Zapisujemy to wszystko jako np. program.cs i kompilujemy. Uruchamiamy program poleceniem:

program.exe

Co to znaczy?

Teraz zajmę się tłumaczeniem wcześniej napisanego kodu.

 using System  
/*W tej linijce każemy kompilatorowi używać przestrzeni nazw System. 
Czym jest przestrzeń nazw? Jest to zbiór nazw, których używamy do programowania. 
W jednej przestrzeni nazw nie moga pojawić się dwie identyczne nazwy. Można implementować wiele przestrzeni nazw, ale o tym później.*/

public 
//jest to modyfikator dostepu. Zgodnie z nazwą jest ona publiczna - z każdego miejsca programu możemy do niej się dostać

class Klasa
//jest to klasyczna definicja Klasy. Czym są klasy dowiecie się w następnym rozdziale.

public static void Main(string[] args)
//jest to deklaracja metody. Metoda pozwala klasie działać.
//Metoda public static void Main() musi znaleźć się w każdym programie.
//To jest punkt w którym program zaczyna się wykonywać.

Console.WriteLine("Witaj świecie!");
//Nakazuje Console ( Konsoli ) Write ( napisać ) w nowej Line ( linijce ) ciąg znaków "Witaj świecie."

Czym jest tekst zamieszczony między /*, a */ lub po // ? Jest to komentarz. Warto go używać w większych programach, aby się nie pogubić. Jest całkowicie ignorowany przez kompilator.

Typy danych

Podział typów danych

Typy danych dzielimy na dwie podstawowe grupy:

• Typy Wartościowe
  • proste (eng. primityve types , simple types)
  • wyliczeniowe (eng. enum types)
  • strukturalne (eng. struct types)

• Typy Referencyjne
  • klasowe
  • interfejsowe
  • delegacyjne
  • tablicowe

89.65.85.38 (dyskusja)a gdzie decimal?

Typy proste

Nazwa	Rodzaj	Zakres Wartości
bool	wartość logiczna prawda/fałsz	true lub false
byte	liczba całkowita	0 do 255
sbyte		-128 do 127
ushort		0 do 216-1
short		-215 do 215-1
uint		0 do 232-1
int		-231 do 231-1
ulong		0 do 264-1
long		-263 do 263-1
float	liczba zmiennoprzecinkowa	około -1,5*10-45 do 3,4*1038
double		około -5,0*10-324 do 1,7*10308
char	Pojedynczy znak Unicode
string	Ciąg znaków Unicode

Zmienne

Typy proste stosujemy bardzo często. Są one zwane zmiennymi. Zmienne deklarujemy oraz inicjalizujemy. Istnieją dwie metody, którymi możemy się posłużyć do tworzenia zmiennych.

• Inicjalizacja oraz przypisanie wartości później, np.

//... bardzo przydatny kod...
int zmienna; //zmienną deklarujemy wpisując jej typ oraz nazwę. Nazwa jest niemal dowolna. Nie może ona być słowem kluczowym języka C#.
//... więcej przydatnego kodu...
zmienna = 10; //inicjalizujemy, czyli przypisujemy zmiennej wartość.

• Inicjalizacja oraz przypisanie w jednej linijce

//ponownie przydatny kod...
int zmienna = 10; //tutaj łączymy obie konstrukcje. Tworzymy zmienną typu int i przypisujemy jej wartość 10.
//więcej kodu.

Jak posługiwać się zmiennymi? Jest to niezwykle proste. Aby użyć zmiennej musimy użyć jej nazwy - już nie wpisujemy typu przed zmienną! Ponownie istnieją dwie metody użycia zmiennej.

string zmienna = "Lalala";
Console.Writeline("Moja zmienna to:"+zmienna);

lub

string zmienna = "Lalala";
Console.Writeline("Moja zmienna to:{0}", zmienna);

Wyliczenia

Konstrukcja programistyczna zwana wyliczeniem jest przydatna. Nie stosuje jej się co chwilę, lecz świadomość, że coś takiego istnieje jest niezwykle ważna. Wyliczenie tworzymy tak:

enum PoryRoku
{
Wiosna,
Lato,
Jesien,
Zima
}

Co tutaj się dzieje? Tworzymy wyliczenie o nazwie PoryRoku. W środku tego wyliczenia są 4 elementy: Wiosna, Lato, Jesien i Zima. Każdemu z tych elementów jest przypisywana kolejna wartość liczbowa typu int. Czyli ten zapis jest równoważny zapisowi:

enum PoryRoku
{
Wiosna = 0;
Lato = 1;
Jesien = 2;
Zima = 3;
}

Możemy oczywiście takową kolejność zmienić:

enum PoryRoku
{
Wiosna = 3;
Lato =2;
Jesien =4;
Zima =1;
}
</syntaxhighlighte>
Albo rozpocząć od innej liczby, niż zero:
<syntaxhighlight lang=csharp>
enum PoryRoku
{
Wiosna = 1; //nowa wartość dla wiosny, oznacza nowe wartości dla reszty pór roku.
Lato, //Lato = 2
Jesien, //Jesien = 3
Zima, //Zima = 4
}

O strukturach będzie traktował jeden z kolejnych rozdziałów.

Klasa

Klasa

Klasa to podstawowa konstrukcja logiczna, na której bazuje cały język C#, ponieważ to ona definiuje każdy obiekt i określa jego możliwości. Jedną z najważniejszych cech klasy jest to, że definiuje nowy typ danych. Jest to swoisty szablon pewnego obiektu, natomiast obiekt jest egzemplarzem klasy. Można powiedzieć że klasa opisuje w sposób abstrakcyjny parametry i funkcje konkretnych bytów.

Przykładowo gdyby tworzyć obiektową grę wyścigi, takimi bytami nazwiemy obiekty w grze, czyli Samochody i Tor wyścigowy. Jak z definicji wynika, obiekty te mogą posiadać różne parametry oraz funkcje, które są zdefiniowane w szablonie czyli klasie. W dalszej części rozdziału będziemy rozbudowywać nasze byty o nowe funkcje i parametry.

Deklaracja klasy i parametrów

Zacznijmy od podstaw, czyli od deklaracji klasy oraz podstawowych parametrów. W naszym przykładzie będą dwie klasy Samochod oraz TorWyscigowy. Dla samochodu stworzymy 3 podstawowe parametry, czyli pojemność baku, prędkość maksymalna oraz prędkość aktualna. Natomiast tor będzie posiadał parametry tj. liczba aut na torze oraz samochód prowadzący. Oczywiście parametrów, można stworzyć nieskończenie wiele, natomiast dla przykładu taka liczba jest w zupełności wystarczająca.

class Pojazd
{
	double pojemnoscBaku;
	int predkoscMaksymalna;
	int predkoscAktualna;
}

class TorWyscigowy
{
        int liczbaAutNaTorze;
        Pojazd prowadzacy;
}

Nowo utworzone klasy definiują nam nowe typy danych. Są one takie same jak nazwa klasy, czyli Pojazd oraz TorWyscigowy. Istotną sprawą jest to, że sama definicja class nie tworzy jeszcze obiektu, jest to jedynie szablon.

Tworzenie obiektu

Aby utworzyć egzemplarz klasy, czyli obiekt, należy wykonać poniższą instrukcję:

Pojazd auto1 = new Pojazd(); //Tworzy obiekt klasy Pojazd o nazwie auto1
Pojazd auto2 = new Pojazd(); //Tworzy inny obiekt klasy Pojazd o nazwie auto2

Dostęp do obiektu

Na początku definiując klasę, zdefiniowaliśmy kilka parametrów początkowych. Aby dostać się do parametrów (również do metod) wykorzystuje się operator kropki [.], operator ten łączy nazwę obiektu z nazwą składowej.

auto1.predkoscMaksymalna = 180;
auto2.predkoscMaksymalna = 210;

Metody klasy

Oprócz parametrów klasy, można tworzyć również metody. Określają one w pewnym sensie funkcje danego obiektu. Tak również jest w świecie rzeczywistym, auto oprócz parametrów tj. prędkość maksymalna czy pojemność baku, posiada funkcje przyśpieszania, zwalniania itd. W podobny sposób można opisać tor wyścigowy.

class Pojazd
{
    public double pojemnoscBaku;
    public int predkoscMaksymalna;
    public int predkoscAktualna;

    public void przyspiesz(int predkosc)
    {
        this.predkoscAktualna += predkosc;
    }

    public void zwolnij(int predkosc)
    {
        this.predkoscAktualna -= predkosc;
    }
}

class TorWyscigowy
{
    public int liczbaAutNaTorze;
    public Pojazd prowadzacy;

    public void dodajSamochodDoWyscigu()
    {
        liczbaAutNaTorze++;
    }

    public void zmienProwadzacego(Pojazd prowadzacy)
    {
        this.prowadzacy = prowadzacy;
    }
}

Poniżej przykład wykorzystania utworzonych klas, czyli symulacja wyścigu

//Zadeklarowanie nowych obiektów w grze
Pojazd auto1 = new Pojazd();
Pojazd auto2 = new Pojazd();
TorWyscigowy tor = new TorWyscigowy();

//Dodadnie dwóch samochodów do wyścigu
tor.dodajSamochodDoWyscigu();
tor.dodajSamochodDoWyscigu();

//Zmiana prędkości samochodów
auto1.przyspiesz(100);
auto2.przyspiesz(120);

//auto2 jedzie szybciej od auto1 wiec to ono obejmuje prowadzenie
tor.zmienProwadzacego(auto2);

//Statystyki wyścigu
Console.WriteLine("Na torze jest: " + tor.liczbaAutNaTorze + " samochodów.");
Console.WriteLine("Aktualna prędkość auta prowadzącego w wyścigu wynosi: " + tor.prowadzacy.predkoscAktualna);

Konstruktor

Inicjalizacja wszystkich zmiennych po kolei, podczas tworzenia nowego obiektu, jest zajęciem uciążliwym. Już nie wspominając o inicjalizacji kilkunastu obiektów z kilkoma parametrami. Aby ułatwić te zadania, stworzono narzędzie jakimi są konstruktory. Jak z samej nazwy można wywnioskować, konstruktor, to narzędzie do konstruowania obiektu. Co za tym idzie jest wywoływany podczas inicjalizacji. Tak więc każda klasa musi zawierać konstruktor. No dobrze, ktoś by zapytał dlaczego w powyższych przykładach brakuje konstruktora? Odpowiedź jest prosta, jeśli nie napiszemy żadnego konstruktora, to C# sam sobie stworzy, w domyśle, pusty konstruktor. Możemy się o tym przekonać podczas inicjalizacji obiektu, ponieważ po słowie kluczowym new wywołujemy konstruktor domyślny:

Pojazd auto1 = new Pojazd();

Analizując powyższy fragment kodu, można zauważyć że konstruktor jest podobny do metody, o takiej samej nazwie co klasa. Od metody różni się tym, że nie może zwracać żadnych wartości. Poniższy przykład pokazuje jak należy definiować konstruktor podstawowy inicjalizujący wybrane parametry.

class Pojazd
{
    public double pojemnoscBaku;
    public int predkoscMaksymalna;
    public int predkoscAktualna;

    public Pojazd()
    {
        this.predkoscMaksymalna = 200;
        this.pojemnoscBaku = 50.0;
    }
}

Konstruktor sparametryzowany

Wcześniej omawialiśmy konstruktor prosty, który umożliwia nam inicjalizacje parametrów; jednak takie przypisywanie wartości nie jest zbyt uniwersalnym rozwiązaniem, ponieważ każdorazowe utworzenie obiektu nadaje takie same parametry. W celu lepszej kontroli nad inicjalizacją utworzymy konstruktor sparametryzowany. Podczas tworzenia nowego konstruktora, skorzystamy z możliwości przeciążania metod.

class Pojazd
{
    public double pojemnoscBaku;
    public int predkoscMaksymalna;
    public int predkoscAktualna;

    public Pojazd()
    {
        this.predkoscMaksymalna = 200;
        this.pojemnoscBaku = 50.0;
    }

    public Pojazd(int predkoscMaksymalna, double pojemnoscBaku)
    {
        this.predkoscMaksymalna = predkoscMaksymalna;
        this.pojemnoscBaku = pojemnoscBaku;
    }
}

Nowy konstruktor przyjmuje dwa parametry, a następnie przekazuje je do parametrów globalnych, oznaczonych słówkiem kluczowym this. Poniżej przykład zastosowania obu konstruktorów. Na koniec jeszcze dodam wzmiankę, że konstruktorów możemy tworzyć nieskończenie wiele. Jest tylko jedno ograniczenie, każdy nowy konstruktor musi przyjmować inne parametry, od istniejących konstruktorów. Podczas inicjalizacji odpowiedni konstruktor jest wybierany automatycznie, poprzez dopasowanie typów i ilości przekazywanych parametrów.

//Wykorzystujemy konstruktor domyślny
Pojazd auto1 = new Pojazd();

//Wykorzystujemy konstruktor sparametryzowany
Pojazd auto2 = new Pojazd(150, 45.0);

Słowo kluczowe this

Słowo kluczowe this umożliwia metodzie odwołanie się do obiektu który ją wywołał. W powyższych przykładach wykorzystywaliśmy słowo kluczowe this przed nazwą parametru, aby zaznaczyć, że odwołujemy się do parametrów globalnych aktualnego obiektu. Tak na prawdę użycie słówka kluczowego this nie jest wymagane - poza jedną sytuacją. Chodzi o ukrywanie zmiennych składowych. W przykładzie z konstruktorem sparametryzowanym dla zachowania spójności nazw zastosowaliśmy takie same nazwy parametrów konstruktora, jak parametry globalne. W tym przykładzie słowem kluczowym this oznaczamy parametry globalne, natomiast parametry bez słowa kluczowego this odwołują się do parametrów konstruktora.

Operatory

Operatory pozwalają wykonywać rózne operacje takie jak dodawanie i wiele innych. Dzielimy je na:

• arytmetyczne
• bitowe
• logiczne
• przypisania
• porównania
• pozostałe

Operatory arytmetyczne

Operatorami arytmetycznymi są:

+ dodawanie

- odejmowanie

* mnożenie

/ dzielenie

% dzielenie modulo (reszta z dzielenia)

? operator trójargumentowy (przykład: A < B ? A : B - jeżeli A jest mniejsze od B to A, w przeciwnym razie B)

++ inkrementacja

-- dekrementacja

W tych dwóch ostatnich występuje podział na post- i pre-. Pre- ink/dekrementuje przed użyciem a post- po użyciu zmiennej.

Operatory bitowe

Służą do operowania na pojedynczych bitach naszych zmienych. Wyróżniamy tu:

bitowe AND &

bitowe OR |

XOR ^

przesunięcia bitowe lewe i prawe << >>

Operatory logiczne

Są z pewnością znane każdemu kto uczył się jednego z działów matematyki - logiki. Mamy tu:

logiczne AND (i) &&

logiczne OR (lub) ||

negację logiczną NOT (nie) !

Operatory przypisania

Służą do przypisywania wartości zmiennej. Oprócz prostego = mamy także jego połączenia z innymi operatorami np. +=, <<= czy &=

Operatory porównania

Służą do porównywania wartości po obu swoich stronach. Mamy ==,!=,<,>,<=,>=

Instrukcje sterujące

Instrukcja if

Najprostsza postać ogólna:

if(warunek) //instrukcja do wykonania, jeśli więcej to w klamerce

Instrukcje zostaną wykonane jeśli warunek spełniony

Inna konstrukcja uwzględnia sytuację, w której warunek nie został spełniony

if(warunek){
 //instrukcje
}
else{
 //instrukcje jeśli niespełniony warunek
}

Można także wielokrotnie sprawdzić warunek:

if(warunek1){
 //instrukcje
}
else if(warunek2){
 //instrukcje jeśli niespełniony warunek1, ale spełniony warunek2
}
else{
 //instrukcje jeśli niespełniony warunek1 ani warunek2 
}

Instrukcja switch

Jest stosowana zamiast if jeśli potrzebujesz sprawdzić wiele wariantów jednej zmiennej (może działać tylko dla wartości liczbowych, nie dla typu char itp!):

switch(a){
case 1:
//instrukcje1;
break; //konieczne
case 2:
//instrukcje2;
break;
default: //jeśli żaden niespełniony
//instrukcje;
}

Instrukcja for

Ta instrukcja i dwie następne to pętle. Służą do wielokrotnego wykonywania kodu.

for (int i=1;i<=100;i++){
Console.WriteLine(i.ToString());
}

Pętla będzie wykonywana na zmiennej i od wartości 1 tak długo aż i osiągnie wartość 100. Z każdym kolejnym przejściem pętli zmienna i jest postinkremetowana.

Instrukcja foreach

Pętla ta rożni się nieco od for. Przechodzi kolejno przez wszystkie elementy tablicy lub innej kolekcji. Przechodząc przez dany element zapisuje go do zmiennej tymczasowej zdefiniowanej w nagłówku pętli. Taka zmienna tworzona jest dokładnie raz dla każdego elementu. Zmienna ta jest dostępna tylko do odczytu a każda próba ustawienia jej wartości wywoła błąd podczas kompilacji. Dla tablic jednowymiarowych przejście następuje od indeksu 0 i postępuje w porządku rosnącym. W przypadku tablic wielowymiarowych przeszukanie następuje dla skrajnie prawego indeksu.

int[] tab = {1, 2, 3, 4, 5};
foreach(int val in tab)
{
 Console.WriteLine(val.ToString());
}

Instrukcja while

Składnia:

while (wyrażenie logiczne) { ciało pętli }

Instrukcje zawarte w ciele pętli wykonywane są dopóki wyrażenie logiczne jest prawdziwe. Jeżeli wyrażenie od początku będzie miało wartość false ciało nie wykona się ani raz.

Przykład:

int a=1;
while (a<=100){
Console.WriteLine(a.ToString());
a++;
}

Instrukcja do while

Składnia:

do {ciało pętli} while (wyrażenie logiczne)

Instrukcje zawarte w ciele pętli wykonywane są dopóki wyrażenie logiczne jest prawdziwe, jak w przypadku pętli while. Tym razem jednak najpierw następuje wykonanie instrukcji, a dopiero później sprawdzany jest warunek (i - jeśli jest spełniony - ponowne przejście pętli). W związku z tym pętla zawsze wykona się przynajmniej raz, niezależnie od warunku.

Przykład:

int a=1;
do 
{
Console.WriteLine(a.ToString());
a++;
} while (a<=100)

Część 2
Programowanie obiektowe

Programowanie obiektowe

Wstęp

Podstawą języka C# jest możliwość tworzenia nowych złożonych typów przez programistę. Jest to podstawowa cecha języków obiektowych. Programista ma możliwość zdefiniowania nowych typów reprezentujących rzeczywisty problem. Typ taki posiada zdefiniowane właściwości i metody, które odzwierciedlają rzeczywiste cechy obiektu/problemu. Na przykład dla obiektu samochód właściwością może być kolor, natomiast metodą uruchomSilnik(). W języku C# nowe typy tworzy się przez deklaracje i definicje klasy.

Klasa

Tworząc nową klasę należy ją wpierw zadeklarować używając słowa kluczowego class. Pełna składnia deklaracji wygląda następująco:

[atrybuty] [modyfikatory dostępu] class nazwaNowejKlasy [klasa bazowa] [, interfejsy]]

W platformie .NET każda klasa dziedziczy po wspólnej klasie bazowej System.Object. Dziedziczenie to jest domyślne i ma charakter niejawny, zatem nie wymaga żadnych dodatkowych zapisów.

Następnie należy zdefiniować jej metody i pola.

Stałe : Stałe służą do przechowywania zmiennych reprezentujących stałą wartość. Do ich deklaracji wykorzystujemy słowo kluczowe const.

using System;
class Klasa
{
	public const int x = 5;
	public const string y = "string";
}
class Program
{
	static void Main()
	{
		//Prawidłowe odwołanie się do stałej
		Console.WriteLine(Klasa.y);
		Klasa c = new Klasa();
		//Poniższa instrukcja spowoduje błąd
		//Dostęp do stałej za pośrednictwem obiektu jest niemożliwy
		Console.WriteLine(c.y);
	}
}

Powyższy przykład pokazuje sposób deklaracji stałych wewnątrz klasy. Słowo kluczowe const może posłużyć do deklaracji wielu stałych wewnątrz jednego wyrażenia. Deklarowana stała musi być typu prostego np. integer lub string. Należy pamiętać również że dostęp do stałej za pośrednictwem obiektu spowoduje błąd.

Pola : Podobnie jak stałe służą do przechowywania danych wewnątrz klasy. Pole różni się od stałej tym iż można jego wartość zmieniać lub ustalać w trakcie wykonywania programu. Ponadto pola w przeciwieństwie do stałej nie muszą być typu prostego. Pola powinny być deklarowane z atrybutem private aby zapobiec możliwości zamiany ich wartości z zewnątrz. Jeżeli podczas deklaracji pola nie zostanie mu przypisana wartość otrzyma one wartość domyślna dla swojego typu.

Właściwości : Umożliwiają kontrolowany dostęp do wartości zapisanych wewnątrz klasy. Składnia :

[atrybut] <modyfikator> <typ danych> <nazwa>
{
	[modyfikator] get
	{
		......
		return(wartość właściwości)
	}
	[modyfikator]set
	{
		//kod zapisujący do pola wartość reprezentowaną przez zmienną value
	}
}

Blok get wykonywane jest podczas żądania wartości właściwości. Natomiast blok set podczas próby zapisania nowej wartości.

Metody

Metody to funkcje zawarte w klasie służące do wykonywania operacji na obiektach. Przykładem takiej metody może byc uruchomSilnik() dla obiektu samochód lub zaszczekaj() dla obiektu pies. Metoda jest identyfikowana przez swoją nazwę, listę typów oraz parametrów składające się na sygnaturę. Sygnatura jest unikatowa wewnątrz klasy. Wywołujemy je: obiekt.metoda(parametry)

Przykład :

public
class Klasa
{
	int x;
	int y;
	void Show()
	{
		Console.WriteLine("X:"+this.x+"Y:"+this.y);
	}
}

Konstruktor

Jest to specjalna metoda wywoływana przy tworzeniu nowego obiektu klasy. Ta metoda ma taką samą nazwę jak nazwa klasy.

Dodajmy do naszej klasy konstruktor:

public
class Klasa
{
	int x;
	int y;
	public Klasa(int x, int y)
	{
		this.x = x;
		this.y = y;
	}
	void Show()
	{
		Console.WriteLine("X:"+this.x+"Y:"+this.y);
	}
}

Dziedziczenie i przeciążanie metod

Dziedzicznie to mechanizm pozwalający na "dziedziczenie" pól i metod jednej klasy przez drugą. Klasa może jawnie dziedziczyć tylko po jednej klasie (każda dodatkowo niejawnie dziedziczy po klasie Object). Klasa dziedziczona jest nazywana klasą nadrzędną, a ta która dziedziczy klasą podrzędną. Przeciążanie metod pozwala na umieszczenie w kodzie dwóch metod o tej samej nazwie, ale różnych parametrach. Teraz praktyka:

public
class Klasa
{
	int x;
	int y;
	public Klasa(int x,int y)
	{
		this.x = x;
		this.y = y;
	}
	void Show()
	{
		Console.WriteLine("X:"+this.x+"Y:"+this.y);
	}
}

class Klasa2: Klasa //Klasa2 dziedziczy po Klasa
{
	int x, y, z;
	public Klasa(int x,int y,int z)
	{
		this.x = x;
		this.y = y;
		this.z = z;
	}
	void Show()
	{
		Console.WriteLine("X:"+this.x+"Y:"+this.y+"Z"+this.z);
	}
}

Obiekt

Obiekt jest elementem typu nazwa_klasy. Obiekty należą do typów referencyjnych. Nowy obiekt naszej klasy tworzymy:

Klasa obiekt;

Należy jeszcze wywołać konstruktor:

obiekt = new Klasa();

Można to połączyć w jeden zapis:

Klasa obiekt = new Klasa();

Tablice

Czemu tablice są w programowaniu obiektowym?

Czytelnik, który zna inne języki takie jak C czy C++ może się zdziwić czemu tablice są w dziale na temat programowania obiektowego. Otóż w C# tablice należą do typów referencyjnych i są użytkowane jak obiekty.

Klasą bazową dla tablic jest klasa System.Array. Klasa ta definiuje wiele przydatnych metod, wykorzystywanych do pracy z tablicami. Przykładowo można by wymienić:

Składowa klasy Array	Opis
Clear()	metoda statyczna wypełniająca tablice 0 dla wartości lub null dla typów referencyjnych.
Lenght	właściwość jedynie do odczytu, zwraca liczbę elementów danej tablicy.
Reverse()	odwraca kolejnośc tablicy jednowymiarowej.

Używanie tablic

Aby stworzyć tablicę 10 zmiennych typu int piszemy:

int[] tablica = new int[10];

Do tablicy odwołujemy się tak jak w w/w językach czyli nazwa[indeks]. Należy pamiętać, że pierwszy element ma indeks 0 a ostatni rozmiar_tablicy-1. Przypisujemy wartość pierwszemu, a następnie ostatniemu elementowi naszej tablicy:

tablica[0]=1;
tablica[9]=10;

Odwołanie do elementu o indeksie 10 wywoła błąd i aplikacja natychmiast się zakończy.

Tablicę można także bezpośrednio inicjalizować:

int[] tablica = {1,2,3,4,5};

Tablica wielowymiarowa

Jej użytkowanie i tworzenie niewiele się różni. Każdy kolejny wymiar podajemy po przecinku w nawiasie kwadratowym:

int[,] tablica = new int[2,2];
tablica[1,0]=1;
int[,] tablica2 = {{1,2},{3,4}};

Tablice nieregularne

Ciekawostką w C# są tablice wielowymiarowe, w których jeden z wymiarów może być zmienny. Podajemy jedynie pierwszy wymiar a drugi pomijamy:

int[][] tablica = new int[3][];
tablica[0]= new int[4];
tablica[1]=new int[2];
tablica[2]=new int[8];

Tablice jako parametry oraz zwracane wartości

Tablice jako parametr są zwykle wykorzystywane, gdy do metody trzeba przekazywać zmienną liczbę parametrów danego typu. Np. gdy chcemy stworzyć metodę do obliczania średniej arytmetycznej.

public static double Srednia(double[] dane)
        {
            double wynik = 0.0;

            for (int i = 0; i < dane.Length; i++)
            {
                wynik += dane[i];
            }

            return wynik / dane.Length;
        }

//Przykłady zastosowania
Srednia(1.0, 2.0, 3.0, 4.0);

double[] dane = {1.0, 2.0, 3.0, 4.0};
Srednia(dane);

Inne zastosowanie tablic to wykorzystanie ich jako zwracana funkcja - z zastrzeżeniem, iż poniższy przykład należy przetestować w praktyce, gdyż może zawierać błędy

public static int[] dane()
        {
            int[] dane = {1, 2, 3, 4};

            foreach (int dana in dane)
            {
                dana += 5;
            }

            return dane;
        }

Wyjątki

Wyjątki to mechanizm w programowaniu obiektowym pozwalający łatwo wyłapać błędy. Uwalnia to nas od specjalnych zmiennych i wielu instrukcji warunkowych, żeby sprawdzać czy nastąpił błąd. Jeśli nasz program nie ma w kodzie obsługi wyjątków to w pewnym sensie obsługuje je za nas framework tzn. wypisze komunikat, że nastąpił nieobsłużony wyjątek podając jego nazwę, np. IndexOutOfRangeException (w tłumaczeniu: wyjątek poza zasięgiem indeksu). Do obsługi wyjątków używamy bloku try...catch :

try
{
	//blok, w którym może nastąpić wyjątek 
}
catch(TypWyjątku identyfikatorWyjątku)
{
	//instrukcje do wykonania jeśli wyjątek nastąpi w czasie wykonywania kodu z bloku try
}
finally
{
	//instrukcje które wykonają się niezależnie od tego czy wyjątek zostanie wyrzucony czy nie
	//blok finally można pominąć
}

Oczywiście można umieścić więcej bloków catch jeśli chcemy. Każdy wtedy będzie się zajmował innym typem wyjątków. Należy pamiętać, że istnieje hierarchia wyjątków:

• Exception
  • SystemException
    • IndexOutOfRangeException

Należy wyjątki obsługiwać od najniższych do najwyższych w hierarchii. Jeśli pomieszamy hierarchię to kompilator zgłosi błąd, że ten sam wyjątek chcemy obsłużyć drugi raz.

Przykład:

using System;

public
class main
{
	public static int Main()
	{
		int[] tablica = {1,2,3,4,5}
		try
		{
			tablica[5]=6;
		}
		catch(IndexOutOfRangeException) 
		{
			Console.WriteLine("Nastąpiło odwołanie poza tablicę!!!");
		}
                return 0;
	}
}

Wyrzucanie wyjątków

Możemy również sami wyrzucać wyjątki. Robimy to za pomocą instrukcji throw

using System;

class Program
{
	void KupZiemniaki(int ile)
	{
		if(ile < 0)
		{
			//nie możemy kupić ujemnej liczby czegoś więc rzucamy wyjątek
			//po wykonaniu instrukcji throw program wyjdzie z funkcji KupZiemniaki i 
			//dalszy kod się nie wykona
			throw new Exception("Nie można kupić ujemnej liczby ziemniaków");
		}
		//...
	}
	public static int Main()
	{
		Console.WriteLine("Ile ziemniaków chcesz kupić?");
		int ilosc = int.Parse(Console.ReadLine());
		try
		{
			KupZiemniaki(ilosc);
		}
		catch(Exception ex)
		{
			Console.WriteLine("Wystąpił błąd przy kupowaniu ziemniaków!");
		}
                return 0;
	}
}

Interfejsy

Interfejsy są mechanizmem zastępującym dziedziczenie wielokrotne. Interfejsy są implementowane przez klasę (zapis taki sam jak przy dziedziczeniu). Każda klasa może implementować wiele interfejsów. Należy pamiętać, że zgodnie z notacją węgierską języka C# przyjęto nazywanie interfejsów INazwa. Pozwala to jednoznacznie stwierdzić, że mamy do czynienia z interfejsem o nazwie Nazwa. Przykład:

interface IShow
{
	void Show();
}

public
class Klasa :IShow
{
	int x;
	void Show()
	{
		Console.WriteLine(x);
	}
}

Jak zauważyliście w przykładzie w interfejsie nie ma kodu metody Show. W interfejsie nie można zdefiniować metody, dopiero klasa, która implementuje ten interfejs ma zawierać kod metody. W innych wypadkach wywoła to błąd.

Część 3
Tworzenie graficznego interfejsu

Okno

Teraz utworzymy naszą pierwszą aplikację okienkową. Do tego celu potrzebna nam jest biblioteka System.Windows.Forms zawarta w .NET Frameworku. Oto nasza aplikacja okienkowa:

using System;
using System.Windows.Forms;

public
class main
{
	public static void Main()
	{
		Application.Run(new Form());
	}
}

Uruchamiając naszą aplikację zauważymy pewien nieprzyjemny szczegół - pod okienkiem jest konsolka. To dlatego, że do parametrów kompilacji nie dopisaliśmy /t:winexe :

csc /t:winexe program.cs

Teraz nie ma konsolki pod naszym oknem.

Teraz wyświetlimy okno o ustalonym przez nas rozmiarze:

using System;
using System.Windows.Forms;

public
class Okno:Form
{
	public Okno()
	{
		this.Width=320;
		this.Height=240;
	}
	public static void Main()
	{
		Application.Run(new Okno());
	}
}

Delegaty i zdarzenia

Zdarzenia

Zdarzenia można traktować jako wysokopoziomowe przerwania. Służą do interakcji programu z użytkownikiem. Dzięki nim nasz program odpowiednio zareaguje na przykład na kliknięcie myszką na przycisk.

W tym przykładzie okno ma przycisk na którego kliknięcie reaguje:

using System;
using System.Windows.Forms;

public
class Okno:Form
{
	Button przycisk = new Button();
	public Okno()
	{
		this.Width=320;
		this.Height=240;
		przycisk.Top=50;
		przycisk.Left=100;
		przycisk.Text="Kliknij";
		EventHandler eh = new EventHandler(this.PrzyciskClicked);
		przycisk.Click += eh;
		this.Controls.Add(przycisk);
	}
	public void PrzyciskClicked(Object sender, EventArgs e)
	{
		MessageBox.Show("Tekst komunikatu");
	}
}

public
class main
{
	public static void Main()
	{
		Application.Run(new Okno());
	}
}

Komponenty

Podczas tworzenia graficznego interfejsu użytkownika (GUI) w języku C# istnieje kilka podstawowych składników, których można użyć. Obejmują one:

Formularz: formularz jest głównym kontenerem aplikacji GUI. Służy jako okno, które wyświetla użytkownikowi interfejs. W języku C# możesz utworzyć nowy formularz, wybierając opcję „Windows Form” z szablonów projektu.

Etykieta: Etykieta to nieedytowalna kontrolka tekstowa, która służy do wyświetlania tekstu lub podpisu w formularzu. Możesz dodać etykietę do formularza, przeciągając ją z Przybornika i upuszczając na formularz.

TextBox: TextBox to edytowalna kontrolka, która umożliwia użytkownikowi wprowadzanie tekstu. Możesz dodać TextBox do formularza, przeciągając go z Przybornika i upuszczając na formularz.

Przycisk: przycisk to kontrolka, którą użytkownik może kliknąć, aby zainicjować akcję, taką jak przesłanie formularza lub zapisanie danych. Możesz dodać przycisk do formularza, przeciągając go z Przybornika i upuszczając na formularz.

ComboBox: ComboBox to formant, który pozwala użytkownikowi wybrać z listy predefiniowanych opcji. Możesz dodać ComboBox do formularza, przeciągając go z Przybornika i upuszczając na formularz.

CheckBox: CheckBox to formant, który pozwala użytkownikowi wybrać jedną lub więcej opcji z listy predefiniowanych wyborów. Możesz dodać CheckBox do formularza, przeciągając go z Przybornika i upuszczając na formularz.

RadioButton: RadioButton to formant, który pozwala użytkownikowi wybrać jedną opcję z listy predefiniowanych wyborów. Możesz dodać RadioButton do formularza, przeciągając go z Przybornika i upuszczając na formularz.

PictureBox: PictureBox to formant, który wyświetla obraz w formularzu. Możesz dodać PictureBox do formularza, przeciągając go z Przybornika i upuszczając na formularz.

To tylko kilka podstawowych komponentów, których możesz użyć podczas tworzenia GUI w języku C#. W Zestawie narzędzi dostępnych jest znacznie więcej elementów sterujących, aw razie potrzeby można również tworzyć własne elementy sterujące.

Licencja

Version 1.2, November 2002

Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

• A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
• B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
• C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
• D. Preserve all the copyright notices of the Document.
• E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
• F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
• G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.
• H. Include an unaltered copy of this License.
• I. Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
• J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
• K. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
• L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
• M. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version.
• N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.
• O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements."

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

8. TRANSLATION

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

9. TERMINATION

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

10. FUTURE REVISIONS OF THIS LICENSE

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:

Copyright (c)  YEAR  YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2
or any later version published by the Free Software Foundation;
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
A copy of the license is included in the section entitled "GNU
Free Documentation License".

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:

with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.