Microsoft Visual C# .NET Step by Step--Version 2003

by Sharp, John; Jagger, Jon

• ISBN13: 9780735619098
• ISBN10: 0735619093
• Edition: 1st
• Format: Paperback
• Copyright: 2003-03-19
• Publisher: Microsoft Press

Summary

Teach yourself Visual C# .NET version 2003--and start developing Microsoft .NET-connected applications--one step at a time. Master language fundamentals at your own pace and use the learn-by-doing exercises to dig in and code!

Author Biography

Jon Jagger is an independent software trainer, designer, and consultant specializing in Visual C# .NET, C++, Java, C, OO, patterns, design, and general programming. His work on this book also was done through Content Master Ltd. Jon is a U.K. C++ standards panel member and a regular contributor to the ACCU Overload journal. His interests include training excellence, design, simplicity, problem solving, and Monty Python (which he says is required knowledge for all software developers). Jon, his wife, Natalie, and their three small children (Ellie, Penny, and Patrick) live in a delightful 104-year-old house overlooking a seven-acre field of barley in a village called Trull (population 300). You can send him an e-mail message at [e-mail].

Table of Contents

Acknowledgments	xv
Introduction	xvii
Part 1 Introducing Microsoft Visual C# and Visual Studio .NET
Welcome to C#	3	(24)
Beginning Programming with the Visual Studio .NET Environment	4	(3)
Writing Your First Program	7	(4)
Using Namespaces	11	(3)
Creating Documentation Using XML and Comments	14	(4)
Creating a Windows Forms Application	18	(9)
Working with Variables, Operators, and Expressions	27	(16)
Understanding Statements	27	(1)
Using Identifiers	28	(1)
Identifying Keywords	28	(1)
Using Variables	29	(2)
Naming Variables	29	(1)
Declaring Variables	30	(1)
Working with Primitive Data Types	31	(4)
Displaying Primitive Data Type Values	32	(3)
Setting Arithmetic Operators	35	(5)
Determining an Operator's Values	35	(1)
Examining Arithmetic Operators	36	(3)
Controlling Precedence	39	(1)
Using Associativity to Evaluate Expressions	40	(1)
Incrementing and Decrementing Variables	40	(3)
Writing Methods and Applying Scope	43	(16)
Declaring Methods	43	(4)
Specifying the Method Declaration Syntax	44	(1)
Writing return Statements	45	(2)
Calling Methods	47	(1)
Specifying the Method Call Syntax	47	(1)
Understanding Scope	48	(3)
Creating Local Scope with a Method	49	(1)
Creating Class Scope with a Class	49	(1)
Overloading Identifiers	50	(1)
Writing and Calling Methods	51	(8)
Using Decision Statements	59	(14)
Declaring bool Variables	59	(1)
Using Boolean Operators	60	(2)
Understanding Equality and Relational Operators	60	(1)
Understanding Logical Operators	61	(1)
Summarizing Operator Precedence and Associativity	62	(1)
Executing if Statements	62	(5)
Understanding if Statement Syntax	63	(1)
Using Blocks to Group Statements	64	(1)
Cascading if Statements	64	(3)
Using switch Statements	67	(2)
Understanding switch Statement Syntax	68	(1)
Following the switch Statement Rules	69	(4)
Using Iteration Statements	73	(20)
Using Compound Assignment Operators	73	(2)
Writing while Statements	75	(1)
Writing for Statements	76	(1)
Understanding for Statement Scope	77	(1)
Writing do Statements	77	(16)
Managing Errors and Exceptions	93	(22)
Coping with Errors	93	(1)
Trying Code and Catching Exceptions	94	(1)
Using Multiple catch Handlers	95	(1)
Writing a General catch Handler	96	(4)
Using Checked and Unchecked Integer Arithmetic	100	(4)
Writing checked Statements	100	(1)
Writing Checked Expressions	101	(3)
Throwing Exceptions	104	(5)
Writing a finally Block	109	(6)
Part 2 Understanding the C# Language
Creating and Managing Classes and Objects	115	(20)
What Is Classification?	115	(1)
What Is Encapsulation?	116	(1)
Controlling Accessibility	117	(2)
Working with Constructors and the new Keyword	119	(9)
Overloading Constructors	121	(7)
Understanding static Methods and Data	128	(7)
Creating a Shared Field	129	(1)
Creating a static Field with the const Keyword	130	(5)
Understanding Values and References	135	(18)
Copying int Variables and Classes	135	(4)
Using ref and out Parameters	139	(4)
Creating ref Parameters	140	(1)
Creating out Parameters	141	(2)
What Are the Stack and the Heap?	143	(1)
Using the Stack and the Heap	143	(1)
What Is System.Object?	144	(2)
Boxing	146	(1)
Unboxing	146	(2)
Pointers and Unsafe Code	148	(5)
Creating Value Types with Enumerations and Structs	153	(18)
Working with Enumerations	153	(4)
Declaring an Enumeration Type	154	(1)
Choosing Enumeration Literal Values	154	(1)
Choosing an Enumeration's Underlying Type	154	(1)
Using an Enumeration	155	(2)
Working with Struct Types	157	(14)
Declaring Struct Types	158	(1)
Understanding Struct and Class Differences	158	(2)
Declaring Struct Variables	160	(1)
Understanding Struct Definite Assignment	161	(1)
Calling Struct Constructors	162	(1)
Copying Struct Variables	163	(1)
Understanding Keyword-Type Equivalences	164	(7)
Using Arrays and Collections	171	(22)
What Is an Array?	171	(8)
Declaring Array Variables	171	(1)
Creating Array Instances	172	(1)
Initializing Array Variables	173	(1)
Accessing Individual Array Elements	174	(1)
Iterating Through an Array	175	(1)
Copying Arrays	176	(2)
Using the System.Array Class	178	(1)
What Are Collection Classes?	179	(14)
ArrayList	180	(2)
Queue	182	(1)
Stack	183	(1)
SortedList	184	(2)
Comparing Arrays and Collections	186	(1)
Using Collection Classes to Play Cards	186	(7)
Understanding Parameter Arrays	193	(14)
Creating Overloaded Methods	193	(1)
Using Array Arguments	194	(13)
Declaring params Arrays	195	(3)
Using params object [ ]	198	(2)
Using params Arrays	200	(4)
Using the Main Method	204	(3)
Working with Inheritance	207	(24)
What Is Inheritance?	207	(1)
Understanding Core Syntax	208	(18)
Base Classes and Derived Classes	208	(1)
Calling Base Class Constructors	209	(1)
new Methods	210	(1)
virtual Methods	211	(1)
override Methods	212	(1)
protected Access	213	(1)
Creating Interfaces	214	(1)
Syntax	215	(1)
Restrictions	215	(1)
Implementing an Interface	216	(1)
Abstract Classes	217	(3)
Sealed Classes	220	(1)
Sealed Methods	220	(1)
Extending an Inheritance Hierarchy	220	(6)
Working with Multiple Interfaces	226	(2)
Syntax	226	(1)
Explicit Interface Implementation	226	(2)
Summarizing Keyword Combinations	228	(3)
Using Garbage Collection and Resource Management	231	(18)
Garbage Collection	231	(5)
Comparing Values and Objects	231	(1)
The Life and Times of an Object	232	(1)
Writing Destructors	233	(1)
Why Use the Garbage Collector?	234	(1)
How Does the Garbage Collector Run?	235	(1)
Recommendations	236	(1)
Resource Management	236	(13)
The Disposal Method Pattern	236	(1)
Exception-Safe Disposal	237	(1)
The using Statement	238	(1)
Adapting to IDisposable	239	(1)
Calling a Disposal Method from a Destructor	240	(2)
Making Code Exception-Safe	242	(7)
Part 3 Creating Components
Implementing Properties to Access Attributes	249	(16)
Comparing Fields and Methods	249	(2)
What Are Properties?	251	(3)
get Accessors	252	(1)
set Accessors	252	(1)
Read/Write Properties	253	(1)
Read-Only Properties	253	(1)
Write-Only Properties	254	(1)
Understanding the Property Restrictions	254	(1)
Using Static Properties	255	(2)
Declaring Interface Properties	257	(8)
Using Properties in a Windows Application	258	(7)
Using Indexers	265	(16)
What Is an Indexer?	265	(7)
An Example That Doesn't Use Indexers	265	(2)
The Same Example Using Indexers	267	(2)
get Accessors	269	(1)
set Accessors	269	(1)
Read/Write Indexers	269	(1)
Read-Only Indexers	270	(1)
Write-Only Indexers	270	(1)
Comparing Indexers and Methods	271	(1)
Comparing Indexers and Arrays	271	(1)
Comparing Indexers and Properties	272	(1)
Interface Indexers	272	(1)
Using Indexers in a Windows Application	273	(8)
Delegates and Events	281	(20)
Using Delegate Declarations and Instances	281	(9)
An Example That Doesn't Use a Delegate	281	(3)
The Same Example Using a Delegate	284	(1)
Declaring a Delegate	284	(1)
Calling a Delegate	285	(1)
Creating a Delegate Instance	286	(2)
Using Delegates	288	(2)
Enabling Notifications with Events	290	(11)
Declaring an Event	291	(1)
Subscribing to an Event	291	(1)
Unsubscribing from an Event	292	(1)
Calling an Event	292	(1)
Understanding GUI Events	293	(2)
Using Events	295	(6)
Operator Overloading	301	(18)
Working with Operators	301	(11)
Understanding Operators	301	(1)
Implementing Operator Constraints	302	(1)
Overloaded Operators	303	(1)
Creating Symmetric Operators	304	(2)
Understanding Compound Assignment	306	(1)
Declaring Increment and Decrement Operators	307	(1)
Using Operator Pairs	308	(1)
Implementing an Operator	309	(3)
Declaring Conversion Operators	312	(7)
Providing Built-In Conversions	312	(1)
Declaring User-Defined Conversion Operators	312	(1)
Creating Symmetric Operators (Again)	313	(1)
Adding an Implicit Conversion Operator	314	(5)
Part 4 Working with Windows Applications
Introducing Windows Forms	319	(22)
Creating Your Application	320	(7)
Creating a Windows Forms Application	320	(4)
What Are the Common Windows Forms Properties?	324	(2)
Changing Properties Programmatically	326	(1)
Adding Controls to the Form	327	(8)
Using Windows Forms Controls	327	(2)
Setting Control Properties	329	(3)
Changing Properties Dynamically	332	(3)
Publishing Events in Windows Forms	335	(6)
Processing Events in Windows Forms	335	(6)
Working with Menus	341	(16)
Menu Guidelines and Style	341	(1)
Adding Menus and Processing Menu Events	342	(8)
Creating a Menu	342	(2)
Setting Menu Item Properties	344	(3)
Other Menu Item Properties	347	(1)
Menu Events	348	(2)
Pop-Up Menus	350	(7)
Creating Pop-Up Menus	350	(7)
Performing Validation	357	(14)
Validating Data	357	(1)
The CausesValidation Property	358	(1)
Validation Events	358	(1)
An Example---Customer Maintenance	358	(13)
Performing Validation with a Sledge Hammer	359	(4)
Being Unobtrusive	363	(3)
Using an ErrorProvider Control	366	(5)
Using Complex Controls	371	(26)
The Explorer Interface	371	(2)
Splitter Windows, Docking Controls, and Panels	373	(4)
Working with the Splitter and Docked Controls	373	(3)
Using a Panel	376	(1)
Docking the Controls	376	(1)
Controls for Navigating Data	377	(20)
Working with the TreeView Control	378	(8)
Using a ListView Control	386	(11)
Using the MDI, Windows, and Dialog Boxes	397	(18)
What Is the Multiple Document Interface?	398	(7)
Building an MDI Application	398	(6)
Alternatives to MDI	404	(1)
Creating Dialog Boxes	405	(4)
Displaying Modal and Modeless Dialog Boxes	405	(4)
Using Common Dialog Controls	409	(6)
Using the SaveFileDialog Control	409	(6)
Creating GUI Components	415	(22)
Working with User Controls	415	(11)
Building the Login User Control	416	(7)
Using the Login User Control	423	(3)
Specializing Controls Using Subclassing	426	(11)
Creating a ToggleButton Control	427	(4)
Using the ToggleButton Control	431	(6)
Part 5 Managing Data
Using a Database	437	(22)
Using ADO.NET Databases	437	(1)
Using the Northwind Traders Database	438	(21)
Accessing the Database	439	(9)
Using ADO.NET Programmatically	448	(11)
Working with Data Binding and DataSets	459	(20)
Windows Forms Controls and Data Binding	460	(8)
Using Simple Data Binding	460	(4)
Using Complex Data Binding	464	(4)
Disconnected DataSets	468	(11)
Creating a Disconnected DataSet	468	(4)
Handling Updates with a Disconnected DataSet	472	(7)
Handling XML	479	(22)
Why XML?	479	(5)
The Goals of XML	480	(1)
The Structure of XML	480	(1)
XML Schemas	481	(2)
XML as a Transport Format and Protocol	483	(1)
XML APIs and the .NET Framework	483	(1)
The Employee Timesheet System	484	(17)
Creating an XML Schema	484	(6)
Building the Timesheet Recording Application	490	(4)
Creating the Timesheet Analysis Application	494	(7)
Part 6 Building Web Applications
Introducing ASP.NET	501	(24)
Understanding the Internet as an Infrastructure	502	(3)
Understanding Web Server Requests and Responses	502	(1)
Managing State	503	(1)
Understanding ASP.NET	504	(1)
Creating Web Applications with ASP.NET	505	(20)
Building an ASP.NET Application	505	(9)
Understanding Server Controls	514	(11)
Understanding Validation Controls	525	(10)
Comparing Server and Client Validations	525	(10)
Server Validation	526	(1)
Client Validation	526	(1)
Implementing Client Validation	527	(8)
Accessing Data with Web Forms	535	(24)
Using the Web Forms DataGrid Control	535	(1)
Managing Security	536	(5)
Understanding Forms-Based Security	536	(1)
Implementing Forms-Based Security	537	(4)
Querying Data	541	(9)
Displaying Customer Information	542	(4)
Retrieving Data on Demand	546	(2)
Optimizing Data Access	548	(2)
Editing Data	550	(9)
Deleting Rows	550	(3)
Updating Rows	553	(6)
Building ASP.NET Applications	559	(20)
Additional Features of the DataGrid Control	559	(9)
Sorting a DataGrid	560	(3)
Using Column Templates	563	(5)
Navigating Between Forms	568	(11)
Using Buttons and Hyperlinks	569	(10)
Building an XML Web Service	579	(18)
What Is an XML Web Service?	579	(5)
The Role of SOAP	581	(1)
What Is the Web Services Description Language?	582	(2)
Building the ProductService Web Service	584	(13)
Creating the ProductService Web Service	584	(5)
Handling Complex Data	589	(8)
Consuming a Web Service	597
Web Services, Clients, and Proxies	597
Talking SOAP: The Difficult Way	598
Talking SOAP: The Easy Way	598
Consuming the ProductService Web Service	599
Executing a Web Method Asynchronously	606