Search and Find

Book Title

Author/Publisher

Table of Contents

Show eBooks for my device only:

 

Introducing Visual C# 2010

Introducing Visual C# 2010

of: Adam Freeman

Apress, 2011

ISBN: 9781430231721 , 1320 Pages

Format: PDF, Read online

Copy protection: DRM

Windows PC,Mac OSX Apple iPad, Android Tablet PC's Read Online for: Windows PC,Mac OSX,Linux

Price: 34,99 EUR



More of the content

Introducing Visual C# 2010


 

Title Page

1

Copyright Page

2

Contents at a Glance

4

Table of Contents

6

About the Authors

32

About the Technical Reviewers

33

Acknowledgments

34

PART 1 Getting Started

35

Chapter 1 Introduction

36

Who Should Read This Book?

36

What Is Covered in This Book?

36

What Do You Need to Read This Book?

37

What Is the Structure of This Book?

37

What Is in Each Chapter?

37

Getting the Example Code

39

Finding More Information

39

The MSDN C# Programming Guide

39

Online Forums

39

Other Books

39

Summary

39

Chapter 2 Getting Ready

40

Installing the Software

40

Installing Visual Studio 2010

40

Installing SQL Server 2008

42

Installing the Silverlight Tools

43

Downloading the Sample Code and Data

43

Creating Your First C# Project

43

Creating the Project

44

Editing the Code

46

Compiling and Running the Program

47

Features That I Use Before Explaining Them

47

The using statements

47

The namespace statement

48

The class statement

48

The Main method

48

The Code Comments

49

The Console.WriteLine and Console.ReadLine methods

49

Summary

49

Chapter 3 Understanding C# and the .NET Framework

50

C# and the .NET Framework at a Glance

50

Introducing C#

50

Introducing the .NET Framework

51

Introducing the Common Language Runtime

51

Introducing the Class Library

51

The Relationship between C# and the .NET Framework

52

Using C# Code Files

52

Understanding Assemblies

53

The Key Features of C# and the .NET Framework

55

Understanding Object-Orientation

55

Understanding Type Safety

55

Understanding Automatic Memory Management

56

Understanding the Just-In-Time Compiler

56

Understanding Parallel Processing

56

Understanding Unmanaged/Native Code Support

57

Understanding the .NET Technology Spectrum

57

Understanding ASP.NET

59

Understanding LINQ

59

Understanding the Task Parallel Library

60

Understanding User Interfaces

60

Understanding ADO.NET

61

Understanding the Windows Communication Foundation

62

Understanding .NET Cross-Platform Support

62

Summary

63

PART 2 The C# Language

64

Chapter 4 C# Fundamentals and Keyword Reference

66

Language Fundamentals

66

A Simple C# Program

66

C# Syntax

67

Identifiers

67

Keywords

70

Literals

70

Operators

71

Punctuators

72

Statements

73

Comments

73

Types

74

Value Types

75

Reference Types

76

Definite Assignment and Null References

78

Common Programming Tasks

79

Assigning Values

79

Making Comparisons

80

Performing Selections

82

Using an if Statement

82

Using a switch Statement

84

Iterating Data Items

86

Using a for Loop

86

Using a foreach Loop

89

Using a do...while Loop

91

Using a while Loop

92

Keyword and Operator Reference

93

Type Keywords

94

bool

95

byte, sbyte

95

char

95

class

96

decimal, double, float

96

delegate

97

dynamic

97

enum

98

interface

98

object

99

string

100

struct

100

short, ushort, int, uint, long, ulong

101

void

101

var

102

Modifiers

102

public, protected, private, internal

102

abstract

104

const

104

event

104

in, out

105

override

106

readonly

106

sealed

107

static

107

virtual

108

Selection Keywords

108

if, else

108

switch, case, default

108

Iterator Keywords

108

for

109

foreach

109

do, while

109

Jump Keywords

109

break

109

continue

109

goto

110

return

110

Exception Handling Keywords

110

throw

110

try, catch, finally

111

Arithmetic Overflow Keywords

111

checked, unchecked

111

Synchronization Keywords

112

lock

112

Parameter Keywords

112

params

112

ref

113

out

114

Namespace Keywords

114

namespace

114

using

115

Literal Keywords

115

null

115

true, false

116

Object Keywords

116

is, as

116

new

116

typeof

117

LINQ Keywords

117

Other Keywords

117

base

117

get, set, value

118

global

118

implicit, explicit

118

operator

119

partial

119

using

119

this

119

yield

119

Operators

120

[ ] Operator

120

( ) Operator

120

Dot (.) Operator

120

:: Operator

120

+, -, *, /, % Operators

121

==, !=, >, >=, <, <= Operators

121

++, +=, --, -= Operators

121

&&, || Operators

121

&, |, ^,

&, |, ^,

121

121

=> Operator

122

=, +=, -=, *=, /=, %=, &=, >>=, <<=, ^= Operators

122

Summary

122

Chapter 5 Numeric and Boolean Types

123

Numeric Types

124

Using Numeric Literals

125

Using Literal Suffixes

127

Using Literal Prefixes

128

Implicit and Explicit Numeric Type Conversions

130

Using Overflow Checking

133

Using Struct Members

135

Common Members

135

Using Type-Specific Members

139

Using Numeric Operators

141

Arithmetic Operators

141

Unary Operators

145

Relational Operators

148

Logical Operators

150

Assignment Operators

154

Working with Very Large Integer Values

158

The Boolean Type

159

Using Boolean Literals

159

Using Boolean Results

160

Using Struct Members

161

Summary

162

Chapter 6 Classes and Objects

163

Creating a Basic Class

164

Adding Features to a Class

165

Adding Fields

165

Adding Methods

166

Adding a Constructor

167

Creating Objects from Classes

168

Using Objects

171

Reading and Modifying Fields

172

References to Common Objects

174

Using Static Fields

179

Calling Methods

180

Class Inheritance

182

Understanding Inheritance

185

Overriding Methods

188

Inheriting Derivations

189

Understanding Encapsulation

191

Understanding Polymorphism

192

Casting Objects and Type Checking

197

Implicit vs. Explicit Casting

197

Type Conversion Exceptions

201

Avoiding Explicit Cast Exceptions

202

Testing an Object’s Type

202

Casting Without Exceptions

204

Boxing and Unboxing

205

Using Nested Classes

207

Using Class Modifiers

208

Creating Static Classes

208

Creating Abstract Classes

210

Creating Sealed Classes

211

Creating Partial Classes

211

Using Access Modifiers

212

Summary

213

Chapter 7 Fields

214

Defining and Using Fields

215

Defining Fields

215

Initializing Fields

215

Reading and Updating Fields

217

Working Directly with Field Values

218

Allowing Other Classes to Read and Modify Properties

219

Exposing Properties with Field Values

220

Understanding Reference Type Fields

223

The Fourth Stage of the Life Cycle

224

Applying Field Modifiers

225

Creating Static Fields

225

Creating Read-Only Fields

227

Using the const keyword

227

Using the readonly Keyword

228

Applying Access Modifiers

230

Hiding Base Class Fields

230

Using the volatile Keyword

232

Summary

232

Chapter 8 Properties, Indexers, and Operators

233

Creating a Property

234

Creating a Field-Backed Property

234

Using a Property

237

Creating an Automatically Implemented Property

238

Creating an Asymmetric Property

239

Creating a Computed Property

239

Mapping a Property Type to a Field Type

240

Using Access Modifiers

240

Using Other Modifiers

241

Using the virtual and override Modifiers

242

Using the abstract Modifier

243

Using the sealed Keyword

243

Using the static Keyword

244

Creating an Indexer

245

Using Multiple Indexers

246

Creating a Validating Indexer

247

Creating an Indexer with Multiple Arguments

248

Creating Custom Operators

249

Creating Custom Unary Operators

249

Creating Custom Binary Operators

251

Creating Custom Conversion Operators

255

Summary

257

Chapter 9 Methods

258

Creating and Using a Simple Method

260

Defining the Method Name

261

Defining the Result Type

261

Defining the Parameters

262

Defining the Modifiers

263

Defining the Method Body

266

Using the Methods

267

Understanding Parameters

268

Using Value Parameters

268

Using Reference Parameters

272

Using Output Parameters

274

Using Parameter Arrays

276

Using Optional Parameters

278

Using Named Parameters

279

Understanding Method Bodies

280

Using Local Variables

280

Naming Variables

282

Understanding Variable Scope and Lifetime

284

Using Method Results

285

Understanding Method Modifiers

286

Using Access Modifiers

286

Creating Static Methods

286

Creating Virtual Methods

287

Creating Sealed Methods

287

Creating Abstract Methods

288

Overloading Methods

288

Hiding and Overriding Methods

291

Hiding Methods

292

Overriding Methods

294

Sealing Methods

296

Understanding Method Specialization

297

Special Methods

298

The Main Method

298

Constructors

301

Using the Default Constructor

303

Initializing Properties and Fields at Construction

303

Overloading Constructors

304

Calling Base Class Constructors

309

Controlling Access to Constructors

312

Creating Copy Constructors

313

Using Static Constructors

316

Creating Factory Methods

318

Destructors

319

Iterator Blocks

320

Using the yield Keyword

321

Exposing Field Iterators

322

Using Multiple yield Statements

323

Using Named Iterator Blocks

324

Partial Methods

325

Abstract Methods

328

Extension Methods

330

Summary

333

Chapter 10 Delegates, Events, and Anonymous Methods

334

Using Delegates

335

Using Delegates for Callbacks

337

Multicasting with Delegates

339

Delegating Selectively

341

Interrogating Delegates

342

Using Events

344

Defining and Publishing EventHandler Pattern Events

346

Creating Nongeneric Events

351

Creating Events Without Custom Data

352

Applying Modifiers to Events

354

Using Action and Func Delegates

355

Using Action Delegates

355

Using Func Delegates

357

Anonymous Methods

358

Capturing Outer Variables

360

Lambda Expressions

363

Summary

365

Chapter 11 Namespaces

366

Consuming Namespaces

366

Using Fully Qualified Names

367

Importing Namespaces

368

Creating Namespaces

369

Nesting Namespaces

371

Logically Nesting Namespaces

372

Spreading Namespaces Across Files

373

Adding Types to Existing Namespaces

375

Disambiguating Namespaces and Types

376

Disambiguation with Fully Qualified Names

378

Disambiguating with Aliases

378

Aliasing Namespaces

379

Resolving Type or Namespace Hiding

380

Summary

382

Chapter 12 Interfaces, Structs, and Enums

383

Using Interfaces

384

Defining and Using a Simple Interface

384

Defining an Interface

384

Implementing an Interface

385

Using an Interface

386

Specifying Interface Members

386

Specifying Methods

387

Specifying Properties

387

Specifying an Event

389

Specifying an Indexer

390

Deriving Interfaces

390

Deriving from Multiple Base Interfaces

391

Defining a Partial Interface

393

Implementing Interfaces

393

Implementing Multiple Interfaces

394

Explicitly Implementing an Interface

395

Inheriting Interface Implementations

397

Implementing an Interface in an Abstract Class

398

Using Structs

399

Defining and Instantiating a Struct

399

Implementing Interfaces

401

Differences Between Structs and Classes

402

Base Structs and Inheritance

403

Defining Fields

403

Defining a Struct Constructor

403

Copying a Struct

404

Using an Enum

408

Defining an Enum

408

Using an Enum

409

Using Underlying Types and Numeric Values

410

Combining Enum Values

411

Summary

412

Chapter 13 Arrays

413

Defining and Initializing Arrays

415

Getting and Setting Array Values

417

Using Array Initializers

419

Enumerating Arrays

421

Enumerating with a for Loop

421

Enumerating with a foreach Loop

423

Enumerating Using IEnumerator and IEnumerator

424

Breaking from Enumerations

426

Using System.Array Members

428

Sorting Arrays

428

Processing All of the Elements in an Array

429

Resizing and Copying an Array

430

Finding Items in an Array

434

Using Arrays with LINQ

436

Using Arrays as Collections

437

Using Multidimensional Arrays

437

Using Rectangular Arrays

438

Getting and Setting Rectangular Array Values

439

Using Rectangular Array Initializers

439

Enumerating a Rectangular Array

440

Creating Rectangular Arrays with Additional Dimensions

442

Using Jagged Arrays

443

Getting and Setting Jagged Array Values

444

Using Jagged Array Initializers

445

Enumerating a Jagged Array

445

Summary

446

Chapter 14 Exceptions

447

Handling Exceptions

448

Using try Statements and catch Clauses

449

Handling Different Exception Types

452

Using Specific catch Clauses

453

Using General catch Clauses

454

Omitting catch Clauses

454

Nesting try Statements

455

Using Exception Members

455

Using finally Clauses

458

Throwing Exceptions

460

Rethrowing Exceptions

464

Creating and Throwing Custom Exceptions

466

Throwing Meaningful Exceptions

469

Mapping One Exception Type to Another

470

Creating Exception Chains

472

Aggregating Exceptions

474

Summary

479

Chapter 15 Generic and Anonymous Types

480

Using Generic Types

481

Defining a Generic Class

483

Creating Objects from Generic Classes

483

Implementing and Using Generic Class Members

484

Defining Multiple Parameter Types

487

Casting from Parameterized Types

488

Constraining Parameterized Types

489

Applying Multiple Constrains to a Parameterized Type

491

Constraining Multiple Parameterized Types

492

Defining a Method-Specific Parameterized Type

492

Deriving from a Generic Base Class

494

Inheriting Type Deferral

494

Specifying Parameterized Types

497

Creating Generic Interfaces

498

Creating Generic Structs

499

Type Variance

499

Covariance

502

Contravariance

503

Combining Contravariance and Covariance

504

Using the default Keyword

504

Using Anonymous Types

505

Summary

507

Chapter 16 Strings and Characters

508

Working with Characters

509

Expressing Characters Using Literals

509

Performing Operations on Characters

510

Using Struct Members

511

Using Strings

513

Expressing Strings Using String Literals

513

Using String Escape Sequences and Verbatim Literals

514

Performing Operations on Strings

515

Comparing Strings

516

Combining Strings

518

Reading Individual Characters

519

Enumerating a String

520

Using Strings in a switch Statement

521

Using Regular Expressions

522

Using Class Members

523

Manipulating Strings

523

Searching Strings

526

Other Class Members

527

Using the StringBuilder Class

529

Creating a StringBuilder Object

529

Using a StringBuilder Object

529

Using the Append and Insert Methods

532

Using the StringBuilder Indexer

533

Formatting Strings

534

Using Composite Formatting

534

Other Composite Formatting Methods

535

Specifying Alignment

536

Escaping Braces

537

Formatting Types

538

Using a Format Component

538

Creating String Representations of Custom Types

541

Performing Custom Composite Formatting

543

Summary

545

Chapter 17 Attributes

546

Using Attributes

546

Applying Attributes with Parameters

548

Testing for an Attribute

549

Testing for an Attribute Applied to a Class

549

Testing for an Attribute Applied to a Field

552

Testing for an Attribute Applied to a Property

555

Testing for an Attribute Applied to a Method

557

Creating a Custom Attribute

559

Using a Custom Attribute

560

Defining Properties in a Custom Attribute

562

Controlling How a Custom Attribute Can Be Used

562

Controlling Attribute Inheritance

564

Summary

565

Chapter 18 Garbage Collection

566

Explicitly Running the Garbage Collector

567

Implementing a Destructor

568

Destructors vs. Finalizers

569

Problems with Destructors

570

Performance Impact

570

Uncertain Execution

570

Uncertain Ordering

570

Using Disposal

571

Using Weak References

573

Summary

574

PART 3 The .NET Class Library

575

Chapter 19 Collections

577

The ICollection Interface

579

Generic Lists

580

The IList Interface

581

The List Collection

582

Adding, Retrieving, and Removing Items

583

Finding List Items

585

Sorting List Items

591

Processing Items

597

Other List Members

598

The LinkedList Collection

601

Adding, Retrieving, and Removing Items

602

Finding List Items

606

The SortedList Collection

607

Adding, Retrieving, and Removing Items

608

Other SortedList Members

611

Generic Dictionaries

611

The IDictionary Interface

612

The KeyValuePair Structure

614

The Dictionary Collection

615

Adding, Retrieving, and Removing Items

616

Other Dictionary Members

618

The SortedDictionary Collection

619

Generic Sets

621

The ISet Interface

621

The HashSet Collection

623

The SortedSet Collection

625

Generic Queues and Stacks

628

The Queue Collection

628

The Stack Collection

630

Other Generic Collection Interfaces

632

The IComparer Interface

632

The IEqualityComparer Interface

634

Treating Arrays as Collections

635

Creating Constrained Collections

639

Read-Only Lists

639

Other Read-Only Collections

640

Legacy Collections

643

Summary

645

Chapter 20 Files, Streams, and IO

646

Working with Files and Directories

647

Using the System.IO.Directory Class

647

Enumerating Files and Directories

647

Getting and Setting Information for a File or Directory

653

Changing the Current Working Directory

654

Using the FileInfo and DirectoryInfo Classes

655

Using the FileInfo Class

656

Using the DirectoryInfo Class

659

Using the System.IO.File Class

664

Using the File Convenience Methods

665

Using the Stream, Reader, and Writer Methods

667

Using the System.IO.Path Class

668

Monitoring for Changes

670

Filtering the Monitored Files and Directories

673

Filtering the Triggers for a Change Event

674

Working with Streams, Readers, and Writers

675

Using Streams

675

Using the System.IO.Stream Class (in Detail)

678

Using Base Streams

682

Using Pass-Through Streams

688

Using Readers and Writers

691

Reading and Writing Binary Data

692

Reading and Writing Textual Data

695

Summary

698

Chapter 21 Networking & WCF

699

Requesting Data

699

Using WebClient Members to Configure a Request

701

Using WebClient Members to Retrieve Data

703

Getting the WebClient Response Headers

704

Using WebClient Events

706

Programming with Sockets

708

Creating a Simple TCP Client & Server

708

Creating the Server

709

Creating the Client

713

Writing a Parallel Server

715

The Windows Communication Foundation

717

Creating the WCF Server

718

Creating the Service Contract

718

Creating the WCF Client

721

Other Useful Network Classes

724

Writing a Simple Web Server

724

Using Connectionless Networking

728

Using the Domain Name System

731

Summary

733

Chapter 22 Time & Dates

734

Measuring Small Amounts of Time

735

Working with Periods of Time

738

Creating and Using TimeSpan Values

738

Performing Operations on TimeSpan Values

742

Formatting TimeSpan Strings

743

Creating Custom TimeSpan Format Strings

744

Working with Particular Dates and Times

746

Creating and Using DateTime Values

747

Performing Operations on DateTime Values

750

Formatting DateTime Strings

753

Creating Custom DateTime Format Strings

754

Summary

756

Chapter 23 Serialization

757

Using Binary Serialization

758

Serializing Graphs of Objects

761

Serializing Multiple Objects to a Single Stream

763

Selectively Serializing Fields

766

Using Serialization Callbacks

767

Version Tolerance

770

Adding Tolerance for Specific Changes

773

Using SOAP Serialization

774

Version Tolerance

776

Serializing Generic Objects

777

Using XML Serialization

777

Selectively Serializing Fields

779

Mapping Members to Elements and Attributes

780

Changing the Name for Attributes and Elements

781

Using Data Contract Serialization

782

Preparing a Class for Data Contract Serialization

782

Generating Portable XML

783

Generating .NET-specific XML

784

Generating JSON

786

Summary

787

Chapter 24 Serialization

788

Understanding Single- and Multi-Threaded Execution

789

Getting Started with Tasks

793

Creating a Task

793

Starting a Task

794

Waiting for a Task

795

Getting Results from Tasks

797

Passing Parameters to a Task

799

Getting the Status of a Task

801

Using the Status Properties

803

Canceling Tasks

803

Checking and Throwing in a Single Statement

805

Cancelling Multiple Tasks

807

Handling Task Exceptions

808

Handling an Exception in a Task Body

808

Handling an Exception from a Trigger Method

810

Handling Exceptions from Multiple Tasks

811

Dealing with Exceptions using Task Properties

813

Using a Custom Exception Escalation Policy

815

Chaining Tasks Together

817

Creating a Simple Continuation

817

Getting Details of the Antecedent

818

Providing a Continuation Result

819

Creating Chains of Continuations

821

Creating Selective Continuations

822

Sharing Data between Tasks

824

Understanding a Critical Region

827

Creating a Critical Region

827

Avoiding Synchronization

829

Using Concurrent Collections

830

Summary

834

Chapter 25 Asynchronous Methods and Parallel Loops

835

Using Asynchronous Methods

836

Using Pre-Built Asynchronous Methods

836

Asynchronously Calling Any Method

839

Waiting for an Asynchronous Method to Complete

840

Mixing Asynchronous Methods and Tasks

843

Using Parallel Loops

844

Creating a Parallel ForEach Loop

844

Creating a Parallel For Loop

846

Breaking and Stopping Parallel Loops

847

Summary

851

Chapter 26 Other Useful Features and Classes

852

Converting Between Types

853

Returning Multiple Results from Methods Using Tuples

855

Aliasing Generic Types

858

Using Nullable Types

860

Using the Null-Coalescing Operator

861

Working with the Console

862

Reading from and Writing to the Console

862

Making the Console Beep

865

Modifying the Appearance of the Console

865

Generating Random Numbers

867

Converting Strings to and from Bytes

868

Getting Environment Information

869

Performing Math Operations

871

Using Conditional Compilation

872

Using Visual Studio to Define Symbols

874

Conditionally Compiling Methods

875

Checking Network Connectivity

877

Listening for Connectivity Changes

878

Summary

879

PART 4 Data and Databases

880

Chapter 27 LINQ to Objects

881

Performing a Simple LINQ Query

882

Understanding LINQ to Objects Data Sources

884

Enumerating Results Manually

885

Using Results as Data Sources

886

Understanding Query Results

888

The Range Variable Type

888

The Result Type

888

Explicitly Specifying the Range Variable Type

890

Letting the Compiler Infer Types

891

Performing LINQ Operations

892

Filtering Data

893

Projecting Data

894

Projecting a Single Member

895

Projecting Anonymous Types

896

Projecting Derived Data

897

Ordering Data

899

Grouping Data

903

Grouping Using a Boolean Value

905

Grouping Using an Anonymous Type

907

Querying Grouped Data

908

Using Method Syntax

909

Understanding Deferred Execution

913

Reusing Queries

913

Referring to Variables

914

Forcing Immediate Execution

915

Converting Query Results

917

Using Legacy Collections as LINQ Data Sources

920

Explicitly Specifying the Range Variable Type

920

Using Cast and OfType Extension Methods

921

Performing Advanced LINQ Operations

923

Aggregating Data

923

Joining Data

925

Creating Combinations of Data

928

Creating Additional Range Variables

929

Summary

931

Chapter 28 Parallel LINQ

932

Performing a Parallel LINQ Query

932

Understanding PLINQ Result Ordering

935

Preserving Order in a PLINQ query

937

Forcing Parallel Execution

938

Performing Queries without Results

939

Summary

940

Chapter 29 LINQ to XML

941

Using the LINQ XML Classes

942

Creating XML Declaratively

942

Using Arbitrary Types to Create XElements

944

Creating Other XML Node Types

946

Creating Valid XML Documents

948

Populating an XElement or XDocument with an IEnumerable

949

Reading and Writing XML Files

950

Saving XML

950

Loading XML

952

Processing XML Declaratively

952

Filtering Elements by Name

954

Finding All Descendants

955

Modifying XML

956

Using LINQ to XML Queries

960

Querying XML for Data

961

Creating XML from LINQ Queries

962

Create Objects from XML

965

Modifying and Transforming XML Data

966

Adding Elements to XML

966

Creating a CSV File from XML

968

Creating XML from CSV Data

969

Changing and Deleting Elements

971

Sorting XML

973

Grouping XML

974

Using Parallel LINQ to Process XML

976

Summary

979

Chapter 30 LINQ to Entities

980

Getting Ready

981

Preparing the Database

982

Creating the Model

982

Using LINQ to Entities

988

Using the Data Model Context

989

Using Table Properties and Row Objects

990

Understanding the IQueryable Interface

992

Enumerating the Results

993

Navigating Using Foreign Key Relationships

994

Querying Using Navigation Properties

997

Using Navigation Data Efficiently

998

Performing Common Database Operations

1000

Querying Data

1000

Compiling Queries

1000

Querying Views

1003

Querying Stored Procedures

1004

Inserting Data into the Database

1008

Inserting Attached Objects

1010

Updating Data in the Database

1011

Deleting Data

1013

Enabling Concurrency Checking

1014

Summary

1015

Chapter 31 LINQ to DataSet

1016

Connecting to and Querying a Database

1017

Setting Up the Database

1017

Creating a Connection to the Database

1019

Storing Connection Strings

1023

Executing a SQL Query

1025

Understanding the DataSet Class

1027

Enumerating Results with DataTable and DataRow Objects

1029

Querying DataSets with LINQ

1031

Perform Joins on a DataSet

1033

Comparing Data

1036

Querying for Data Intersects

1036

Subtracting Results

1038

Performing Database Operations Using Cached Data

1039

Inserting Data

1039

Modifying Data

1042

Deleting Data

1044

Summary

1045

PART 5 User Interfaces

1046

Chapter 32 Windows Forms

1048

Building a Stand-Alone Window Forms Program

1048

Creating the Project

1049

Adding the Controls

1051

Setting the Control Properties

1053

Configuring the Labels

1053

Configuring the TextBoxes and NumericUpDowns

1054

Configuring the Button

1056

Adding the MenuStrip and StatusStrip

1056

Setting the Control Names

1058

Setting the Tab Order

1060

Wiring the Controls

1060

Wiring the Quit Menu

1061

Wiring the TextBoxes

1063

Wiring the Button

1066

Setting the Icon

1068

Testing the Program

1068

Using Windows Forms Data Binding

1068

Creating the Project and Creating the Data Model

1068

Creating and Using the Object Data Source

1069

Formatting the Grid Control

1071

Loading the Data

1073

Wiring the Save Button

1073

Testing the Program

1074

Two Program Variations

1075

Filtering the Data with LINQ

1075

Displaying Data Fields

1076

Windows 7 UI Integration

1078

Using Aero Glass

1078

Summary

1081

Chapter 33 Windows Presentation Foundation

1083

Building a Stand-Alone WPF Program

1083

Creating the Project

1083

Adding the Controls

1086

Setting the Control Properties

1088

Configuring the Label Controls

1088

Configuring the TextBox Controls

1088

Configuring the TextBlock Control

1089

Configuring the Button

1090

Adding the StatusBar Item

1090

Adding the StatusBar Item

1091

Adding the Menu Item

1091

Setting the Tab Order

1091

Wiring the Controls

1092

Wiring the Quit Menu

1092

Wiring the TextBox Controls

1093

Wiring the Button

1094

Managing the Focus

1095

Focusing on the First Control

1095

Selecting the TextBox Text on Focus

1096

Setting the Program Icon and Window Name

1096

Testing the Program

1096

Using WPF Data Binding

1097

Formatting the DataGrid Control

1098

Loading the Data

1099

Wiring the Button

1099

Testing the Program

1100

Using WPF-Specific Features

1100

Using WPF Animations

1100

Creating the Project

1101

Adding the Animation

1101

Testing the Animation

1103

Combining Multiple Animations

1103

Using WPF Commands

1104

Creating the Project

1104

Configuring the Button Controls

1105

Adding and Configuring the MenuItem Control

1106

Binding the Command

1106

Selectively Activating the Command

1108

Using Commands to Set Control Content

1110

Summary

1138

Chapter 34 ASP.NET

1113

Building a Web Forms Program

1113

Creating the Project

1113

Adding the Controls

1116

Setting the Control Properties

1118

Configuring the Labels

1118

Configuring the TextBox Controls

1118

Configuring the Button

1120

Setting the Tab Order

1120

Wiring the Button Control

1121

Setting the Focus

1121

Testing the Program

1122

Using Web Forms Data Binding

1122

Create the Project and the Entity Data Model

1123

Adding the Web Form

1123

Creating the Web Forms Data Source

1123

Adding the GridView Control

1125

Testing the Program

1126

Using ASP.NET Dynamic Data

1127

Creating the Project

1127

Creating the Entity Data Model

1128

Registering the Data Model

1128

Testing the Program

1128

Customizing a Dynamic Data Application

1130

Changing the Name of a Table

1131

Changing the Name and Visibility of a Column

1133

Selecting Tables to Be Displayed

1134

Customizing the Display Template

1136

Summary

1138

Chapter 35 Silverlight

1139

Creating the Swimming Calculator

1140

Creating the Project

1140

Defining the Layout

1142

Adding Grid Columns

1142

Adding the StackPanel Controls

1144

Adding the TextBox Controls

1145

Adding the Label Controls

1146

Adding the TextBlock Control

1147

Adding the Button Control

1148

Adjusting the Layout

1149

Wiring the Button

1150

Adding a Child Window

1151

Using a WCF RIA Service

1154

Creating the Project

1155

Creating the Data Model

1155

Creating the Domain Service Class

1156

Creating the Silverlight Client

1158

Adding the Data

1159

Configuring the DataGrid Control

1159

Configuring the ComboBox Control

1160

Wiring the ComboBox Control

1161

Testing the Application

1163

Using Silverlight Out-of-Browser Support

1163

Configuring the Out-of-Browser Support

1164

Using a Silverlight Program Out-of-Browser

1166

Making Installation Part of the Interface

1167

Using Other Out-of-Browser Features

1171

Summary

1171

PART 6 Advanced Topics

1172

Chapter 36 Windows Integration

1173

Using the Windows Event Log

1173

Reading an Event Log

1174

Writing to an Event Log

1177

Creating the Event Source

1177

Writing Events

1178

Using Elevated Privileges

1179

Creating a Windows Service

1181

Creating the Service Class

1182

Adding the Service Functionality

1184

Adding the Service Installer

1186

Add the MSI Installer

1187

Installing the Service

1189

Creating the Client

1191

Using the Windows Registry

1191

Searching the Registry

1191

Reading and Modifying the Registry

1194

Summary

1195

Chapter 37 Cryptography and Security

1196

Encrypting and Decrypting Data

1197

Creating and Using Encryption Keys

1197

Encrypting Data

1200

Decrypting Data

1201

Using the Windows Data Protection API

1202

Using Hash Codes

1204

Generating a Hash Code

1205

Verifying a Hash Code

1207

Generating Secure Random Numbers

1208

Working Securely with Strings

1209

Summary

1211

Chapter 38 Testing and Debugging

1212

Using the Debug and Trace Classes

1213

Using the Debug Class

1213

Making Assertions

1215

Disabling Debug Statements

1217

Using Debug Listeners

1218

Other Debug Methods

1220

Using the Trace Class

1223

Using Static Code Analysis

1225

Selecting the Code Analysis Rules

1225

Performing Static Analysis

1226

Dealing with a Rule Violation

1227

Suppressing a Single Occurrence

1228

Suppressing Every Occurrence

1230

Using Code Contracts

1232

Installing and Enabling Code Contract Support

1232

Writing Code Contracts

1233

Using Precondition Contracts

1233

Using Postcondition Contracts

1234

Using Assertion Contracts

1235

Using Invariant Contracts

1236

Using the Static Checker

1237

Using the Runtime Checker

1240

Summary

1241

Index

1242