Rozdział 2. Pierwszy program C#

W tym rozdziale napiszemy prawdziwie użyteczny pierwszy program C# (C sharp) — zwłaszcza dla tych z was, którzy pracują w branży produkcji okien. Zaczniemy od opracowania bardzo prostego rozwiązania i przyjrzymy się instrukcjom C# wykonującym podstawowe operacje na danych. Następnie ulepszymy nasz program za pomocą dodatkowych elementów języka C#.

Zadaniem naszego pierwszego programu będzie odczytanie szerokości i wysokości okna, a następnie podanie wymaganej ilości drewna i szkła do wyprodukowania okna o podanych wymiarach. To problem nakreślony w sekcji 1.2.2. Przejdziemy teraz do jego rozwiązania.

2.1. Przykładowy program w C#

Analizę języka C# najlepiej jest chyba zacząć od razu od pierwszego programu. Oto on:

using System;
class GlazerCalc
{
    static void Main() 
    {
        double width, height, woodLength, glassArea;
        string widthString, heightString;
        widthString = Console.ReadLine();
        width = double.Parse(widthString);
        heightString = Console.ReadLine();
        height = double.Parse(heightString);
        woodLength = 2 * ( width + height ) * 3.25;
        glassArea = 2 * ( width * height );
        Console.WriteLine ( "Długośćdrewna: " +
                woodLength + " stopy") ; 
        Console.WriteLine( "Powierzchniaszyby: " +
                glassArea + " m kw." ); } }

Przykład 01. Program GlazerCalc

To poprawnie napisany program — dałoby się go skompilować i uruchomić. Za sedno jego działania odpowiadają dwie wyróżnione linijki. Ogólnie rzecz ujmując, kod znajdujący się przed wyróżnionym fragmentem odpowiada za konfigurację i pobranie wartości, które mają zostać przetworzone. Z kolei kod następujący po oznaczonych wierszach wyświetla wynik operacji użytkownikowi.

Przyjrzymy się teraz kolejno każdej linijce tego kodu i sprawdzimy co wnosi do naszego pierwszego programu.

2.1.1. using System;

Ważnym aspektem nauki programowania jest opanowanie dodatkowych elementów funkcjonalności systemu, które mogą usprawnić nasz pierwszy program.

To instrukcja przekazująca kompilatorowi C#, że chcemy korzystać z przestrzeni nazw System. Przestrzeń nazw to obszar, w obrębie którego nazwy przybierają znaczenie. Z przestrzeni tych korzystamy także w zwykłych rozmowach. Jeśli użyję przestrzeni nazw Futbol i powiem „postawili w polu karnym autobus”, to opiszę w ten sposób taktykę zespołu. Moje zdanie nabierze jednak zupełnie innego znaczenia w przestrzeni nazw Transport.

W przypadku języka C# w przestrzeni nazw System opisanych jest wiele przydatnych składników. Jednym z nich jest obiekt Console, dzięki któremu mogę napisać to, co ma zostać wyświetlone na ekranie użytkownika. Jeśli chciałbym odwołać się do tego obiektu poprzez nazwę Console, to muszę poinformować kompilator, że korzystam z przestrzeń nazw System. Oznacza to, że gdy odwołam się do czegoś po konkretnej nazwie, kompilator sprawdzi, czy nazwa ta występuje w przestrzeni System. W dalszej części książki będziemy korzystać także z innych przestrzeni nazw.

2.1.2. classGlazerCalc

Klasy stanowią fundament programowania obiektowego, o czym przekonamy się później.

Program C# składa się z co najmniej jednej klasy. Klasa to kontener przechowujący dane i kod programu wykonujący określone zadanie. W przypadku naszego kalkulatora, klasa zawiera tylko jedną metodę, która oblicza długość drewna i powierzchnię szyby. W razie potrzeby klasy mogą jednak zawierać o wiele więcej składników.

Każdej utworzonej klasie należy nadać identyfikator. Naszą klasę nazwaliśmy GlazerCalc, ponieważ nazwa ta odzwierciedla działanie klasy. Na razie nie przejmujcie się zbytnio klasami. Jeśli jakieś tworzycie, starajcie się tylko wybierać dla nich sensowne nazwy.

Jeszcze jedno: zgodnie z konwencją nazwa pliku zawierającego daną klasę powinna odzwierciedlać nazwę tej klasy — innymi słowy, powyższy program powinien być przechowywany w pliku GlazerCalc.cs.

2.1.3. Słowo kluczowe static

Słowo kluczowe dbające o to, by następująca po nim metoda była zawsze obecna i zawarta w wykorzystywanej klasie. W kontekście obiektów to niepozorne słowo ma wiele ciekawych implikacji. Póki co będę jednak wdzięczny, jeśli po prostu będziecie go używać, dzięki czemu wasze programy będą działać prawidłowo.

2.1.4. Słowo kluczowe void

Angielskie słowo void oznacza próżnię — czyli nic. W programowaniu słowo kluczowe void mówi, że metoda, którą zamierzamy opisać nie będzie zwracać niczego co by było nam potrzebne. Wykona po prostu swoje zadanie i zakończy działanie. Czasami pisze się metody zwracające jakiś wynik (skorzystamy nawet z tego rodzaju metody w dalszej części programu).

Jeśli jednak nie chcemy, by ktoś przez przypadek wykorzystał wartość zwracaną przez naszą metodę Main, możemy jasno określić, że nie zwraca ona nic. Programy są dzięki temu bezpieczniejsze, ponieważ kompilator wie, że jeśli ktoś próbuje się odwołać do wartości zwracanej przez tę metodę, to najwyraźniej popełnia błąd.

2.1.5. Metoda Main

Metodom nadaje się własne nazwy, odpowiadające działaniu tychże metod. Wyjątek stanowi Main. To w tej metodzie (która może występować tylko jeden jedyny raz) zaczyna się działanie programu. Gdy program zostaje wczytany i uruchomiony, pierwszą metodą jaka otrzymuje nad nim kontrolę jest właśnie Main. Gdybyśmy ją pominęli, to system dosłownie nie wiedziałby od czego zacząć.

2.1.6. Operator ()

To nawiasy niezawierające niczego. Choć brzmi to głupio, dzięki nim kompilator wie, że metoda Main nie ma żadnych parametrów. Parametr metody przekazuje jej jakiś materiał, nad którym może pracować. Definiując metodę, informujemy język C#, że operuje ona na jednym lub większej liczbie elementów. Przykładowo metoda sin(x) mogłaby operować na liczbie zmiennoprzecinkowej wyrażającej wartość kąta x. Metody omówimy jeszcze szczegółowo w dalszej części książki.

2.1.7. Nawias klamrowy — {

To nawias klamrowy. Jak to z nawiasami bywa, występują one w parach — jeden z nich jest otwierający, a drugi zamykający. Korzystając z nawiasów, można pogrupować fragmenty programu w zbitki. Taka zbitka nazywana jest blokiem. Blok może zawierać deklaracje wykorzystywanych w jego zakresie zmiennych i sekwencję wykonywanych po kolei instrukcji. W naszym przypadku klamry zawierają fragmenty odpowiedzialne za działanie metody Main.

Gdy kompilator natrafi na klamrę zamykającą na końcu bloku, to wie, że metoda dobiegła końca i należy przejść do wykonania kolejnej (jeśli jeszcze jakaś została). Skutki niedomknięcia nawiasu zawsze są tragiczne…

2.1.8. Słowo kluczowe double

Słowo to oznacza „liczbę zmiennoprzecinkową o podwójnej precyzji”.

W trakcie działania nasz program musi pamiętać pewne wartości. Co szczególnie istotne, wczytuje wartość szerokości i wysokości okna, a następnie oblicza i wyświetla wartość powierzchni szyby oraz długości drewna. Miejsca, w których przechowywane są wartości nazywane są w języku C# zmiennymi. Na początku dowolnego bloku możemy przekazać C# informację, że chcemy zarezerwować trochę przestrzeni na przechowywanie danych. Każda zmienna może przechowywać określony rodzaj wartości. Zasadniczo C# obsługuje trzy rodzaje danych: liczby zmiennoprzecinkowe, liczby całkowite i tekst (litery, cyfry, znaki przestankowe). Mówiąc o utworzeniu zmiennej, mamy na myśli jej zadeklarowanie.

Zmienna typu double może przechowywać szeroki zakres wartości o bardzo wysokiej precyzji.

Zmienne określonego typu deklaruje się poprzez podanie typu danych, a następnie wymienienie nazw, jakie zmienne mają przyjąć. Na tę chwilę będziemy korzystać z typu double. Później będziemy używać innych typów.

2.1.9. width, height, woodLength, glassArea

To lista. W C# elementy na liście rozdziela się przecinkami. W tym przypadku mamy do czynienia z listą zmiennych. Gdy kompilator widzi słowo double (omówione wyżej), to spodziewa się także nazwy co najmniej jednej zmiennej jaka ma zostać utworzona. Przeglądając podaną listę, tworzy on „pudełka”, w których będą przechowywane wartości typu double i nadaje im odpowiednie nazwy. Od tego momentu możemy odwoływać się do wskazanych nazw, a kompilator będzie wiedzieć, że korzystamy z konkretnej zmiennej.

2.1.10. Średnik

Średnik (;) sygnalizuje koniec listy nazw zmiennych, a jednocześnie koniec deklaracji. Wszystkie instrukcje w programach C# są zakończone średnikiem, dzięki czemu kompilator się nie pogubi.

Średnik odgrywa bardzo ważną rolę, bowiem mówi kompilatorowi, w którym miejscu kończy się dana instrukcja. Jeśli kompilator nie znajdzie średnika w spodziewanym miejscu, to zgłasza błąd. Średniki spełniają zatem podobne zadanie co otwory perforacyjne w taśmie filmowej — dzięki nim program przebiega wyznaczonym torem.

2.1.11. string widthString, heightString;

Utworzyliśmy już zmienne, które przechowują liczby. Teraz zaś deklarujemy zmienne z łańcuchami tekstu. Będą nam potrzebne, ponieważ od użytkownika liczby wczytywane są w postaci tekstu. Dopiero później konwertujemy je na wartości liczbowe. Zmienne widthString i heightString (zwróćcie uwagę na odpowiednio dopasowane nazwy) będą zawierać wczytane liczby w wersji tekstowej.

2.1.12. widthString =

Jest to instrukcja przypisania. W tej instrukcji zmieniamy wartość zmiennej. Nasz program odczyta otrzymany od użytkownika tekst i umieści wynik w zmiennej, którą nazwaliśmy widthString. Należy pamiętać, że zmienna to tylko nazwane „pudełko” mające określony rozmiar i mogące przechowywać jeden element danych (w tym przypadku jest to łańcuch).

Programy w dużej mierze składają się z instrukcji przypisujących zmiennym nowe wartości w związku z dokonywanymi obliczeniami. W języku C# za przypisanie odpowiada znak równości. Pierwszą część instrukcji stanowi nazwa zdefiniowanej już zmiennej. Po niej następuje znak =, czyli mostek, którym wartość z prawej strony wędruje do zmiennej po lewej. Taka metafora, wybaczcie.

2.1.13. Console

Po prawej stronie znaku równości znajduje się to, co ma zostać przypisane do widthString. W tym przypadku wynik ten będzie łańcuchem zwróconym przez metodę ReadLine. Stanowi ona część obiektu o nazwie Console, który kontroluje dane wejściowe i wyjściowe pobierane od użytkownika i do niego zwracane. Kropka oddziela identyfikator obiektu od identyfikatora metody.

2.1.14. ReadLine

W ten sposób oznaczamy, że ma zostać wywołana metoda ReadLine. Prosimy program, by prędziutko wykonał wszelkie znajdujące się w niej instrukcje i z powrotem stawił się do naszej dyspozycji. Za pomocą metod możemy podzielić program na kilka części, z których każda odpowiedzialna jest za wykonanie konkretnego zadania. Korzystając z takiego rozwiązania, wystarczy napisać dany fragment kodu tylko raz, umieścić go w metodzie i wywoływać tę metodę kiedy tylko będziemy chcieli wykonać zadanie, za które odpowiedzialny jest kod. Biblioteka standardowa C# zawiera liczne wbudowane metody, którymi możemy posłużyć się w naszych programach. ReadLine jest jedną z nich.

W czasie wykonywania programu wywołana zostaje metoda ReadLine. Program czeka, aż użytkownik wprowadzi tekst i naciśnie klawisz Enter. Wpisany tekst jest następnie zwracany w postaci łańcucha przez metodę ReadLine, a wynik wywołania metody zostaje umieszczony w zmiennej widthString.

2.1.15. Operator ()

Po wywołaniu metody podajemy jej parametry. Parametr to coś przekazywane metodzie, by mogła wykonać na tym czymś operacje. Parametry można porównać do surowców wykorzystywanych w jakimś procesie. Jeśli chodzi o metodę ReadLine, to nie bazuje ona na żadnych surowcach — potrzebne informacje uzyska od użytkownika, który sam je wprowadzi. Listę parametrów musimy podać jednak nawet wtedy, gdy jest ona pusta.

2.1.16. ;

Średnik już widzieliśmy. Oznacza koniec instrukcji programu.

2.1.17. width =

To kolejne przypisanie. Zmiennej width zostaje przypisana wartość. Wiele instrukcji, jakie umieścicie w swoich programach będzie po prostu przenosić dane i wykonywać na nich operacje.

2.1.18. double

Pozostała część przypisania wygląda nieco strasznie, lecz nie ma w niej nic skomplikowanego. Prosimy Pana double (to coś, co przechowuje liczbę zmiennoprzecinkową o podwójnej precyzji), by załatwił dla nas małą sprawę. W tym przypadku chodzi o to, by „wziąć łańcuch przechowywany w zmiennej widthString i zamienić go na liczbę zmiennoprzecinkową o podwójnej precyzji”. Pan double dostarcza tę „usługę” w postaci metody o nazwie Parse.

Zwróćcie uwagę, że w C# udostępnianie metod nie jest niczym nagannym. Dzięki temu program może wykonać to, czego chcemy. Gdy będziecie projektować większe programy, to przekonacie się, że najlepiej jest wówczas tworzyć komponenty, które udostępniają metody wykonujące pożądane zadania. Biblioteka C# udostępniana jest jako zbiór metod — będziecie musieli nauczyć się, gdzie znaleźć odpowiednią metodę i jak z niej skorzystać. To tak jak w życiu — trzeba wiedzieć, do kogo zwrócić się o pomoc…

2.1.19. Metoda Parse

Metoda Parse ma za zadanie przekonwertować otrzymany łańcuch na liczbę zmiennoprzecinkową o podwójnej precyzji. W tym celu musi przeanalizować łańcuch, wyciągnąć z niego każdą liczbę i obliczyć faktyczną wartość wyrażenia, np. „12” oznaczać będzie dziesięć i dwie jednostki. Taka analiza nazywana jest często parsowaniem — stąd też wywodzi się nazwa wykorzystywanej przez nas metody. Metodzie przekazuje się łańcuch, który ma zostać sparsowany, a ta zwraca zidentyfikowaną liczbę.

Zauważ, że jest tu sporo miejsca na niecne występki. Jeśli użytkownik nie wprowadzi wartości bądź wpisze coś w stylu „Dwadzieścia pięć”, to metoda Parse nie będzie w stanie odczytać liczby i jej wywołanie zakończy się niepowodzeniem. Co dokładnie się wtedy dzieje i jak można temu zapobiec będzie tematem jednej z przyszłych sekcji — odrobina napięcia nie zaszkodzi.

2.1.20. (widthString);

Jak już widzieliśmy, wywołaniu metody muszą towarzyszyć surowce (parametry). W przypadku metody ReadLine nie ma żadnych parametrów, lecz musimy to zaznaczyć, podając pustą listę. Metoda Parse musi natomiast otrzymać łańcuch, którego analizę ma przeprowadzić. Przekazujemy go poprzez podanie w nawiasie nazwy zmiennej łańcuchowej zawierającej tekst (widthString), tak jak powyżej. Wartość informacji w zmiennej widthString (czyli wpisanego przez użytkownika tekstu) zostaje przekazana do metody Parse, która dokona analizy i wydobędzie liczbę.

2.1.21. heightString = Console.ReadLine(); height = double.Parse(heightString);

Powyższe instrukcje ponownie wczytują tekst, tym razem zawierający wartość wysokości, i konwertują go na wartość o podwójnej precyzji.

2.1.22. woodLength = 2*(width + height)*3.25;

Oto sedno programu — to ten fragment wykonuje główne zadanie. Pobiera wartości wysokości oraz szerokości i wykorzystuje je do obliczenia wymaganej długości drewna.

Pisząc programy, korzystam z nawiasów nawet jeśli nie wymaga tego kompilator. Dzięki temu program jest czytelniejszy.

Obliczenie wykonywane przez program ma postać powyższego wyrażenia. Należy w tym miejscu zwrócić uwagę na zastosowanie nawiasów, które modyfikują kolejność w jakiej obliczane są zawarte w wyrażeniu wartości. Zwykle C# oblicza wyrażenia w przewidywalny sposób — pierwszeństwo ma mnożenie i dzielenie, a w następnej kolejności wykonywane jest dodawanie i odejmowanie. W powyższym wyrażeniu chciałem jednak, by pewne działania zostały wykonane wcześniej, dlatego posłużyłem się rozwiązaniem zaczerpniętym z matematyki i oznaczyłem pierwszeństwo wybranego fragmentu za pomocą nawiasu.

Zauważ również, że zastosowałem współczynnik 3,25, by zgodnie z życzeniem klienta długość drewna podawana była w stopach. Jeden metr to mniej więcej 3,25 stopy, zatem mnożę wynik w metrach przez taki współczynnik.

Występujące w wyrażeniu znaki + i * nazywane są operatorami, ponieważ powodują wykonanie danej operacji. Pozostałe elementy to tak zwane argumenty wyrażenia. To na nich działają operatory.

2.1.23. glassArea = 2 * ( width * height );

Ten wiersz powtarza omówione obliczenia dla powierzchni szyby. Powierzchnia podana jest w metrach kwadratowych, zatem nie wymagana jest dodatkowa konwersja. Jedno działanie mnożenia umieściłem w nawiasie, by zaznaczyć, że chcę obliczyć powierzchnię dwa razy (dla dwóch szyb). Nie jest to szczególnie wymagane, ale wydaje mi się, że dzięki temu kod jest czytelniejszy.

2.1.24. Console.WriteLine

To wywołanie metody, tak jak w przypadku ReadLine. Różnica polega jednak na tym, że powyższa metoda pobiera wartość i wyświetla ją w konsoli.

2.1.25. Nawias — (

To początek listy parametrów dla tego wywołania. Z zapisem tym spotkaliśmy się już przy okazji omawiania metod Parse i ReadLine.

2.1.26. "Długość drewna: "

To literał łańcuchowy, czyli łańcuch zawierający tekst, który pojawia się w programie dosłownie. Umieszczamy go w cudzysłowie — dzięki temu kompilator wie, że przekazujemy mu wartość, a nie instrukcję.

2.1.27. +

Plus to operator dodawania. Widzieliśmy jak za jego pomocą można dodać do siebie dwie liczby całkowite. Tutaj jednak plus to coś z zupełnie innej beczki. W tym przypadku oznacza on, że będziemy dodawać dwa łańcuchy.

Będziecie musieli się przyzwyczaić do roli kontekstu w waszych programach. Przerabialiśmy to już przy okazji omawiania przestrzeni nazw, a teraz mamy do czynienia z kontekstem w przypadku operatorów. C# na podstawie kontekstu określa działanie jakie ma wykonać. W przypadku poprzedniego plusa, znajdującego się pomiędzy dwoma liczbami zmiennoprzecinkowymi o podwójnej precyzji, chodziło o „zsumowanie składników działania”. Tutaj po lewej stronie plusa znajduje się łańcuch. Oznacza to, że zamiast matematycznego dodawania zostanie wykonana konkatenacja.

2.1.28. woodLength

To kolejny przykład ilustrujący znaczenie kontekstu. Poprzednio używaliśmy zmiennej woodLength jako liczbowej reprezentacji wartości, która w przypadku tego programu określa wymaganą długość drewna. W tym jednak kontekście (na końcu łańcucha) nie da się jej tak zastosować.

Kompilator C# musi zatem poprosić przechowywany w woodLength element danych, by zamienił się w łańcuch, dzięki czemu będzie go można prawidłowo użyć w tym miejscu. Na szczęście taka zamiana jest możliwa, a program zadziała zgodnie z naszymi oczekiwaniami.

To bardzo ważne, by zrozumieć, o co tutaj dokładnie chodzi. Rozważcie poniższy przykład:

Console.WriteLine ( 2.0 + 3.0 );

Ten kod wykona działanie na liczbach (2,0 + 3,0) i zwróci wartość zmiennoprzecinkową o podwójnej precyzji. Wynik ten zostanie następnie poproszony o przekazanie swojej wersji łańcuchowej, która ma zostać wydrukowana, czyli tego:

5

Jednak w przypadku tego kodu:

Console.WriteLine ( "2.0" + 3.0 );

znak + zostanie potraktowany jako operator konkatenacji dwóch łańcuchów. Kompilator poprosi wartość 3, by zamieniła się w łańcuch (brzmi dziwnie, ale tak się stanie), po czym otrzymamy wynik:

2.03

Na końcu łańcucha "2.0" zostanie dodana tekstowa reprezentacja wartości 3.0. Zmiana w wykonaniu działania wynika w całości z kontekstu, w jakim przeprowadzana jest operacja.

Wyobraźcie sobie, że wszystkie zmienne w programie są oznaczone metadanymi (znowu to słowo), a podstawie których kompilator decyduje co ma zrobić. Zmienna heightString opatrzona jest informacją, która mówi kompilatorowi: „to łańcuch — jeśli widzisz znak plusa, to wykonaj konkatenację”. Zmienna woodLength jest natomiast oznaczona metadanymi, które informują, że jest „to wartość zmiennoprzecinkowa o podwójnej precyzji — jeśli widzisz znak plusa, to wykonaj działanie arytmetyczne”.

2.1.29. + " stopy"

To raz jeszcze konkatenacja. Na koniec dodajemy słowo „stopy”. Zawsze gdy wyświetlam jakąś wartość, to na końcu umieszczam jednostki. W ten sposób łatwiej sprawić, że wartości będą zrozumiałe.

2.1.30. )

Nawias oznacza koniec parametru metody WriteLine. Podczas wywołania metody program najpierw składa łańcuch ze wszystkich komponentów, łącząc (konkatenując) je w jedną całość. Otrzymana wartość łańcuchowa zostaje następnie przekazana metodzie, która wyświetli ją w konsoli.

2.1.31. ;

Średnik oznacza koniec instrukcji.

2.1.32. }

Nadeszła pora, by omówić coś naprawdę ważnego. Program jest już w zasadzie gotowy — dodaliśmy wszystkie potrzebne elementy funkcjonalności. Musimy jednak jeszcze przekazać kompilatorowi, że program dobiegł końca. Powyższy pierwszy zamykający nawias klamrowy oznacza koniec bloku kodu, który stanowi treść główną metody Main. Blok kodu zaczynamy od znaku { i kończymy znakiem }. Widząc zamykającą klamrę, kompilator myśli sobie: „to koniec metody Main”.

2.1.33. }

Drugi zamykający nawias klamrowy pełni równie ważną rolę — oznacza koniec klasy GlazerCalc. W C# wszystko istnieje w obrębie jakiejś klasy. Klasa może zawierać mnóstwo rzeczy, w tym metody. Jeśli chcemy (a na dalszym etapie chcieć będziemy), to w klasie możemy umieścić kilka metod. Na razie jednak wystarczy nam tylko ta jedna metoda. Druga klamra zamykająca oznacza zatem koniec klasy.

2.1.34. Znaki interpunkcyjne

W tym miejscu kończymy nasz program. Jak zapewne zauważyliście, sporo mówimy o znakach interpunkcyjnych. Pełnią one kluczową rolę i muszą być stosowane tak, jak wymaga tego C#. W przeciwnym razie spowodujemy błąd kompilacji. Jak można wywnioskować, kompilator jest zbyt głupi, by zrozumieć podany mu kod!

Szybko nauczycie się szukać błędów i je wyłapywać. Przekonacie się, że kompilator nie zawsze wykryje nasze pomyłki — pomyślcie, co by się stało, gdyby zabrakło znaku. To, że kompilator uznał program za poprawny nie oznacza jednak, że wszystko będzie działać prawidłowo!

Warto też pamiętać, że kompilatora nie obchodzi wygląd kodu, dlatego poniższy zapis jest teoretycznie równie dobry:

usingSystem;classGlazerCalc{staticvoidMain(){doublewidth, height, woodLength, glassArea;stringwidthString, heightString;widthString = Console.ReadLine();width = double.Parse(widthString);heightString = Console.ReadLine();height = double.Parse(heightString);woodLength = 2 * ( width + height ) * 3.25;glassArea = 2 * ( width * height );Console.WriteLine ( "Długość drewna: " + woodLength + " stopy );Console.WriteLine( "Powierzchnia szyby: " + glassArea + " m kw." );}}

— jeśli jednak ktoś z was napisze program w ten sposób, to dostanie ode mnie po łapach!