Verfügbarkeit: Visual C# 2019

Gespeichert in:

Bibliographische Detailangaben
Titel:	Visual C# 2019 Grundlagen, Profiwissen und Rezepte
Weiterer Titel:	Visual C sharp
Von:	Jürgen Kotz
Person:	Kotz, Jürgen Verfasser aut
Hauptverfasser:	Kotz, Jürgen (VerfasserIn)
Format:	Buch
Sprache:	Deutsch
Veröffentlicht:	München Hanser [2019]
Schlagworte:	Visual Studio 2019 C sharp Visual C sharp 2019 Visual C sharp.NET
Online-Zugang:	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=031536737&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	Auf dem Cover: "C#-Grundlagen, LINQ, OOP, ADO.NET, EF und WPF, über 150 Praxisbeispiele"
Beschreibung:	XXV, 1010 Seiten Illustrationen, Diagramme 25 cm
ISBN:	9783446458024 3446458026

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV046156738
003	DE-604
005	20210205
007	t\|
008	190912s2019 gw a\|\|\| \|\|\|\| 00\|\|\| ger d
016	7		\|a 1184416737 \|2 DE-101
020			\|a 9783446458024 \|9 978-3-446-45802-4
020			\|a 3446458026 \|9 3-446-45802-6
035			\|a (OCoLC)1099685045
035			\|a (DE-599)DNB1184416737
040			\|a DE-604 \|b ger \|e rda
041	0		\|a ger
044			\|a gw \|c XA-DE-BY
049			\|a DE-M347 \|a DE-1050 \|a DE-210 \|a DE-706 \|a DE-523 \|a DE-12 \|a DE-1046 \|a DE-83 \|a DE-860 \|a DE-91G \|a DE-M100 \|a DE-634 \|a DE-526 \|a DE-B768 \|a DE-Aug4 \|a DE-11
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a DAT 302f \|2 stub
084			\|a DAT 358f \|2 stub
084			\|a DAT 652f \|2 stub
100	1		\|a Kotz, Jürgen \|e Verfasser \|0 (DE-588)124099343 \|4 aut
245	1	0	\|a Visual C# 2019 \|b Grundlagen, Profiwissen und Rezepte \|c Jürgen Kotz
246	1	3	\|a Visual C sharp
264		1	\|a München \|b Hanser \|c [2019]
264		4	\|c © 2019
300			\|a XXV, 1010 Seiten \|b Illustrationen, Diagramme \|c 25 cm
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
500			\|a Auf dem Cover: "C#-Grundlagen, LINQ, OOP, ADO.NET, EF und WPF, über 150 Praxisbeispiele"
650	0	7	\|a Visual Studio 2019 \|0 (DE-588)1193260337 \|2 gnd \|9 rswk-swf
650	0	7	\|a C sharp \|0 (DE-588)4616843-6 \|2 gnd \|9 rswk-swf
650	0	7	\|a Visual C sharp 2019 \|0 (DE-588)1196645582 \|2 gnd \|9 rswk-swf
650	0	7	\|a Visual C sharp.NET \|0 (DE-588)4682222-7 \|2 gnd \|9 rswk-swf
689	0	0	\|a Visual C sharp 2019 \|0 (DE-588)1196645582 \|D s
689	0		\|5 DE-604
689	1	0	\|a Visual Studio 2019 \|0 (DE-588)1193260337 \|D s
689	1	1	\|a C sharp \|0 (DE-588)4616843-6 \|D s
689	1		\|8 1\p \|5 DE-604
689	2	0	\|a Visual C sharp.NET \|0 (DE-588)4682222-7 \|D s
689	2		\|8 2\p \|5 DE-604
776	0	8	\|i Erscheint auch als \|n Online-Ausgabe \|z 978-3-446-46099-7
776	0	8	\|i Erscheint auch als \|n Online-Ausgabe, EPUB \|z 978-3-446-46253-3
856	4	2	\|m DNB Datenaustausch \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=031536737&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
883	1		\|8 1\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
883	1		\|8 2\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
943	1		\|a oai:aleph.bib-bvb.de:BVB01-031536737

Datensatz im Suchindex

DE-BY-TUM_call_number	0102 DAT 358f 2019 A 5135
DE-BY-TUM_katkey	2440535
DE-BY-TUM_location	01
DE-BY-TUM_media_number	040009427636
_version_	1821934098582601728
adam_text	INHALT VORWORT ..................................................................................................... XXIII TEIL I: GRUNDLAGEN ....................................................................................... 1 1 EINSTIEG IN VISUAL STUDIO 2019 .......................................................... 3 1.1 DIE INSTALLATION VON VISUAL STUDIO 2019 ................................................................ 3 1.1.1 UEBERBLICK UEBER DIE PRODUKTPALETTE .................................... 3 1.1.2 ANFORDERUNGEN AN HARD- UND SOFTWARE ...................................................... 4 1.2 UNSER ALLERERSTES C#-PROGRAMM .............................................................................. 5 1.2.1 VORBEREITUNGEN ........................................................................................... 5 1.2.2 QUELLCODE SCHREIBEN ................................................................................... 7 1.2.3 PROGRAMM KOMPILIEREN UND TESTEN ............................................................ 8 1.2.4 EINIGE ERLAEUTERUNGEN ZUM QUELLCODE ........................................................ 9 1.2.5 KONSOLENANWENDUNGEN SIND OUT ................................................................ 10 1.3 DIE WINDOWS-PHILOSOPHIE ....................................................................................... 10 1.3.1 MENSCH-RECHNER-DIALOG .............................................................................. 10 1.3.2 OBJEKT- UND EREIGNISORIENTIERTE PROGRAMMIERUNG ...................................... 11 1.3.3 PROGRAMMIEREN MIT VISUAL STUDIO 2019 .................................................... 12 1.4 DIE ENTWICKLUNGSUMGEBUNG VISUAL STUDIO 2019 .................................................. 13 1.4.1 NEUES PROJEKT ............................................................................................... 14 1.4.2 DIE WICHTIGSTEN FENSTER .............................................................................. 16 1.5 MICROSOFTS .NET-TECHNOLOGIE................................................................................... 20 1.5.1 ZUR GESCHICHTE VON .NET ............................................................................ 20 1.5.2 .NET-FEATURES UND BEGRIFFE ........................................................................ 22 1.6 PRAXISBEISPIELE ......................................................................................................... 29 1.6.1 UNSERE ERSTE WINDOWS-FORMS-ANWENDUNG ................................................. 30 1.6.2 UMRECHNUNG EURO-DOLLAR ............................................................................ 35 2 GRUNDLAGEN DER SPRACHE C# ............................................................... 45 2.1 GRUNDBEGRIFFE .......................................................................................................... 45 2.1.1 ANWEISUNGEN ............................................................................................... 45 2.1.2 BEZEICHNER ................................................................................................... 46 2.1.3 SCHLUESSELWOERTER ............................................................................................ 47 2.1.4 KOMMENTARE ................................................................................................ 48 2.2 DATENTYPEN, VARIABLEN UND KONSTANTEN .................................................................. 49 2.2.1 FUNDAMENTALE TYPEN .................................................................................. 49 2.2.2 WERTETYPEN VERSUS VERWEISTYPEN .............................................................. 50 2.2.3 BENENNUNG VON VARIABLEN .......................................................................... 51 2.2.4 DEKLARATION VON VARIABLEN .......................................................................... 51 2.2.5 TYPSUFFIXE ..................................................................................................... 52 2.2.6 ZEICHEN UND ZEICHENKETTEN ........................................................................ 53 2.2.7 OBJECT-DATENTYP ............................................................................................ 55 2.2.8 KONSTANTEN DEKLARIEREN .............................................................................. 56 2.2.9 NULLABLE TYPES .............................................................................................. 56 2.2.10 TYPINFERENZ .................................................................................................. 58 2.2.11 GUELTIGKEITSBEREICHE UND SICHTBARKEIT ......................................................... 59 2.3 KONVERTIEREN VON DATENTYPEN .................................................................................. 59 2.3.1 IMPLIZITE UND EXPLIZITE KONVERTIERUNG ....................................................... 59 2.3.2 WELCHER DATENTYP PASST ZU WELCHEM? ......................................................... 62 2.3.3 KONVERTIEREN VON STRING .............................................................................. 62 2.3.4 DIE CONVERT-KLASSE ...................................................................................... 64 2.3.5 DIE PARSE-METHODE ...................................................................................... 65 2.3.6 BOXING UND UNBOXING .................................................................................. 65 2.4 OPERATOREN ............................................................................................................... 67 2.4.1 ARITHMETISCHE OPERATOREN .......................................................................... 68 2.4.2 ZUWEISUNGSOPERATOREN ................................................................................ 70 2.4.3 LOGISCHE OPERATOREN .................................................................................... 71 2.4.4 RANGFOLGE DER OPERATOREN ............................................................................ 73 2.5 KONTROLLSTRUKTUREN ................................................................................................... 74 2.5.1 VERZWEIGUNGSBEFEHLE .................................................................................. 74 2.5.2 SCHLEIFENANWEISUNGEN ................................................................................ 79 2.6 BENUTZERDEFINIERTE DATENTYPEN ................................................................................ 82 2.6.1 ENUMERATIONEN ............................................................................................ 82 2.6.2 STRUKTUREN ................................................................................................... 83 2.7 NUTZERDEFINIERTE METHODEN ...................................................................................... 86 2.7.1 METHODEN MIT RUECKGABEWERT ...................................................................... 86 2.7.2 METHODEN OHNE RUECKGABEWERT .................................................................... 88 2.7.3 PARAMETERUEBERGABE MIT REF .......................................................................... 89 2.7.4 PARAMETERUEBERGABE MIT OUT ........................................................................ 90 2.7.5 METHODENUEBERLADUNG .................................................................................. 91 2.7.6 OPTIONALE PARAMETER .................................................................................... 92 2.7.7 BENANNTE PARAMETER .................................................................................... 93 2.8 PRAXISBEISPIELE ......................................................................................................... 94 2.8.1 VOM PAP ZUR KONSOLENANWENDUNG ............................................................ 94 2.8.2 EIN KONSOLEN- IN EIN WINDOWS-PROGRAMM VERWANDELN ............................. 97 2.8.3 SCHLEIFENANWEISUNGEN VERSTEHEN .............................................................. 99 2.8.4 BENUTZERDEFINIERTE METHODEN UEBERLADEN ................................................... 101 2.8.5 ANWENDUNGEN VON VISUAL BASIC NACH C# PORTIEREN .................................. 104 3 OOP-KONZEPTE ......................................................................................... 113 3.1 KLEINE EINFUEHRUNG IN DIE OOP ................................................................................ 113 3.1.1 HISTORISCHE ENTWICKLUNG ............................................................................ 114 3.1.2 GRUNDBEGRIFFE DER OOP ................................................................................ 115 3.1.3 SICHTBARKEIT VON KLASSEN UND IHREN MITGLIEDERN ....................................... 117 3.1.4 ALLGEMEINER AUFBAU EINER KLASSE .............................................................. 118 3.1.5 DAS ERZEUGEN EINES OBJEKTS ........................................................................ 120 3.1.6 EINFUEHRUNGSBEISPIEL .................................................................................... 123 3.2 EIGENSCHAFTEN ........................................................................................................... 128 3.2.1 EIGENSCHAFTEN MIT ZUGRIFFSMETHODEN KAPSELN ............................................ 128 3.2.2 BERECHNETE EIGENSCHAFTEN .......................................................................... 130 3.2.3 LESE-/SCHREIBSCHUTZ .................................................................................... 132 3.2.4 PROPERTY-ACCESSOREN .................................................................................... 133 3.2.5 STATISCHE FELDER/EIGENSCHAFTEN .................................................................. 134 3.2.6 EINFACHE EIGENSCHAFTEN AUTOMATISCH IMPLEMENTIEREN ............................. 136 3.3 METHODEN ................................................................................................................. 138 3.3.1 OEFFENTLICHE UND PRIVATE METHODEN .............................................................. 138 3.3.2 UEBERLADENE METHODEN .................................................................................. 139 3.3.3 STATISCHE METHODEN ..................................................................................... 140 3.4 EREIGNISSE ................................................................................................................. 142 3.4.1 EREIGNIS HINZUFUEGEN ................................................................................... 142 3.4.2 EREIGNIS VERWENDEN ................................................................................... 145 3.5 ARBEITEN MIT KONSTRUKTOR UND DESTRUKTOR .............................................................. 148 3.5.1 KONSTRUKTOR UND OBJEKTINITIALISIERER .......................................................... 149 3.5.2 DESTRUKTOR UND GARBAGE COLLECTOR .............................................................. 152 3.5.3 MIT USING DEN LEBENSZYKLUS DES OBJEKTS KAPSELN ..................................... 154 3.6 VERERBUNG UND POLYMORPHIE ................................................................................... 155 3.6.1 METHOD-OVERRIDING ..................................................................................... 155 3.6.2 KLASSEN IMPLEMENTIEREN .............................................................................. 156 3.6.3 IMPLEMENTIEREN DER OBJEKTE ...................................................................... 159 3.6.4 AUSBLENDEN VON MITGLIEDERN DURCH VERERBUNG ......................................... 160 3.6.5 ALLGEMEINE HINWEISE UND REGELN ZUR VERERBUNG ...................................... 162 3.6.6 POLYMORPHES VERHALTEN ................................................................................ 163 3.6.7 DIE ROLLE VON SYSTEM.OBJECT ........................................................................ 166 3.7 SPEZIELLE KLASSEN ..................................................................................................... 167 3.7.1 ABSTRAKTE KLASSEN ....................................................................................... 167 3.7.2 VERSIEGELTE KLASSEN ..................................................................................... 168 3.7.3 PARTIELLE KLASSEN ......................................................................................... 169 3.7.4 STATISCHE KLASSEN ......................................................................................... 170 3.8 SCHNITTSTELLEN (INTERFACES) ....................................................................................... 171 3.8.1 DEFINITION EINER SCHNITTSTELLE ....................................................................... 171 3.8.2 IMPLEMENTIEREN EINER SCHNITTSTELLE ............................................................ 172 3.8.3 ABFRAGEN, OB SCHNITTSTELLE VORHANDEN IST ................................................... 173 3.8.4 MEHRERE SCHNITTSTELLEN IMPLEMENTIEREN ..................................................... 173 3.8.5 SCHNITTSTELLENPROGRAMMIERUNG IST EIN WEITES FELD ..................................... 174 3.9 PRAXISBEISPIELE .......................................................................................................... 174 3.9.1 EIGENSCHAFTEN SINNVOLL KAPSELN .................................................................. 174 3.9.2 EINE STATISCHE KLASSE ANWENDEN ................................................................ 177 3.9.3 VOM FETTEN ZUM SCHLANKEN CLIENT .............................................................. 179 3.9.4 SCHNITTSTELLENVERERBUNG VERSTEHEN ............................................................ 190 3.9.5 RECHNER FUER KOMPLEXE ZAHLEN .................................................................... 194 3.9.6 SORTIEREN MIT ICOMPARABLE/ICOMPARER ....................................................... 203 3.9.7 EINEN OBJEKTBAUM IN GENERISCHEN LISTEN ABSPEICHERN ............................. 208 3.9.8 OOP BEIM KARTENSPIEL ERLERNEN .................................................................. 213 3.9.9 EINE KLASSE ZUR MATRIZENRECHNUNG ENTWICKELN ......................................... 218 4 ARRAYS, STRINGS, FUNKTIONEN ................................................................. 225 4.1 DATENFELDER (ARRAYS) ................................................................................................ 225 4.1.1 ARRAY DEKLARIEREN ........................................................................................ 226 4.1.2 ARRAY INSTANZIIEREN ...................................................................................... 226 4.1.3 ARRAY INITIALISIEREN ...................................................................................... 227 4.1.4 ZUGRIFF AUF ARRAY-ELEMENTE ........................................................................ 228 4.1.5 ZUGRIFF MITTELS SCHLEIFE ................................................................................ 229 4.1.6 MEHRDIMENSIONALE ARRAYS .......................................................................... 230 4.1.7 ZUWEISEN VON ARRAYS .................................................................................. 232 4.1.8 ARRAYS AUS STRUKTURVARIABLEN .................................................................... 233 4.1.9 LOESCHEN UND UMDIMENSIONIEREN VON ARRAYS ............................................. 234 4.1.10 EIGENSCHAFTEN UND METHODEN VON ARRAYS ................................................... 236 4.1.11 UEBERGABE VON ARRAYS .................................................................................. 237 4.2 VERARBEITEN VON ZEICHENKETTEN ................................................................................ 239 4.2.1 ZUWEISEN VON STRINGS .................................................................................. 239 4.2.2 EIGENSCHAFTEN UND METHODEN VON STRING-VARIABLEN ................................. 240 4.2.3 WICHTIGE METHODEN DER STRING-KLASSE ......................................................... 242 4.2.4 DIE STRINGBUILDER-KLASSE .............................................................................. 244 4.3 REGULAERE AUSDRUECKE .................................................................................................. 247 4.3.1 WOZU WERDEN REGULAERE AUSDRUECKE VERWENDET? ......................................... 247 4.3.2 EINE KLEINE EINFUEHRUNG ................................................................................ 248 4.3.3 WICHTIGE METHODEN/EIGENSCHAFTEN DER KLASSE REGEX ............................... 248 4.3.4 KOMPILIERTE REGULAERE AUSDRUECKE ................................................................ 250 4.3.5 REGEXOPTIONS-ENUMERATION ........................................................................ 251 4.3.6 METAZEICHEN (ESCAPE-ZEICHEN) .................................................................... 252 4.3.7 ZEICHENMENGEN (CHARACTER SETS) ................................................................ 253 4.3.8 QUANTIFIZIERER ............................................................................................... 254 4.3.9 ZERO-WIDTH ASSERTIONS ................................................................................ 256 4.3.10 GRUPPEN ....................................................................................................... 259 4.3.11 TEXT ERSETZEN ............................................................................................... 260 4.3.12 TEXT SPLITTEN ................................................................................................. 261 4.4 DATUMS- UND ZEITBERECHNUNGEN .............................................................................. 262 4.4.1 DIE DATETIME-STRUKTUR ................................................................................ 262 4.4.2 WICHTIGE EIGENSCHAFTEN VON DATETIME-VARIABLEN ..................................... 263 4.4.3 WICHTIGE METHODEN VON DATETIME-VARIABLEN ............................................. 264 4.4.4 WICHTIGE MITGLIEDER DER DATETIME-STRUKTUR ............................................... 265 4.4.5 KONVERTIEREN VON DATUMSTRINGS IN DATETIME-WERTE ................................. 265 4.4.6 DIE TIMESPAN-STRUKTUR ................................................................................ 266 4.5 MATHEMATISCHE FUNKTIONEN .................................................................................... 268 4.5.1 UEBERBLICK ..................................................................................................... 268 4.5.2 ZAHLEN RUNDEN ............................................................................................. 268 4.5.3 WINKEL UMRECHNEN ...................................................................................... 269 4.5.4 POTENZ- UND WURZELOPERATIONEN .................................................................. 269 4.5.5 LOGARITHMUS UND EXPONENTIALFUNKTIONEN ................................................... 269 4.5.6 ZUFALLSZAHLEN ERZEUGEN ................................................................................ 270 4.5.7 KREISBERECHNUNG ......................................................................................... 271 4.6 ZAHLEN-UND DATUMSFORMATIERUNGEN ...................................................................... 271 4.6.1 ANWENDEN DER TOSTRING-METHODE .............................................................. 272 4.6.2 ANWENDEN DER FORMAT-METHODE ................................................................ 273 4.6.3 STRINGINTERPOLATION ..................................................................................... 274 4.7 PRAXISBEISPIELE ......................................................................................................... 275 4.7.1 ZEICHENKETTEN VERARBEITEN .......................................................................... 275 4.7.2 ZEICHENKETTEN MIT STRINGBUILDER ADDIEREN ................................................. 278 4.7.3 REGULAERE AUSDRUECKE TESTEN .......................................................................... 281 4.7.4 METHODENAUFRUFE MIT ARRAY-PARAMETERN ................................................... 283 5 WEITERE SPRACHFEATURES ....................................................................... 287 5.1 NAMESPACES (NAMENSRAEUME) .................................................................................. 287 5.1.1 EIN KLEINER UEBERBLICK .................................................................................. 287 5.1.2 EINEN EIGENEN NAMESPACE EINRICHTEN ........................................................ 288 5.1.3 DIE USING-ANWEISUNG ................................................................................. 289 5.1.4 NAMESPACE ALIAS ......................................................................................... 290 5.2 OPERATORENUEBERLADUNG ............................................................................................. 291 5.2.1 SYNTAXREGELN ............................................................................................... 291 5.2.2 PRAKTISCHE ANWENDUNG ................................................................................ 291 5.3 COLLECTIONS (AUFLISTUNGEN) ....................................................................................... 293 5.3.1 DIE SCHNITTSTELLE IENUMERABLE .................................................................... 293 5.3.2 ARRAYLIST ..................................................................................................... 295 5.3.3 HASHTABLE ..................................................................................................... 297 5.3.4 INDEXER ......................................................................................................... 297 5.4 GENERICS .................................................................................................................. 300 5.4.1 GENERICS BIETEN TYPSICHERHEIT ..................................................................... 300 5.4.2 GENERISCHE METHODEN .................................................................................. 301 5.4.3 ITERATOREN ..................................................................................................... 302 5.5 GENERISCHE COLLECTIONS ............................................................................................ 303 5.5.1 LIST-COLLECTION STATT ARRAYLIST .................................................................... 303 5.5.2 VORTEILE GENERISCHER COLLECTIONS ................................................................ 304 5.5.3 CONSTRAINTS ................................................................................................... 304 5.6 DAS PRINZIP DER DELEGATES ........................................................................................ 305 5.6.1 DELEGATES SIND METHODENZEIGER .................................................................. 305 5.6.2 EINEN DELEGATE-TYP DEKLARIEREN .................................................................. 305 5.6.3 EIN DELEGATE-OBJEKT ERZEUGEN .................................................................... 306 5.6.4 DELEGATES VEREINFACHT INSTANZIIEREN .......................................................... 308 5.6.5 ANONYME METHODEN ............................................................................... 308 5.6.6 LAMBDA-AUSDRUECKE ...................................................................................... 310 5.6.7 LAMBDA-AUSDRUECKE IN DER TASK PARALLEL LIBRARY ....................................... 312 5.7 DYNAMISCHE PROGRAMMIERUNG ................................................................................ 313 5.7.1 WOZU DYNAMISCHE PROGRAMMIERUNG? ......................................................... 314 5.7.2 DAS PRINZIP DER DYNAMISCHEN PROGRAMMIERUNG ....................................... 314 5.7.3 OPTIONALE PARAMETER SIND HILFREICH ............................................................ 317 5.7.4 KOVARIANZ UND KONTRAVARIANZ .................................................................... 317 5.8 WEITERE DATENTYPEN ................................................................................................. 318 5.8.1 BIGLNTEGER ..................................................................................................... 318 5.8.2 COMPLEX ....................................................................................................... 321 5.8.3 TUPLE ......................................................................................................... 321 5.8.4 SORTEDSETO ................................................................................................. 322 5.9 PRAXISBEISPIELE ......................................................................................................... 324 5.9.1 ARRAYLIST VERSUS GENERISCHE LIST ................................................................ 324 5.9.2 GENERISCHE IENUMERABLE-INTERFACES IMPLEMENTIEREN ............................... 327 5.9.3 DELEGATES, ANONYME METHODEN, LAMBDA EXPRESSIONS ............................... 330 5.9.4 DYNAMISCHER ZUGRIFF AUF COM INTEROP ....................................................... 334 6 EINFUEHRUNG IN LINQ ............................................................................... 339 6.1 LINQ-GRUNDLAGEN ..................................................................................................... 339 6.1.1 DIE LINQ-ARCHITEKTUR .................................................................................. 339 6.1.2 ANONYME TYPEN .......................................................................................... 341 6.1.3 ERWEITERUNGSMETHODEN .............................................................................. 342 6.2 ABFRAGEN MIT LINQ TO OBJECTS .................................................................................. 343 6.2.1 GRUNDLEGENDES ZUR LINQ-SYNTAX ................................................................ 344 6.2.2 ZWEI ALTERNATIVE SCHREIBWEISEN VON LINQ-ABFRAGEN ................................. 345 6.2.3 UEBERSICHT DER WICHTIGSTEN ABFRAGEOPERATOREN ........................................... 346 6.3 LINQ-ABFRAGEN IM DETAIL .......................................................................................... 347 6.3.1 DIE PROJEKTIONSOPERATOREN SELECT UND SELECTMANY ................................... 348 6.3.2 DER RESTRIKTIONSOPERATOR WHERE ................................................................ 350 6.3.3 DIE SORTIERUNGSOPERATOREN ORDERBY UND THENBY ..................................... 350 6.3.4 DER GRUPPIERUNGSOPERATOR GROUPBY .......................................................... 352 6.3.5 VERKNUEPFEN MIT JOIN .................................................................................... 354 6.3.6 AGGREGAT-OPERATOREN .................................................................................... 355 6.3.7 VERZOEGERTES AUSFUEHREN VON LINQ-ABFRAGEN ............................................... 357 6.3.8 KONVERTIERUNGSMETHODEN ............................................................................ 358 6.3.9 ABFRAGEN MIT PLINO .................................................................................... 359 6.4 PRAXISBEISPIELE ......................................................................................................... 362 6.4.1 DIE SYNTAX VON LINQ-ABFRAGEN VERSTEHEN ................................................. 362 6.4.2 AGGREGAT-ABFRAGEN MIT LINO ...................................................................... 365 6.4.3 LINO IM SCHNELLDURCHGANG ERLERNEN .......................................................... 367 6.4.4 STRINGS MIT LINO ABFRAGEN UND FILTERN ....................................................... 370 6.4.5 DUPLIKATE AUS EINER LISTE ODER EINEM ARRAY ENTFERNEN ............................. 371 6.4.6 ARRAYS MIT LINO INITIALISIEREN .................................................................... 374 6.4.7 ARRAYS PER LINO MIT ZUFALLSZAHLEN FUELLEN ................................................. 376 6.4.8 EINEN STRING MIT WIEDERHOLMUSTER ERZEUGEN ............................................. 378 6.4.9 MIT LINO ZAHLEN UND STRINGS SORTIEREN .................................................... 379 6.4.10 MIT LINO COLLECTIONS VON OBJEKTEN SORTIEREN ............................................. 380 6.4.11 ERGEBNISSE VON LINQ-ABFRAGEN IN EIN ARRAY KOPIEREN .............................. 383 7 NEUERUNGEN VON C# IM UEBERBLICK ....................................................... 385 7.1 C# 4.0 - VISUAL STUDIO 2010 .................................................................................... 385 7.1.1 DATENTYP DYNAMIC ....................................................................................... 385 7.1.2 BENANNTE UND OPTIONALE PARAMETER ............................................................. 386 7.1.3 KOVARIANZ UND KONTRAVARIANZ .................................................................... 387 7.2 C# 5.0- VISUAL STUDIO 2012 ................................................................................... 388 7.2.1 ASYNC UND AWAIT ......................................................................................... 388 7.2.2 CALLERLNFO ..................................................................................................... 389 7.3 VISUAL STUDIO 2013 ................................................................................................... 390 7.4 C# 6.0 - VISUAL STUDIO 2015 .................................................................................... 390 7.4.1 STRING INTERPOLATION ..................................................................................... 390 7.4.2 SCHREIBGESCHUETZTE AUTOPROPERTIES .............................................................. 390 7.4.3 INITIALISIERER FUER AUTOPROPERTIES ................................................................ 391 7.4.4 EXPRESSION BODY FUNKTIONSMEMBER .......................................................... 391 7.4.5 USING STATIC ................................................................................................... 392 7.4.6 BEDINGTER NULLOPERATOR ................................................................................ 392 7.4.7 AUSNAHMENFILTER ......................................................................................... 393 7.4.8 NAMEOF-AUSDRUECKE ....................................................................................... 393 7.4.9 AWAIT IN CATCH UND FINALLY ............................................................................ 394 7.4.10 INDEXINITIALISIERER ....................................................................................... 394 7.5 C# 7.0 -VISUAL STUDIO 2017 ................................................................................... 394 7.5.1 OUT-VARIABLEN ............................................................................................... 394 7.5.2 TUPEL ............................................................................................................. 395 7.5.3 MUSTERVERGLEICH ........................................................................................... 396 7.5.4 DISCARDS ....................................................................................................... 398 7.5.5 LOKALE REF-VARIABLEN UND RUECKGABETYPEN ................................................... 398 7.5.6 LOKALE FUNKTIONEN ...................................................................................... 398 7.5.7 MEHR EXPRESSION-BODIED MEMBER .............................................................. 399 7.5.8 THROW-AUSDRUECKE .......................................................................................... 399 7.5.9 VERBESSERUNG DER NUMERISCHEN LITERALEN SYNTAX ..................................... 399 7.6 C# 7.1 BIS 7.3 -VISUAL STUDIO 2019 ....................................................................... 400 7.6.1 C# 7.1 ........................................................................................................... 400 7.6.2 C# 7.2 ........................................................................................................... 401 7.6.3 C# 7.3 ........................................................................................................... 402 7.6.4 VISUAL STUDIO 2019 - LIVE SHARE ................................................................ 403 TEIL II: WPF-ANWENDUNGEN .......................................................................... 407 8 EINFUEHRUNG IN WPF ................................................................................. 409 8.1 EINFUEHRUNG ............................................................................................................... 409 8.1.1 WAS KANN EINE WPF-ANWENDUNG? .............................................................. 410 8.1.2 DIE EXTENSIBLE APPLICATION MARKUP LANGUAGE ........................................... 411 8.1.3 VERBINDEN VON XAML UND C#-CODE .......................................................... 416 8.1.4 ZIELPLATTFORMEN ............................................................................................ 421 8.1.5 APPLIKATIONSTYPEN ........................................................................................ 422 8.1.6 VOR- UND NACHTEILE VON WPF-ANWENDUNGEN ............................................... 423 8.1.7 WEITERE DATEIEN IM UEBERBLICK .................................................................... 424 8.2 ALLES BEGINNT MIT DEM LAYOUT .................................................................................. 426 8.2.1 ALLGEMEINES ZUM LAYOUT ............................................................................ 426 8.2.2 POSITIONIEREN VON STEUERELEMENTEN ............................................................ 428 8.2.3 CANVAS ......................................................................................................... 432 8.2.4 STACKPANEL ................................................................................................... 433 8.2.5 DOCKPANEL ................................................................................................... 435 8.2.6 WRAPPANEL ................................................................................................... 437 8.2.7 UNIFORMGRID ................................................................................................. 438 8.2.8 GRID ............................................................................................................... 439 8.2.9 VIEWBOX ....................................................................................................... 444 8.2.10 TEXTBLOCK ..................................................................................................... 446 8.3 DAS WPF-PROGRAMM ................................................................................................. 449 8.3.1 DIE APP-KLASSE ............................................................................................ 450 8.3.2 DAS STARTOBJEKT FESTLEGEN ............................................................................ 450 8.3.3 KOMMANDOZEILENPARAMETER VERARBEITEN ..................................................... 452 8.3.4 DIE ANWENDUNG BEENDEN ............................................................................ 453 8.3.5 AUSWERTEN VON ANWENDUNGSEREIGNISSEN ................................................... 453 8.4 DIE WINDOW-KLASSE ................................................................................................. 454 8.4.1 POSITION UND GROESSE FESTLEGEN ...................................................................... 454 8.4.2 RAHMEN UND BESCHRIFTUNG .......................................................................... 455 8.4.3 DAS FENSTER-ICON AENDERN .............................................................................. 456 8.4.4 ANZEIGE WEITERER FENSTER ............................................................................ 456 8.4.5 TRANSPARENZ ................................................................................................. 456 8.4.6 ABSTAND ZUM INHALT FESTLEGEN .................................................................... 457 8.4.7 FENSTER OHNE FOKUS ANZEIGEN ...................................................................... 458 8.4.8 EREIGNISFOLGE BEI FENSTERN .......................................................................... 458 8.4.9 EIN PAAR WORTE ZUR SCHRIFTDARSTELLUNG ....................................................... 459 8.4.10 EIN PAAR WORTE ZUR DARSTELLUNG VON CONTROLS ............................................. 462 8.4.11 WIRD MEIN FENSTER KOMPLETT MIT WPF GERENDERT? ..................................... 463 9 UEBERSICHT WPF-CONTROLS ........................................................................ 465 9.1 ALLGEMEINGUELTIGE EIGENSCHAFTEN .............................................................................. 465 9.2 LABEL ......................................................................................................................... 467 9.3 BUTTON, REPEATBUTTON, TOGGLEBUTTON ........................................................................ 468 9.3.1 SCHALTFLAECHEN FUER MODALE DIALOGE .............................................................. 468 9.3.2 SCHALTFLAECHEN MIT GRAFIK .............................................................................. 470 9.4 TEXTBOX, PASSWORDBOX ............................................................................................. 471 9.4.1 TEXTBOX ......................................................................................................... 471 9.4.2 PASSWORDBOX ............................................................................................... 473 9.5 CHECKBOX ................................................................................................................... 474 9.6 RADIOBUTTON ............................................................................................................. 476 9.7 LISTBOX, COMBOBOX ................................................................................................... 477 9.7.1 LISTBOX ......................................................................................................... 477 9.7.2 COMBOBOX ................................................................................................... 480 9.7.3 DEN CONTENT FORMATIEREN ............................................................................ 482 9.8 IMAGE ........................................................................................................................ 484 9.8.1 GRAFIK PER XAML ZUWEISEN ........................................................................ 484 9.8.2 GRAFIK ZUR LAUFZEIT ZUWEISEN ...................................................................... 484 9.8.3 BILD AUS DATEI LADEN ................................................................................... 486 9.8.4 DIE GRAFIKSKALIERUNG BEEINFLUSSEN ............................................................ 487 9.9 MEDIAELEMENT ........................................................................................................... 488 9.10 SLIDER, SCROLLBAR ....................................................................................................... 490 9.10.1 SLIDER ........................................................................................................... 490 9.10.2 SCROLLBAR ....................................................................................................... 492 9.11 SCROLLVIEWER ............................................................................................................. 492 9.12 MENU, CONTEXTMENU ................................................................................................. 493 9.12.1 MENU ............................................................................................................. 494 9.12.2 TASTENKUERZEL ............................................................................................... 495 9.12.3 GRAFIKEN ....................................................................................................... 496 9.12.4 WEITERE MOEGLICHKEITEN ................................................................................ 498 9.12.5 CONTEXTMENU ............................................................................................... 498 9.13 TOOLBAR ...................................................................................................................... 499 9.14 STATUSBAR, PROGRESSBAR ........................................................................................... 502 9.14.1 STATUSBAR ..................................................................................................... 502 9.14.2 PROGRESSBAR ................................................................................................. 504 9.15 BORDER, GROUPBOX, BULLETDECORATOR .......................................................................... 505 9.15.1 BORDER ........................................................................................................... 505 9.15.2 GROUPBOX ..................................................................................................... 506 9.15.3 BULLETDECORATOR ............................................................................................ 507 9.16 RICHTEXTBOX ............................................................................................................... 509 9.16.1 VERWENDUNG UND ANZEIGE VON VORDEFINIERTEM TEXT ................................... 510 9.16.2 NEUES DOKUMENT ZUR LAUFZEIT ERZEUGEN ..................................................... 511 9.16.3 SICHERN VON DOKUMENTEN ............................................................................ 512 9.16.4 LADEN VON DOKUMENTEN .............................................................................. 513 9.16.5 TEXTE PER CODE EINFUEGEN/MODIFIZIEREN ........................................................ 514 9.16.6 TEXTE FORMATIEREN ........................................................................................ 515 9.16.7 EDITINGCOMMANDS ........................................................................................ 517 9.16.8 GRAFIKEN/OBJEKTE EINFUEGEN .......................................................................... 518 9.16.9 RECHTSCHREIBKONTROLLE .................................................................................. 519 9.17 FLOWDOCUMENTPAGEVIEWER & CO ............................................................................... 520 9.17.1 FLOWDOCUMENTPAGEVIEWER .......................................................................... 520 9.17.2 FLOWDOCUMENTREADER .................................................................................. 520 9.17.3 FLOWDOCUMENTSCROLLVIEWER ........................................................................ 521 9.18 FLOWDOCUMENT ........................................................................................................... 521 9.18.1 FLOWDOCUMENT PER XAML BESCHREIBEN ....................................................... 522 9.18.2 FLOWDOCUMENT PER CODE ERSTELLEN .............................................................. 524 9.19 EXPANDER, TABCONTROL ............................................................................................... 526 9.19.1 EXPANDER ....................................................................................................... 526 9.19.2 TABCONTROL ..................................................................................................... 527 9.20 POPUP ......................................................................................................................... 529 9.21 TREEVIEW ................................................................................................................... 531 9.22 LISTVIEW ..................................................................................................................... 535 9.23 DATAGRID ................................................................................................................... 535 9.24 CALENDAR/DATEPICKER ................................................................................................. 536 9.25 ELLIPSE, RECTANGLE, LINE UND CO ................................................................................. 540 9.25.1 ELLIPSE ........................................................................................................... 541 9.25.2 RECTANGLE ....................................................................................................... 541 9.25.3 LINE ............................................................................................................... 542 10 WICHTIGE WPF-TECHNIKEN ...................................................................... 543 10.1 EIGENSCHAFTEN ......................................................................................................... 543 10.1.1 ABHAENGIGE EIGENSCHAFTEN (DEPENDENCY PROPERTIES) ............................. 543 10.1.2 ANGEHAENGTE EIGENSCHAFTEN (ATTACHED PROPERTIES) ................................. 545 10.2 EINSATZ VON RESSOURCEN .......................................................................................... 545 10.2.1 WAS SIND EIGENTLICH RESSOURCEN? ............................................................ 545 10.2.2 WO KOENNEN RESSOURCEN GESPEICHERT WERDEN? ......................................... 546 10.2.3 WIE DEFINIERE ICH EINE RESSOURCE? .......................................................... 547 10.2.4 STATISCHE UND DYNAMISCHE RESSOURCEN ................................................... 548 10.2.5 WIE WERDEN RESSOURCEN ADRESSIERT? ....................................................... 550 10.2.6 SYSTEMRESSOURCENEINBINDEN .................................................................. 550 10.3 DAS WPF-EREIGNISMODELL ........................................................................................ 551 10.3.1 EINFUEHRUNG ............................................................................................... 551 10.3.2 ROUTED EVENTS ......................................................................................... 552 10.3.3 DIREKTE EVENTS ......................................................................................... 554 10.4 VERWENDUNG VON COMMANDS ................................................................................ 554 10.4.1 EINFUEHRUNG ZU COMMANDS ...................................................................... 555 10.4.2 VERWENDUNG VORDEFINIERTER COMMANDS ................................................. 555 10.4.3 DAS ZIEL DES COMMANDS .......................................................................... 557 10.4.4 VORDEFINIERTE COMMANDS ........................................................................ 558 10.4.5 COMMANDS AN EREIGNISMETHODEN BINDEN ............................................... 558 10.4.6 WIE KANN ICH EIN COMMAND PER CODE AUSLOESEN? ................................... 560 10.4.7 COMMAND-AUSFUEHRUNG VERHINDERN ........................................................ 561 10.5 DAS WPF-STYLE-SYSTEM ........................................................................................... 561 10.5.1 UEBERSICHT ................................................................................................. 561 10.5.2 BENANNTE STYLES ....................................................................................... 562 10.5.3 TYP-STYLES ................................................................................................. 564 10.5.4 STYLES ANPASSEN UND VERERBEN ................................................................ 565 10.6 VERWENDEN VON TRIGGERN ....................................................................................... 568 10.6.1 EIGENSCHAFTEN-TRIGGER (PROPERTY TRIGGERS) ............................................. 568 10.6.2 EREIGNIS-TRIGGER ....................................................................................... 570 10.6.3 DATEN-TRIGGER ........................................................................................... 571 10.7 EINSATZ VON TEMPLATES ........................................................................................... 572 10.7.1 NEUES TEMPLATE ERSTELLEN ........................................................................ 572 10.7.2 TEMPLATE ABRUFEN UND VERAENDERN .......................................................... 576 10.8 TRANSFORMATIONEN, ANIMATIONEN, STORYBOARDS .................................................... 579 10.8.1 TRANSFORMATIONEN ................................................................................... 579 10.8.2 ANIMATIONEN MIT DEM STORYBOARD REALISIEREN ....................................... 584 11 WPF-DATENBINDUNG ............................................................................. 589 11.1 GRUNDPRINZIP ......................................................................................................... 589 11.1.1 BINDUNGSARTEN ......................................................................................... 590 11.1.2 WANN EIGENTLICH WIRD DIE QUELLE AKTUALISIERT? ....................................... 592 11.1.3 GEHT ES AUCH ETWAS LANGSAMER? .............................................................. 593 11.1.4 BINDUNG ZUR LAUFZEIT REALISIEREN ............................................................ 594 11.2 BINDEN AN OBJEKTE ................................................................................................. 595 11.2.1 OBJEKTE IM XAML-CODE INSTANZIIEREN .................................................. 596 11.2.2 VERWENDEN DER INSTANZ IM C#-QUELLCODE ............................................... 597 11.2.3 ANFORDERUNGEN AN DIE QUELL-KLASSE ...................................................... 598 11.2.4 INSTANZIIEREN VON OBJEKTEN PER CH-CODE ............................................... 599 11.3 BINDEN VON COLLECTIONS ......................................................................................... 601 11.3.1 ANFORDERUNG AN DIE COLLECTION ................................................................ 601 11.3.2 EINFACHE ANZEIGE ..................................................................................... 602 11.3.3 NAVIGIEREN ZWISCHEN DEN OBJEKTEN ......................................................... 603 11.3.4 EINFACHE ANZEIGE IN EINER LISTBOX ........................................................... 605 11.3.5 DATATEMPLATES ZUR ANZEIGEFORMATIERUNG ............................................... 606 11.3.6 MEHR ZU LIST- UND COMBOBOX .................................................................. 607 11.3.7 VERWENDUNG DER LISTVIEW ...................................................................... 609 11.4 NOCH EINMAL ZURUECK ZU DEN DETAILS ...................................................................... 612 11.4.1 NAVIGIEREN IN DEN DATEN .......................................................................... 612 11.4.2 SORTIEREN .................................................................................................. 614 11.4.3 FILTERN ........................................................................................................ 614 11.4.4 LIVE SHAPING ............................................................................................ 615 11.5 ANZEIGE VON DATENBANKINHALTEN ............................................................................ 617 11.5.1 DATENMODELL PER EF-DESIGNER ERZEUGEN ................................................. 617 11.5.2 DIE PROGRAMMOBERFLAECHE ........................................................................ 621 11.5.3 DER ZUGRIFF AUF DIE DATEN ........................................................................ 622 11.6 FORMATIEREN VON WERTEN ........................................................................................ 624 11.6.1 IVALUECONVERTER ........................................................................................ 625 11.6.2 BINDINGBASE.STRINGFORMAT-EIGENSCHAFT ................................................. 627 11.7 DAS DATAGRID ALS UNIVERSALWERKZEUG .................................................................... 627 11.7.1 GRUNDLAGEN DER ANZEIGE .......................................................................... 627 11.7.2 UL-VIRTUALISIERUNG .................................................................................... 629 11.7.3 SPALTEN SELBST DEFINIEREN ......................................................................... 629 11.7.4 ZUSATZINFORMATIONEN IN DEN ZEILEN ANZEIGEN ........................................... 631 11.7.5 VOM BETRACHTEN ZUM EDITIEREN ............................................................... 632 11.8 PRAXISBEISPIEL - COLLECTIONS IN HINTERGRUNDTHREADS FUELLEN ................................. 633 TEIL III: TECHNOLOGIEN ..................................................................................... 637 12 ZUGRIFF AUF DAS DATEISYSTEM ................................................................ 639 12.1 GRUNDLAGEN ............................................................................................................... 639 12.1.1 KLASSEN FUER DEN ZUGRIFF AUF DAS DATEISYSTEM ......................................... 640 12.1.2 STATISCHE VERSUS INSTANZEN-KLASSE ......................................................... 640 12.2 UEBERSICHTEN ........................................................................................................... 641 12.2.1 METHODEN DER DIRECTORY-KLASSE ............................................................... 642 12.2.2 METHODEN EINES DIRECTORYINFO-OBJEKTS ................................................... 642 12.2.3 EIGENSCHAFTEN EINES DIRECTORYINFO-OBJEKTS ........................................... 642 12.2.4 METHODEN DER FILE-KLASSE ......................................................................... 643 12.2.5 METHODEN EINES FILEINFO-OBJEKTS ............................................................. 644 12.2.6 EIGENSCHAFTEN EINES FILEINFO-OBJEKTS ..................................................... 644 12.3 OPERATIONEN AUF VERZEICHNISEBENE ........................................................................ 645 12.3.1 EXISTENZ EINES VERZEICHNISSES/EINER DATEI FESTSTELLEN ......................... 645 12.3.2 VERZEICHNISSE ERZEUGEN UND LOESCHEN ..................................................... 646 12.3.3 VERZEICHNISSE VERSCHIEBEN UND UMBENENNEN ....................................... 646 12.3.4 AKTUELLES VERZEICHNIS BESTIMMEN .......................................................... 647 12.3.5 UNTERVERZEICHNISSE ERMITTELN ................................................................ 647 12.3.6 ALLE LAUFWERKE ERMITTELN ........................................................................ 648 12.3.7 DATEIEN KOPIEREN UND VERSCHIEBEN ........................................................ 649 12.3.8 DATEIEN UMBENENNEN .............................................................................. 649 12.3.9 DATEIATTRIBUTE FESTSTELLEN ........................................................................ 650 12.3.10 VERZEICHNIS EINER DATEI ERMITTELN .......................................................... 651 12.3.11 ALLE IM VERZEICHNIS ENTHALTENEN DATEIEN ERMITTELN ............................. 652 12.3.12 DATEIEN UND UNTERVERZEICHNISSE ERMITTELN ........................................... 652 12.4 WEITERE WICHTIGE KLASSEN .................................................................................... 653 12.4.1 DIE PATH-KLASSE ....................................................................................... 653 12.4.2 DIE KLASSE FILESYSTEMWATCHER ................................................................ 654 12.4.3 DIE KLASSE ZIPARCHIVE ............................................................................ 656 12.5 DATEI-UND VERZEICHNISDIALOGE .................................... 657 12.5.1 OPENFILEDIALOG ....................................................................................... 658 12.5.2 SAVEFILEDIALOG ......................................................................................... 660 12.6 PRAXISBEISPIELE ....................................................................................................... 661 12.6.1 INFOS UEBER VERZEICHNISSE UND DATEIEN GEWINNEN ................................... 661 12.6.2 EINE VERZEICHNISSTRUKTUR IN DIE TREEVIEW EINLESEN ............................. 666 13 DATEIEN LESEN UND SCHREIBEN ............................................................. 671 13.1 GRUNDPRINZIP DER DATENPERSISTENZ ........................................................................ 671 13.1.1 DATEIEN UND STREAMS ............................................................................... 671 13.1.2 DIE WICHTIGSTEN KLASSEN .......................................................................... 672 13.1.3 ERZEUGEN EINES STREAMS .. . ..................................................................... 673 13.2 DATEIPARAMETER ....................................................................................................... 673 13.2.1 FILEACCESS ............................................................................................... 673 13.2.2 FILEMODE ................................................................................................... 674 13.2.3 FILESHARE ................................................................................................. 674 13.3 TEXTDATEIEN ............................................................................................................. 675 13.3.1 EINE TEXTDATEI BESCHREIBEN BZW. NEU ANLEGEN ....................................... 675 13.3.2 EINE TEXTDATEI LESEN ............................................................................... 676 13.4 BINAERDATEIEN ........................................................................................................... 678 13.4.1 LESE-/SCHREIBZUGRIFF ............................................................................... 678 13.4.2 DIE METHODEN READALLBYTES UND WRITEALLBYTES ................................... 679 13.4.3 ERZEUGEN VON BINARYREADER/BINARYWRITER ........................................... 679 13.5 SEQUENZIELLE DATEIEN ............................................................................................. 680 13.5.1 LESEN UND SCHREIBEN VON STRUKTURIERTEN DATEN ..................................... 680 13.5.2 SERIALISIEREN VON OBJEKTEN ...................................................................... 681 13.6 DATEIEN VERSCHLUESSELN ........................................................................................... 682 13.6.1 DAS METHODENPAERCHEN ENCRYPT/DECRYPT ............................................... 683 13.6.2 VERSCHLUESSELN MIT DER CRYPTOSTREAM-KLASSE ......................................... 683 13.7 PRAXISBEISPIELE ....................................................................................................... 684 13.7.1 AUF EINE TEXTDATEI ZUGREIFEN .................................................................. 684 13.7.2 EINEN OBJEKTBAUM PERSISTENT SPEICHERN ............................................... 688 13.7.3 EINE DATEI VERSCHLUESSELN ........................................................................ 693 13.7.4 PDFS ERSTELLEN/EXPORTIEREN .................................................................... 698 13.7.5 EINE CSV-DATEI ERSTELLEN .......................................................................... 702 13.7.6 EINE CSV-DATEI MIT LIND LESEN UND AUSWERTEN ..................................... 703 13.7.7 EINEN KORREKTEN DATEINAMEN ERZEUGEN ................................................. 706 14 ASYNCHRONE PROGRAMMIERUNG ........................................................... 707 14.1 UEBERSICHT ................................................................................................................. 708 14.1.1 MULTITASKING VERSUS MULTITHREADING ....................................................... 708 14.1.2 DEADLOCKS .................................................................................................. 709 14.1.3 PACING ....................................................................................................... 710 14.2 PROGRAMMIEREN MIT THREADS .................................................................................. 711 14.2.1 EINFUEHRUNGSBEISPIEL ................................................................................ 711 14.2.2 WICHTIGE THREAD-METHODEN .................................................................... 713 14.2.3 WICHTIGE THREAD-EIGENSCHAFTEN .............................................................. 715 14.2.4 EINSATZ DER THREADPOOL-KLASSE ............................................................... 716 14.3 SPERRMECHANISMEN ................................................................................................ 717 14.3.1 THREADING OHNE LOCK ................................................................................ 718 14.3.2 THREADING MIT LOCK .................................................................................. 719 14.3.3 DIE MONITOR-KLASSE .................................................................................. 722 14.3.4 MUTEX ....................................................................................................... 726 14.3.5 METHODEN FUER DIE PARALLELE AUSFUEHRUNG SPERREN ................................... 727 14.3.6 SEMAPHORE ................................................................................................ 728 14.4 INTERAKTION MIT DER PROGRAMMOBERFLAECHE ............................................................. 730 14.4.1 DIE WERKZEUGE .......................................................................................... 731 14.4.2 EINZELNE STEUERELEMENTE MIT INVOKE AKTUALISIEREN ............................... 731 14.4.3 MEHRERE STEUERELEMENTE AKTUALISIEREN ................................................... 732 14.4.4 IST EIN INVOKE-AUFRUF NOETIG? .................................................................... 733 14.4.5 UND WAS IST MIT WPF? .............................................................................. 733 14.5 TIMER-THREADS ....................................................................................................... 735 14.6 ASYNCHRONE PROGRAMMIERENTWURFSMUSTER .......................................................... 736 14.6.1 KURZUEBERSICHT .......................................................................................... 736 14.6.2 POLLING ..................................................................................................... 738 14.6.3 CALLBACK VERWENDEN ................................................................................ 739 14.6.4 CALLBACK MIT PARAMETERUEBERGABE VERWENDEN ....................................... 740 14.6.5 CALLBACK MIT ZUGRIFF AUF DIE PROGRAMMOBERFLAECHE ............................... 741 14.7 ASYNCHRONER AUFRUF BELIEBIGER METHODEN ............................................................ 743 14.7.1 DIE BEISPIELKLASSE .................................................................................... 743 14.7.2 ASYNCHRONER AUFRUF OHNE CALLBACK ......................................................... 744 14.7.3 ASYNCHRONER AUFRUF MIT CALLBACK UND ANZEIGEFUNKTION ..................... 745 14.7.4 AUFRUF MIT RUECKGABEWERTEN (PER EIGENSCHAFT) ....................................... 746 14.7.5 AUFRUF MIT RUECKGABEWERTEN (PER ENDLNVOKE) ....................................... 747 14.8 ES GEHT AUCH EINFACHER - ASYNC UND AWAIT ............................................................ 748 14.8.1 DER WEG VON SYNCHRON ZU ASYNCHRON ..................................................... 748 14.8.2 ACHTUNG: FEHLERQUELLEN! .......................................................................... 751 14.8.3 EIGENE ASYNCHRONE METHODEN ENTWICKELN ............................................. 753 14.9 PRAXISBEISPIELE ...................................................................................................... 755 14.9.1 PROZESS- UND THREAD-INFORMATIONEN GEWINNEN ..................................... 755 14.9.2 EIN EXTERNES PROGRAMM STARTEN .............................................................. 758 15 DIE TASK PARALLEL LIBRARY ..................................................................... 761 15.1 UEBERBLICK ............................................................................................................... 761 15.1.1 PARALLEL-PROGRAMMIERUNG ........................................................................ 761 15.1.2 MOEGLICHKEITEN DER TPL ............................................................................ 764 15.1.3 DER CLR-THREADPOOL ................................................................................ 764 15.2 PARALLELE VERARBEITUNG MIT PARALLEL.INVOKE .......................................................... 765 15.2.1 AUFRUFVARIANTEN ....................................................................................... 766 15.2.2 EINSCHRAENKUNGEN ................................................................................... 767 15.3 VERWENDUNG VON PARALLEL.FOR ................................................................................ 767 15.3.1 ABBRECHEN DER VERARBEITUNG .................................................................. 769 15.3.2 AUSWERTEN DES VERARBEITUNGSSTATUS ...................................................... 770 15.3.3 UND WAS IST MIT ANDEREN ITERATOR-SCHRITTWEITEN? ................................... 771 15.4 COLLECTIONS MIT PARALLEL.FOREACH VERARBEITEN ...................................................... 772 15.5 DIE TASK-KLASSE ....................................................................................................... 773 15.5.1 EINEN TASK ERZEUGEN ............................................................................... 773 15.5.2 DEN TASK STARTEN ..................................................................................... 774 15.5.3 DATENUEBERGABE AN DEN TASK ............................................................. 775 15.5.4 WIE WARTE ICH AUF DAS ENDE DES TASKS? ................................................ 777 15.5.5 TASKS MIT RUECKGABEWERTEN .................................................................... 778 15.5.6 DIE VERARBEITUNG ABBRECHEN .................................................................. 781 15.5.7 FEHLERBEHANDLUNG ................................................................................... 785 15.5.8 WEITERE EIGENSCHAFTEN ............................................................................ 786 15.6 ZUGRIFF AUF DAS USER INTERFACE ............................................................................... 788 15.6.1 TASK-ENDE UND ZUGRIFF AUF DIE OBERFLAECHE ............................................. 788 15.6.2 ZUGRIFF AUF DAS UI AUS DEM TASK HERAUS ................................................ 789 15.7 WEITERE DATENSTRUKTUREN IM UEBERBLICK ................................................................ 791 15.7.1 THREADSICHERE COLLECTIONS ...................................................................... 791 15.7.2 PRIMITIVE FUER DIE THREADSYNCHRONISATION .............................................. 792 15.8 PARALLEL LINO (PLINQ) ........................................................................................... 792 15.9 PRAXISBEISPIELE ....................................................................................................... 792 15.9.1 BLOCKINGCOLLECTION ................................................................................. 792 15.9.2 PLINQ ....................................................................................................... 796 16 DEBUGGING, FEHLERSUCHE UND FEHLERBEHANDLUNG ............................ 797 16.1 DER DEBUGGER ........................................................................................................ 797 16.1.1 ALLGEMEINE BESCHREIBUNG ...................................................................... 797 16.1.2 DIE WICHTIGSTEN FENSTER .......................................................................... 798 16.1.3 DEBUGGING-OPTIONEN ................................................................................ 802 16.1.4 PRAKTISCHES DEBUGGING AM BEISPIEL ....................................................... 804 16.2 ARBEITEN MIT DEBUG UND TRACE .............................................................................. 808 16.2.1 WICHTIGE METHODEN VON DEBUG UND TRACE ............................................. 808 16.2.2 BESONDERHEITEN DER TRACE-KLASSE ........................................................... 812 16.2.3 TRACELISTENER-OBJEKTE .............................................................................. 813 16.3 CALLER INFORMATION .................................................................................................. 816 16.3.1 ATTRIBUTE .................................................................................................... 816 16.3.2 ANWENDUNG .............................................................................................. 816 16.4 FEHLERBEHANDLUNG .................................................................................................. 817 16.4.1 ANWEISUNGEN ZUR FEHLERBEHANDLUNG ..................................................... 817 16.4.2 TRY-CATCH .................................................................................................... 818 16.4.3 TRY-FINALLY .................................................................................................. 822 16.4.4 DAS STANDARDVERHALTEN BEI AUSNAHMEN FESTLEGEN ................................. 825 16.4.5 DIE EXCEPTION-KLASSE ................................................................................ 826 16.4.6 FEHLER/AUSNAHMEN AUSLOESEN .................................................................. 827 16.4.7 EIGENE FEHLERKLASSEN .............................................................................. 827 16.4.8 EXCEPTIONHANDLING ZUR DEBUGZEIT ........................................................... 829 16.4.9 CODE CONTRACTS ........................................................................................ 829 17 JSON UND XML IN THEORIE UND PRAXIS ............................................... 831 17.1 JSON - JAVASCRIPTOBJECTNOTATION .......................................................................... 831 17.1.1 GRUNDLAGEN .............................................................................................. 831 17.1.2 DE-/SERIALISIERUNG MIT JSON .................................................................. 832 17.2 XML - ETWAS THEORIE .............................................................................................. 835 17.2.1 UEBERSICHT ................................................................................................. 836 17.2.2 DER XML-GRUNDAUFBAU ............................................................................ 837 17.2.3 WOHLGEFORMTE DOKUMENTE ...................................................................... 838 17.2.4 PROCESSING INSTRUCTIONS (PI) .................................................................... 840 17.2.5 ELEMENTE UND ATTRIBUTE .......................................................................... 841 17.3 XSD-SCHEMAS ......................................................................................................... 842 17.3.1 XML-SCHEMAS IN VISUAL STUDIO ANALYSIEREN ........................................... 843 17.3.2 XML-DATEI MIT XSD-SCHEMA ERZEUGEN ................................................... 846 17.3.3 XSD-SCHEMA AUS EINER XML-DATEI ERZEUGEN ......................................... 847 17.4 VERWENDUNG DES DOM UNTER .NET ........................................................................ 848 17.4.1 UEBERSICHT ................................................................................................. 848 17.4.2 DOM-INTEGRATION IN C# ............................................................................ 849 17.4.3 LADEN VON DOKUMENTEN .......................................................................... 850 17.4.4 ERZEUGEN VON XML-DOKUMENTEN ............................................................ 851 17.4.5 AUSLESEN VON XML-DATEIEN .................................................................... 853 17.4.6 DIREKTZUGRIFF AUF EINZELNE ELEMENTE ....................................................... 854 17.4.7 EINFUEGEN VON INFORMATIONEN .................................................................. 855 17.4.8 SUCHEN IN DEN BAUMZWEIGEN .................................................................. 858 17.5 XML-VERARBEITUNG MIT LINQ TO XML .................................................................... 861 17.5.1 DIE LINQ TO XML-API .............................................................................. 861 17.5.2 NEUE XML-DOKUMENTE ERZEUGEN ............................................................ 863 17.5.3 LADEN UND SICHERN VON XML-DOKUMENTEN ........................................... 864 17.5.4 NAVIGIEREN IN XML-DATEN ........................................................................ 866 17.5.5 AUSWAEHLEN UND FILTERN ............................................................................ 868 17.5.6 MANIPULIEREN DER XML-DATEN ................................................................ 869 17.5.7 XML-DOKUMENTE TRANSFORMIEREN .......................................................... 870 17.6 WEITERE MOEGLICHKEITEN DER XML-VERARBEITUNG ..................................................... 874 17.6.1 SCHNELLES SUCHEN IN XML-DATEN MIT XPATHNAVIGATOR ........................... 874 17.6.2 SCHNELLES AUSLESEN VON XML-DATEN MIT XMLREADER ............................. 876 17.6.3 ERZEUGEN VON XML-DATEN MIT XMLWRITER ............................................... 878 17.6.4 XML TRANSFORMIEREN MIT XSLT ................................................................ 880 17.7 PRAXISBEISPIELE ....................................................................................................... 882 17.7.1 MIT DEM DOM IN XML-DOKUMENTEN NAVIGIEREN ................................... 882 17.7.2 XML-DATEN IN EINE TREEVIEW EINLESEN ................................................... 887 17.7.3 IN DOKUMENTEN MIT DEM XPATHNAVIGATOR NAVIGIEREN ........................... 891 18 EINFUEHRUNG IN ADO.NET UND ENTITY FRAMEWORK .............................. 899 18.1 EINE KLEINE UEBERSICHT ........................................................................................... 899 18.1.1 DIE ADO.NET-KLASSENHIERARCHIE ............................................................ 899 18.1.2 DIE KLASSEN DER DATENPROVIDER .............................................................. 900 18.1.3 DAS ZUSAMMENSPIEL DER ADO.NET-KLASSEN........................................... 903 18.2 DAS CONNECTION-OBJEKT ......................................................................................... 904 18.2.1 ALLGEMEINER AUFBAU ................................................................................ 904 18.2.2 SQLCONNECTION ......................................................................................... 904 18.2.3 SCHLIESSEN EINER VERBINDUNG ..................................................................... 905 18.2.4 EIGENSCHAFTEN DES CONNECTION-OBJEKTS .................................................. 906 18.2.5 METHODEN DES CONNECTION-OBJEKTS ........................................................ 908 18.2.6 DER CONNECTIONSTRINGBUILDER ................................................................... 909 18.2.7 CONNECTIONSTRING IN DER KONFIGURATIONSDATEI ....................................... 910 18.3 DAS COMMAND-OBJEKT ........................................................................................... 911 18.3.1 ERZEUGEN UND ANWENDEN EINES COMMAND-OBJEKTS ............................... 911 18.3.2 ERZEUGEN MITTELS CREATECOMMAND-METHODE ......................................... 912 18.3.3 EIGENSCHAFTEN DES COMMAND-OBJEKTS .................................................... 912 18.3.4 METHODEN DES COMMAND-OBJEKTS .......................................................... 915 18.3.5 FREIGABE VON CONNECTION-UND COMMAND-OBJEKTEN ............................. 917 18.4 PARAMETER-OBJEKTE ................................................................................................. 919 18.4.1 ERZEUGEN UND ANWENDEN EINES PARAMETER-OBJEKTS ............................... 919 18.4.2 EIGENSCHAFTEN DES PARAMETER-OBJEKTS .................................................... 920 18.5 DAS COMMANDBUILDER-OBJEKT ................................................................................ 921 18.5.1 ERZEUGEN ................................................................................................. 921 18.5.2 ANWENDEN ............................................................................................... 922 18.6 DAS DATAREADER-OBJEKT .......................................................................................... 922 18.6.1 DATAREADER ERZEUGEN .............................................................................. 923 18.6.2 DATEN LESEN .............................................................................................. 923 18.6.3 EIGENSCHAFTEN DES DATAREADERS .............................................................. 924 18.6.4 METHODEN DES DATAREADERS .................................................................... 925 18.7 DAS DATAADAPTER-OBJEKT ........................................................................................ 925 18.7.1 DATAADAPTER ERZEUGEN ............................................................................ 926 18.7.2 COMMAND-EIGENSCHAFTEN ........................................................................ 927 18.7.3 FILL-METHODE .............................................................................................. 928 18.7.4 UPDATE-METHODE ...................................................................................... 929 18.7.5 DATASET ..................................................................................................... 930 18.8 ENTITY FRAMEWORK .................................................................................................... 933 18.8.1 UEBERBLICK .................................................................................................. 933 18.8.2 CODEFIRST .................................................................................................. 934 18.8.3 CODEFIRST AUS DATENBANK ........................................................................ 940 18.9 PRAXISBEISPIELE ....................................................................................................... 948 18.9.1 WICHTIGE ADO.NET-OBJEKTE IM EINSATZ ................................................... 948 18.9.2 EINE AKTIONSABFRAGE AUSFUEHREN .............................................................. 951 18.9.3 EINE STOREDPROCEDURE AUFRUFEN ............................................................... 955 18.9.4 DATEN MIT ENTITY FRAMEWORK LADEN UND ALS JSON SPEICHERN ................ 958 19 WEITERE TECHNIKEN ............................................................................... 969 19.1 ZUGRIFF AUF DIE ZWISCHENABLAGE ............................................................................ 969 19.1.1 DAS CLIPBOARD-OBJEKT .............................................................................. 969 19.1.2 ZWISCHENABLAGE-FUNKTIONEN FUER TEXTBOXEN ........................................... 971 19.2 .NET-REFLECTION ....................................................................................................... 971 19.2.1 UEBERSICHT ................................................................................................. 972 19.2.2 ASSEMBLY LADEN ........................................................................................ 972 19.2.3 MITTELS GETTYPE UND TYPE INFORMATIONEN SAMMELN ............................. 973 19.2.4 DYNAMISCHES LADEN VON ASSEMBLIES ..................................................... 975 19.3 PRAXISBEISPIELE ....................................................................................................... 977 19.3.1 NUTZER UND GRUPPEN DES AKTUELLEN SYSTEMS ERMITTELN ......................... 977 19.3.2 TESTEN, OB NUTZER IN EINER GRUPPE ENTHALTEN IST ................................... 980 19.3.3 DIE IP-ADRESSEN DES COMPUTERS ERMITTELN ............................................. 981 19.3.4 DIVERSE SYSTEMINFORMATIONEN ERMITTELN ................................................. 983 ANHANG A: GLOSSAR ...................................................................................... 991 ANHANG B: WICHTIGE DATEIEXTENSIONS ....................................................... 995 INDEX ............................................................................................................... 997
any_adam_object	1
author	Kotz, Jürgen
author_GND	(DE-588)124099343
author_facet	Kotz, Jürgen
author_role	aut
author_sort	Kotz, Jürgen
author_variant	j k jk
building	Verbundindex
bvnumber	BV046156738
classification_rvk	ST 250
classification_tum	DAT 302f DAT 358f DAT 652f
ctrlnum	(OCoLC)1099685045 (DE-599)DNB1184416737
discipline	Informatik
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02421nam a2200565 c 4500</leader><controlfield tag="001">BV046156738</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20210205 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">190912s2019 gw a\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1184416737</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783446458024</subfield><subfield code="9">978-3-446-45802-4</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3446458026</subfield><subfield code="9">3-446-45802-6</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1099685045</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1184416737</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-BY</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-M347</subfield><subfield code="a">DE-1050</subfield><subfield code="a">DE-210</subfield><subfield code="a">DE-706</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-12</subfield><subfield code="a">DE-1046</subfield><subfield code="a">DE-83</subfield><subfield code="a">DE-860</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-M100</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-526</subfield><subfield code="a">DE-B768</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-11</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 302f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 358f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 652f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Kotz, Jürgen</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)124099343</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Visual C# 2019</subfield><subfield code="b">Grundlagen, Profiwissen und Rezepte</subfield><subfield code="c">Jürgen Kotz</subfield></datafield><datafield tag="246" ind1="1" ind2="3"><subfield code="a">Visual C sharp</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">München</subfield><subfield code="b">Hanser</subfield><subfield code="c">[2019]</subfield></datafield><datafield tag="264" ind1=" " ind2="4"><subfield code="c">© 2019</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XXV, 1010 Seiten</subfield><subfield code="b">Illustrationen, Diagramme</subfield><subfield code="c">25 cm</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auf dem Cover: "C#-Grundlagen, LINQ, OOP, ADO.NET, EF und WPF, über 150 Praxisbeispiele"</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Visual Studio 2019</subfield><subfield code="0">(DE-588)1193260337</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">C sharp</subfield><subfield code="0">(DE-588)4616843-6</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Visual C sharp 2019</subfield><subfield code="0">(DE-588)1196645582</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Visual C sharp.NET</subfield><subfield code="0">(DE-588)4682222-7</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Visual C sharp 2019</subfield><subfield code="0">(DE-588)1196645582</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">Visual Studio 2019</subfield><subfield code="0">(DE-588)1193260337</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2="1"><subfield code="a">C sharp</subfield><subfield code="0">(DE-588)4616843-6</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="2" ind2="0"><subfield code="a">Visual C sharp.NET</subfield><subfield code="0">(DE-588)4682222-7</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="2" ind2=" "><subfield code="8">2\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe</subfield><subfield code="z">978-3-446-46099-7</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe, EPUB</subfield><subfield code="z">978-3-446-46253-3</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">DNB Datenaustausch</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=031536737&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">2\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-031536737</subfield></datafield></record></collection>
id	DE-604.BV046156738
illustrated	Illustrated
indexdate	2024-12-20T18:44:39Z
institution	BVB
isbn	9783446458024 3446458026
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-031536737
oclc_num	1099685045
open_access_boolean
owner	DE-M347 DE-1050 DE-210 DE-706 DE-523 DE-12 DE-1046 DE-83 DE-860 DE-91G DE-BY-TUM DE-M100 DE-634 DE-526 DE-B768 DE-Aug4 DE-11
owner_facet	DE-M347 DE-1050 DE-210 DE-706 DE-523 DE-12 DE-1046 DE-83 DE-860 DE-91G DE-BY-TUM DE-M100 DE-634 DE-526 DE-B768 DE-Aug4 DE-11
physical	XXV, 1010 Seiten Illustrationen, Diagramme 25 cm
publishDate	2019
publishDateSearch	2019
publishDateSort	2019
publisher	Hanser
record_format	marc
spellingShingle	Kotz, Jürgen Visual C# 2019 Grundlagen, Profiwissen und Rezepte Visual Studio 2019 (DE-588)1193260337 gnd C sharp (DE-588)4616843-6 gnd Visual C sharp 2019 (DE-588)1196645582 gnd Visual C sharp.NET (DE-588)4682222-7 gnd
subject_GND	(DE-588)1193260337 (DE-588)4616843-6 (DE-588)1196645582 (DE-588)4682222-7
title	Visual C# 2019 Grundlagen, Profiwissen und Rezepte
title_alt	Visual C sharp
title_auth	Visual C# 2019 Grundlagen, Profiwissen und Rezepte
title_exact_search	Visual C# 2019 Grundlagen, Profiwissen und Rezepte
title_full	Visual C# 2019 Grundlagen, Profiwissen und Rezepte Jürgen Kotz
title_fullStr	Visual C# 2019 Grundlagen, Profiwissen und Rezepte Jürgen Kotz
title_full_unstemmed	Visual C# 2019 Grundlagen, Profiwissen und Rezepte Jürgen Kotz
title_short	Visual C# 2019
title_sort	visual c 2019 grundlagen profiwissen und rezepte
title_sub	Grundlagen, Profiwissen und Rezepte
topic	Visual Studio 2019 (DE-588)1193260337 gnd C sharp (DE-588)4616843-6 gnd Visual C sharp 2019 (DE-588)1196645582 gnd Visual C sharp.NET (DE-588)4682222-7 gnd
topic_facet	Visual Studio 2019 C sharp Visual C sharp 2019 Visual C sharp.NET
url	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=031536737&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT kotzjurgen visualc2019grundlagenprofiwissenundrezepte AT kotzjurgen visualcsharp

Verfügbarkeit

‌

Per Fernleihe bestellen Per Fernleihe bestellen Inhaltsverzeichnis