Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie \ Visual C#

Microsoft Visual C# 2013 Krok po kroku Język: 1

978-83-7541-145-4

Cena Brutto: 102.90

Cena netto: 98.00

Ilość:
Wersja: Drukowana
Autor John Sharp
Liczba_stron 880
Wydawnictwo Microsoft Press
Oprawa miękka
Data_Wydania 2014-01-29


Microsoft

Visual C# 2013

Krok po kroku

______________________________________________________________________________

Książka z serii:

Programowanie


Książka z grupy:

C#



    Książka wprowadzi Cię w podstawy programowania w Visual C#. Będziesz mógł we własnym zakresie i we własnym tempie nauczyć się programować w najnowszej wersji 2013. Książka powinna także zainteresować osoby posiadające podstawowe umiejętności w programowaniu i chcące zapoznać się z Visual C# 2013. Dzięki ćwiczeniom zawartym w podręczniku praktycznie zapoznasz się z podstawowymi elementami języka C# w nowej wersji. Stworzysz działających aplikacje oraz dodatki z przeznaczeniem dla Windows 8.

Podręcznik C# - krok po kroku, podpowie Ci jak:
  • napisać stabilny kod z  możliwością przechwytywania i obsługi zgłaszanych wyjątków
  • pisać i debugować aplikacje w C# przy zastosowaniu Visual Studio 2013
  • używać zmiennych, identyfikatorów, wyrażeń, operatorów
  • budować interfejsy i tworzyć klasy abstrakcyjne
  • edytować i przedstawiać dane przy zastosowaniu wiązania danych Microsoft ADO.NET Entity Framework
  • odpowiadać na gesty i działania użytkownika
  • zarządzać zdarzeniami z wielu różnych źródeł
  • zarabiać na pisaniu aplikacji dla Sklepu Windows
Link do pobrania plików ćwiczeń i przykładów zawarty jest w książce.

Podręcznik C#

przeznaczony dla tych, którzy rozpoczynają swoją przygodę z tym językiem - polecam.

Pragniemy Państwa zapewnić, iż dokładamy wszelkich możliwych starań, by opisy książek i podręczników, zawarte na naszych stronach internetowych, zawierały bieżące i wiarygodne materiały. Może jednak, mimo naszych wysiłków, w opisy książek wkraść się przekłamanie z naszej strony niezamierzone. Nie może to stanowić powodu do roszczeń. O ile macie Państwo jakiekolwiek pytania lub wątpliwości - prosimy o kontakt z naszym ekspertem lub z z działem handlowym.  Postaramy się  odpowiedzieć na wszystkie Państwa pytania zanim podejmiecie Państwo decyzje o złożeniu zamówienia.
#z

Wstęp . . . . . . xiii

Część I: Wprowadzenie do języka Microsoft Visual C#

oraz programu Microsoft Visual Studio 2013

1 Wprowadzenie do języka C# . . . . . . . 3

Rozpoczynamy programowanie przy użyciu środowiska Visual Studio 2013 . . . . . . 3

Piszemy pierwszy program . . .  . . . . 9

Przestrzenie nazw.. . . . . . 16

Tworzenie aplikacji graficznej. . . . . . . . . . . . 20

Analiza aplikacji Sklepu Windows. . . . .  . . . 35

Analiza aplikacji WPF.. 38

Dodawanie kodu do aplikacji graficznej. . . . . . . . . 40

Podsumowanie.. . . . . . . . . 43

Krótki przegląd rozdziału 1. . . . . . . . . . . . . 44

 

2 Zmienne, operatory i wyrażenia. . . . .. . . . 45

Instrukcje.. . . . . . . . . . . . . . 45

Identyfikatory.. . . . . . . . . . 46

Słowa kluczowe.. . . . . 47

Zmienne.. . . . . . . . . . . . . . 48

Nazywanie zmiennych.48

Deklarowanie zmiennych. . . . . . . . . . . . . . . . . . . . . . 49

Podstawowe typy danych.50

Zmienne lokalne bez przypisanej wartości. . . . . . . 50

Wyświetlanie wartości podstawowych typów danych . . . . . . . . . . . . . . . . . . . . . . 51

Posługiwanie się operatorami arytmetycznymi. . . . . . 60

Operatory i typy danych. . . . . . . . . . . . . . . . . . . . . . . 60

Poznajemy operatory arytmetyczne. . . . . . . . . . . . . 62

Kontrolowanie pierwszeństwa. . . . . . . . . . . . . . . . . . 68

Stosowanie zasad łączności przy wyznaczaniu wartości wyrażeń . . . . . . . . . . . . 69

Zasady łączności a operator przypisania. . . . . . . . . 70

Inkrementacja i dekrementacja wartości zmiennych. . 71

Formy przyrostkowe i przedrostkowe. . . . . . . . . . . . 72

Deklarowanie zmiennych lokalnych o niejawnie określonym typie danych . . . . . . 73

Podsumowanie.. . . . . . . . . 74

Krótki przegląd rozdziału 2. . . . . . . . . . . . . . . . . . . . . . . 75

 

3 Tworzenie metod i stosowanie zasięgów zmiennych. . . . . . . . . . . . . . . . . 77

Tworzenie metod.. . . . . . . 77

Deklarowanie metody.78

Zwracanie danych przez metodę.. . . . . . . . . . . . . . . 79

Wywoływanie metod.. 82

Stosowanie zasięgu.. . . . . 84

Definiowanie zasięgu lokalnego. . . . . . . . . . . . . . . . 85

Definiowanie zasięgu klasy. . . . . . . . . . . . . . . . . . . . . 86

Przeciążanie metod.. . 86

Tworzenie metod.. . . . . . . 87

Stosowanie parametrów opcjonalnych oraz nazwanych argumentów. . . . . . . . . . . 97

Definiowanie parametrów opcjonalnych. . . . . . . . . 99

Przekazywanie nazwanych argumentów. . . . . . . . 100

Rozwiązywanie niejednoznaczności związanych z parametrami

opcjonalnymi i argumentami nazwanymi. . . . . . 100

Podsumowanie.. . . . . . . . 107

Krótki przegląd rozdziału 3. . . . . . . . . . . . . . . . . . . . . . 107

 

4 Instrukcje wyboru. . . . . . . . . . . . . . . . . . . . . . 109

Deklarowanie zmiennych logicznych. . . . . . . . . . . . . . 109

Stosowanie operatorów logicznych. . . . . . . . . . . . . . . 110

Operatory równościowe oraz operatory relacji. . . 110

Warunkowe operatory logiczne. . . . . . . . . . . . . . . . 111

Skracanie działania.. . 112

Podsumowanie informacji o pierwszeństwie oraz łączności operatorów . . . . .113

Podejmowanie decyzji przy użyciu instrukcji if. . . . . . 114

Składnia instrukcji if.. 114

Grupowanie instrukcji w bloki. . . . . . . . . . . . . . . . . 116

Kaskadowe łączenie instrukcji if. . . . . . . . . . . . . . . . 117

Stosowanie instrukcji switch. . . . . . . . . . . . . . . . . . . . . . 123

Składnia instrukcji switch. . . . . . . . . . . . . . . . . . . . . 124

Reguły stosowania instrukcji switch. . . . . . . . . . . . 125

Podsumowanie.. . . . . . . . 129

Krótki przegląd rozdziału 4. . . . . . . . . . . . . . . . . . . . . . 130

 

5 Złożone instrukcje przypisania oraz instrukcje iteracji . . . . . . . . . . . . . . 131

Złożone operatory przypisania. . . . . . . . . . . . . . . . . . . 131

Instrukcja while.. . . . . . . . 133

Instrukcja for.. . . . . . . . . . 140

Zasięg instrukcji for.. 141

Instrukcja do.. . . . . . . . . . 142

Podsumowanie.. . . . . . . . 152

Krótki przegląd rozdziału 5. . . . . . . . . . . . . . . . . . . . . . 153

 

6 Obsługa błędów i wyjątków. . . . . . . . . . . . . 155

Zmaganie się z błędami.156

Wypróbowywanie kodu i przechwytywanie wyjątków . . . . . . . . . . . . . . . . . . . . . . . 156

Nieobsłużone wyjątki.158

Stosowanie kilku bloków obsługi pułapki. . . . . . . 159

Przechwytywanie wielu wyjątków. . . . . . . . . . . . . . 160

Propagowanie wyjątków. . . . . . . . . . . . . . . . . . . . . . 167

Wykonywanie operacji arytmetycznych z kontrolą lub bez kontroli

przepełnienia.. . . . . . . . 170

Pisanie instrukcji objętych kontrolą przepełniania171

Pisanie wyrażeń objętych kontrolą przepełniania.172

Zgłaszanie wyjątków.. . . 175

Stosowanie bloku finally.181

Podsumowanie.. . . . . . . . 183

Krótki przegląd rozdziału 6. . . . . . . . . . . . . . . . . . . . . . 183

 

Część II: Omówienie modelu obiektowego języka C#

7 Tworzenie i zarządzanie klasami oraz obiektami . . . . . . . . . . . . . . . . . . . 187

Omówienie klasyfikacji.. 188

Cele hermetyzacji.. . . . . . 188

Definiowanie i używanie klas. . . . . . . . . . . . . . . . . . . . . 189

Kontrolowanie dostępności. . . . . . . . . . . . . . . . . . . . . . 190

Konstruktory.. . . . . . . 193

Przeciążanie konstruktorów. . . . . . . . . . . . . . . . . . . 194

Metody i dane statyczne. . . . . . . . . . . . . . . . . . . . . . . . 204

Tworzenie pól współdzielonych. . . . . . . . . . . . . . . . 205

Tworzenie pól statycznych przy użyciu słowa kluczowego const . . . . . . . . . . . 206

Klasy statyczne.. . . . . 206

Klasy anonimowe.. . . 209

Podsumowanie.. . . . . . . . 211

Krótki przegląd rozdziału 7. . . . . . . . . . . . . . . . . . . . . . 211

 

8 Wartości i referencje. . . . . . . . . . . . . . . . . . . . 213

Kopiowanie klas oraz zmiennych typu wartościowego . . . . . . . . . . . . . . . . . . . . . . . 213

Wartości null oraz typy danych dopuszczające stosowanie wartości null . . . . . . .220

Typy danych dopuszczające stosowanie wartości Null . . . . . . . . . . . . . . . . . . . . 222

Właściwości typów danych dopuszczających stosowanie wartości Null . . . . . . 223

Używanie parametrów typu ref i out. . . . . . . . . . . . . . 224

Tworzenie parametrów typu ref. . . . . . . . . . . . . . . . 225

Tworzenie parametrów typu out. . . . . . . . . . . . . . . 226

Sposób organizacji pamięci komputera. . . . . . . . . . . . 228

Korzystanie ze stosu oraz ze sterty. . . . . . . . . . . . . 230

Klasa System.Object.. . . . 231

Opakowywanie typów danych wewnątrz obiektów. 232

Rozpakowywanie typów danych, opakowanych wewnątrz obiektów . . . . . . . . . . 233

Bezpieczne rzutowanie danych. . . . . . . . . . . . . . . . . . . 235

Operator is.. . . . . . . . . 235

Operator as.. . . . . . . . 236

Podsumowanie.. . . . . . . . 238

Krótki przegląd rozdziału 8. . . . . . . . . . . . . . . . . . . . . . 239

 

9 Tworzenie typów wartości przy użyciu wyliczeń oraz struktur . . . . . . . 241

Wyliczeniowe typy danych. . . . . . . . . . . . . . . . . . . . . . . 241

Deklarowanie wyliczeniowego typu danych. . . . . 242

Stosowanie wyliczeniowych typów danych. . . . . . 242

Wybór wartości literałów wyliczeniowych. . . . . . . 243

Wybór typu danych używanego do wewnętrznego

reprezentowania wartości wyliczeniowych. . . . . 244

Struktury.. . . . . . . . . . . . . 247

Deklarowanie struktury. . . . . . . . . . . . . . . . . . . . . . . 249

Omówienie różnic pomiędzy strukturami i klasami . . . . . . . . . . . . . . . . . . . . . . . 250

Deklarowanie zmiennych strukturalnych. . . . . . . . 252

Omówienie inicjalizacji struktur. . . . . . . . . . . . . . . . 253

Kopiowanie zmiennych strukturalnych. . . . . . . . . . 258

Podsumowanie.. . . . . . . . 263

Krótki przegląd rozdziału 9. . . . . . . . . . . . . . . . . . . . . . 263

 

10 Tablice.. . . . . . . . 265

Deklarowanie i tworzenie tablicy. . . . . . . . . . . . . . . . . 265

Deklarowanie zmiennych tablicowych. . . . . . . . . . 266

Tworzenie instancji tablicy. . . . . . . . . . . . . . . . . . . . 266

Wypełnianie tablic danymi i ich używanie. . . . . . . . . 268

Tworzenie tablic o niejawnie określonym typie elementów . . . . . . . . . . . . . . . . 269

Korzystanie z indywidualnych elementów tablicy270

Wykonywanie iteracji poprzez elementy tablicy. . 271

Przekazywanie tablic jako parametrów i zwracanie ich jako wartości metod . 272

Kopiowanie tablic.. . . . . 275

Tablice wielowymiarowe.276

Tworzenie tablic nieregularnych. . . . . . . . . . . . . . . 277

Podsumowanie.. . . . . . . . 289

Krótki przegląd rozdziału 10. . . . . . . . . . . . . . . . . . . . . 289

 

11 Tablice parametrów. . . . . . . . . . . . . . . . . . . . . 291

Przeciążanie: krótkie przypomnienie faktów. . . . . . . . 291

Używanie argumentów będących tablicami. . . . . . . . 292

Spis treści vii

Deklarowanie tablicy parametrów typu params. . 294

Używanie parametru typu params object[ ]. . . . . . 297

Stosowanie tablicy parametrów typu params. . . . 298

Porównanie tablic parametrów z parametrami opcjonalnymi . . . . . . . . . . . . . . . . . 301

Podsumowanie.. . . . . . . . 304

Krótki przegląd rozdziału 11. . . . . . . . . . . . . . . . . . . . . 304

 

12 Dziedziczenie... 305

Czym jest dziedziczenie?. . . . . . . . . . . . . . . . . . . . . . . . 305

Korzystanie z mechanizmów dziedziczenia. . . . . . . . . 306

Powtórka informacji na temat klasy System.Object . . . . . . . . . . . . . . . . . . . . . . . 308

Wywoływanie konstruktora klasy bazowej. . . . . . 309

Przypisywanie klas.. . 310

Deklarowanie metod z użyciem słowa kluczowego new . . . . . . . . . . . . . . . . . . . 312

Deklarowanie metod wirtualnych. . . . . . . . . . . . . . 313

Deklarowanie metod z użyciem słowa kluczowego override . . . . . . . . . . . . . . . 315

Omówienie dostępu chronionego. . . . . . . . . . . . . . 318

Metody rozszerzające.. . 324

Podsumowanie.. . . . . . . . 329

Krótki przegląd rozdziału 12. . . . . . . . . . . . . . . . . . . . . 329

 

13 Tworzenie interfejsów oraz definiowanie klas abstrakcyjnych . . . . . . . 331

Interfejsy.. . . . . . . . . . . . . 332

Definiowanie interfejsu. . . . . . . . . . . . . . . . . . . . . . . 333

Implementowanie interfejsu. . . . . . . . . . . . . . . . . . . 333

Odwoływanie się do klasy za pomocą jej interfejsu . . . . . . . . . . . . . . . . . . . . . . . 335

Praca z wieloma interfejsami. . . . . . . . . . . . . . . . . . 336

Jawne implementowanie interfejsu. . . . . . . . . . . . . 337

Ograniczenia interfejsów.. . . . . . . . . . . . . . . . . . . . . 339

Definiowanie i używanie interfejsów. . . . . . . . . . . . 340

Klasy abstrakcyjne.. . . . . 351

Metody abstrakcyjne.353

Klasy zamknięte.. . . . . . . 353

Metody zamknięte.. . 354

Implementowanie i używanie klas abstrakcyjnych354

Podsumowanie.. . . . . . . . 362

Krótki przegląd rozdziału 13. . . . . . . . . . . . . . . . . . . . . 363

 

14 Proces oczyszczania pamięci i zarządzanie zasobami . . . . . . . . . . . . . . . 365

Żywot obiektów.. . . . . . . 366

Tworzenie destruktorów. . . . . . . . . . . . . . . . . . . . . . 367

Dlaczego istnieje proces oczyszczania pamięci?. . 369

Działanie procesu oczyszczania pamięci. . . . . . . . 371

Zalecenia.. . . . . . . . . . 372

Zarządzanie zasobami.. . 373

Metody sprzątające.. 373

Sprzątanie w sposób odporny na występowanie wyjątków . . . . . . . . . . . . . . . . 374

Instrukcja using oraz interfejs IDisposable. . . . . . . 375

Wywoływanie metody Dispose z poziomu destruktora . . . . . . . . . . . . . . . . . . . . 376

Implementacja metody sprzątającej w sposób odporny

na występowanie wyjątków. . . . . . . . . . . . . . . . . . . . 379

Podsumowanie.. . . . . . . . 388

Krótki przegląd rozdziału 14. . . . . . . . . . . . . . . . . . . . . 389

 

Część III: Tworzenie rozszerzalnych typów danych w języku C#

15 Implementacja właściwości zapewniających dostęp do pól . . . . . . . . . . 393

Implementacja kapsułkowania przy użyciu metod. . 393

Co to są właściwości?.. . 395

Używanie właściwości. . . . . . . . . . . . . . . . . . . . . . . . 398

Właściwości tylko do odczytu. . . . . . . . . . . . . . . . . 398

Właściwości tylko do zapisu. . . . . . . . . . . . . . . . . . . 399

Dostępność właściwości. . . . . . . . . . . . . . . . . . . . . . 400

Ograniczenia właściwości. . . . . . . . . . . . . . . . . . . . . . . . 400

Deklarowanie właściwości interfejsu. . . . . . . . . . . . . . . 402

Zastępowanie metod właściwościami. . . . . . . . . . . 404

Generowanie automatycznych właściwości. . . . . . . . . 408

Inicjalizowanie obiektów przy użyciu właściwości. . . 409

Podsumowanie.. . . . . . . . 414

Krótki przegląd rozdziału 15. . . . . . . . . . . . . . . . . . . . . 414

 

16 Indeksatory.. . . 417

Co to jest indeksator?.. . 417

Przykład bez użycia indeksatorów. . . . . . . . . . . . . . 417

Ten sam przykład z wykorzystaniem indeksatorów . . . . . . . . . . . . . . . . . . . . . . . 420

Akcesory indeksatora.422

Porównanie indeksatorów i tablic. . . . . . . . . . . . . . 423

Indeksatory w interfejsach. . . . . . . . . . . . . . . . . . . . . . . 424

Stosowanie indeksatorów w aplikacjach Windows. . 426

Podsumowanie.. . . . . . . . 432

Krótki przegląd rozdziału 16. . . . . . . . . . . . . . . . . . . . . 433

 

17 Typy ogólne.. . . 435

Problem z typem Object. . . . . . . . . . . . . . . . . . . . . . . . 435

Rozwiązanie z użyciem typów ogólnych. . . . . . . . . . . 439

Typy ogólne a klasy uogólnione. . . . . . . . . . . . . . . 441

Typy ogólne i nakładanie ograniczeń. . . . . . . . . . . 442

Tworzenie klasy ogólnej.442

Teoria drzew binarnych. . . . . . . . . . . . . . . . . . . . . . . 442

Budowanie klasy drzewa binarnego przy użyciu typu ogólnego . . . . . . . . . . . 446

Tworzenie metody ogólnej. . . . . . . . . . . . . . . . . . . . . . 455

Definiowanie metody ogólnej do budowy drzewa binarnego . . . . . . . . . . . . . . 456

Interfejsy ogólne i niezgodność typów. . . . . . . . . . . . 458

Interfejsy kowariantne. . . . . . . . . . . . . . . . . . . . . . . . 460

Interfejsy kontrawariantne. . . . . . . . . . . . . . . . . . . . 462

Podsumowanie.. . . . . . . . 464

Krótki przegląd rozdziału 17. . . . . . . . . . . . . . . . . . . . . 465

 

18 Kolekcje.. . . . . . 467

Co to są klasy kolekcji?.. 467

Klasa kolekcji List<T>. . . . . . . . . . . . . . . . . . . . . . . . 469

Klasa kolekcji LinkedList<T>. . . . . . . . . . . . . . . . . . . 472

Klasa kolekcji Queue<T>. . . . . . . . . . . . . . . . . . . . . 473

Klasa kolejki Stack<T>. . . . . . . . . . . . . . . . . . . . . . . . 474

Klasa kolekcji Dictionary<TKey, TValue>. . . . . . . . 476

Klasa kolekcji SortedList<TKey, TValue>. . . . . . . . . 477

Klasa kolekcji HashSet<T>. . . . . . . . . . . . . . . . . . . . 478

Inicjalizowanie kolekcji.. 480

Metody Find, predykaty i wyrażenia lambda. . . . . . . 481

Porównanie tablic i kolekcji. . . . . . . . . . . . . . . . . . . . . . 483

Wykorzystanie klas kolekcji do gry w karty. . . . . . 483

Podsumowanie.. . . . . . . . 488

Krótki przegląd rozdziału 18. . . . . . . . . . . . . . . . . . . . . 488

 

19 Wyliczanie kolekcji. . . . . . . . . . . . . . . . . . . . . . 491

Wyliczanie elementów kolekcji. . . . . . . . . . . . . . . . . . . 491

Ręczna implementacja modułu wyliczającego. . . 493

Implementowanie interfejsu IEnumerable. . . . . . . 497

Implementowanie modułu wyliczającego przy użyciu iteratora . . . . . . . . . . . . . . . 500

Prosty iterator.. . . . . . 500

Definiowanie modułu wyliczającego dla klasy Tree<TItem> przy

użyciu iteratora.. . . 502

Podsumowanie.. . . . . . . . 505

Krótki przegląd rozdziału 19. . . . . . . . . . . . . . . . . . . . . 505

 

20 Wydzielanie logiki aplikacji i obsługa zdarzeń . . . . . . . . . . . . . . . . . . . . . 507

Co to są delegaty.. . . . . . 508

Przykłady delegatów w bibliotece klas .NET Framework . . . . . . . . . . . . . . . . . . 509

Przykład zautomatyzowanej fabryki. . . . . . . . . . . . 511

Implementowanie systemu sterowania fabryką bez użycia delegatów . . . . . . 512

Implementowanie sterowania fabryką przy użyciu delegata . . . . . . . . . . . . . . . 512

Deklarowanie i używanie delegatów. . . . . . . . . . . . 515

Delegaty i wyrażenia lambda.. . . . . . . . . . . . . . . . . . . . 525

Tworzenie adaptera metody. . . . . . . . . . . . . . . . . . . 525

Różne formy wyrażeń lambda. . . . . . . . . . . . . . . . . 526

Włączanie powiadomień za pomocą zdarzeń. . . . . . 528

Deklarowanie zdarzenia. . . . . . . . . . . . . . . . . . . . . . 528

Subskrypcja zdarzenia. . . . . . . . . . . . . . . . . . . . . . . . 529

Anulowanie subskrypcji zdarzenia. . . . . . . . . . . . . 530

Zgłaszanie zdarzenia.530

Zdarzenia interfejsu użytkownika. . . . . . . . . . . . . . . . . 531

Używanie zdarzeń.. . 533

Podsumowanie.. . . . . . . . 540

Krótki przegląd rozdziału 20. . . . . . . . . . . . . . . . . . . . . 540

 

21 Odpytywanie danych w pamięci przy użyciu wyrażeń

w języku zapytań. . . . . . . . . . . . . . . . . . . . . . . 543

Co to jest LINQ (Language-Integrated Query)?. . . . . 544

Używanie LINQ w aplikacjach C#. . . . . . . . . . . . . . . . . 545

Wybieranie danych.. 546

Filtrowanie danych.. . 549

Porządkowanie, grupowanie i agregowanie danych . . . . . . . . . . . . . . . . . . . . . . 550

Łączenie danych.. . . . 552

Operatory zapytań.. . 553

Odpytywanie danych w obiektach Tree<TItem>. 556

LINQ i opóźnione przetwarzanie. . . . . . . . . . . . . . . 562

Podsumowanie.. . . . . . . . 566

Krótki przegląd rozdziału 21. . . . . . . . . . . . . . . . . . . . . 566

 

22 Przeciążanie operatorów. . . . . . . . . . . . . . . . 569

Czym są operatory... . . . 569

Ograniczenia operatorów. . . . . . . . . . . . . . . . . . . . . 570

Operatory przeciążone. . . . . . . . . . . . . . . . . . . . . . . 571

Tworzenie operatorów symetrycznych. . . . . . . . . . 572

Przetwarzanie złożonej instrukcji przypisania. . . . . . . 574

Deklarowanie operatorów zwiększających i zmniejszających . . . . . . . . . . . . . . . . . . 575

Operatory porównań w strukturach i klasach. . . . . . . 576

Definiowanie par operatorów. . . . . . . . . . . . . . . . . . . . 577

Implementowanie operatorów. . . . . . . . . . . . . . . . . . . 578

Operatory konwersji.. . . 585

Wbudowane metody konwersji. . . . . . . . . . . . . . . . 585

Implementowanie własnych operatorów konwersji . . . . . . . . . . . . . . . . . . . . . . . 586

Spis treści xi

Tworzenie operatorów symetrycznych – uzupełnienie . . . . . . . . . . . . . . . . . . . . 587

Zapisywanie operatorów konwersji. . . . . . . . . . . . . 588

Podsumowanie.. . . . . . . . 591

Krótki przegląd rozdziału 22. . . . . . . . . . . . . . . . . . . . . 591

 

Część IV: Tworzenie profesjonalnych aplikacji dla Windows 8.1

23 Przyśpieszanie działania za pomocą zadań595

Po co stosować wielozadaniowość przy użyciu przetwarzania równoległego? . . 595

Narodziny procesora wielordzeniowego. . . . . . . . 597

Implementowanie wielozadaniowości w .NET Framework . . . . . . . . . . . . . . . . . . . . 598

Zadania, wątki i pula wątków. . . . . . . . . . . . . . . . . . 599

Tworzenie, uruchamianie i kontrolowanie zadań. 600

Używanie klasy Task do implementacji równoległości . . . . . . . . . . . . . . . . . . . . . 603

Tworzenie abstrakcji zadań za pomocą klasy Parallel . . . . . . . . . . . . . . . . . . . . . 614

Kiedy nie używać klasy Parallel. . . . . . . . . . . . . . . . 619

Anulowanie zadań i obsługa wyjątków. . . . . . . . . . . . 621

Mechanizm anulowania kooperatywnego. . . . . . . 622

Kontynuowanie w przypadku zadań anulowanych lub przerwanych

z powodu wyjątku.. 636

Podsumowanie.. . . . . . . . 637

Krótki przegląd rozdziału 23. . . . . . . . . . . . . . . . . . . . . 637

 

24 Skracanie czasu reakcji za pomocą działań asynchronicznych . . . . . . . . 641

Implementowanie metod asynchronicznych.. . . . . . . 642

Definiowanie metod asynchronicznych: postawienie problemu . . . . . . . . . . . . 643

Definiowanie metod asynchronicznych: rozwiązanie . . . . . . . . . . . . . . . . . . . . . . 646

Definiowanie metod asynchronicznych zwracających wartości . . . . . . . . . . . . . 652

Metody asynchroniczne i interfejsy API środowiska Windows Runtime . . . . . . 653

Zrównoleglanie deklaratywnego dostępu do danych za pomocą PLINQ . . . . . . . 657

Wykorzystanie PLINQ do poprawy wydajności podczas

wykonywania iteracji po elementach kolekcji. . 657

Anulowanie zapytania PLINQ. . . . . . . . . . . . . . . . . . 663

Synchronizowanie współbieżnych operacji dostępu do danych . . . . . . . . . . . . . . . 663

Blokowanie danych.. 666

Elementarne narzędzia synchronizacji umożliwiające koordynowanie zadań . 667

Anulowanie synchronizacji. . . . . . . . . . . . . . . . . . . . 670

Współbieżne klasy kolekcji. . . . . . . . . . . . . . . . . . . . 670

Wykorzystanie kolekcji współbieżnej i blokady do implementacji

dostępu do danych przystosowanego do trybu wielowątkowego . . . . . . . . . 671

Podsumowanie.. . . . . . . . 682

Krótki przegląd rozdziału 24. . . . . . . . . . . . . . . . . . . . . 682

 

25 Implementowanie interfejsu użytkownika aplikacji Sklepu Windows . 685

Co to jest aplikacja Sklepu Windows?. . . . . . . . . . . . . 686

Budowa aplikacji Sklepu Windows przy użyciu szablonu Blank App . . . . . . . . . . . 690

Implementowanie skalowalnego interfejsu użytkownika . . . . . . . . . . . . . . . . . . 693

Stosowanie stylów do interfejsu użytkownika. . . . 726

Podsumowanie.. . . . . . . . 736

Krótki przegląd rozdziału 25. . . . . . . . . . . . . . . . . . . . . 736

 

26 Wyświetlanie i wyszukiwanie danych w aplikacjach Sklepu Windows . 739

Implementowanie wzorca projektowego Model-View-ViewModel . . . . . . . . . . . . 740

Wyświetlanie danych przy użyciu mechanizmu wiązania danych . . . . . . . . . . . 741

Modyfikowanie danych przy użyciu wiązania danych . . . . . . . . . . . . . . . . . . . . . 747

Stosowanie wiązania danych do kontrolki ComboBox . . . . . . . . . . . . . . . . . . . . 751

Tworzenie składnika ViewModel. . . . . . . . . . . . . . . 753

Dodawanie poleceń do składnika ViewModel. . . 758

Kontrakty systemu Windows 8.1. . . . . . . . . . . . . . . . . . 769

Implementowanie kontraktu Search. . . . . . . . . . . . 770

Nawigowanie do wybranego elementu. . . . . . . . . 782

Podsumowanie.. . . . . . . . 787

Krótki przegląd rozdziału 26. . . . . . . . . . . . . . . . . . . . . 788

 

27 Dostęp do zdalnej bazy danych z poziomu aplikacji Sklepu Windows . 789

Pobieranie informacji z bazy danych. . . . . . . . . . . . . . 790

Wstawianie, aktualizacja i usuwanie danych za pośrednictwem

usługi web typu REST. . . . . . . . . . . . . . . . . . . . . . . 810

Podsumowanie.. . . . . . . . 829

Krótki przegląd rozdziału 27. . . . . . . . . . . . . . . . . . . . . 830

Indeks.. . . .

powrót
 
Produkty Podobne
Microsoft Visual C# 2013 Krok po kroku
Microsoft Visual C# 2013 Step by Step
Windows Runtime via C#
Zestaw 2 książek dla programistów (Visual C# 2012 Krok po kroku + Poznaj Microsoft Visual Basic 2012)
Microsoft Visual Studio 2012. Programowanie w C#
Start Here! Learn Microsoft Visual C# 2010
Build Your Own ASP.NET 4 Web Site Using C# & VB, 4th Edition
Microsoft Visual C# 2010 Krok po kroku
Microsoft Visual C# 2010 Step by Step
Microsoft Visual C# 2008 krok po kroku
Więcej produktów