Index

Symbols

+ (addition) operator, Mathematical Operators, Multicasting
&& (And) operator, Use of Logical Operators with Conditionals
= (assignment) operator, The Assignment Operator (=), Copying Strings
/* (asterisk), Examining Your First Program
@ (at) symbol, Verbatim Strings
{} (braces)
class-body, Defining Classes
namespaces, Examining Your First Program
^ (caret), The Regex Class
: (colon), Calling Base Class Constructors
- - (decrement) operator, Increment and Decrement Operators
/ (division) operator, Mathematical Operators
. (dot) operator, Examining Your First Program, Access Modifiers
= (equals sign), Relational Operators
== (equals) operator, The Equals Operator
>= (greater than or equal to) operator, Relational Operators, The Equals Operator
> (greater than) operator, Relational Operators, The Equals Operator
++ (increment) operator, Increment and Decrement Operators, Relational Operators, Creating Useful Operators
[ ] (index) operator, Accessing Array Elements, Other Useful String Methods
<= (less than or equal to) operator, The Equals Operator
< (less than) operator, The Equals Operator
% (modulus) operator, The modulus Operator (%)
for loops, controlling, Controlling a for loop with the modulus operator
* (multiplication) operator, Mathematical Operators
!= (not-equals) operator, The Equals Operator
( ) (parentheses), Examining Your First Program, The Regex Class
+ (plus sign) operator, Using the operator Keyword
+= (plus-equals) operator, Multicasting
; (semicolon), Statements
/// (slashes), Examining Your First Program
[ ] (square brackets), Declaring Arrays
- (subtraction) operator, Mathematical Operators
| (vertical bar), The Regex Class

A

Abort signals, The continue statement
abstract base classes, comparing to interfaces, Implementing an Interface
abstract classes, Abstract Classes
abstraction, defining, Abstract Classes
access
members of interfaces, Casting to an Interface
modifiers, Defining Classes, Access Modifiers, Controlling Access
Quick Find/Quick Replace, Find and Replace
Visual Studio 2005
File menu, File Menu
menus and toolbars, Menus and Toolbars
projects and solutions, Start Page
Start Page, Start Page
accessors
set, The set Accessor
Add Connection dialog box, Data Binding
adding
connections, Data Binding
controls, Adding Controls, Server Controls, Data Binding
events, Expanding a directory, Adding Controls and Events
files as text, Find All References
items to a Dictionary class, Dictionaries
radio groups, Server Controls
Sort( ) method, Versioning with new and override
Advanced command, Advanced
AfterCheck( ) method, Expanding a directory
aggregation, Class Relationships
aliases, code snippets, View Menu
allocation of memory, Memory Allocation: The Stack Versus the Heap
analysis, object-oriented programming, Polymorphism
anonymous methods, applying, Using Anonymous Methods
Application.Exit( ) method, Using the Visual Studio Designer
applications
.NET platform, The .NET Platform
ASP.NET, The Development Environment
adding controls, Enabling Debugging
adding controls/events, Adding Controls and Events
creating Web Forms, Creating a Web Form
data binding, Data Binding
server controls, Server Controls
Web Form events, Web Form Events
Web Forms, Programming ASP.NET Applications
compilers, The Compiler
console, The Development Environment
Hello World, Your First Program: Hello World
MDI, Inside the Integrated Development Environment
RAD, Creating a Simple Windows Form, Understanding Web Forms
structure of, The Structure of C# Applications
viewing, Examining Your First Program
Visual Studio 2005
applying Designer, Creating a Simple Windows Form
building and running, Building and Running
creating, Projects and Solutions
Windows, The Development Environment
creating forms, Creating a Simple Windows Form
creating real-world, Creating a Real-World Application
applying
anonymous methods, Using Anonymous Methods
arrays, Arrays
declaring, Declaring Arrays
foreach statements, The foreach Statement
initializing elements, The foreach Statement
methods, Array Methods
multidimensional, Multidimensional Arrays
params keyword, The params Keyword
sorting, Sorting Arrays
delegates, Using Delegates to Specify Methods at Runtime
Designer (Visual Studio 2005), Creating a Simple Windows Form
finally blocks, The finally Statement
indexers, Creating Your Own Collections
queues, Generic Queues
regular expressions, Regular Expressions
stacks, Generic Stacks
static fields, Using Static Fields
arguments, Examining Your First Program
events, Understanding Web Forms
methods, Access Modifiers
ArithmeticException, Creating Dedicated catch Statements
arrays
applying, Using Arrays
declaring, Declaring Arrays
elements, Declaring Arrays
initializing, The foreach Statement
foreach statements, The foreach Statement
jagged, Jagged Arrays
methods, Array Methods
multidimensional, Multidimensional Arrays
params keyword, The params Keyword
rectangular, Multidimensional Arrays
sorting, Sorting Arrays, Creating objects that can be sorted by the generic list
as operators, The is and as Operators
ASP.NET
applications, The Development Environment
controls, adding, Adding Controls and Events
data binding, Data Binding
Web Forms, Programming ASP.NET Applications
creating, Creating a Web Form
events, Understanding Web Forms
server controls, Server Controls
assigning indexers, Indexers and Assignment
association, classes, Class Relationships
asterisk (/*), Examining Your First Program
attributes, Defining Classes
.NET, Implementing an Interface
customizing, Implementing an Interface
Auto Hide window, Inside the Integrated Development Environment
Autos window, Examining Values: The Autos and Locals Windows, Set Your Watch, The Equals Operator
avoiding boxing with generics, Avoiding Boxing with Generics

B

base classes, Instantiating Objects, Inheritance
BeforeExpand event, Expanding a directory
BinarySearch( ) method, Array Methods
binding data, Data Binding
blocks
catch, The try and catch Statements
single-statement if, Single-Statement if Blocks
try, The throw Statement
bookmarks, Go To ..., Incremental search
bool type, Non-Numeric Types: char and bool
Borland Delphi, The C# Language
boxing
types, Boxing and Unboxing Types
branching
methods, Conditional Branching Statements
statements, C# Language Fundamentals
conditional, Conditional Branching Statements
unconditional, Unconditional Branching Statements
break statement, The continue statement
breaking out for loops, Breaking out of a for loop
Breakpoint Condition dialog box, Examining Values: The Autos and Locals Windows
Breakpoint Hit Count dialog box, Examining Values: The Autos and Locals Windows
breakpoints
conditions, setting, Setting Conditions and Hit Counts
running to, Conversion Operators
setting, Setting a Breakpoint
bugs, Bugs, Errors, and Exceptions
Build menu, Building and Running, Refactor Menu
building applications, Building and Running
Button class, factoring, Specialization and Generalization
buttons
Clear events, Handling the Clear button event
Copy events, Handling the Clear button event
Delete events, Handling the Delete Button Event
Events, Using the Visual Studio Designer
Show All Files, The partial Keyword

C

C#, The .NET 2.0 Framework
applications, structure of, The Structure of C# Applications
C-style comments, Examining Your First Program
calculate operators, Increment and Decrement Operators
Call Stack window, The Call Stack
call stacks, How the Call Stack Works
calling
destructors, Destroying Objects
methods, Examining Your First Program, Conditional Branching Statements
tracking, The Call Stack
multiple methods, Multicasting
Camel notation, Symbolic Constants
capabilities, Object-Oriented Programming
caret (^), The Regex Class
case statements, Falling-Through and Jumping-to Cases
casting
interfaces, Casting to an Interface
objects, Enumerations
catch statement, The try and catch Statements
dedicated, Creating Dedicated catch Statements
chaining assignments, The Assignment Operator (=)
characters, The Regex Class
incremental searches, Incremental search
strings
comparing, Manipulating Strings
concatenating, Concatenating Strings
creating, Creating Strings
escape characters, Escape Characters
literals, Creating Strings
manipulating, Manipulating Strings
modifying, The StringBuilder Class
regular expressions, Regular Expressions
searching substrings, Finding Substrings
splitting, Splitting Strings
testing for equality, Testing for Equality
verbatim, Verbatim Strings
WriteLine( ) method, Increment and Decrement Operators
child classes, Inheritance
Choose Data Source dialog box, Data Binding
Choose Toolbox dialog box, Choose Toolbox Items
chords, Menus and Toolbars
Class View, Class View
class-body, Defining Classes
classes, Examining Your First Program
abstract, Abstract Classes
abstract base, comparing to interfaces, Implementing an Interface
association, Class Relationships
base, Inheritance
Button, factoring, Specialization and Generalization
child, Inheritance
composed, Class Relationships
Console, Examining Your First Program
constructors, Constructors
defining, Defining Classes
derived, Specialization, Inheritance
abstract classes, Abstract Classes
Dictionary, Dictionaries
DirectoryInfo, TreeNode objects
DisplayClock, Events and Delegates
Document, implementing interfaces, Implementing an Interface
EventArgs, Events and Delegates
events, Multicasting
delegates, Events and Delegates
publishing, Publishing and Subscribing
subscribing, Publishing and Subscribing
Exception, Exception Class Methods and Properties
FCL, The .NET 2.0 Framework, Understanding Web Forms
Fraction, Operator Overloading
generics, Generics and Collections
initializers, Initializers
instance members, Static and Instance Members
List, Framework Generic Collections
creating, Generic Lists: List<T>
sorting, Creating objects that can be sorted by the generic list
memory allocation, Memory Allocation: The Stack Versus the Heap
methods
arguments, Method Arguments
Call Stack window, The Call Stack
encapsulating data with properties, Encapsulating Data with Properties
returning multiple values, Returning Multiple Values
names, modifying, Code-Behind Files
new, deriving, Implementing Inheritance
Object, The Root of All Classes: Object
object-oriented programming, Classes and Objects
defining, Defining a Class
relationships, Class Relationships
objects, destroying, Destroying Objects
Pair<T>, Using Delegates to Specify Methods at Runtime
parent, Inheritance
Queue, Generic Queues
Regex, The Regex Class
root, Inheritance, The Root of All Classes: Object
sealed, Inheritance and Polymorphism, Sealed Classes
specialization, Inheritance and Polymorphism
Stack, Generic Stacks
static members, Static and Instance Members
String, Strings
StringBuilder, Splitting Strings
Tester, Creating a Time Class
this keyword, The this Keyword
Time, creating, Creating a Time Class
Clear button events, Handling the Clear button event
Clear( ) method, Array Methods
Click event, Publishing and Subscribing
clients, The Three Pillars of Object-Oriented Programming
interfaces, implementing, Implementing the Interface on the Client
clipboards, cycle clipboard ring, Find and Replace
Close( ) method, Memory Allocation: The Stack Versus the Heap
CLR (Common Language Runtime), The .NET Platform
exception handling, The throw Statement
code
IntelliSense, IntelliSense
outlining, Outlining
separation, Understanding Web Forms
snippets, IntelliSense
spaghetti, Creating Loops with goto
Code Definition window, Code Definition
Code Snippets Manager command, Code Snippets Manager
code-behind files, Code-Behind Files
collections
creating, Creating Your Own Collections
dictionaries, Dictionaries
editing, Server Controls
elements, sorting, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
FIFO, Generic Queues
generic interfaces, Generic Collection Interfaces
IComparer<T> interface, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
interfaces, Collection Interfaces
LIFO, Generic Stacks
columns, multidimensional arrays, Multidimensional Arrays
combining interfaces, Combining Interfaces
commands
Advanced, Advanced
bookmarks, Bookmarks
Code Snippets Manager, Code Snippets Manager
Connect To Database, Connect To Database
Connect To Device, Connect To Device
External Tools, External Tools
Find All References, Find All References
Insert File As Text, Insert File As Text ...
IntelliSense, IntelliSense
options, External Tools
outlining, Outlining
Toolbox, Toolbox
comments, Examining Your First Program
C-style, Examining Your First Program
documentation (XML), XML Documentation Comments
commonalities, factoring out, Specialization and Generalization
Compare( ) method, Manipulating Strings
CompareTo( ) method, Creating objects that can be sorted by the generic list
comparing
String class, Manipulating Strings
String.Compare( ) method, Using Delegates to Specify Methods at Runtime
strings, Manipulating Strings
compilers, The Compiler
errors, Types and Compiler Errors
composed classes, Class Relationships
Compress( ) method, Implementing More than One Interface
conditional branching statements, Conditional Branching Statements
conditionals
operators, The Conditional Operator
configuration
breakpoints, Setting a Breakpoint
collections, Creating Your Own Collections
constructors, Constructors
Data Source Configuration Wizard, Data Binding
delegates, Delegates and Events
interfaces, combining, Combining Interfaces
operators, creating useful, Creating Useful Operators
strings, Strings
structs, Memory Allocation: The Stack Versus the Heap
types, polymorphism, Creating Polymorphic Types
UI forms, Creating the Basic UI Form
Web Forms, Creating a Web Form
Windows applications
creating forms, Creating a Simple Windows Form
creating real-world applications, Creating a Real-World Application
Configure Data Source dialog box, Data Binding
Connect To Database command, Connect To Database
Connect To Device command, Connect To Device
connections, adding, Data Binding
console applications, The Development Environment
running, Building and Running
Console class, Examining Your First Program
Console.Writeline( ) method, Increment and Decrement Operators
constants, Constants
enumerations, Enumerations
literal, Constants
symbolic, Constants
constructors, Constructors
declaring, Constructors
signatures, Overloading Methods
constructs
indexers, Collection Interfaces
while (true), The while (true) construct
containers, Visual Studio, Start Page
continue statement, The continue statement
control characters, WriteLine( ) method, Increment and Decrement Operators
controlling
access, Controlling Access
for loops, Controlling a for loop with the modulus operator
controls, Defining Classes, Server Controls
adding, Adding Controls, Server Controls, Adding Controls and Events
data binding, Data Binding
properties, Using the Visual Studio Designer
server, Server Controls
server-side, Code-Behind Files
TreeView, populating, Populating the TreeView Controls
conventions, naming, Symbolic Constants
converting
conversion operators, Conversion Operators
explicit conversions, Enumerations
implicit conversion, Enumerations
boxing, Boxing and Unboxing Types
Copy button events, Handling the Clear button event
Copy( ) method, Array Methods
copying, Find and Replace
strings, Concatenating Strings
CreateInstance( ) method, Array Methods
customizing
attributes, Implementing an Interface
exceptions, Custom Exceptions
cutting, Find and Replace
cycle clipboard ring, Find and Replace

D

data binding, Data Binding
data hiding, Encapsulating Data with Properties
Data menu, Debug Menu
Data Source Configuration Wizard, Data Binding
Debug menu, Building and Running
debugging
breakpoints, setting, Setting a Breakpoint
values, viewing, Examining Values: The Autos and Locals Windows
Watch window, Set Your Watch
Debugging Not Enabled dialog box, Enabling Debugging
declaring
arrays, Using Arrays
constructors, Constructors
destructors, Destroying Objects
indexer properties, Collection Interfaces
dedicated catch statements, Creating Dedicated catch Statements
default values
arrays, Understanding Default Values
primitive types, Constructors
defining
classes, Defining a Class, Classes and Objects
delegates, Delegates and Events
interfaces, Interfaces
parameters, Method Arguments
variables, Variables
definite assignment
out parameters and, out Parameters and Definite Assignment
variables, Definite Assignment
delegates, Delegates and Events
events, Events and Delegates
event keyword, The event Keyword
troubleshooting, Solving Delegate Problems with Events
methods
applying anonymous, Using Anonymous Methods
specifying at runtime, Delegates
multicasting, Multicasting
SecondChangeEventHandler, Events and Delegates
derived classes, Specialization, Inheritance
abstract classes, Abstract Classes
deriving
objects, Specialization and Generalization
design
object-oriented programming, Polymorphism
destroying objects, Destroying Objects
destructors, Destroying Objects
development environments, .NET Framework, The .NET Platform
dialog boxes, Choose Toolbox Items
Add Connection, Data Binding
Breakpoint Condition, Examining Values: The Autos and Locals Windows
Breakpoint Hit Count, Setting Conditions and Hit Counts
Choose Data Source, Data Binding
Choose Toolbox, Choose Toolbox Items
Configure Data Source, Data Binding
Debugging Not Enabled, Enabling Debugging
Find Symbol, Find and Replace
Go To Line, Go To ...
New Breakpoint, Using the Debug Menu to Set Your Breakpoint
New Project, Templates
dictionaries, Dictionaries
directories
expanding, Expanding a directory
files, moving into, Handling TreeView Events
DirectoryInfo class, TreeNode objects
DisplayClock class, Events and Delegates
DisplayVals( ) method, The params Keyword
Dispose( ) method, Destroying Objects
DivideByZeroException, Creating Dedicated catch Statements
division operator (/), Mathematical Operators
division, floating point, Mathematical Operators
do...while loops, The do ... while Loop
Dockable window, Inside the Integrated Development Environment
Document class, implementing interfaces, Implementing an Interface
Document Outline window, Task List
documentation (XML) comments, XML Documentation Comments
DoDivide( ) method, Creating Dedicated catch Statements
double type, Numeric Types
Dynamic Help window, Inside the Integrated Development Environment

E

Edit menu, Edit Menu
editing
collections, Server Controls
fonts, Using the Visual Studio Designer
elements, Adding Controls
<div>, Adding Controls
arrays, Using Arrays
initializing, The foreach Statement
collections, sorting, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
headers for loops, Optional for loop header elements
encapsulation, Object-Oriented Programming
delegates, Delegates and Events
object-oriented programming, Encapsulation
properties, Encapsulating Data with Properties
equality, defining, Conversion Operators
Equals( ) method, The Equals Operator
Error List window, Inside the Integrated Development Environment, Error List
errors, Bugs, Errors, and Exceptions
compilers, Types and Compiler Errors
escape characters, Escape Characters
evaluation, short-circuit, Short-Circuit Evaluation
events, Multicasting
adding, Expanding a directory, Adding Controls and Events
arguments, Web Form Events
BeforeExpand, Expanding a directory
Clear button, Handling the Clear button event
Click, Events
Copy button, Handling the Clear button event
delegates, Events and Delegates
non-postback, Postback Versus Non-Postback Events
OnLoad, overriding, Adding Controls and Events
postback, Postback Versus Non-Postback Events
publishing, Publishing and Subscribing
subscribing, Publishing and Subscribing
Visual Studio, Using the Visual Studio Designer
Web Forms, Understanding Web Forms
exceptions, Bugs, Errors, and Exceptions
ArithmeticException, Creating Dedicated catch Statements
call stacks, How the Call Stack Works
catch statement, The try and catch Statements
dedicated, Creating Dedicated catch Statements
customizing, Custom Exceptions
DivideByZeroException, Creating Dedicated catch Statements
Exception class methods/properties, Exception Class Methods and Properties
finally statement, The finally Statement
handlers, searching, Throwing Exceptions
MyCustomException, Custom Exceptions
throw statement, The throw Statement
throwing, Throwing Exceptions
try statement, The try and catch Statements
unhandled, The throw Statement
existing interfaces, combining, Combining Interfaces
expanding
directories, Expanding a directory
variables, Examining Values: The Autos and Locals Windows
explicit conversions, Enumerations
explicit interfaces, implementing, Explicit Interface Implementation
explicit keyword, Conversion Operators
explicit parameters, Encapsulating Data with Properties
Expression Builder, Find and Replace
expressions, Expressions
conditional, The Conditional Operator
regular, The StringBuilder Class
searching, Go To ...
extending interfaces, Extending Interfaces
extensions, .sln files, Projects and Solutions
External Tools command, Choose Toolbox Items

F

factoring
Button class, Specialization and Generalization
commonalities, Specialization and Generalization
FCL (Framework Class Library), The C# Language, Web Form Events
Fibonacci Series, Object-Oriented Analysis and Design
fields
member, Defining a Class
selecting, Data Binding
File menu, File Menu
FileCopier utility, Creating a Real-World Application
source code, Handling the Delete Button Event
files
code-behind, Code-Behind Files
Find in Files utility, Go To ...
sorting, Sorting the list of selected files
text, inserting, Find All References
files.sln, Projects and Solutions
finally statement, The finally Statement
Find All References command, Find All References
Find and Replace options, Find and Replace
Find in Files utility, Go To ...
Find Results window, Inside the Integrated Development Environment
Find Symbol dialog box, Find and Replace
Find Symbol Results window, Inside the Integrated Development Environment
FindString( ) method, Indexing on Other Values
floating windows, Inside the Integrated Development Environment
floating-point division, Simple Arithmetical Operators (+, -, *, / )
for loops, The for Loop
breaking out, Breaking out of a for loop
controlling, Controlling a for loop with the modulus operator
header elements, Optional for loop header elements
foreach statements, arrays, The foreach Statement
forever loops, Optional for loop header elements
Format menu, Format Menu
formatting windows, resizing, Inside the Integrated Development Environment
forms
Web Forms, Programming ASP.NET Applications
creating, Creating a Web Form
events, Understanding Web Forms
server controls, Server Controls
Windows
creating, Creating a Simple Windows Form
creating real-world applications, Creating a Real-World Application
Fraction class, Using the operator Keyword

G

garbage collection, Destroying Objects
generalization, Specialization and Generalization
generics, The C# Language, Generics and Collections
collections
.NET Framework, Framework Generic Collections
interfaces, Generic Collection Interfaces
lists
sorting, Creating objects that can be sorted by the generic list
get accessor, The get Accessor
get( ) method, Creating Your Own Collections
GetCheckedFiles( ) method, Implementing the Copy Button Event
GetDirectories( ) method, TreeNode objects
GetEnumerator( ) method, Array Methods
GetLogicalDrives( ) method, TreeNode objects
GetSubDirectoryNodes( ) method, Recursing through the subdirectories
GetTime( ) method, Returning Multiple Values
Getting Started box (Visual Studio 2005), Start Page
Go To Line dialog box, Go To ...
goto statements, creating loops with, Iteration (Looping) Statements
Graphical User Interfaces (GUIs), Inside the Integrated Development Environment
groups, adding radio, Server Controls
GUIs (Graphical User Interfaces), Inside the Integrated Development Environment

H

handling
events, Events and Delegates
exceptions
catch statement, The try and catch Statements
dedicated catch statements, Creating Dedicated catch Statements
searching, Throwing Exceptions
try statement, The try and catch Statements
has-a relationship, The Three Pillars of Object-Oriented Programming
headers, for lops, Optional for loop header elements
heaps, Memory Allocation: The Stack Versus the Heap
Hejlsberg, Anders, The C# Language
Hello World, Your First Program: Hello World
Help menu, Help Menu
HelpLink property, Exception Class Methods and Properties
Hide window, Inside the Integrated Development Environment
hiding base classes, Inheritance
hierarchies
methods, tracking, The Call Stack
root classes, The Root of All Classes: Object
Hour property, Encapsulating Data with Properties
HTML (Hypertext Markup Language), Server Controls
source code, viewing, Adding Controls and Events

I

IComparer<T> interface, implementing, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
ICompressible interface, Implementing More than One Interface
IDE (Integrated Development Environment), The Structure of C# Applications
identifiers, Variables
labels, Creating Loops with goto
IDisposable interface, Destroying Objects
IEnumerable<T> interface, The IEnumerable<T> Interface
if statements, if Statements
nested, Nested if Statements
if...else statements, if ... else Statements
ILDasm, Implementing an Interface
implementing
equality operators, The Equals Operator
interfaces, Interfaces
explicit, Explicit Interface Implementation
multiple, Implementing More than One Interface
overriding, Overriding Interface Implementations
polymorphism, Polymorphism
private, Encapsulation
specialization, Inheritance
implements relationship, Implementing an Interface
implicit conversion, Enumerations
boxing, Boxing and Unboxing Types
implicit parameters, Encapsulating Data with Properties
Import and Export Settings, Import and Export Settings
Import and Export Settings dialog box, Import and Export Settings
incremental searches, Incremental search
indexers, Collection Interfaces
applying, Creating Your Own Collections
IndexOf( ) method, Array Methods
inheritance, Specialization, Inheritance and Polymorphism, Inheritance
polymorphism, Polymorphism
initializers, The for Loop, Initializers
initializing
arrays
elements, Accessing Array Elements
multidimensional, Rectangular Arrays
definite assignment, Definite Assignment
variables, Variables
Insert File As Text command, Find All References
instances
members, Static and Instance Members
this keyword, The this Keyword
instantiation
interfaces, Casting to an Interface
integers
sorting, Creating objects that can be sorted by the generic list
IntelliSense, IntelliSense
OnLoad event, overriding, Adding Controls and Events
Visual Studio, Using the Visual Studio Designer
interfaces
abstract base classes, comparing, Implementing an Interface
casting, Casting to an Interface
collections, Creating Your Own Collections
combining, Combining Interfaces
extending, Extending Interfaces
FileCopier, Creating a Real-World Application
GUIs, Inside the Integrated Development Environment
IComparer<T>, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
ICompressible, Implementing More than One Interface
IDisposable, Destroying Objects
implementing, Interfaces
explicit, Explicit Interface Implementation
multiple, Implementing More than One Interface
overriding, Overriding Interface Implementations
MDI, Inside the Integrated Development Environment
operators, The is and as Operators
public, Encapsulation
Web Forms, Understanding Web Forms
intrinsic types, Types
invoking static methods, Invoking Static Methods
is operator, The is and as Operators
IStorable object, Implementing an Interface
Item property, Dictionaries
iteration, looping statements, Iteration (Looping) Statements
iterators, The for Loop
omitting, Optional for loop header elements

J

jagged arrays, Jagged Arrays
JIT (Just In Time) compilers, The Compiler
Just In Time (JIT) compilers, The Compiler

K

keys, Menus and Toolbars
dictionaries, Dictionaries
keywords, Examining Your First Program
delegate, Delegates and Events
event, Solving Delegate Problems with Events
explicit, Conversion Operators
finally, The finally Statement
new, Invoking Static Methods
operator, Operator Overloading
params, The params Keyword
partial, The partial Keyword
protected, Controlling Access
static, Examining Your First Program
this, Initializers
value, The get Accessor
void, Examining Your First Program

L

LastIndexOf( ) method, Array Methods
Length property, Array Methods
less than operator (<), The Equals Operator
less than or equal to operator (<=), The Equals Operator
libraries, FCL, The C# Language, Web Form Events
List class
sorting, Creating objects that can be sorted by the generic list
literal constants, Constants
literals
regular expressions, Regular Expressions
strings, Strings
local scope, Memory Allocation: The Stack Versus the Heap
local variables, Memory Allocation: The Stack Versus the Heap
Locals window, Examining Values: The Autos and Locals Windows
Look in: drop-down, Find and Replace
looping statements, Creating Loops with goto
loops
do...while, The do ... while Loop
for
breaking out, Breaking out of a for loop
controlling, Controlling a for loop with the modulus operator
header elements, Optional for loop header elements
forever, Optional for loop header elements
goto statements, creating with, Iteration (Looping) Statements
while, Creating Loops with goto

M

Macro Explorer window, Task List
Main( ) method, Examining Your First Program
keywords, Examining Your First Program
manipulating strings, Manipulating Strings
mathematical operators, Mathematical Operators
MDI (Multiple Document Interface) applications, Inside the Integrated Development Environment
member fields, Defining a Class
member variables, initializers, Initializers
members
Regex class, The Regex Class
StringBuilder class, The StringBuilder Class
members of interfaces, accessing, Casting to an Interface
memory allocation, Memory Allocation: The Stack Versus the Heap
menus, Refactor Menu
Breakpoint, Setting Conditions and Hit Counts
Build, Building and Running
Class View, Class View
Data, Data Menu
Debug, Building and Running
Edit, Menus and Toolbars
File, Menus and Toolbars
Format, Format Menu
Help, Help Menu
New Web Site, Creating a Web Form
project, Other windows
Tools, Tools Menu
Visual Studio, Menus and Toolbars
Window, Window Menu
Message property, Exception Class Methods and Properties
metacharacters, regular expressions, Regular Expressions
metaphors (for objects), Creating Models
methods, Examining Your First Program
abstract, Abstract Classes
AfterCheck( ), Expanding a directory
Application.Exit( ), Using the Visual Studio Designer
arguments, Method Arguments
Array.Sort( ), Sorting Arrays
arrays, Jagged Arrays
BinarySearch( ), Array Methods
branching, Conditional Branching Statements
Call Stack window, The Call Stack
calling, Examining Your First Program, Unconditional Branching Statements
Clear( ), Array Methods
Close( ), Destroying Objects
Compare( ), Manipulating Strings
CompareTo( ), Creating objects that can be sorted by the generic list
Compress( ), Implementing More than One Interface
Console.WriteLine( ), Increment and Decrement Operators
Copy( ), Array Methods
CreateInstance( ), Array Methods
delegates, Delegates and Events
applying anonymous, Using Anonymous Methods
multicasting, Multicasting
specifying at runtime, Delegates
DisplayCurrentTime( ), Creating a Time Class
DisplayVals( ), The params Keyword
Dispose( ), Destroying Objects
DoDivide( ), Creating Dedicated catch Statements
Equals( ), The Equals Operator
Exception class, Exception Class Methods and Properties
get( ), Creating Your Own Collections
GetDirectories( ), TreeNode objects
GetEnumerator( ), Array Methods
GetLogicDrives( ), TreeNode objects
GetMethod( ), Returning Multiple Values
GetSubDirectoryNodes( ), Recursing through the subdirectories
IndexOf( ), Array Methods
LastIndexOf( ), Array Methods
Main( ), Examining Your First Program
keywords, Examining Your First Program
multiple values, returning, Returning Multiple Values
names( ) (parentheses), Examining Your First Program
Next( ), Creating objects that can be sorted by the generic list
overloading, Inside Methods
properties, encapsulating with, Encapsulating Data with Properties
Read( ), IStorable interface, Defining the Interface
ReadLine( ), The continue statement
Reverse( ), Array Methods
Run( ), Invoking Static Methods, Returning Multiple Values
set( ), Creating Your Own Collections
SetCheck( ), Expanding a directory
Sort( ), Array Methods
delegates, Using Delegates to Specify Methods at Runtime
String class, Manipulating Strings
SuppressFinalize( ), Destroying Objects
System.Array, Array Methods
TextFunc( ), The finally Statement
ToString( )
overriding, The Root of All Classes: Object
types, defining behavior, Defining a Class
Uncompress( ), Implementing More than One Interface
WriteLine( ), Examining Your First Program
Microsoft Intermediate Language (MSIL), The Compiler
models, object-oriented programming, Classes and Objects
modifiers, access, Method Arguments, Controlling Access
modifying
breakpoints, Using the Debug Menu to Set Your Breakpoint
strings, The StringBuilder Class
MSIL (Microsoft Intermediate Language), The Compiler
multicasting, Multicasting
multidimensional arrays, Multidimensional Arrays
Multiple Document Interface (MDI) applications, Inside the Integrated Development Environment
multiple interfaces, implementing, Implementing More than One Interface
multiple values, returning, Returning Multiple Values
multiplication operator (*), Mathematical Operators
MyCustomException, Custom Exceptions
myMulticastDelegate, Multicasting

N

names
methods, Examining Your First Program
namespaces, Examining Your First Program
System, Examining Your First Program
naming
conventions, Symbolic Constants
parameters, Using the operator Keyword
navigating
bookmarks, Incremental search
Visual Studio, Templates, Menus and Toolbars
nested if statements, Start Page, Nested if Statements
.NET
attributes, Implementing an Interface
Framework, The .NET 2.0 Framework
generic collections, Framework Generic Collections
platform, C# 2005 and .NET 2.0
New Breakpoint dialog box, Using the Debug Menu to Set Your Breakpoint
New Web Site menu, Creating a Web Form
Next( ) method, Creating objects that can be sorted by the generic list
Nodes property, Expanding a directory
nodes, TreeNode objects, TreeNode objects
non-postback events, Postback Versus Non-Postback Events
not-equals operator (!=), The Equals Operator
Notepad, Hello World, Your First Program: Hello World
numeric types, Numeric Types

O

Object Browser window, Task List
Object class, The Root of All Classes: Object
object-oriented programming, The C# Language
analysis, Object-Oriented Analysis and Design
classes, Classes and Objects
defining, Defining a Class
relationships, Class Relationships
design, Object-Oriented Analysis and Design
encapsulation, The Three Pillars of Object-Oriented Programming
models, Creating Models
objects, Classes and Objects
polymorphism, Polymorphism
specialization, Specialization
objects
arrays
applying, Using Arrays
declaring, Declaring Arrays
foreach statements, The foreach Statement
initializing elements, The foreach Statement
methods, Array Methods
multidimensional, Multidimensional Arrays
params keyword, The params Keyword
sorting, Sorting Arrays
casting, Enumerations
classes, Examining Your First Program
constructors, Constructors
defining, Defining Classes
destroying, Destroying Objects
initializers, Initializers
instance members, Static and Instance Members
memory allocation, Memory Allocation: The Stack Versus the Heap
static members, Static and Instance Members
this keyword, The this Keyword
delegates, Delegates and Events
deriving, Specialization and Generalization
IStorable, Implementing an Interface
lists, sorting, Creating objects that can be sorted by the generic list
metaphors for, Object-Oriented Programming
object-oriented programming, Classes and Objects
strings, Strings
tracking, Set Your Watch
TreeNode, TreeNode objects
omitting iterators, Optional for loop header elements
OnLoad event, overriding, Adding Controls and Events
operator keyword, Using the operator Keyword
operators
addition (+), Mathematical Operators, Multicasting
as, The is and as Operators
assignment (=), The Assignment Operator (=)
calculate, Increment and Decrement Operators
conditionals, The Conditional Operator
conversion, Conversion Operators
decrement (- -), Increment and Decrement Operators
division (/), Mathematical Operators
dot (.), Examining Your First Program
equals (==), The Equals Operator
greater than (>), Relational Operators, The Equals Operator
greater than or equal to (>=), Relational Operators, The Equals Operator
increment (++), Increment and Decrement Operators, Relational Operators, Creating Useful Operators
is, The is and as Operators
less than (<), The Equals Operator
less than or equal to (<=), The Equals Operator
mathematical, Mathematical Operators
modulus (%)
controlling for loops, Controlling a for loop with the modulus operator
multiplication (*), Mathematical Operators
not-equals (!=), The Equals Operator
overloading, creating useful, Creating Useful Operators
plus sign (+), Using the operator Keyword
plus-equals (+=), Multicasting
postfix, The Prefix and Postfix Operators
prefix, The Prefix and Postfix Operators
reassign, Increment and Decrement Operators
relational, Relational Operators
subtraction (-), Mathematical Operators
ternary, The Conditional Operator
options
Find and Replace, Find and Replace
searching, Go To ...
Options command, Options
out of scope, Memory Allocation: The Stack Versus the Heap
outlining, Outlining
Document Outline window, Task List
Output window, Inside the Integrated Development Environment, Output
overloading
methods, Inside Methods
operators
conversion, Conversion Operators
creating useful, Creating Useful Operators
equals (==), The Equals Operator
plus sign (+), Using the operator Keyword
overriding
interfaces, implementing, Overriding Interface Implementations
OnLoad events, Adding Controls and Events
ToString( ) method, The Root of All Classes: Object
virtual methods, Creating Polymorphic Types

P

parameters, Examining Your First Program
defining, Method Arguments
naming, Using the operator Keyword
passing, Method Arguments
params keyword, The params Keyword
parent classes, Inheritance
partial keyword, Creating a Real-World Application
Pascal notation, Symbolic Constants
passing
parameters, Method Arguments
value types by references, Passing Value Types by Reference
pasting, Find and Replace
patterns, regular expressions, Regular Expressions
performance, Performance Tools
platforms, .NET, The .NET Platform
plus sign operator (+), Using the operator Keyword
plus-equals operator (+=), Multicasting
polymorphism, Inheritance and Polymorphism, Polymorphism
object-oriented programming, Polymorphism
postfix operators, Increment or Decrement by 1
primitive types, values, Constructors
private implementation, The Three Pillars of Object-Oriented Programming
programming
ASP.NET
creating Web Forms, Creating a Web Form
data binding, Data Binding
server controls, Server Controls
Web Form events, Web Form Events
Web Forms, Programming ASP.NET Applications
object-oriented, The C# Language
analysis, Object-Oriented Analysis and Design
class relationships, Class Relationships
classes, Classes and Objects
defining classes, Defining a Class
design, Object-Oriented Analysis and Design
encapsulation, The Three Pillars of Object-Oriented Programming
models, Creating Models
objects, Classes and Objects
polymorphism, Polymorphism
specialization, Specialization
outlining, Outlining
programs
.NET, C# 2005 and .NET 2.0
compilers, The Compiler
Hello World, Your First Program: Hello World
source code, What’s in a Program?
starting, Building and Running
viewing, Examining Your First Program
Project menu, Project Menu
projects
Visual Studio, Start Page
properties, Encapsulation
encapsulating, Encapsulating Data with Properties
Exception class, Exception Class Methods and Properties
HelpLink, Exception Class Methods and Properties
Hour, Encapsulating Data with Properties
indexers, declaring, Collection Interfaces
Item, Dictionaries
Length, Accessing Array Elements, Other Useful String Methods
length, Array Methods
Message, Exception Class Methods and Properties
Nodes, Clicking the source TreeView
offset, Dictionaries
StackTrace, Exception Class Methods and Properties
Status, Implementing the Interface on the Client
String class, Manipulating Strings
System.Array, Array Methods
Properties window, Inside the Integrated Development Environment, Properties
public interfaces, The Three Pillars of Object-Oriented Programming

Q

Quick Find, Find and Replace
Quick Replace, Find and Replace
QuickWatch, Set Your Watch
recalculations, The Call Stack

R

RAD (Rapid Application Development), Creating a Simple Windows Form
Web Forms, Programming ASP.NET Applications
radio groups, Server Controls
ReadLine( ) method, The continue statement
reassign operators, Increment and Decrement Operators
recalculations, QuickWatch, The Call Stack
rectangular arrays, Rectangular Arrays
recursing through subdirectories, Recursing through the subdirectories
recursion, Getting the files in the directory
references
searching, Find All References
types, Memory Allocation: The Stack Versus the Heap
delegates, Delegates and Events
Regex class, The Regex Class
regular expressions, Regular Expressions
searching, Go To ...
relational operators, Relational Operators
relationships
classes, Defining a Class
generalization, Specialization and Generalization
has-a, Class Relationships
implements, Interfaces
polymorphism, Polymorphism
specialization, Inheritance and Polymorphism
inheritance, Inheritance
removing warnings, Abstract Classes
replacing
Find and Replace options, Find and Replace
Quick Replace, Find and Replace
resizing, windows, Inside the Integrated Development Environment
responsibilities, Object-Oriented Programming
returning multiple values, Returning Multiple Values
Reverse( ) method, Array Methods
root classes, Inheritance, The Root of All Classes: Object
root of virtual dispatch, Versioning with new and override
rows, multidimensional arrays, Multidimensional Arrays
Run( ) method, Returning Multiple Values
running
applications, Building and Running
to breakpoints, Conversion Operators
runtime
specifying methods at, Delegates

S

scope
.NET, C# 2005 and .NET 2.0
local, Memory Allocation: The Stack Versus the Heap
sealed classes, Specialization and Generalization, Sealed Classes
searching
exception handlers, Throwing Exceptions
Find and Replace options, Find and Replace
Find in Files utility, Go To ...
incremental searches, Incremental search
options, Find and Replace
Quick Find, Find and Replace
references, Find All References
String class, Manipulating Strings
substrings, Finding Substrings
symbols, Find and Replace
selecting fields, Data Binding
semicolon (;), Statements
separation, code, Understanding Web Forms
servers, The Three Pillars of Object-Oriented Programming
controls, Server Controls
set( ) method, Creating Your Own Collections
SetCheck( ) method, Expanding a directory
Show All Files button, The partial Keyword
signatures
constructors, Overloading Methods
delegates, Delegates and Events
slashes (///), Examining Your First Program
.sln files, Projects and Solutions
Solution Explorer, Inside the Integrated Development Environment
solutions, Visual Studio, Start Page
Sort( ) method, Array Methods
delegates, Using Delegates to Specify Methods at Runtime
sorting
arrays, Sorting Arrays, Creating objects that can be sorted by the generic list
elements, Controlling how elements in a generic collection are sorted by implementing IComparer<T>
files, Sorting the list of selected files
integers, Creating objects that can be sorted by the generic list
List class, Creating objects that can be sorted by the generic list
source code, The Structure of C# Applications, What’s in a Program?
compilers, The Compiler
Hello World, Your First Program: Hello World
HTML, viewing, Adding Controls and Events
methods, Examining Your First Program
spaghetti code, Creating Loops with goto
specialization, Inheritance and Polymorphism
inheritance, Inheritance
polymorphism, Polymorphism
object-oriented programming, Specialization
stacks, Memory Allocation: The Stack Versus the Heap
call, How the Call Stack Works
unwinding, Searching for an Exception Handler, How the Call Stack Works
StackTrace property, Exception Class Methods and Properties
Start Page (Visual Studio 2005), Start Page
starting programs, Building and Running
state, Object-Oriented Programming
statements, C# Language Fundamentals
braces ({}), Single-Statement if Blocks
branching, Statements
conditional, Conditional Branching Statements
unconditional, Unconditional Branching Statements
break, Breaking out of a for loop
case, switch Statements
catch, The try and catch Statements
dedicated, Creating Dedicated catch Statements
continue, The continue statement
expressions, Expressions
finally, The finally Statement
foreach, arrays, The foreach Statement
goto, creating loops with, Iteration (Looping) Statements
if
nested, Nested if Statements
looping, Iteration (Looping) Statements
switch
strings, Switch on string Statements
throw, The throw Statement
try, The throw Statement
whitespace, Whitespace
WriteLine( ), Variables
static keyword, Examining Your First Program
static members, Static and Instance Members
Status property, Implementing More than One Interface
String class, Creating Strings
methods/properties, Manipulating Strings
strings, Strings
comparing, Manipulating Strings
creating, Creating Strings
escape characters, Escape Characters
literals, Creating Strings
manipulating, Manipulating Strings
modifying, The StringBuilder Class
Regex class, The Regex Class
regular expressions, Regular Expressions
splitting, Splitting Strings
verbatim, Verbatim Strings
structure of applications, The Structure of C# Applications
subdirectories, recursing through, Recursing through the subdirectories
subtraction operator (-), Mathematical Operators
SuppressFinalize( ) method, Destroying Objects
switch statements, switch Statements
symbolic constants, Symbolic Constants
symbols, searching, Go To ...
syntax, What’s in a Program?
System.Array, Array Methods
System.Exception, Throwing Exceptions

T

Tabbed Document window, Inside the Integrated Development Environment
Task List window, Inside the Integrated Development Environment, Task List
templates, Templates
web sites, Creating a Web Form
ternary operator, The Conditional Operator
TestFunc( ) method, The finally Statement
text, Regular Expressions
files, inserting, Find All References
incremental searches, Incremental search
this keyword, The this Keyword
throw statement, The throw Statement
throwing exceptions, Throwing Exceptions
call stacks, How the Call Stack Works
finally statement, The finally Statement
toolbars, Menus and Toolbars
Toolbox command, Toolbox
Toolbox window, Using the Visual Studio Designer
ToString( ) method
overriding, The Root of All Classes: Object
tracking
method calls, The Call Stack
objects/variables, Set Your Watch
TreeNode objects, TreeNode objects
trees, root classes, The Root of All Classes: Object
troubleshooting
debugging
setting breakpoints, Setting a Breakpoint
viewing values, Examining Values: The Autos and Locals Windows
Watch window, Set Your Watch
delegates, Events and Delegates
try statement, The try and catch Statements
Turbo Pascal, The C# Language
type safety, The C# Language
types, Examining Your First Program
arrays
applying, Using Arrays
declaring, Declaring Arrays
foreach statements, The foreach Statement
initializing elements, The foreach Statement
methods, Array Methods
multidimensional, Multidimensional Arrays
params keyword, The params Keyword
sorting, Sorting Arrays
boxing, Boxing and Unboxing Types
delegates, Delegates and Events
errors, Types and Compiler Errors
exceptions, Bugs, Errors, and Exceptions
float, Numeric Types
generics, Generics and Collections
intrinsic, Types
methods, defining behavior, Defining a Class
numeric, Numeric Types
primitive, values, Constructors
references, Memory Allocation: The Stack Versus the Heap, Delegates
runtime, Creating Polymorphic Types
unboxing, Boxing and Unboxing Types
values, Memory Allocation: The Stack Versus the Heap

U

UML (Unified Modeling Language), specialization, Specialization and Generalization
unboxing types, Boxing and Unboxing Types
Uncompress( ) method, Implementing More than One Interface
unconditional branching statements, Unconditional Branching Statements
unhandled exceptions, The throw Statement
Unified Modeling Language (UML), specialization, Specialization and Generalization
unwinding stacks, The throw Statement, How the Call Stack Works
Use checkbox, Find and Replace
use-case scenarios, Object-Oriented Analysis and Design
utilities
debuggers, setting breakpoints, Setting a Breakpoint
FileCopier, Creating a Real-World Application
source code, Handling the Delete Button Event
Find in Files, Find and Replace
ILDasm, Implementing an Interface

V

values
constants, Constants
debugging, viewing, Examining Values: The Autos and Locals Windows
dictionaries, Dictionaries
expressions, Expressions
initializers, Initializers
multiple, returning, Returning Multiple Values
primitive types, Constructors
types, Memory Allocation: The Stack Versus the Heap
variables, Types, Variables
definite assignment, Definite Assignment
expanding, Examining Values: The Autos and Locals Windows
initializers, Initializers
local, Memory Allocation: The Stack Versus the Heap
tracking, Set Your Watch
verbatim strings, Verbatim Strings
vertical bar (|), The Regex Class
View menu, View Menu
viewing
attributes, Implementing an Interface
breakpoints, Using the Debug Menu to Set Your Breakpoint
HTML source code, Adding Controls and Events
programs, The Compiler
values, debugging, Examining Values: The Autos and Locals Windows
Visual Studio 2005
applications, building and running, Building and Running
menus, Menus and Toolbars
projects and solutions, Start Page
Start Page, Start Page
toolbars, Menus and Toolbars
Web Forms, Understanding Web Forms
XML documentation comments, XML Documentation Comments
void keyword, Examining Your First Program

W

warnings, removing, Abstract Classes
Watch window, Set Your Watch
web applications, creating, Web Sites
Web Forms, Programming ASP.NET Applications
controls
adding, Adding Controls
server, Server Controls
creating, Creating a Web Form
events, Understanding Web Forms
web sites, New Web Site menu, Creating a Web Form
while (true) construct, The while (true) construct
while loops, The while Loop
whitespace, Whitespace
wildcards, Find and Replace
Wiltamuth, Scott, The C# Language
Window menu, Window Menu
Windows
.NET Framework, The .NET 2.0 Framework
applications, The Development Environment
controls, Defining Classes
forms
creating, Creating a Simple Windows Form
creating real-world applications, Creating a Real-World Application
windows
Autos, Examining Values: The Autos and Locals Windows, Set Your Watch, The Equals Operator
Breakpoints, Using the Debug Menu to Set Your Breakpoint
Call Stack, The Call Stack
Code Definition, Code Definition
Dynamic Help, Inside the Integrated Development Environment
Error List, Inside the Integrated Development Environment, Error List
Find Results, Inside the Integrated Development Environment
Find Symbol Results, Inside the Integrated Development Environment
floating, Inside the Integrated Development Environment
Locals, Examining Values: The Autos and Locals Windows
Object Browser, Task List
Output, Inside the Integrated Development Environment, Output
Properties, Inside the Integrated Development Environment, Properties
resizing, Inside the Integrated Development Environment
Task List, Inside the Integrated Development Environment, Task List
text editing, Inside the Integrated Development Environment
Toolbox, Using the Visual Studio Designer
Watch, Set Your Watch
wizards, Data Source Configuration, Data Binding
WriteLine( ) method, Examining Your First Program
WriteLine( ) statement, Variables

X

XML documentation comments, XML Documentation Comments
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset