Sue Brandreth's Learning Resources

Preface; Who This Book Is For; Conventions Used in This Book; Using Code Examples; Safari® Books Online; How to Contact Us; Acknowledgments; Chapter 1: Introducing C#; 1.1 Why C#?; 1.2 Why Not C#?; 1.3 C#’s Defining Features; 1.4 Visual Studio; 1.5 Anatomy of a Simple Program; 1.6 Summary; Chapter 2: Basic Coding in C#; 2.1 Local Variables; 2.2 Statements and Expressions; 2.3 Comments and Whitespace; 2.4 Preprocessing Directives; 2.5 Intrinsic Data Types; 2.6 Operators; 2.7 Flow Control; 2.8 Summary; Chapter 3: Types; 3.1 Classes; 3.2 Structs; 3.3 Members; 3.4 Interfaces; 3.5 Enums; 3.6 Other Types; 3.7 Partial Types and Methods; 3.8 Summary; Chapter 4: Generics; 4.1 Generic Types; 4.2 Constraints; 4.3 Zero-Like Values; 4.4 Generic Methods; 4.5 Inside Generics; 4.6 Summary; Chapter 5: Collections; 5.1 Arrays; 5.2 List; 5.3 List and Sequence Interfaces; 5.4 Implementing Lists and Sequences; 5.5 Dictionaries; 5.6 Sets; 5.7 Queues and Stacks; 5.8 Linked Lists; 5.9 Concurrent Collections; 5.10 Tuples; 5.11 Summary; Chapter 6: Inheritance; 6.1 Inheritance and Conversions; 6.2 Interface Inheritance; 6.3 Generics; 6.4 System.Object; 6.5 Accessibility and Inheritance; 6.6 Virtual Methods; 6.7 Sealed Methods and Classes; 6.8 Accessing Base Members; 6.9 Inheritance and Construction; 6.10 Special Base Types; 6.11 Summary; Chapter 7: Object Lifetime; 7.1 Garbage Collection; 7.2 Destructors and Finalization; 7.3 IDisposable; 7.4 Boxing; 7.5 Summary; Chapter 8: Exceptions; 8.1 Exception Sources; 8.2 Handling Exceptions; 8.3 Throwing Exceptions; 8.4 Exception Types; 8.5 Unhandled Exceptions; 8.6 Asynchronous Exceptions; 8.7 Summary; Chapter 9: Delegates, Lambdas, and Events; 9.1 Delegate Types; 9.2 Inline Methods; 9.3 Events; 9.4 Delegates Versus Interfaces; 9.5 Summary; Chapter 10: LINQ; 10.1 Query Expressions; 10.2 Deferred Evaluation; 10.3 LINQ, Generics, and IQueryable; 10.4 Standard LINQ Operators; 10.5 Sequence Generation; 10.6 Other LINQ Implementations; 10.7 Summary; Chapter 11: Reactive Extensions; 11.1 Rx and .NET Versions; 11.2 Fundamental Interfaces; 11.3 Publishing and Subscribing with Delegates; 11.4 Sequence Builders; 11.5 LINQ Queries; 11.6 Rx Query Operators; 11.7 Schedulers; 11.8 Subjects; 11.9 Adaptation; 11.10 Timed Operations; 11.11 Summary; Chapter 12: Assemblies; 12.1 Visual Studio and Assemblies; 12.2 Anatomy of an Assembly; 12.3 Type Identity; 12.4 Loading Assemblies; 12.5 Assembly Names; 12.6 Portable Class Libraries; 12.7 Packaged Deployment; 12.8 Protection; 12.9 Summary; Chapter 13: Reflection; 13.1 Reflection Types; 13.2 Reflection Contexts; 13.3 Summary; Chapter 14: Dynamic Typing; 14.1 The dynamic Type; 14.2 dynamic and Interoperability; 14.3 Inside Dynamic; 14.4 Limitations of dynamic; 14.5 Summary; Chapter 15: Attributes; 15.1 Applying Attributes; 15.2 Defining and Consuming Custom Attributes; 15.3 Summary; Chapter 16: Files and Streams; 16.1 The Stream Class; 16.2 Windows 8 and IRandomAccessStream; 16.3 Text-Oriented Types; 16.4 Files and Directories; 16.5 Serialization; 16.6 Summary; Chapter 17: Multithreading; 17.1 Threads; 17.2 Synchronization; 17.3 Tasks; 17.4 Other Asynchronous Patterns; 17.5 Cancellation; 17.6 Parallelism; 17.7 Summary; Chapter 18: Asynchronous Language Features; 18.1 Asynchronous Keywords: async and await; 18.2 The await Pattern; 18.3 Error Handling; 18.4 Summary; Chapter 19: XAML; 19.1 XAML-Based Frameworks; 19.2 XAML Basics; 19.3 Layout; 19.4 Controls; 19.5 Text; 19.6 Data Binding; 19.7 Graphics; 19.8 Styles; 19.9 Summary; Chapter 20: ASP.NET; 20.1 Razor; 20.2 Web Forms; 20.3 MVC; 20.4 Routing; 20.5 Summary; Chapter 21: Interoperability; 21.1 Calling Native Code; 21.2 Platform Invoke; 21.3 COM; 21.4 Windows Runtime; 21.5 Unsafe Code; 21.6 C++/CLI and the Component Extensions; 21.7 Summary; Colophon;|

• Preface
• Chapter 1: Introducing C#
• Chapter 2: Basic Coding in C#
• Chapter 3: Types
• Chapter 4: Generics
• Chapter 5: Collections
• Chapter 6: Inheritance
• Chapter 7: Object Lifetime
• Chapter 8: Exceptions
• Chapter 9: Delegates, Lambdas, and Events
• Chapter 10: LINQ
• Chapter 11: Reactive Extensions
• Chapter 12: Assemblies
• Chapter 13: Reflection
• Chapter 14: Dynamic Typing
• Chapter 15: Attributes
• Chapter 16: Files and Streams
• Chapter 17: Multithreading
• Chapter 18: Asynchronous Language Features
• Chapter 19: XAML
• Chapter 20: ASP.NET
• Chapter 21: Interoperability

INTRODUCTION xxv

PART I: GETTING STARTED

CHAPTER 1: INTRODUCING C# 3

A Short History of Object–Oriented Programming (OOP) 4

Installing C# 5

Downloading Visual Studio Professional 5

A Test Program Using C# 8

Creating a Project 9

The C# Integrated Development Environment 10

The Major IDE Windows 10

Using the Source Code Window 12

Adding a Toolbox Object to a Windows Form 13

Changing the Text of a Label Object 14

Running the Program 16

Summary 16

CHAPTER 2: UNDERSTANDING OBJECTS 19

Understanding Objects 20

Everyday Use of Objects 20

Class Properties 20

Class Methods 22

How Many Properties, How Many Methods? 23

Classes Are Simplifi cations of Objects 23

What Do I Do After I’ve Defi ned a Class? 23

Instantiating an Object of a Class 26

I Have an Object…Now What? 29

Why Hide the Data Inside an Object? 32

Getting Started with Objects 32

Developing a Program Plan 38

Where to Start? The Five Program Steps 38

The Five Program Steps 38

Creating a Simple Application Using Objects 40

Using the Program Steps to Create a Program Plan 40

1: Initialization 40

2: Input 41

3: Process 42

4: Display 43

5: Termination 43

Using C# to Implement Your Program Plan 43

Critique of the btnDisplayOutput Click Event Code 53

Summary 54

PART II: UNDERSTANDING C# SYNTAX

CHAPTER 3: UNDERSTANDING DATA TYPES 59

Computer Data 59

Integer Data Types 60

Range of Integer Data Types 61

Understanding Binary Numbers 61

Signed Integer Values 62

Which Integer Should You Use? 62

Variable Naming Rules and Conventions 63

Floating–Point Data Types 71

Which Floating–Point Data Type Should You Use? 74

Monetary Values: The Decimal Data Type 74

Using IntelliSense to Locate Program Errors 76

Syntax Rules and Error Messages 76

The Boolean Data Type 77

Summary 79

CHAPTER 4: UNDERSTANDING C# STATEMENTS 81

Basic Building Blocks of a Programming Language 82

Operands and Operators 82

Expressions 83

Statements 83

Operator Precedence 84

Overriding the Default Precedence Order 85

Defi ning Variables 87

Defi ning a Variable from the Compiler’s Point of View 87

Step 1: Preliminary Syntax Checking 87

Step 2: Symbol Table Checking 87

Step 3: Defi ning a Variable 89

Using a Variable in a Program 90

Bucket Analogy 91

Types of Program Errors 93

Syntax Errors 93

Semantic Errors 93

Logic Errors 94

The Visual Studio Debugger 94

The Debugging Process 94

Making Repetitious Debugging Easier 95

Using the Visual Studio Debugger 97

Setting a Breakpoint 97

Using a Breakpoint to Examine Variables 98

Single–Stepping the Program 100

Defensive Coding 101

Write Your Code So That Someone Else Can Easily Understand It 101

Use Program Comments 101

Use Meaningful Variable Names 103

Avoid Magic Numbers 104

Use a Consistent Coding Style 105

Take a Break 105

Use a Second Set of Eyes 105

Summary 106

CHAPTER 5: UNDERSTANDING REFERENCE DATA TYPES 109

String Variables 110

Defi ning a String Reference Variable 110

The Meaning of null 111

Why Reference Types Are Diff erent from Value Types 113

Reference Variable Rules 113

Reference Type Variables Versus Value Type Variables 115

Why Do Reference Variables Work the Way They Do? 115

Pass by Value Versus Pass by Reference 116

A Little Effi ciency Gain 116

Using String Variables 117

String Concatenation 117

Shorthand Assignment Operators 117

String Manipulation 118

String Length 118

Letting IntelliSense Show You Properties and Methods 119

Using an IntelliSense Option 120

An Important Distinction Between Properties and Methods 120

Thinking About Object Properties and Methods 120

Strings and Escape Sequences 131

Verbatim String Literals 132

DateTime Reference Objects 133

DateTime and ToString( ) Conversions 133

Class Constructors 139

Invoking the Application 139

The UpdateTimeInfo( ) Method 140

Overloaded Methods 141

Method Signatures 142

The Refresh Button 143

Summary 144

CHAPTER 6: MAKING DECISIONS IN CODE 147

Relational Operators 148

Using Relational Operators―The if Statement 148

The if–else Statement 152

Shorthand for Simple if–else: The Ternary Operator 154

Style Considerations for if and if–else Statements 155

Nested if Statements 157

RDC 158

Logical Operators 160

Using the Logical Operators 162

Associativity 163

The switch Statement 164

Summary 167

CHAPTER 7: STATEMENT REPETITION USING LOOPS 169

Program Loops 170

Good Loops, Bad Loops 170

The Three Conditions of a Well–Behaved Loop 170

The for Loop 171

Increment and Decrement Operators 172

Sequencing in a for Loop 173

When to Use a for Loop 179

Nested for Loops 179

Use the Debugger as a Learning Tool 182

while Loops 182

Why Have More Than One Type of Loop? 184

do–while Program Loops 185

The continue Statement 189

Summary 190

CHAPTER 8: UNDERSTANDING ARRAYS AND COLLECTIONS 193

What Is an Array? 194

Some Array Details 195

Array Element Versus Array Index 195

N – 1 Rule 196

Casts 201

The ListView Object 201

Arrays Are Objects 206

Multidimensional Arrays 207

Initializing Arrays 211

Variations for Initializing an Array 212

Which Array Defi nition/Initialization Syntax Is Best? 212

Code Like a User 212

Initializing Multidimensional Arrays 213

Initializer Lists for String Objects 213

Ragged Arrays 215

Defi ning Ragged Arrays at Runtime 215

Collections 216

ArrayList Objects 218

Summary 221

PART III: WRITING YOUR OWN CLASSES

CHAPTER 9: DESIGNING CLASSES 227

Class Design 228

Scope 230

Block Scope 231

Local Scope 232

Class Scope 232

Namespace Scope 233

Visualizing Scope 233

Why Does C# Support Scope? 235

Think Before You Write 235

Designing a Program 236

The Five Program Steps 236

Initialization Step 236

Input Step 238

Process Step 238

Display Step 238

Termination Step 238

Look at the Forest, Not Just the Trees 238

UML Light 239

Access Specifi ers 239

Access Specifi ers and Scope 240

The static Keyword 241

UML Methods 242

Design Intent and Access Specifi ers for Methods 242

Class Property and Method Names 244

Think Like a User 245

The clsDates Design 245

namespace Modifi er 247

Class Organization 248

static Data Versus Instance Members 248

Property and Helper Methods 249

General Methods 249

User Interfaces Versus User Interfaces 252

Summary 252

CHAPTER 10: DESIGNING AND WRITING CUSTOM CLASSES 255

Constructors 256

Default Constructors 256

Nondefault Constructors 256

Constructor Overloading 257

Constructor Sloppiness 257

Fixing the Constructor Problem 258

Always Call the Default Constructor 259

Property Methods 259

Property Methods and Getters and Setters 260

Property Method Rules 261

How the get Property Methods Work 262

How Does Visual Studio Know Whether to

Use the get or set Statement Block? 263

What to Do if an Error Occurs in a Property Method 264

Method Coupling and Cohesion 266

Cohesion 266

Coupling 266

Class Design for Deck–of–Cards Program 267

UML Class Diagram for Shuffl e Deck Program 268

Class Constants and Properties 268

Class Methods 269

The clsCardDeck Code 273

Class Properties, Constructor, and Property Methods 275

Class General Methods 276

Designing a Card Game Using clsCardDeck 278

Design Considerations 279

What Kind of Architecture? 279

Sideways Refi nement 280

Summary 291

CHAPTER 11: EXCEPTION HANDLING AND DEBUGGING 295

Overview 296

Bugs 296

Syntax Errors 296

Semantic Errors 296

Logic Errors 297

Input Errors 297

Data Validation 297

Limit User Input 298

Check Boxes 301

Combination Boxes 302

Date and Time Input 304

Exception Handling 306

try–catch Statement Blocks 308

Anticipating a Specifi c Exception 310

Fuzzy Exception Messages 312

The fi nally Statement Block 313

Program Debugging 314

The Nature of the Beast 314

Detection 314

Isolation 316

The Visual Studio Debugger 316

The Locals Window 317

The Immediate Window 318

Single–Stepping Through the Program 318

Backing Up from a Breakpoint 319

The Debug Toolbar 319

Finding the Bug 320

Scaff old Code 321

Toggling Scaff old Code 322

Defensive Coding 322

Summary 323

CHAPTER 12: GENERICS 327

What Are Generics? 327

Recursion 333

Data Problems 333

Introduction to Generics 334

Generics Versus ArrayLists 334

Boxing and Unboxing 335

Generic Quicksort 343

Using Generics with Constraints and Interfaces 347

Interfaces 347

Why Use an Interface? 348

Using an Interface 349

How Do You Know an Interface Is Implemented for a Data Type? 350

Summary 354

PART IV: STORING DATA

CHAPTER 13: USING DISK DATA FILES 359

Directories 360

The DriveInfo Class 360

Directory Class 360

DirectoryInfo Class 361

File Class 367

FileInfo Class 368

Types of Files 369

Textual Versus Binary Data Files 370

Sequential Versus Random Access Files 380

Sequential Files 380

Advantages and Disadvantages of Sequential Files 380

Random Access Files 381

Fixed Record Sizes 381

Advantages and Disadvantages of Random Access Files 383

Serialization and Deserialization 411

To Serialize or Not to Serialize 417

MDI, Menus, and File Dialogs 418

Summary 422

CHAPTER 14: USING DATABASES 425

What Is a Database? 425

The Structure of a Database 426

Database Tables, Fields, and Records 426

Designing Fields for a Database Table 427

Data Normalization 428

Creating Your Own Databases 432

Using SQL Server Management Studio 432

Using SQL 435

The SELECT Statement 435

The WHERE Predicate 436

The ORDER BY Clause 436

Aggregates 437

A DBMS System 438

Displaying Database Data Without Data Binding 451

Performing the Query 452

Edit a Record (UPDATE) 454

Summary 456

CHAPTER 15: USING LINQ 459

Using LINQ 459

Query Keywords 460

Summary 470

PART V: ADVANCED TOPICS

CHAPTER 16: INHERITANCE AND POLYMORPHISM 475

What Is Inheritance? 476

An Inheritance Example 476

The Base and Derived Classes 478

The protected Access Specifi er 479

Advantages of Inherited Relationships 480

Base Classes Are Not Derived Classes 491

Abstract Classes 491

Polymorphism 492

Extension Methods 495

Summary 498

CHAPTER 17: PRINTING AND THREADING 501

Using a Printer 501

Threading 509

A Threading Program 510

What Have You Gained with Threading? 515

Refactoring 516

Rename 516

Extract Method 516

Summary 520

CHAPTER 18: WEB PROGRAMMING 523

Static Web Pages 523

Dynamic Web Pages 530

Summary 535

APPENDIX: ANSWERS TO EXERCISES 539

INDEX 577

Introduction; Who should read this book; Who should not read this book; Organization of this book; Conventions and features in this book; System requirements; Code samples; Acknowledgments; Errata and book support; We want to hear from you; Stay in touch; Introducing Microsoft Visual C# and Microsoft Visual Studio 2013; Chapter 1: Welcome to C#; 1.1 Beginning programming with the Visual Studio 2013 environment; 1.2 Writing your first program; 1.3 Using namespaces; 1.4 Creating a graphical application; 1.5 Summary; 1.6 Quick Reference; Chapter 2: Working with variables, operators, and expressions; 2.1 Understanding statements; 2.2 Using identifiers; 2.3 Using variables; 2.4 Working with primitive data types; 2.5 Using arithmetic operators; 2.6 Incrementing and decrementing variables; 2.7 Declaring implicitly typed local variables; 2.8 Summary; 2.9 Quick Reference; Chapter 3: Writing methods and applying scope; 3.1 Creating methods; 3.2 Applying scope; 3.3 Writing methods; 3.4 Using optional parameters and named arguments; 3.5 Summary; 3.6 Quick reference; Chapter 4: Using decision statements; 4.1 Declaring Boolean variables; 4.2 Using Boolean operators; 4.3 Using if statements to make decisions; 4.4 Using switch statements; 4.5 Summary; 4.6 Quick reference; Chapter 5: Using compound assignment and iteration statements; 5.1 Using compound assignment operators; 5.2 Writing while statements; 5.3 Writing for Statements; 5.4 Writing do statements; 5.5 Summary; 5.6 Quick reference; Chapter 6: Managing errors and exceptions; 6.1 Coping with errors; 6.2 Trying code and catching exceptions; 6.3 Using checked and unchecked integer arithmetic; 6.4 Throwing exceptions; 6.5 Using a finally block; 6.6 Summary; 6.7 Quick reference; Understanding the C# object model; Chapter 7: Creating and managing classes and objects; 7.1 Understanding classification; 7.2 The purpose of encapsulation; 7.3 Defining and using a class; 7.4 Controlling accessibility; 7.5 Understanding static methods and data; 7.6 Summary; 7.7 Quick reference; Chapter 8: Understanding values and references; 8.1 Copying value type variables and classes; 8.2 Understanding null values and nullable types; 8.3 Using ref and out parameters; 8.4 How computer memory is organized; 8.5 The System.Object class; 8.6 Boxing; 8.7 Unboxing; 8.8 Casting data safely; 8.9 Summary; 8.10 Quick reference; Chapter 9: Creating value types with enumerations and structures; 9.1 Working with enumerations; 9.2 Working with structures; 9.3 Summary; 9.4 Quick reference; Chapter 10: Using arrays; 10.1 Declaring and creating an array; 10.2 Populating and using an array; 10.3 Copying arrays; 10.4 Using multidimensional arrays; 10.5 Summary; 10.6 Quick reference; Chapter 11: Understanding parameter arrays; 11.1 Overloading—a recap; 11.2 Using array arguments; 11.3 Comparing parameter arrays and optional parameters; 11.4 Summary; 11.5 Quick reference; Chapter 12: Working with inheritance; 12.1 What is inheritance?; 12.2 Using inheritance; 12.3 Understanding extension methods; 12.4 Summary; 12.5 Quick reference; Chapter 13: Creating interfaces and defining abstract classes; 13.1 Understanding interfaces; 13.2 Abstract classes; 13.3 Sealed classes; 13.4 Summary; 13.5 Quick reference; Chapter 14: Using garbage collection and resource management; 14.1 The life and times of an object; 14.2 Resource management; 14.3 Implementing exception-safe disposal; 14.4 Summary; 14.5 Quick reference; Defining extensible types with C#; Chapter 15: Implementing properties to access fields; 15.1 Implementing encapsulation by using methods; 15.2 What are properties?; 15.3 Understanding the property restrictions; 15.4 Declaring interface properties; 15.5 Generating automatic properties; 15.6 Initializing objects by using properties; 15.7 Summary; 15.8 Quick reference; Chapter 16: Using indexers; 16.1 What is an indexer?; 16.2 Indexers in interfaces; 16.3 Using indexers in a Windows application; 16.4 Summary; 16.5 Quick reference; Chapter 17: Introducing generics; 17.1 The problem with the object type; 17.2 The generics solution; 17.3 Creating a generic class; 17.4 Creating a generic method; 17.5 Variance and generic interfaces; 17.6 Summary; 17.7 Quick reference; Chapter 18: Using collections; 18.1 What are collection classes?; 18.2 Using collection initializers; 18.3 The Find methods, predicates, and lambda expressions; 18.4 Comparing arrays and collections; 18.5 Summary; 18.6 Quick reference; Chapter 19: Enumerating collections; 19.1 Enumerating the elements in a collection; 19.2 Implementing an enumerator by using an iterator; 19.3 Summary; 19.4 Quick reference; Chapter 20: Decoupling application logic and handling events; 20.1 Understanding delegates; 20.2 Lambda expressions and delegates; 20.3 Enabling notifications by using events; 20.4 Understanding user interface events; 20.5 Summary; 20.6 Quick reference; Chapter 21: Querying in-memory data by using query expressions; 21.1 What is Language-Integrated Query?; 21.2 Using LINQ in a C# application; 21.3 Summary; 21.4 Quick reference; Chapter 22: Operator overloading; 22.1 Understanding operators; 22.2 Understanding compound assignment evaluation; 22.3 Declaring increment and decrement operators; 22.4 Comparing operators in structures and classes; 22.5 Defining operator pairs; 22.6 Implementing operators; 22.7 Understanding conversion operators; 22.8 Summary; 22.9 Quick reference; Building professional Windows 8.1 applications with C#; Chapter 23: Improving throughput by using tasks; 23.1 Why perform multitasking by using parallel processing?; 23.2 Implementing multitasking by using the Microsoft .NET Framework; 23.3 Canceling tasks and handling exceptions; 23.4 Summary; 23.5 Quick reference; Chapter 24: Improving response time by performing asynchronous operations; 24.1 Implementing asynchronous methods; 24.2 Using PLINQ to parallelize declarative data access; 24.3 Synchronizing concurrent access to data; 24.4 Summary; 24.5 Quick reference; Chapter 25: Implementing the user interface for a Windows Store app; 25.1 What is a Windows Store app?; 25.2 Using the Blank App template to build a Windows Store app; 25.3 Summary; 25.4 Quick reference; Chapter 26: Displaying and searching for data in a Windows Store app; 26.1 Implementing the Model-View-ViewModel pattern; 26.2 Summary; 26.3 Quick reference; Chapter 27: Accessing a remote database from a Windows Store app; 27.1 ; 27.2 Summary; 27.3 Quick reference; About the author;|

• Introduction
• Introducing Microsoft Visual C# and Microsoft Visual Studio 2013
  • Chapter 1: Welcome to C#
  • Chapter 2: Working with variables, operators, and expressions
  • Chapter 3: Writing methods and applying scope
  • Chapter 4: Using decision statements
  • Chapter 5: Using compound assignment and iteration statements
  • Chapter 6: Managing errors and exceptions
• Understanding the C# object model
  • Chapter 7: Creating and managing classes and objects
  • Chapter 8: Understanding values and references
  • Chapter 9: Creating value types with enumerations and structures
  • Chapter 10: Using arrays
  • Chapter 11: Understanding parameter arrays
  • Chapter 12: Working with inheritance
  • Chapter 13: Creating interfaces and defining abstract classes
  • Chapter 14: Using garbage collection and resource management
• Defining extensible types with C#
  • Chapter 15: Implementing properties to access fields
  • Chapter 16: Using indexers
  • Chapter 17: Introducing generics
  • Chapter 18: Using collections
  • Chapter 19: Enumerating collections
  • Chapter 20: Decoupling application logic and handling events
  • Chapter 21: Querying in-memory data by using query expressions
  • Chapter 22: Operator overloading
• Building professional Windows 8.1 applications with C#
  • Chapter 23: Improving throughput by using tasks
  • Chapter 24: Improving response time by performing asynchronous operations
  • Chapter 25: Implementing the user interface for a Windows Store app
  • Chapter 26: Displaying and searching for data in a Windows Store app
  • Chapter 27: Accessing a remote database from a Windows Store app

Preface

1: Introduction
2: Using objects
3: Inside objects
4: Control and arrays
5: Graphical user interfaces with Views
6: Exceptions and Debugging
7: Files and streams
8: Collections
9: Polymorphism and inheritance
10: Graphics and networking

The appendixes are:
A: List of Forms
B: Keywords and operators
C: Formatters
D: Unicode
E: Useful namespaces
F: The Views.Form class
G: Debugging with Windows

Description

C# (‘C Sharp’) is an object-oriented, network-enabled programming language, developed expressly for Microsoft’s .Net platform. C# provides the features that are the most important to programmers: object-orientation, graphics, GUI components, internet-based client/server networking and distributed computing. C# Concisely is an introductory text which teaches object-oriented programming using the C# language.  The reader is involved in object-orientation from the beginning, while developing skills in the use of control structures and data structures. The book covers nearly all of the language and its important namespaces, including collections and  networking, and works through polymorphism and extensibility thoroughly. While targeted at first year students, C# Concisely is equally applicable for those wishing to convert from other languages, and will be an invaluable resource for students at all levels.

Features

• Strong focus on complete programs as examples throughout the book including six case studies
• Use of object-oriented concepts from the beginning
• Extensive use of GUIs in programming examples to give them a modern and visually interesting feel
• A chapter and an appendix devoted to debugging C# programs using tools provided on the Windows platform
• Quiz questions and programming exercises are provided at the end of every chapter.  Summaries of key language features appear throughout, and the book contains several appendices for reference
• Concludes with a chapter giving the student a taste of graphics, events, networking and web programming.

Table of Contents

Preface

1: Introduction
2: Using objects
3: Inside objects
4: Control and arrays
5: Graphical user interfaces with Views
6: Exceptions and Debugging
7: Files and streams
8: Collections
9: Polymorphism and inheritance
10: Graphics and networking

The appendixes are:
A: List of Forms
B: Keywords and operators
C: Formatters
D: Unicode
E: Useful namespaces
F: The Views.Form class
G: Debugging with Windows

Back Cover

C# is an object-oriented, network-enabled programming language,

developed expressly for Microsoft’s .NET platform. C# and the

associated class libraries provide the features that are the most

important to programmers: object-orientation, graphics,

GUI components, internet-based client-server networking and

distributed computing.

 

C# Concisely

is an introductory text which teaches object-oriented

programming using the C# language. The reader is involved in

object-orientation from the beginning, while developing skills in the

use of control structures and data structures. The book covers nearly

all of the language and its important namespaces, including collections

and networking, and works through polymorphism and extensibility

in depth.

 

Key Features

• Strong focus on complete programs as examples throughout the book

• Use of object-oriented concepts from the beginning

• Extensive use of GUIs to give programs a modern and visually

interesting feel

• A chapter and an appendix devoted to debugging C# programs

• Quiz questions and programming exercises are provided at the end of

every chapter.

• Summaries of key language features appear throughout, in a novel and

precise way

• Several appendices cross-reference key features in the book

• Includes a chapter giving a taste of graphics, events, networking and web

programming.

While targeted at first year students, C# Concisely is equally

applicable for those wishing to convert from other languages, and will

be an invaluable resource for students at all levels.

Introduction 1

Who Should Read This Book? 2

What You Need to Know Before You Read This Book 2

How This Book Is Organized 3

1 Introducing the NET Platform 5

A Historical Perspective 5

A 10,000-Feet View of the NET Platform. 9

The Common Language Infrastructure 12

The Multilanguage Aspect of NET 15

Introducing NET Assemblies. 16

The Common Type System Explained 17

Executing Managed Code 24

Diving into the Common Language Runtime 32

The Base Class Library 51

Summary 54

2 Introducing the C# Programming Language 55

The Evolution of C# 55

A Sneak Peek at the Future 95

Summary 102

3 Getting Started with NET Development Using C# 103

Installing the NET Framework 103

Your First Application: Take One 113

Visual Studio 2012 119

Your First Application: Take Two 127

Summary 173

4 Language Essentials 175

The Entry Point 175

Keywords 181

A Primer on Types 184

Built-In Types 190

Local Variables. 212

Intermezzo on Comments 223

Arrays 230

The Null Reference 239

Nullable Value Types 243

Summary 249

5 Expressions and Operators 251

What Are Expressions? 251

The Evaluation Stack 255

Arithmetic Operators 258

String Concatenation 269

Shift Operators 274

Relational Operators 275

Logical Operators 277

Conditional Operators 281

An Operator’s Result Type 284

Null-Coalescing Operator 285

Assignment 287

Summary 299

6 A Primer on Types and Objects 301

Implicit Versus Explicit Conversions 301

The typeof Operator: A Sneak Peek at Reflection 319

Default Value Expression 322

Creating Objects with the new Operator 324

Member Access 336

Invocation Expressions 340

Element Access 348

Summary 349

7 Simple Control Flow 351

What Are Statements, Anyway? 351

Expression Statements 353

The Empty Statement 355

Statement Blocks. 356

Declarations 357

Selection Statements 358

Iteration Statements 375

A Peek at Iterators 391

Loops in the Age of Concurrency 398

The goto Statement 400

The return Statement 404

Summary 406

8 Basics of Exceptions and Resource Management 407

Exception Handling 407

Deterministic Resource Cleanup 438

Locking on Objects 448

Summary 462

9 Introducing Types 463

Types Revisited 463

Classes Versus Structs 466

Type Members 486

Summary 499

10 Methods 501

Defining Methods 501

Specifying the Return Type 502

Declaring Parameters 504

Overloading 519

Extension Methods 524

Partial Methods 534

Extern Methods 538

Refactoring 540

Code Analysis 545

Summary 546

11 Fields, Properties, and Indexers 547

Fields 547

An Intermezzo About Enums 563

Properties 574

Indexers 580

Summary 583

12 Constructors and Finalizers 585

Constructors 585

Static Constructors 592

Destructors (Poorly Named Finalizers) 595

Summary 608

13 Operator Overloading and Conversions 609

Operators 609

Conversions 633

Summary 647

14 Object-Oriented Programming 649

The Cornerstones of Object Orientation 649

Inheritance for Classes 663

Protected Accessibility 674

Polymorphism and Virtual Members 676

Abstract Classes 688

Interface Types 690

Summary 699

15 Generic Types and Methods 701

Life Without Generics 701

Getting Started with Generics 704

Declaring Generic Types 707

Using Generic Types 712

Performance Intermezzo 714

Operations on Type Parameters 718

Generic Constraints 720

Generic Methods 736

Co- and Contravariance 743

Summary 754

16 Collection Types 755

Nongeneric Collection Types 755

Generic Collection Types 765

Thread-Safe Collection Types 778

Other Collection Types 786

Summary 787

17 Delegates 789

Functional Programming 789

What Are Delegates? 794

Delegate Types 794

Delegate Instances 798

Invoking Delegates 811

Putting It Together: An Extensible Calculator 815

Case Study: Delegates Used in LINQ to Objects 819

Asynchronous Invocation 823

Combining Delegates 835

Summary 842

18 Events 843

The Two Sides of Delegates 844

A Reactive Application 845

How Events Work 853

Raising Events, the Correct Way 855

add and remove Accessors 857

Detach Your Event Handlers 861

Recommended Event Patterns 871

Case Study: INotifyProperty Interfaces and UI Programming 880

Countdown, the GUI Way 890

Event Interoperability with WinRT 896

Introduction to Reactive Programming 898

Summary 911

19 Language Integrated Query Essentials 913

Life Without LINQ 914

LINQ by Example 921

Query Expression Syntax 931

Summary 975

20 Language Integrated Query Internals 977

How LINQ to Objects Works 977

Standard Query Operators 1000

The Query Pattern 1033

Parallel LINQ 1036

Expression Trees 1045

Summary 1055

21 Reflection 1057

Typing Revisited, Static and Otherwise. 1058

Reflection 1063

Lightweight Code Generation 1091

Expression Trees 1101

Summary 1117

22 Dynamic Programming 1119

The dynamic Keyword in C# 4.0    1119

DLR Internals 1137

Office and COM Interop 1159

Summary 1174

23 Exceptions 1175

Life Without Exceptions 1175

Introducing Exceptions 1178

Exception Handling 1180

Throwing Exceptions 1196

Defining Your Own Exception Types 1198

(In)famous Exception Types 1201

Summary 1220

24 Namespaces 1221

Organizing Types in Namespaces 1221

Declaring Namespaces 1227

Importing Namespaces 1231

Summary 1240

25 Assemblies and Application Domains 1241

Assemblies 1241

Application Domains 1286

Summary 1298

26 Base Class Library Essentials 1301

The BCL: What, Where, and How? 1303

The Holy System Root Namespace 1311

Facilities to Work with Text 1356

Summary 1372

27 Diagnostics and Instrumentation 1373

Ensuring Code Quality 1374

Instrumentation 1388

Controlling Processes 1396

Summary 1398

28 Working with I/O 1399

Files and Directories 1399

Monitoring File System Activity 1407

Readers and Writers 1409

Streams: The Bread and Butter of I/O 1415

A Primer to (Named) Pipes 1434

Memory-Mapped Files in a Nutshell 1437

Overview of Other I/O Capabilities 1440

Summary 1440

29 Threading and Synchronization 1443

Using Threads 1444

Thread Pools 1474

Synchronization Primitives 1482

Summary 1511

30 Task Parallelism and Data Parallelism 1513

Pros and Cons of Threads 1514

The Task Parallel Library 1515

Task Parallelism 1520

Data Parallelism 1542

Summary 1550

31 Asynchronous Programming 1551

Why Asynchronous Programming Matters 1551

Old Asynchronous Programming Patterns 1564

Asynchronous Methods and await Expressions 1584

Behind the Scenes 1610

Advanced Topics 1634

Summary 1641

32 Introduction to Windows Runtime 1643

What Is Windows Runtime? 1643

Creating a Windows Runtime Component 1658

Overview of the Windows Runtime APIs 1667

Summary 1669

Index 1671