C# 5.0 Programmer's Reference

Recommendations

Info

592 ❘ CHAPTER 26 Reflection The EchoDll example, which is also available for download on this book’s website, creates a control library (DLL) that the InvokeEchoer program can load. (The EchoDll example must be compiled for the InvokeEchoer example to work properly.) It uses the following code to define the Echoer class. public class Echoer { // The objexct's message. public string Message = "Message not set"; } // Display the message in a MessageBox. public void ShowMessage(string caption) { MessageBox.Show(Message, caption); } This class has a public string field named Message and a public method named ShowMessage. The following code shows how the InvokeEchoer program loads and uses the EchoDll library. // Load the DLL, create an Echoer, and invoke the ShowMessage method. private void invokeButton_Click(object sender, EventArgs e) { // Load the DLL assembly. Assembly dll = Assembly.LoadFile(dllTextBox.Text); // Find the Echoer class's Type. Type echoer = dll.GetType("EchoDll.Echoer"); // Create an Echoer object. object myEchoer = Activator.CreateInstance(echoer); // Set the Message field. FieldInfo fieldInfo = echoer.GetField("Message"); fieldInfo.SetValue(myEchoer, messageTextBox.Text); // Get a MethodInfo for the ShowMessage method. MethodInfo methodInfo = echoer.GetMethod("ShowMessage"); } // Invoke the method on the object. object[] args = { captionTextBox.Text }; methodInfo.Invoke(myEchoer, args); The program first uses the Assembly.LoadFile method to load the EchoDll assembly. It then uses the Assembly’s GetType method to get a Type object that represents the Echoer class’s type. Next, the code uses the System.Activator class to create an instance of the Echoer type. If you pass the Activator class’s CreateInstance method additional parameters, it invokes the class’s constructor that best fits the parameters. In this example, the Echoer class has no constructors, so the code doesn’t pass any extra parameters to the CreateInstance method. www.it-ebooks.info
Running Scripts ❘ 593 The program then sets the value of the Echoer object’s Message field. It uses the Echoer type’s GetField method to get a FieldInfo object representing the field. It then uses the FieldInfo object’s SetValue method to set the field’s value for the Echoer instance. The last task the program must perform is invoking the Echoer object’s ShowMessage method. To do that, it calls the Echoer type’s GetMethod method to get a MethodInfo object representing the ShowMessage method. It creates an array of objects to hold the parameters that should be passed to the ShowMessage. Finally, it calls the MethodInfo object’s Invoke method, passing it the Echoer instance for which it should invoke the method and the argument array. This is an awful lot of work to simply display a message box, but the techniques used by the InvokeEchoer program show how to load and explore an assembly at run time. With a little more work and experimentation, you could modify the program to perform other tasks such as ➤➤ ➤➤ ➤➤ ➤➤ ➤➤ Discover the classes defined by an assembly. Create instances of a class. Learn what fields, properties, and methods are defined by each class. Get and set field and property values. Invoke static methods and instance methods. Dangerous DLLs Load an assembly at run time only if you are sure it is safe. If a hacker inserts a bogus DLL in a directory where your code is looking for assemblies, you might be tricked into executing dangerous code. Running Scripts Reflection lets a program learn about existing code. The classes in the System.CodeDom.Compiler namespace enable a program to compile completely new code at run time. You can then use refection to execute the methods defined by the newly compiled code. Time Saver Compiling code at run time is fairly slow, so it’s not a good way to provide features that you know about at design time. If you know at design time that the program needs to do something, just compile that code right into the executable program. You only need to compile code at run time to run scripts and execute code that you can’t predict ahead of time. www.it-ebooks.info
Page 1 and 2:
www.it-ebooks.info
Page 3 and 4:
C# 5.0 PROGRAMMER’S REFERENCE Int
Page 5 and 6:
Appendix V XML. ...................
Page 7 and 8:
C# 5.0 Programmer’s Reference www
Page 9 and 10:
C# 5.0 Programmer’s Reference Rod
Page 11 and 12:
About the Author Rod Stephens start
Page 13 and 14:
Credits Executive Editor Robert Ell
Page 15 and 16:
Acknowledgments Thanks to Bob Ellio
Page 17 and 18:
CONtents Introduction xxxiii PARt I
Page 19 and 20:
CONTENTS Properties 86 Enumerations
Page 21 and 22:
CONTENTS Set Methods 182 Limiting R
Page 23 and 24:
CONTENTS Hiding and Overriding Even
Page 25 and 26:
CONTENTS Resource Files 405 Applica
Page 27 and 28:
CONTENTS Tasks 496 Threads 498 Coor
Page 29 and 30:
CONTENTS Chapter 3 627 Chapter 4 62
Page 31 and 32:
CONTENTS Appendix i: Error Handling
Page 33 and 34:
CONTENTS Appendix s: Filesystem Cla
Page 35 and 36:
Introduction When it comes to progr
Page 37 and 38:
INTRODUCTION This book focuses on t
Page 39 and 40:
INTRODUCTION Part V: Advanced Topic
Page 41 and 42:
INTRODUCTION Source Code As you wor
Page 43 and 44:
INTRODUCTION After you join, you ca
Page 45 and 46:
Part I The C# Ecosystem ▶▶Chapt
Page 47 and 48:
1The C# Environment What’s in Thi
Page 49 and 50:
The C# Compiler ❘ 5 Consider the
Page 51 and 52:
The CLR ❘ 7 C# Program Visual Bas
Page 53 and 54:
Summary ❘ 9 By using all of these
Page 55 and 56:
2Writing a First Program What’s i
Page 57 and 58:
Types of Projects ❘ 13 TIP For a
Page 59 and 60:
Console Applications ❘ 15 Another
Page 61 and 62:
Windows Forms Applications ❘ 17 T
Page 63 and 64:
WPF Applications ❘ 19 If you skip
Page 65 and 66:
Windows Store Applications ❘ 21 A
Page 67 and 68:
Summary ❘ 23 } // Place the frame
Page 69 and 70:
Exercises ❘ 25 6. Repeat Exercise
Page 71 and 72:
3Program and Code File Structure Wh
Page 73 and 74:
Hidden Files ❘ 29 Figure 3-2: A p
Page 75 and 76:
Preprocessor Directives ❘ 31 The
Page 77 and 78:
Page 79 and 80:
Page 81 and 82:
Code File Structure ❘ 37 { ... }
Page 83 and 84:
Code File Structure ❘ 39 Unnecess
Page 85 and 86:
Code File Structure ❘ 41 } namesp
Page 87 and 88:
Comments ❘ 43 Comments Comments c
Page 89 and 90:
Comments ❘ 45 XML Comments A norm
Page 91 and 92:
Comments ❘ 47 WindowsFormsApplica
Page 93 and 94:
Exercises ❘ 49 4. Open Project
Page 95 and 96:
Part II C# Language Elements ▶▶
Page 97 and 98:
4Data Types, Variables, and Constan
Page 99 and 100:
Data Types ❘ 55 C# also groups by
Page 101 and 102:
Data Types ❘ 57 Alignment Attribu
Page 103 and 104:
Variable Declaration Syntax ❘ 59
Page 105 and 106:
Page 107 and 108:
Page 109 and 110:
Initialization ❘ 65 } public Car(
Page 111 and 112:
Initialization ❘ 67 Now the progr
Page 113 and 114:
Literal Type Characters ❘ 69 NOTE
Page 115 and 116:
Literal Type Characters ❘ 71 C# a
Page 117 and 118:
Data Type Conversion ❘ 73 The fol
Page 119 and 120:
Data Type Conversion ❘ 75 You can
Page 121 and 122:
Data Type Conversion ❘ 77 This is
Page 123 and 124:
Scope ❘ 79 ToString The ToString
Page 125 and 126:
Scope ❘ 81 Class Scope A variable
Page 127 and 128:
Parameter Declarations ❘ 83 Becau
Page 129 and 130:
Parameter Declarations ❘ 85 Becau
Page 131 and 132:
Properties ❘ 87 Properties also e
Page 133 and 134:
Enumerations ❘ 89 The syntax for
Page 135 and 136:
Enumerations ❘ 91 The following c
Page 137 and 138:
Delegates ❘ 93 To determine wheth
Page 139 and 140:
Summary ❘ 95 For a more interesti
Page 141 and 142:
Exercises ❘ 97 14. Make two metho
Page 143 and 144:
5Operators What’s in This Chapter
Page 145 and 146:
Arithmetic Operators ❘ 101 The +
Page 147 and 148:
Logical Operators ❘ 103 operator
Page 149 and 150:
Bitwise Operators ❘ 105 Because &
Page 151 and 152:
Assignment Operators ❘ 107 Format
Page 153 and 154:
Operator Precedence ❘ 109 Operato
Page 155 and 156:
DateTime and TimeSpan Operations
Page 157 and 158:
Operator Overloading ❘ 113 The fo
Page 159 and 160:
Operator Overloading ❘ 115 curren
Page 161 and 162:
Summary ❘ 117 In this case it may
Page 163 and 164:
Exercises ❘ 119 11. Before each o
Page 165 and 166:
6Methods What’s in This Chapter
Page 167 and 168:
Method Declarations ❘ 123 See the
Page 169 and 170:
Method Declarations ❘ 125 Now sup
Page 171 and 172:
Method Declarations ❘ 127 } Stree
Page 173 and 174:
Method Declarations ❘ 129 If the
Page 175 and 176:
Method Declarations ❘ 131 The fol
Page 177 and 178:
Method Declarations ❘ 133 "RodSte
Page 179 and 180:
Extension Methods ❘ 135 Explicit
Page 181 and 182:
Lambda Expressions ❘ 137 takes no
Page 183 and 184:
Variance ❘ 139 Variance Suppose t
Page 185 and 186:
Asynchronous Methods ❘ 141 This m
Page 187 and 188:
Asynchronous Methods ❘ 143 Next,
Page 189 and 190:
Asynchronous Methods ❘ 145 callba
Page 191 and 192:
Exercises ❘ 147 The chapters so f
Page 193 and 194:
Exercises ❘ 149 The File menu has
Page 195 and 196:
7Program Control Statements What’
Page 197 and 198:
Decision Statements ❘ 153 If it
Page 199 and 200:
Decision Statements ❘ 155 } break
Page 201 and 202:
Looping Statements ❘ 157 To catch
Page 203 and 204:
Looping Statements ❘ 159 Out of C
Page 205 and 206:
Looping Statements ❘ 161 do Loops
Page 207 and 208:
Looping Statements ❘ 163 One appr
Page 209 and 210:
Looping Statements ❘ 165 break St
Page 211 and 212:
Exercises ❘ 167 else if (person.T
Page 213 and 214:
8LINQ What’s in This Chapter ➤
Page 215 and 216:
Introduction to LINQ ❘ 171 ➤➤
Page 217 and 218:
Basic LINQ Query Syntax ❘ 173 Bas
Page 219 and 220:
Basic LINQ Query Syntax ❘ 175 whe
Page 221 and 222:
Basic LINQ Query Syntax ❘ 177 sel
Page 223 and 224:
Advanced LINQ Query Syntax ❘ 179
Page 225 and 226:
Page 227 and 228:
Page 229 and 230:
LINQ Extension Methods ❘ 185 Intr
Page 231 and 232:
LINQ Extension Methods ❘ 187 } };
Page 233 and 234:
LINQ to XML ❘ 189 } } // Return t
Page 235 and 236:
LINQ to XML ❘ 191 LINQ into XML L
Page 237 and 238:
LINQ to XML ❘ 193 the code uses t
Page 239 and 240:
LINQ to ADO.NET ❘ 195 more inform
Page 241 and 242:
LINQ to ADO.NET ❘ 197 ID, first a
Page 243 and 244:
PLINQ ❘ 199 download on the book
Page 245 and 246:
Exercises ❘ 201 how you can prote
Page 247 and 248:
Exercises ❘ 203 9. Copy the progr
Page 249 and 250:
9Error Handling What’s in This Ch
Page 251 and 252:
Bugs Versus Undesirable Conditions
Page 253 and 254:
Page 255 and 256:
Page 257 and 258:
Page 259 and 260:
Page 261 and 262:
Page 263 and 264:
Page 265 and 266:
try catch Blocks ❘ 221 catch (exc
Page 267 and 268:
try catch Blocks ❘ 223 When the f
Page 269 and 270:
try catch Blocks ❘ 225 other exce
Page 271 and 272:
try catch Blocks ❘ 227 In that ca
Page 273 and 274:
Exercises ❘ 229 Summary In practi
Page 275 and 276:
10 Tracing and Debugging What’s i
Page 277 and 278:
The Debug Menu ❘ 233 ➤➤ ➤
Page 279 and 280:
The Breakpoints Window ❘ 235 ➤
Page 281 and 282:
The Immediate Window ❘ 237 Right-
Page 283 and 284:
Trace Listeners ❘ 239 Debug.Liste
Page 285 and 286:
Exercises ❘ 241 The chapters in P
Page 287 and 288:
Part III Object-Oriented Programmin
Page 289 and 290:
11 OOP Concepts What’s in This Ch
Page 291 and 292:
Classes ❘ 247 Method AssignJob Pr
Page 293 and 294:
Encapsulation ❘ 249 Private Prope
Page 295 and 296:
Inheritance ❘ 251 For example, su
Page 297 and 298:
Inheritance ❘ 253 you may discove
Page 299 and 300:
Inheritance ❘ 255 The solution is
Page 301 and 302:
Inheritance ❘ 257 Has-a and Is-a
Page 303 and 304:
Inheritance ❘ 259 This method req
Page 305 and 306:
Inheritance ❘ 261 Ann: Person.Hid
Page 307 and 308:
Polymorphism ❘ 263 } } return "Eu
Page 309 and 310:
Polymorphism ❘ 265 version define
Page 311 and 312:
Exercises ❘ 267 Rewrite the code
Page 313 and 314:
12 Classes and Structures What’s
Page 315 and 316:
Classes ❘ 271 For more informatio
Page 317 and 318:
Classes ❘ 273 Extension Tension Y
Page 319 and 320:
Structures ❘ 275 The class automa
Page 321 and 322:
Structures ❘ 277 Heap and Stack P
Page 323 and 324:
Structures ❘ 279 The parameter ad
Page 325 and 326:
Structures ❘ 281 Argument Type Pa
Page 327 and 328:
Constructors ❘ 283 You can overlo
Page 329 and 330:
Structure Instantiation Details ❘
Page 331 and 332:
Garbage Collection ❘ 287 Note tha
Page 333 and 334:
Garbage Collection ❘ 289 ➤➤
Page 335 and 336:
Events ❘ 291 The following list d
Page 337 and 338:
Events ❘ 293 The EventHandler typ
Page 339 and 340:
Events ❘ 295 } MessageBoxButtons.
Page 341 and 342:
Events ❘ 297 The solution is to g
Page 343 and 344:
Static Methods ❘ 299 This kind of
Page 345 and 346:
Exercises ❘ 301 Exercises 1. Draw
Page 347 and 348:
13 Namespaces What’s in This Chap
Page 349 and 350:
The using Directive ❘ 305 The Sys
Page 351 and 352:
The using Directive ❘ 307 Sometim
Page 353 and 354:
The using Directive ❘ 309 Now whe
Page 355 and 356:
Making Namespaces ❘ 311 The Defau
Page 357 and 358:
Resolving Namespaces ❘ 313 Resolv
Page 359 and 360:
Exercises ❘ 315 private ConsoleTy
Page 361 and 362:
14 Collection Classes What’s in T
Page 363 and 364:
Arrays ❘ 319 Array objects can ha
Page 365 and 366:
System.Collections ❘ 321 Property
Page 367 and 368:
System.Collections ❘ 323 Why Both
Page 369 and 370:
System.Collections ❘ 325 The code
Page 371 and 372:
Dictionaries ❘ 327 The System.Col
Page 373 and 374:
Dictionaries ❘ 329 One overloaded
Page 375 and 376:
Stacks and Queues ❘ 331 } } jobsL
Page 377 and 378:
Stacks and Queues ❘ 333 Console.W
Page 379 and 380:
Generic Collections ❘ 335 Notice
Page 381 and 382:
Collection Initializers ❘ 337 Sta
Page 383 and 384:
Summary ❘ 339 } } // If this numb
Page 385 and 386:
Exercises ❘ 341 e. Finally, to pu
Page 387 and 388:
15 Generics What’s in This Chapte
Page 389 and 390:
Defining Generics ❘ 345 Suppose y
Page 391 and 392:
Defining Generics ❘ 347 } public
Page 393 and 394:
Defining Generics ❘ 349 For examp
Page 395 and 396:
Defining Generics ❘ 351 A generic
Page 397 and 398:
Generics and Extension Methods ❘
Page 399 and 400:
Exercises ❘ 355 The chapters in t
Page 401 and 402:
Part IV Interacting with the Enviro
Page 403 and 404:
16 Printing What’s in This Chapte
Page 405 and 406:
Windows Forms Printing ❘ 361 ➤
Page 407 and 408:
Windows Forms Printing ❘ 363 // S
Page 409 and 410:
Windows Forms Printing ❘ 365 The
Page 411 and 412:
Windows Forms Printing ❘ 367 Simi
Page 413 and 414:
Windows Forms Printing ❘ 369 Prop
Page 415 and 416:
Windows Forms Printing ❘ 371 } }
Page 417 and 418:
Page 419 and 420:
Page 421 and 422:
Windows Forms Printing ❘ 377 Page
Page 423 and 424:
Windows Forms Printing ❘ 379 that
Page 425 and 426:
WPF Printing ❘ 381 Using a Pagina
Page 427 and 428:
WPF Printing ❘ 383 // This exampl
Page 429 and 430:
WPF Printing ❘ 385 } grid.Childre
Page 431 and 432:
WPF Printing ❘ 387 Consectetur
Page 433 and 434:
WPF Printing ❘ 389 To display a F
Page 435 and 436:
Exercises ❘ 391 // Calculate the
Page 437 and 438:
17 Configuration and Resources What
Page 439 and 440:
Environment Variables ❘ 395 To se
Page 441 and 442:
Registry ❘ 397 Method ExpandEnvir
Page 443 and 444:
Registry ❘ 399 Field LocalMachine
Page 445 and 446:
Registry ❘ 401 The following code
Page 447 and 448:
Configuration Files ❘ 403 Figure
Page 449 and 450:
Resource Files ❘ 405 Second, the
Page 451 and 452:
Resource Files ❘ 407 Localization
Page 453 and 454:
Exercises ❘ 409 2. Write a progra
Page 455 and 456:
18 Streams What’s in This Chapter
Page 457 and 458:
Stream ❘ 413 Property Length Posi
Page 459 and 460:
MemoryStream ❘ 415 This code gets
Page 461 and 462:
BinaryReader and BinaryWriter ❘ 4
Page 463 and 464:
StringReader and StringWriter ❘ 4
Page 465 and 466:
StreamReader and StreamWriter ❘ 4
Page 467 and 468:
Summary ❘ 423 Custom Stream Class
Page 469 and 470:
19 File System Objects What’s in
Page 471 and 472:
.NET Framework Classes ❘ 427 Meth
Page 473 and 474:
Page 475 and 476:
.NET Framework Classes ❘ 431 Prop
Page 477 and 478:
Page 479 and 480:
Page 481 and 482:
Page 483 and 484:
Using the Recycle Bin ❘ 439 The f
Page 485 and 486:
Using the Recycle Bin ❘ 441 More
Page 487 and 488:
Summary ❘ 443 The code creates a
Page 489 and 490:
20 Networking What’s in This Chap
Page 491 and 492:
Networking Classes ❘ 447 The WebR
Page 493 and 494:
Downloading Information ❘ 449 Dow
Page 495 and 496:
Downloading Information ❘ 451 Fig
Page 497 and 498:
Downloading Information ❘ 453 The
Page 499 and 500:
Uploading Information ❘ 455 Uploa
Page 501 and 502:
Getting FTP Information ❘ 457 3.
Page 503 and 504:
Sending E‐mail ❘ 459 ➤➤ ➤
Page 505 and 506:
Sending Text Messages ❘ 461 For e
Page 507 and 508:
Exercises ❘ 463 TERm IP (Internet
Page 509 and 510:
Exercises ❘ 465 14. Modify the pr
Page 511 and 512:
Part V Advanced Topics ▶▶Chapte
Page 513 and 514:
21 Regular Expressions What’s in
Page 515 and 516:
Building Regular Expressions ❘ 47
Page 517 and 518:
Page 519 and 520:
Page 521 and 522:
Page 523 and 524:
Using Regular Expressions ❘ 479 M
Page 525 and 526:
Using Regular Expressions ❘ 481 }
Page 527 and 528:
Exercises ❘ 483 For each match, t
Page 529 and 530:
22 Parallel Programming What’s in
Page 531 and 532:
Parallel Programming ❘ 487 Multip
Page 533 and 534:
Interacting with the User Interface
Page 535 and 536:
BackgroundWorker ❘ 491 The follow
Page 537 and 538:
BackgroundWorker ❘ 493 This isn
Page 539 and 540:
BackgroundWorker ❘ 495 for (int i
Page 541 and 542:
Tasks ❘ 497 Method WaitAny WhenAl
Page 543 and 544:
Coordinating Tasks ❘ 499 Creating
Page 545 and 546:
Coordinating Tasks ❘ 501 } if (my
Page 547 and 548:
Thread-Safe Objects ❘ 503 Other L
Page 549 and 550:
Exercises ❘ 505 the BackgroundWor
Page 551 and 552:
Exercises ❘ 507 The following tex
Page 553 and 554:
23 ADO.NET What’s in This Chapter
Page 555 and 556:
Using Bound Controls ❘ 511 free.
Page 557 and 558:
Using Bound Controls ❘ 513 4. The
Page 559 and 560:
Using Bound Controls ❘ 515 If you
Page 561 and 562:
Using Bound Controls ❘ 517 Figure
Page 563 and 564:
Using Bound Controls ❘ 519 b. In
Page 565 and 566:
Using Bound Controls ❘ 521 tools
Page 567 and 568:
Using Bound Controls ❘ 523 6. Cre
Page 569 and 570:
Loading DataSets ❘ 525 Loading Da
Page 571 and 572:
Using ADO.NET ❘ 527 } studentsDat
Page 573 and 574:
Using ADO.NET ❘ 529 Executing Com
Page 575 and 576:
Exercises ❘ 531 Exercises 1. Writ
Page 577 and 578:
24 XML What’s in This Chapter ➤
Page 579 and 580:
Basic XML Syntax ❘ 535 Elements m
Page 581 and 582:
Basic XML Syntax ❘ 537 Character
Page 583 and 584:
Writing XML Data ❘ 539 Method Wri
Page 585 and 586: Writing XML Data ❘ 541 The follow
Page 587 and 588: Writing XML Data ❘ 543 // Save th
Page 589 and 590: Writing XML Data ❘ 545 The follow
Page 591 and 592: Reading XML Data ❘ 547 XML Litera
Page 593 and 594: Reading XML Data ❘ 549 Method Rea
Page 595 and 596: Related Technologies ❘ 551 The Re
Page 597 and 598: Related Technologies ❘ 553 Operat
Page 599 and 600: Related Technologies ❘ 555 This q
Page 601 and 602: Related Technologies ❘ 557 The bo
Page 603 and 604: Exercises ❘ 559 Figure 24-5: The
Page 605 and 606: Exercises ❘ 561 3. Write a progra
Page 607 and 608: 25 Serialization What’s in This C
Page 609 and 610: XML Serialization ❘ 565 The Seria
Page 611 and 612: XML Serialization ❘ 567 // Create
Page 613 and 614: XML Serialization ❘ 569 Each Orde
Page 615 and 616: XML Serialization ❘ 571 In the Or
Page 617 and 618: JSON Serialization ❘ 573 The Data
Page 619 and 620: JSON Serialization ❘ 575 To deser
Page 621 and 622: Binary Serialization ❘ 577 Ignore
Page 623 and 624: Exercises ❘ 579 4. The XmlSeriali
Page 625 and 626: 26 Reflection What’s in This Chap
Page 627 and 628: Learning About Classes ❘ 583 Cust
Page 629 and 630: Getting and Setting Properties ❘
Page 631 and 632: Getting and Setting Properties ❘
Page 633 and 634: Getting Assembly Information ❘ 58
Page 635: Invoking Methods ❘ 591 The follow
Page 639 and 640: Running Scripts ❘ 595 // Generate
Page 641 and 642: Exercises ❘ 597 Summary Most prog
Page 643 and 644: Exercises ❘ 599 ➤➤ ➤➤ For
Page 645 and 646: 27 Cryptography What’s in This Ch
Page 647 and 648: Randomness ❘ 603 through the slot
Page 649 and 650: Randomness ❘ 605 A 32-bit integer
Page 651 and 652: Randomness ❘ 607 The program then
Page 653 and 654: Symmetric Key Encryption ❘ 609 //
Page 655 and 656: Symmetric Key Encryption ❘ 611 {
Page 657 and 658: Symmetric Key Encryption ❘ 613 Ho
Page 659 and 660: Asymmetric Key Encryption ❘ 615 n
Page 661 and 662: Asymmetric Key Encryption ❘ 617 T
Page 663 and 664: Exercises ❘ 619 Length Limitation
Page 665 and 666: Exercises ❘ 621 6. The RandomNumb
Page 667 and 668: Part VI Appendices ▶▶Appendix A
Page 669 and 670: ASolutions to Exercises All the pro
Page 671 and 672: Chapter 3 ❘ 627 When you run the
Page 673 and 674: Chapter 4 ❘ 629 // Code Block 2 .
Page 675 and 676: Chapter 5 ❘ 631 } } } // Get and
Page 677 and 678: Chapter 5 ❘ 633 } }; } public sta
Page 679 and 680: Chapter 6 ❘ 635 12. The following
Page 681 and 682: Chapter 6 ❘ 637 The following cod
Page 683 and 684: Chapter 7 ❘ 639 } case 4: birthst
Page 685 and 686: Chapter 7 ❘ 641 total += values[i
Page 687 and 688:
Chapter 8 ❘ 643 After selecting t
Page 689 and 690:
Chapter 8 ❘ 645 The query orders
Page 691 and 692:
Chapter 8 ❘ 647 10. Example progr
Page 693 and 694:
Chapter 9 ❘ 649 } get { return _N
Page 695 and 696:
Chapter 9 ❘ 651 In this version,
Page 697 and 698:
Chapter 9 ❘ 653 } } Console.Write
Page 699 and 700:
Chapter 10 ❘ 655 The button’s e
Page 701 and 702:
Chapter 10 ❘ 657 An obvious advan
Page 703 and 704:
Chapter 11 ❘ 659 Chapter 11 1. Yo
Page 705 and 706:
Chapter 11 ❘ 661 5. The “is-a
Page 707 and 708:
Chapter 11 ❘ 663 Person Name Addr
Page 709 and 710:
Chapter 12 ❘ 665 Chapter 12 The e
Page 711 and 712:
Chapter 13 ❘ 667 Chapter 13 1. Fi
Page 713 and 714:
Chapter 14 ❘ 669 } string text =
Page 715 and 716:
Chapter 14 ❘ 671 When the user cl
Page 717 and 718:
Chapter 15 ❘ 673 8. The ListAllPr
Page 719 and 720:
Chapter 15 ❘ 675 2. The Increasin
Page 721 and 722:
Chapter 15 ❘ 677 This code create
Page 723 and 724:
Chapter 16 ❘ 679 } { case 1: Draw
Page 725 and 726:
Chapter 16 ❘ 681 // Make the font
Page 727 and 728:
Chapter 17 ❘ 683 } lst.Items.Add(
Page 729 and 730:
Chapter 18 ❘ 685 The following te
Page 731 and 732:
Chapter 18 ❘ 687 } // Save the te
Page 733 and 734:
Chapter 19 ❘ 689 { // Create an a
Page 735 and 736:
Chapter 19 ❘ 691 private void For
Page 737 and 738:
Chapter 19 ❘ 693 8. The ShowGrand
Page 739 and 740:
Chapter 20 ❘ 695 client.DownloadS
Page 741 and 742:
Chapter 20 ❘ 697 } // Request the
Page 743 and 744:
Chapter 20 ❘ 699 10. The UploadSt
Page 745 and 746:
Chapter 20 ❘ 701 14. The FtpListD
Page 747 and 748:
Chapter 21 ❘ 703 } // Display the
Page 749 and 750:
Chapter 21 ❘ 705 7. The following
Page 751 and 752:
Chapter 22 ❘ 707 3. The FiboTasks
Page 753 and 754:
Chapter 22 ❘ 709 The DeadUnlock e
Page 755 and 756:
Chapter 23 ❘ 711 Chapter 23 1. Th
Page 757 and 758:
Chapter 24 ❘ 713 Chapter 24 1. Th
Page 759 and 760:
Chapter 24 ❘ 715 // Display plant
Page 761 and 762:
Chapter 24 ❘ 717 The code then so
Page 763 and 764:
Chapter 24 ❘ 719 T
Page 765 and 766:
Chapter 25 ❘ 721 This code is rea
Page 767 and 768:
Chapter 25 ❘ 723 [XmlIgnore] publ
Page 769 and 770:
Chapter 26 ❘ 725 } } foreach (obj
Page 771 and 772:
Chapter 26 ❘ 727 The following co
Page 773 and 774:
Chapter 27 ❘ 729 is decrypting, t
Page 775 and 776:
Chapter 27 ❘ 731 11. The EncryptW
Page 777 and 778:
BData Types The following table sum
Page 779 and 780:
Casting and Converting Values ❘ 7
Page 781 and 782:
CVariable Declarations The followin
Page 783 and 784:
Enumerated Type Declarations ❘ 73
Page 785 and 786:
DConstant Declarations Constant dec
Page 787 and 788:
EOperators The C# operators fall in
Page 789 and 790:
Operator Precedence ❘ 745 Bitwise
Page 791 and 792:
DateTime and TimeSpan Operators ❘
Page 793 and 794:
FMethod Declarations This appendix
Page 795 and 796:
Extension Methods ❘ 751 An async
Page 797 and 798:
GUseful Attributes The .NET Framewo
Page 799 and 800:
Other Useful Attributes ❘ 755 Oth
Page 801 and 802:
HControl Statements Control stateme
Page 803 and 804:
Looping Statements ❘ 759 Here:
Page 805 and 806:
IError Handling A program can use t
Page 807 and 808:
J LINQ This appendix provides synta
Page 809 and 810:
Basic LINQ Query Syntax ❘ 765 joi
Page 811 and 812:
LINQ Functions ❘ 767 LINQ Functio
Page 813 and 814:
LINQ to XML ❘ 769 LINQ out of XML
Page 815 and 816:
PLINQ ❘ 771 The following list su
Page 817 and 818:
KClasses and Structures This append
Page 819 and 820:
Events ❘ 775 To create a destruct
Page 821 and 822:
LCollection Classes This appendix p
Page 823 and 824:
Collections ❘ 779 Collections Col
Page 825 and 826:
Iterators ❘ 781 }; } for (int i =
Page 827 and 828:
MGeneric Declarations This appendix
Page 829 and 830:
NPrinting and Graphics This appendi
Page 831 and 832:
Windows Forms Printing ❘ 787 ➤
Page 833 and 834:
Page 835 and 836:
Page 837 and 838:
Windows Forms Printing ❘ 793 Stri
Page 839 and 840:
WPF Printing ❘ 795 Method LockBit
Page 841 and 842:
WPF Printing ❘ 797 Nullam dapibu
Page 843 and 844:
OUseful Exception Classes When your
Page 845 and 846:
Standard Exception Classes ❘ 801
Page 847 and 848:
PDate and Time Format Specifiers A
Page 849 and 850:
Custom Format Specifiers ❘ 805 Sp
Page 851 and 852:
Q Other Format Specifiers A program
Page 853 and 854:
Numeric Formatting Sections ❘ 809
Page 855 and 856:
Enumerated Type Formatting ❘ 811
Page 857 and 858:
RStreams The .NET Framework provide
Page 859 and 860:
BinaryReader and BinaryWriter ❘ 8
Page 861 and 862:
TextReader and TextWriter ❘ 817 M
Page 863 and 864:
Text File Stream Methods ❘ 819 Me
Page 865 and 866:
SFilesystem Classes This appendix d
Page 867 and 868:
Framework Classes ❘ 823 File The
Page 869 and 870:
Framework Classes ❘ 825 DriveInfo
Page 871 and 872:
Framework Classes ❘ 827 Property
Page 873 and 874:
Page 875 and 876:
Page 877 and 878:
Recycle Bin ❘ 833 FileIO.FileSyst
Page 879 and 880:
TRegular Expressions This appendix
Page 881 and 882:
Regular Expression Options ❘ 837
Page 883 and 884:
Using Regular Expressions ❘ 839 S
Page 885 and 886:
Using Regular Expressions ❘ 841 T
Page 887 and 888:
UParallel Programming This appendix
Page 889 and 890:
Tasks ❘ 845 Parallel.For The Para
Page 891 and 892:
Threads ❘ 847 ➤➤ ➤➤ Call
Page 893 and 894:
VXML This appendix summarizes usefu
Page 895 and 896:
Writing XML Data ❘ 851 Document O
Page 897 and 898:
Writing XML Data ❘ 853 Method Des
Page 899 and 900:
Reading XML Data ❘ 855 Property A
Page 901 and 902:
Related Technologies ❘ 857 ➤➤
Page 903 and 904:
WSerialization This appendix summar
Page 905 and 906:
JSON Serialization ❘ 861 Attribut
Page 907 and 908:
Binary Serialization ❘ 863 Binary
Page 909 and 910:
XReflection A class’s type provid
Page 911 and 912:
Type ❘ 867 Property IsValueType I
Page 913 and 914:
Type ❘ 869 Method GetNestedType G
Page 915 and 916:
MethodInfo ❘ 871 Method AddEventH
Page 917 and 918:
FieldInfo ❘ 873 FieldInfo A Field
Page 919 and 920:
ParameterInfo ❘ 875 Property Defa
Page 921 and 922:
Index Symbols + (addition) operator
Page 923 and 924:
attributes - Bitmap class Flags, 75
Page 925 and 926:
Class View - classes Class View, 31
Page 927 and 928:
CollectionDataContract attribute -
Page 929 and 930:
data types - Debug menu data types,
Page 931 and 932:
delegate keyword - DownloadFileTask
Page 933 and 934:
#endif directive - exception classe
Page 935 and 936:
FileInfo class - FirstOrDefault met
Page 937 and 938:
global namespace - inheritance glob
Page 939 and 940:
lambda expressions - LINQ L lambda
Page 941 and 942:
memory - methods, ConvertAll memory
Page 943 and 944:
methods, GetResponseStream - method
Page 945 and 946:
NameValueCollection class - operato
Page 947 and 948:
ParameterInfo class - precedence of
Page 949 and 950:
properties, FieldInfo class - prope
Page 951 and 952:
protected internal keyword - #regio
Page 953 and 954:
Serialize method - statements XML,
Page 955 and 956:
StringWriter class - Task class Str
Page 957 and 958:
TryEnter method - Type class TryEnt
Page 959 and 960:
virtual keyword - XDocument class v
Page 961 and 962:
XmlArray attribute - XSLT SOAP (Sim
show all

C# 5.0 Programmer's Reference

Create successful ePaper yourself

Delete template?

Save as template?