C# Primer: A Practical Approach

binary operators, 110

invocation, 107

compound assignment, 108

unary operators, 109

get read access, 69

set write access, 69

access usage, 80

static vs. instance, 79

in constructor, 75

as reference, 76-78

Runtime (CLR), 349

Specification (CLS), 378

cast, 37

derived to base class, 127

explicit, 37, 42, 49

foreach vs. for loop, 39

implicit, 101

operators, see class

overload resolution, 102

smaller than int, 49

standard implicit, 101

see System.ICloneable

D

declaration, 87

Delegate interface, 92

invocation, 90

object reference, 91

reference type, 88

set to instance method, 88

set to multiple methods, 90

set to static method, 88

single vs. multiple methods, 87

see System.IDisposeable

System.Collections.Hashtable

E

enumerator values, 84

relation to int, 84

underlying type, 85

see System.Environment

catch clause, 44-45

catch resolution, 157

defining our own exceptions, 156

Exception class hierarchy, 45, 154-158

arithmetic, 51

checked, 52

conditional, 51

exceptions, 52

integral promotion, 50

overflow, 172

relational, 51

unchecked, 52

F

see System.IDisposable

See also namespaces

see class member function

G

resource cleanup,

see System.IDisposable

See also class destructor

H

System.Collections.Hashtable

I

see interface inheritance

see object-oriented

array, 31

access existing interface, 163-166

allowed member types, 167

contrast to abstract base class, 159

defining an interface, 166-180

determining the exceptions, 173-174

explicit interface member, 178-180

implement all members, 168

implement interface, 160-163

inheritance and visibility, 180-185

inheriting from an interface, 168-174

integration with framework, 174

master copy semantics, 185-187

master finalize semantics, 187-190

resolving ambiguity, 184

simplest definition, 167

virtual methods, 181-183

See also object-oriented

See also System.IEnumerator

K

L

See also garbage collection

M

command-line arguments, 11

program entry point, 2

program exit status, 11

return value, 11

See also garbage collection

System.Collections.Hashtable

N

fully qualified, 5, 8

inheritance resolution, 148

local resolution, 26

name collision, 6

naming rules, 6, 48

resolution based on visiblity, 150

visibility of name, 6

definition, 8

name collision, 7

naming conventions, 10

visibility rules, 8

See also Attributes, DllImport

O

heterogeneous parameter list, 105

universal assignment, 130

See also System.Object

See also universal type system

abstract base class, 118, 132-139

abstract keyword, 135

abstract virtual function, 134

definition, 133

hybrid design, 138-139

abstract derived class, 135

composition, 194

copy semantics

see System.ICloneable

derived class, 118, 143-152

abstract, 143

access hidden member, 135

base constructor, 144

constructor, 143

member access, 147-152

member resolution, 148

new specifier, 149

virtual function, 145-146

deterministic finalization

see System.IDisposable

hybrid base class, 141-142

implementation inheritance, 142

implicit conversion, 127

inheritance hierarchy, 118, 126

member resolution, 150

methods hidden by signature, 184

polymorphism, 118-120

refactoring, 136

single inheritance, 140-141

static member, 137-138

type/subtype, 126

virtual function, 128, 134

abstract, 134-135

covariant return type, 145

override, 145

static invocation, 153

virtual indexers, 136

virtual properties, 136

See also interface inheritance

See also class

precedence, 18, 54-55

overloading, see class

formatted output, 20

See also Console

See also System.IO

functions, see class

operators, see class

subscript, see class indexer

P

class member functions

class member functions

class member functions

R

pass by value, 94-96

See also array

See also class

See also delegate

See also System.Reflection 353

See also System.Type

System.Text.RegularExpressions

see System.Activator

see System.Reflection

as operator, 38

is operator, 38

S

global, 6

local, 24-27

lifetime, 36

order dependent, 26

uninitialized, 24

break, 20

continue, 19

do-while, 25, 56

for, 22, 56

foreach, 13, 39, 56

if, 12, 56

if-else, 13

return, 12-13

switch, 14-16, 57

while, 56

implicit default constructor, 114

initialization, 115

new expression, 114

non-garbage collected, 114

performance, 116

value type, 29

Activator, 363

CreateInstance(), 363, 367

Array, 200-203

BinarySearch(), 203

Clear(), 202

Copy(), 202

CopyTo(), 201

GetLength(), 201

IndexOf(), 202, 203

Sort(), 206

Attribute, see Attributes

Console, 2

ReadLine(), 24

Write(), 2

WriteLine(), 2

DateTime, 208, 226-227

Drawing

Bitmap, 312

Graphics, 314

Environment, 204-207

GetLogicalDirves(), 209

OSVersion, 205

ICloneable, 185-187, 195

IComparable, 160-163, 164-166

IDisposable, 187-190

IEnumerable, 174

IEnumerator, 175-178

Math, 225

namespace introduction, 3

OperatingSystem, 205

PlatformID, 205

TimeSpan, 208

Windows.Forms, see Windows

ArrayList, 33-35, 160

BitArray, 190-197

Hashtable, 41-43

ICollection, 194

IDictionary, 43

Queue, 223

Stack, 221-223

connection string, 252, 253, 325

DataRelation, 251, 257-258

DataSet, 253

DataSet/XML interop, 260

DataTable, 254-257

Select(), 258-259

OleDbCommand, 253

OleDbConnection, 253

OleDbDataAdapter, 253

selection string, 325

SqlClient, 325-326

SqlCommand, 326

SqlConnection, 325

SqlDataAdapter, 326

Process, 207-208

GetCurrentProcess(), 207

GetProcesses(), 207

TraceListener, 223-225

Directory, 209, 210, 212-215

Exists(), 210

GetDirectories(), 213

DirectoryInfo, 209, 212-215

CreateFile(), 213

CreateSubdirectory(), 213

GetFiles(), 213

File, 44, 210, 215-221

Exists(), 210

OpenRead(), 218

OpenWrite(), 218

file read and write, 216-221

FileAccess, 219

FileInfo, 209, 215-221

AppendText(), 217

CreateText(), 217

OpenText(), 217

FileMode, 218

FileShare, 219

Path, 209, 210-212

ChangeExtension(), 211

DirectorySeparatorChar, 214

GetExtension(), 211

Stream, 218-221, 244

Read(), 218

Seek, 219-221

Write(), 218

StreamReader, 17-18, 216-217

StreamWriter, 17-18, 216-217

See also System.Console

HttpWebRequest, 243

Sockets, 245-249

NetworkStream, 245, 248

Socket, 247

Connected, 247

Receive(), 247

Send(), 248

TcpClient, 245, 248-249

GetStream(), 248

TcpListener, 245, 246-248

AcceptSocket(), 247

Start(), 246

Uri, 242

UriBuilder, 243

WebRequest, 243

Create(), 243

GetResponse(), 244

WebResponse, 244

Equals(), 130, 131, 147

GetType(), 131

implicit base class, 131

overriding methods, 146-147

ToString(), 130, 131, 146

Assembly, 350

BindingFlags enum, 358-362

ConstructorInfo, 354, 361

EventInfo, 354

FieldInfo, 354, 359, 360

Invoke(), 362

MemberInfo, 354

MethodInfo, 351, 354, 362-364

ParameterInfo, 354, 357

PropertyInfo, 354, 358, 359

runtime invocation, 362-364

RegularExpressions, 228-235

expression syntax, 228-230

Group, 233

Regex, 231-234

Split(), 233

Replace(), 234

StringBuilder, 23, 147, 195

Monitor, 240-241

Enter(), 240-241

Exit(), 240-241

TryEnter(), 241

Thread, 236-239

Abort(), 239

Join(), 239

Resume(), 238

Sleep(), 237

Start(), 238

Suspend(), 238

ThreadPool, 241

ThreadStart class, 238

access to Info classes, 355

gateway to reflection, 354-356

GetType(), 351

interop with DataSet, 259

Schema, 281

Serialization, 281

whitespace, 268

XmlDocument,

260-263, 272-277

XmlNode hierarchy, 274-276

XmlNodeType, 268-270

XmlSerializer, 263

XmlTextReader, 265-272

XmlTextWriter, 263

XPath, 279-281

XPathNavigator, 279

MoveToFirstChild(), 280

MoveToNext(), 280

Select(), 280

SelectChildren(), 280

XPathDocument, 279

Xsl, 277-279

Load(), 277

Transform(), 277

XslTransform, 277

T

alias for System, 51, 199-200

bool, 14

byte, 35, 49

char, 50

conversion, 37, 49

decimal, 50, 172

double, 50

float, 50

int, 49

long, 49

numeric literals, 49

numeric types, 49-51

predefined, 5

promotion, 50

reference, 28, 36

run-time query, 38

string, 21-23

Equals(), 14

immutable, 23

Split(), 21

unified type system, 35-38

unsigned, 49

value, 28, 36

verbatim string literal, 17

void, 11

U

see System.IDisposable

directive, 2, 4, 8

directive alias, 9

directive vs. qualified name, 5

statement, 190

V

See also enum

See also struct

see params keyword

see class member function

see name

see namespaces

add new item, 65

build program, 65

Class View window, 65

compiler errors, 65

execute program, 65

opening a project, 63-65

Properties window, 286, 287, 290

renaming file, 65

Solution Explorer, 64

Toolbox window, 288

W

See also Attributes, DllImport

Bitmap class, 312

Controls

Button, 293-294, 304

CheckBox, 306

ContextMenu, 307

DataGrid, 308-310

FileDialog, 302-303

Labels, 296-297

ListBox, 299-302

Menus, 306-307

PictureBox, 310-312

RadioButton, 305

TextBox, 292, 292-293

event handlers, 288-295

Click, 293

inspecting events, 295-296

OnPaint(), 313

Quit, 295

TextChanged, 292

MessageBox, 294, 298-299

Project, 285-288

Code view, 290

Designer view, 286, 290

inspecting events, 295

opening a project, 285

Properties window, 286-287, 290

Toolbox window, 288

Preface

C# is a new language invented at Microsoft and introduced with Visual Studio.NET. More than a million lines of C# code already have gone into the implementation of the .NET class framework. This book covers the C# language and its use in programming the .NET class framework, illustrating application domains such as ASP.NET and XML.

My general strategy in presenting the material is to introduce a programming task and then walk through one or two implementations, introducing language features or aspects of the class framework as they prove useful. The goal is to demonstrate how to use the language and class framework to solve problems rather than simply to list language features and the class framework API.

Learning C# is a two-step process: learning the details of the C# language and then becoming familiar with the .NET class framework. This two-step process is reflected in the organization of this text.

In the first step we walk through the language--both its mechanisms, such as class and interface inheritance and delegates, and its underlying concepts, such as its unified type system, reference versus value types, boxing, and so on. This step is covered in the first four chapters.

The second step is to become familiar with the .NET class framework, in particular with Windows and Web programming and the support for XML. This is the focus of the second half of the book.

Working your way through the text should jump-start your C# programming skills. In addition, you'll become familiar with a good swatch of the .NET class framework. All the program code is available for download at my company's Web site www.objectwrite.com.

Mail can be sent to me directly at slippman@objectwrite.com.

Organization of the Book

The book is organized into eight relatively long chapters. The first four chapters focus on the C# language, looking at the built-in language features, the class mechanism, class inheritance, and interface inheritance. The second four chapters explore the various library domains supported within the .NET class framework.

Chapter 1 covers the basic language, as well as some of the fundamental classes provided within the class framework. The discussion is driven by the design of a small program. Concepts such as namespaces, exception handling, and the unified type system are introduced.

Chapter 2 covers the fundamentals of building classes. We look at access permission, distinguish between const and readonly members, and cover specialized methods such as indexers and properties. We walk through the different strategies of member initialization, as well as the rules for operator overloading and conversion operators. We look at the delegate type, which serves as a kind of universal pointer to a function.

Chapters 3 and 4 cover, in turn, class and interface inheritance. Class inheritance allows us to define a family of specialized types that override a generic interface, such as an abstract WebRequest base class and a protocol-specific HttpWebRequest subtype. Interface inheritance, on the other hand, allows us to provide a common service or shared attribute for otherwise unrelated types. For example, the IDisposable interface frees resources. Classes holding database connections or window handles are both likely to implement IDisposable, although they are otherwise unrelated.

Chapter 5 provides a wide-ranging tour of the .NET class library. We look at input and output, including file and directory manipulation, regular expressions, sockets and thread programming, the WebRequest and WebResponse class hierarchies, a brief introduction to ADO.NET and establishing database connections, and the use of XML.

Chapters 6 and 7 cover, in turn, drag-and-drop Windows Forms and Web Forms development. Chapter 7 focuses on ASP.NET, and the Web page life cycle. Both chapters provide lots of examples of using the prebuilt controls and attaching event handlers for user interaction.

The final chapter provides a programmer's introduction to the .NET Common Language Runtime. It focuses on assemblies, type reflection, and attributes, and concludes with a brief look at the underlying intermediate language that is the compilation target of all .NET languages.

Written for Programmers

The book does not assume that you know C++, Visual Basic, or Java. But it does assume that you have programmed in some language. So, for example, I don't assume that you know the exact syntax of the C# foreach loop statement, but I do assume that you know what a loop is. Although I will illustrate how to invoke a function in C#, I assume you know what I mean when I say we "invoke a function." This text does not require previous knowledge of object-oriented programming or of the earlier versions of ASP and ADO.

Some people--some very bright people--argue that under .NET, the programming language is secondary to the underlying Common Language Runtime (CLR) upon which the languages float like the continents on tectonic plates. I don't agree. Language is how we express ourselves, and the choice of one's language affects the design of our programs. The underlying assumption of this book is that C# is the preferred language for .NET programming.

The book is organized into eight relatively long chapters. The first set of four chapters focuses on the C# language, looking at the built-in language features, the class mechanism, class inheritance, and interface inheritance. The second set of four chapters explores the various library domains supported within the .NET class framework, such as regular expressions, threading, sockets, Windows Forms, ASP.NET, and the Common Language Runtime.

Lexical Conventions

Type names, objects, and keywords are set off in Courier font, as in int, a predefined language type; Console, a class defined in the framework; maxCount, an object defined either as a data member or as a local object within a function; and foreach, one of the predefined loop statements. Function names are followed by an empty pair of parentheses, as in WriteLine(). The first introduction of a concept, such as garbage collection or data encapsulation, is highlighted in italics. These conventions are intended to make the text more readable.

Resources

The richest documentation that you will be returning to time and again is the Visual Studio.NET documentation. The .NET framework reference is essential to doing any sort of C#/.NET programming.

Another rich source of information about .NET consists of the featured articles and columns in the MSDN Magazine. I'm always impressed by what I find in each issue. You can find it online at http://msdn.microsoft.com/msdnmag.

The DOTNET mailing list sponsored by DevelopMentor is a rich source of information. You can subscribe to it at http://discuss.develop.com.

Anything Jeffrey Richter, Don Box, Aaron Skonnard, or Jeff Prosise writes about .NET (or XML in Aaron's case) should be considered essential reading. Currently, most of their writing has appeared only as articles in MSDN Magazine.Here is the collection of books that I have referenced or found helpful:

• Active Server Pages+, by Richard Anderson, Alex Homer, Rob Howard, and Dave Sussman, Wrox Press, Birmingham, England, 2000.
• C# Essentials, by Ben Albahari, Peter Drayton, and Brad Merrill, O'Reilly, Cambridge, MA, 2001.
• C# Programming, by Burton Harvey, Simon Robinson, Julian Templeman, and Karli Watson, Wrox Press, Birmingham, England, 2000.
• Essential XML: Beyond Markup, by Don Box, Aaron Skonnard, and John Lam, Addison-Wesley, Boston, 2000.
• Microsoft C# Language Specifications, Microsoft Press, Redmond, WA, 2001.
• A Programmer's Introduction to C#, 2nd Edition, by Eric Gunnerson, Apress, Berkeley, CA, 2001.

Table of Contents

Preface.


1. Hello, C.

Downloadable Sample Chapter

Click below for Sample Chapter related to this title:
lippmanch01.pdf