Index

Symbols

! (not) operator, Use of Logical Operators with Conditionals
precedence of, Operator Precedence
!= (not equal) operator, Relational Operators, Operator Precedence, Logical Pairs
" (double quotes), using escape characters, Choosing a built-in type
# (pound sign), examining special preprocessor directives, Preprocessor Directives
% (modulus) operator, The for loop
precedence of, Operator Precedence
returning remainders, Simple arithmetical operators (+, -, *, /), The modulus operator (%) to return remainders
%= assignment operator, Calculate and reassign operators, Operator Precedence
& (logical AND) operator, Operator Precedence
as an address-of C++ operator, Pointers
&& (and) operator, Use of Logical Operators with Conditionals, Operator Precedence
&= assignment operator, Operator Precedence
( ) (parentheses), Regular Expressions
methods, using, Methods
(T)x operator, Operator Precedence
* (multiplication) operator, Simple arithmetical operators (+, -, *, /)
as a dereference operator, Pointers
operator precedence of, Operator Precedence
*= assignment operator, Operator Precedence
*= operator, Calculate and reassign operators
+ (plus sign)
as an addition operator, Simple arithmetical operators (+, -, *, /)
precedence of, Operator Precedence
++ (increment) operator, Operator Precedence
+= assignment operator, Calculate and reassign operators, Operator Precedence
+= operator, Events and Delegates
- (subtraction) operator, Simple arithmetical operators (+, -, *, /)
precedence of, Operator Precedence
-- (decrement) operator, Operator Precedence
-= assignment operator, Calculate and reassign operators, Operator Precedence
-\> (member access) operator, Pointers
. (member access) operator, The Dot Operator (.)
writing text to the monitor, Console Applications
; (semicolons)
abstract classes and, Abstract Classes
ending statements with, Statements
< (less than) relational operator, If...else statements, Relational Operators, Logical Pairs
precedence of, Operator Precedence
<< operator, Operator Precedence
<<= assignment operator, Operator Precedence
<= operator, Logical Pairs
<= relational operator, Relational Operators, Operator Precedence
= (assignment) operator, Expressions, The Assignment Operator (=)
operator precedence of, Operator Precedence
= assignment operator, Manipulating Strings
== (equal to) relational operator, If...else statements, Relational Operators, Logical Pairs
conversion operators and, Conversion Operators
precedence of, Operator Precedence
strings, manipulating, Manipulating Strings
> (greater than) relational operator, If...else statements, Relational Operators
>= operator, Relational Operators, Logical Pairs
?: (ternary) operator, Operator Precedence
@ (verbatim string literals), Creating Strings
DirectoryInfo object, creating, Creating a DirectoryInfo Object
[ ] (square brackets)
declaring arrays, Declaring Arrays
for indexing[[ ] (square brackets)
indexing, IDictionary
for indexing, Indexers
in strings, Manipulating Strings
jagged arrays and, Jagged arrays
: (colon), Regular Expressions
calling base class constructors, Calling Base Class Constructors
\> (greater than) relational operator, Logical Pairs
precedence of, Operator Precedence
\>= relational operator, Operator Precedence
\>\> operator, Operator Precedence
\>\>= assignment operator, Operator Precedence
\\ (backslashs), using escape characters, Choosing a built-in type , Creating Strings
\\a (alert escape character), Choosing a built-in type
\\f (form feed escape character), Choosing a built-in type
\\n (newline escape character), Choosing a built-in type
\\r (carriage return escape character), Choosing a built-in type
\\t (horizontal tab escape character), Choosing a built-in type
\\v (vertical tab escape character), Choosing a built-in type
^ (bitwise), Regular Expressions
^ (logical XOR) operator, Operator Precedence
^= assignment operator, Operator Precedence
{ } (braces), The for loop
array elements, initializing, Initializing Array Elements
classes, defining, Defining Classes
properties and behaviors, defining, Classes, Objects, and Types
| (vertical bar), Regular Expressions
|= assignment, Operator Precedence
|| (or) operator, Use of Logical Operators with Conditionals, Operator Precedence
~ operator, Operator Precedence

A

abstract classes, Inheritance and Polymorphism, Abstract Classes, Sealed Class, Events and Delegates, C# Keywords
limitations of, Limitations of Abstract
sealed, Sealed Class
vs. interface, Interface Versus Abstract Class
Accept( ) method, Network I/O
AcceptChanges( ) method, Changing Database Records
AcceptSocket( ), Handling Multiple Connections
access modifiers, Access Modifiers, Events and Delegates
controlling, Controlling Access
implementing an interface, Implementing an Interface
ActiveX controls, Importing ActiveX Controls, Adding a control to the Visual Studio toolbox
Adapter( ) method, Array Lists
Add( ) method, Supporting Other .NET Languages, Creating the Proxy, Building a Multi-Module Assembly
ArrayList methods and, Array Lists
hashtables and, Hashtables
indexing and, Indexers
web services, building, Building a Web Service
addition (+) operator, Simple arithmetical operators (+, -, *, /)
precedence of, Operator Precedence
AddRange( ) method, Array Lists
address-of (&) operator, Pointers
ADO.NET, The .NET Framework, Accessing Data with ADO.NET, ADO.NET and XML
data-bound objects, Working with Data-Bound Controls
database records, changing, Changing Database Records, Creating New Records
getting started with, Getting Started with ADO.NET, Using ADO Managed Providers
managed providers, using, Using ADO Managed Providers, Using ADO Managed Providers
object models, The ADO.Net Object Model, The DataAdapter Object
XML and, ADO.NET and XML
alert escape character (\\a), Choosing a built-in type
All attribute target, Attribute Targets
and (&&) operator, Use of Logical Operators with Conditionals, Operator Precedence
app domains, Application Domains, Specifying the marshaling method
contexts for, Context, Marshaling Across Context Boundaries
creating and using, Creating and Using App Domains
marshaling and, Marshaling Across App Domain Boundaries, Specifying the marshaling method
methods and properties for, Application Domains
AppDomain class, Application Domains
append argument, Working with Text Files
Append( ) method, Manipulating Dynamic Strings
AppendFormat( ) method, Manipulating Dynamic Strings
AppendText( ) method, Working with Files
Application Folder in Visual Studio .NET, Setup Project
deployment locations and, Deployment Locations
special folders, adding to, Adding Special Folders
applications
console, Console Applications
deploying, Deploying an Application, Building the Setup Project
domains (see app domains)
web (see web applications)
for Windows, Building Windows Applications , Building the Setup Project
Forms, creating, Creating a Simple Windows Form, XML Documentation Comments
args argument, Dynamic Invocation with InvokeMember( )
arguments
events, Web Form Events
method, Method Arguments
ArrayList class, Array Lists, Implementing the Copy Button Event
arrays, Arrays, System.Array
conversions, Array Conversions, Array Conversions
declaring, Declaring Arrays
default values, understanding, Understanding Default Values
elements, accessing, Accessing Array Elements , Accessing Array Elements
executing with delegate, Setting Order of Execution with Arrays of Delegates, Setting Order of Execution with Arrays of Delegates
lists, Array Lists, Implementing IComparer
multidimensional, Multidimensional Arrays, Jagged arrays
System, System.Array , System.Array
as operator, The as Operator, C# Keywords
vs. is operator, The is Operator Versus the as Operator
objects, Responding to Postback Events
ASP.NET
C# language and, ASP.NET and C#
postback events, responding to, Responding to Postback Events
Web Forms
controls, adding, Adding Controls
life cycles, handling, Web Form Life Cycle
.aspx file extension, Creating a Web Form
storing UI pages, Understanding Web Forms
assemblies, The C# Language, Controlling Access, Assemblies and Versioning, Step 2: Put the shared assembly in the GAC
global cache, The Global Assembly Cache
multi module, Multi-Module Assemblies, Loading the assembly
private, Private Assemblies
shared, Private Assemblies, Step 2: Put the shared assembly in the GAC
Assembly attribute target, Attribute Targets
Assembly.Load static method, Type Discovery
AssemblyInfo.cs file, Building a Multi-Module Assembly
AssemblyLoad event, Application Domains
AssemblyResolve event, Application Domains
AssemblyResolver, loading assemblies, Loading the assembly
assignments
definite, Definite Assignment
indexers and, Indexers and Assignment
asynchronous I/O, Asynchronous I/O, Asynchronous I/O
attributes, The C# Language, Attributes and Reflection, Using an Attribute
applying, Applying Attributes
constructing, Constructing an Attribute
custom, Intrinsic Attributes, Custom Attributes, Using an Attribute
declaring, Declaring an Attribute
intrinsic, Intrinsic Attributes
naming, Naming an Attribute
targets, Attribute Targets
using, Using an Attribute, Using an Attribute
Attributes property, Working with Directories
Attributes( ) method, Working with Files
AutoPostBack property, Postback versus non-postback events
AxImp command line utility, Importing ActiveX Controls, Importing a control
a[x] operator, precedence of, Operator Precedence

B

backslashs (\\), using escape characters, Choosing a built-in type , Creating Strings
base classes, Inheritance
constructors, calling, Calling Base Class Constructors
methods, calling, Calling Base Class Methods
polymorphic methods, creating, Creating Polymorphic Methods
versioning with new/override keywords, Versioning with the new and override Keywords
base keyword, C# Keywords
base-list, Implementing an Interface
BeginRead( ) method
asynchronous I/O and, Asynchronous I/O
performing a binary read, Binary Files
BeginWrite( ) method
asynchronous I/O and, Asynchronous I/O
performing a binary read, Binary Files
Berkeley socket interface, Creating a Network Streaming Server
binary files, Binary Files, Binary Files
BinaryFormatter, Using a Formatter
BinaryReader class, Reading and Writing Data
BinarySearch( ) method, Arrays, Array Lists
BinaryWriter class, Reading and Writing Data
binders, Creating and Using App Domains
argument, Dynamic Invocation with InvokeMember( )
binding, importing the COM DLL to .NET, Importing the COM .DLL to .NET
BindingFlags parameter, Finding particular type members
bitwise (^), Regular Expressions
BizTalk 2000, The .NET Platform
blocks
catch, The catch Statement
finally, The finally Statement, The finally Statement
statement, If...else statements
bool types, Working with Built-in Types, C# Keywords
default values of, Constructors
Boolean variables, Working with Built-in Types
relational operators and, Relational Operators
while loop and, The while loop
Borland Delphi, The C# Language
boxing, Working with Built-in Types
types, Boxing and Unboxing Types
braces ({ }), The for loop
array elements, initializing, Initializing Array Elements
classes, defining, Defining Classes
properties and behaviors, defining, Classes, Objects, and Types
brackets (see square brackets)
branches, compiling code, Statements
break statement, Unconditional Branching Statements, Switch statements: an alternative to nested ifs, Iteration Statements, C# Keywords
continue statement and, The continue and break statements
breakpoint, compiling and running programs, Using the Visual Studio .NET Debugger
browsers
IP addresses and, Network I/O
Web Forms, running on, Understanding Web Forms
Web Services, testing on, Testing Your Web Service
buffered streams, Buffered Streams, Buffered Streams
BufferedStream class, Reading and Writing Data
bugs, Handling Exceptions
built-in types, Types
choosing, Choosing a built-in type
converting, Converting built-in types
buttons, Delegates and Events, Events, Creating a Windows Form Application
Click events and, Publishing and Subscribing
copy buttons, implementing events for, Implementing the Copy Button Event, Sorting the list of selected files
data binding and, Data Binding
delete buttons, handling events for, Handling the Delete Button Event, XML Documentation Comments
objects, Using Notepad
byte integral type, Working with Built-in Types, C# Keywords

C

C# language
ASP.NET and, ASP.NET and C#
fundamentals of, C# Language Fundamentals, #region
keywords, C# Keywords, C# Keywords
.NET framework, C# and the .NET Framework, The C# Language
C++ language, C# and the .NET Framework
style comment, Comments
style pointers for, Pointers
C-Style comments (Ú* ... *Ú), Comments
Cab Project in Visual Studio .NET, Deployment Projects
Calculator class, Building a Server
call stacks, Exception Objects
camel notation, naming variables, Identifiers
Capacity property, Array Lists
Capacity( ) method, Manipulating Dynamic Strings
capture collections, Using CaptureCollection, Using CaptureCollection
carriage return escape character (\\r), Choosing a built-in type
case statement, C# Keywords
case-sensitivity, Case Sensitivity, Manipulating Strings
catch statements, The catch Statement, Creating dedicated catch statements, C# Keywords
call stack, unwinding, Unwinding the call stack, Unwinding the call stack
dedicated, creating, Creating dedicated catch statements, Creating dedicated catch statements
taking corrective action, Taking corrective action
channels, Marshaling and Remoting
char type, Working with Built-in Types, Choosing a built-in type , C# Keywords
default values of, Constructors
enumerations and, Enumerations
Chars( ) method, Manipulating Strings , Manipulating Dynamic Strings
CharSet parameter, P/Invoke
checked operator, C# Keywords
precedence of, Operator Precedence
Class attribute target, Attribute Targets
class keyword, defining types as classes, Classes, Objects, and Types
class members, Classes and Objects
class type, C# Keywords
classes, The .NET Framework, Classes, Objects, and Types, The static Keyword, Classes and Objects, Readonly Fields
abstract, Abstract Classes, Sealed Class
base, Inheritance
methods, calling, Calling Base Class Methods
custom exception, Custom Exceptions
defining, Defining Classes, Method Arguments
indexers, Indexers, Indexing on Other Values
interfaces, implementing, Implementing an Interface, Combining Interfaces
methods, overloading, Overloading Methods and Constructors , Overloading Methods and Constructors
nesting, Nesting Classes
objects, methods for, The Root of all Classes: Object
properties, encapsulating data with, Encapsulating Data with Properties, Readonly Fields
reflection, Viewing MetaData
sealed, accessing, Accessing Sealed Classes and Value Types , Accessing Sealed Classes and Value Types
ClassMembers attribute target, Attribute Targets
clear button event, Handling the Clear button event
Clear property, Queues
Clear( ) method
ArrayList methods and, Array Lists
Hashtable methods and, Hashtables
Stack methods and, Stacks
SystemArray methods and, Arrays
Click event, Publishing and Subscribing
client-side support, Client-side Support
clients
building, Building the Client
streaming network, creating, Creating a Streaming Network Client, Creating a Streaming Network Client
Clone( ) method
ArrayList methods and, Array Lists
Hashtable methods and, Hashtables
Queue methods and, Queues
Stack methods and, Stacks
string class and, Manipulating Strings
Close( ) method, implementing, Implementing the Close Method
CLR (Common Language Runtime), The .NET Framework, Methods, Shared Assemblies, Understanding marshaling with proxies
asynchronous I/O and, Asynchronous I/O
serializing objects, Serialization
threads and, Threads and Synchronization
CLS (Common Language Specification), The .NET Framework, Working with Built-in Types
code-behind C# source files, Understanding Web Forms
collection interfaces, Collection Interfaces, The IComparer Interface
collections
capture, using, Using CaptureCollection, Using CaptureCollection
indexing, Indexers
namespaces, The Dot Operator (.)
regex match, using, Using Regex Match Collections
collisions, Hashtables
colon (:), Regular Expressions
calling base class constructors, Calling Base Class Constructors
columns, Tables, Records, and Columns
COM (Component Object Model)
ActiveX controls, importing, Importing ActiveX Controls, Adding a control to the Visual Studio toolbox
exporting, Exporting .NET Components
importing, Importing COM Components, Exporting .NET Components
COM (Component Object Model), programming, Programming .NET and COM, Pointers
commandString parameter, Getting Started with ADO.NET
comments, Comments
in code, Using the Visual Studio.Net Designer
XML documentation, XML Documentation Comments, XML Documentation Comments
Common Language Runtime (CLR), The .NET Framework, Methods, Shared Assemblies, Understanding marshaling with proxies
asynchronous I/O and, Asynchronous I/O
serializing objects, Serialization
threads and, Threads and Synchronization
Common Language Specification (CLS), The .NET Framework, Working with Built-in Types
Common Type System (CTS), The .NET Framework
Compare( ) method, Manipulating Strings
CompareOrdinal( ) method, Manipulating Strings
CompareTo( ) method, The IComparer Interface, Manipulating Strings
IComparable, implementing, Implementing IComparable
IComparer, implementing, Implementing IComparer
compiling, Compilation and the MSIL, Compiling and Running “Hello World”
normalization and, Normalization
XML files and, XML Documentation Comments
Component Object Model (see COM)
ComputeSum( ) method, Dynamic Invocation with InvokeMember( )
Concat( ) method, Manipulating Strings
concatenation (+) operator, Manipulating Strings
concrete classes, Abstract Classes
conditional branching statements, Statements, Conditional Branching Statements, Switch on string statements
conditionals, using with logical operators, Use of Logical Operators with Conditionals
Configuration namespace, The Dot Operator (.)
connections, handling multiple, Handling Multiple Connections, Handling Multiple Connections
connectionString parameter, Getting Started with ADO.NET
console applications, Console Applications
Console object
dot operator and, The Dot Operator (.)
writing text to the monitor, Console Applications
Console.ReadLine method, The continue and break statements
Console.Write( ) method, The for loop, Conversion Operators, Pointers
const keyword, C# Keywords
declaring constants with, Constants
constants, Variables and Constants, Identifiers
enumerations and, Enumerations, Enumerations
Constructor attribute target, Attribute Targets
constructors, Constructors, Constructors
base classes, calling, Calling Base Class Constructors
defining, Constructors
overloading, Overloading Methods and Constructors , Overloading Methods and Constructors
private, using, Using Private Constructors
structs, and
calling default, Calling the Default Constructor
using static, Using Static Constructors
Contains( ) method
ArrayList method and, Array Lists
Hashtable methods and, Hashtables
Queue methods and, Queues
Stack methods and, Stacks
ContainsKey( ) method, Hashtables
contexts, Marshaling and Remoting, Context, Marshaling Across Context Boundaries
marshaling and, Marshaling Across Context Boundaries
xt-bound and xt-agile objects, Context-Bound and Context-Agile Objects
continue statement, Unconditional Branching Statements, Iteration Statements, The continue and break statements, C# Keywords
controls, Defining Classes
ActiveX, importing, Importing ActiveX Controls, Adding a control to the Visual Studio toolbox
importing, Importing a Control in .NET, Adding a control to the Visual Studio toolbox
Web Forms, adding, Adding Controls, Adding Controls
conversion operators, Conversion Operators
conversions (array), Array Conversions, Array Conversions
copy button, implementing events, Implementing the Copy Button Event, Sorting the list of selected files
copy constructors, Copy Constructors
Copy( ) method, Arrays, Working with Files
strings, manipulating, Manipulating Strings
CopyTo( ) method
FileInfo class and, Working with Files
files, modifying, Modifying Files
Hashtable methods and, Hashtables
ICollection Interface and, The ICollection Interface
Queue methods and, Queues
Stack methods and, Stacks
string class and, Manipulating Strings
Cos( ) method, Late Binding
calling, Late Binding
Count property, Array Lists, Queues, Hashtables
Count( ) method, Stacks
Create( ) method, Working with Directories, Working with Files
CreateChildControls( ) method, Web Form Life Cycle
CreateDirectory( ) method, Working with Directories
CreateDomain( ) method, Application Domains
CreateFile( ) method, Pointers
CreateInstance( ) method, Arrays, Creating and Using App Domains
CreateSubdirectory( ) method, Working with Directories
CreateText( ) method, Working with Files
CreationTime property, Working with Directories, Working with Files
.cs files, Creating a Web Form
CTS (Common Type System), The .NET Framework
CurrentDomain property, Application Domains
custom attributes, Intrinsic Attributes, Custom Attributes, Using an Attribute
custom exceptions, Custom Exceptions, Custom Exceptions

D

data
reading and writing, Reading and Writing Data, Working with Text Files
transient, handling, Handling Transient Data, Handling Transient Data
Data Adapter, Data Adapter
data binding, Data Binding, Responding to Postback Events
setting initial properties, Setting Initial Properties
Data namespaces, The Dot Operator (.)
data tables, combining, Combining Data Tables, Combining Data Tables
data-bound objects, Working with Data-Bound Controls
DataAdapter object, The DataAdapter Object
databases
records, changing, Changing Database Records, Creating New Records
relational, Relational Databases and SQL, SQL
Web Forms, connecting to, Connecting to the Database
DataGrid control, Populating a DataGrid, Populating a DataGrid
DataRelation objects, The ADO.Net Object Model
DataSet class, The ADO.Net Object Model, Changing Database Records
customizing, Customizing the DataSet, Combining Data Tables
DataTable objects, The ADO.Net Object Model, Changing Database Records
DBCommand object, DBCommand and DBConnection
DBConnection object, DBCommand and DBConnection
deadlocks, synchronizing threads, Race Conditions
deadly embrace (deadlocks), Deadlock
Debug identifier, Defining Identifiers
debuggers, Using the Visual Studio .NET Debugger, Using the Visual Studio .NET Debugger
decimal datatype, Working with Built-in Types, C# Keywords
declarative constructs (see attributes)
declarative pinning, Pointers
Declarative Referential Integrity (DRI), Declarative Referential Integrity
decrement (--) operator, Operator Precedence
Decrement method, Using Interlocked
decrement operators, Increment and Decrement Operators
default keyword, C# Keywords
default values
of arrays, Understanding Default Values
of primitive types, Constructors
#define statement, Defining Identifiers
DefineDynamicAssembly( ) method, Application Domains
definite assignments, Definite Assignment
passing parameters with, Passing Out Parameters with Definite Assignment , Passing Out Parameters with Definite Assignment
Delegate attribute target, Attribute Targets
delegate keyword, C# Keywords
delegates, Delegates and Events, Multicasting , Asynchronous I/O
buttons, creating, Using Notepad
events and, Events and Delegates, Events and Delegates
executing with arrays, Setting Order of Execution with Arrays of Delegates, Setting Order of Execution with Arrays of Delegates
multicasting, Multicasting , Multicasting
as properties, Delegates as Properties
specifying methods at runtime, Using Delegates to Specify Methods at Runtime, Using Delegates to Specify Methods at Runtime
static, Static Delegates
delete button, handling events, Handling the Delete Button Event, XML Documentation Comments
Delete( ) method, Working with Directories, Working with Files
delimiters, Manipulating Dynamic Strings
Dequeue( ) method, Queues
dereference (*) operator, Pointers
derived classes, Inheritance, Controlling Access
Design Patterns (Gamma), Publishing and Subscribing
design tools for Windows Forms, Using the Visual Studio.Net Designer
destructors (C#), The C# Destructor
structs and, Defining Structs
dictionaries, Dictionaries, IDictionaryEnumerator Interface
keys and values collections, The Keys and Values Collections
Dictionary classes, developing, Namespaces
digital signatures, Strong Names
dimensions of arrays, Rectangular arrays
directories, Files and Directories, Reading and Writing Data
DirectoryInfo object, creating, Creating a DirectoryInfo Object, Creating a DirectoryInfo Object
working with, Working with Directories, Creating a DirectoryInfo Object
Directory class, Working with Directories, Reading and Writing Data
Directory property, Working with Files
DirectoryInfo class, Reading and Writing Data
discovery, SOAP, WSDL, and Discovery
type, Type Discovery
Dispose( ) method, Finalize Versus Dispose, Web Form Life Cycle
Div( ) method, Building a Web Service
division (Ú) operator, Simple arithmetical operators (+, -, *, /), Operator Precedence
DllImportAttribute class, P/Invoke
DLLs (dynamic link libraries), The C# Language, Building Windows Applications , Creating a Web Form
assemblies and, Assemblies and Versioning
COM components, importing, Importing COM Components, Exporting .NET Components
multi-module assemblies and, Multi-Module Assemblies
do statement, C# Keywords
signaling loops and iteration statements, Statements
while loop and, The do . . . while loop
domains (application), Application Domains, Specifying the marshaling method
dot operator (.)
writing text to the monitor, Console Applications
double quotes (“), using escape characters, Choosing a built-in type
double type, Working with Built-in Types, C# Keywords
DrawWindow( ) method, Using the Visual Studio .NET Debugger
DRI (Declarative Referential Integrity), Declarative Referential Integrity
dynamic invocation, Reflection Emit
with interfaces, Dynamic Invocation with Interfaces, Dynamic Invocation with Interfaces
InvokeMember( ) and, Dynamic Invocation with InvokeMember( ), Dynamic Invocation with InvokeMember( )
reflection emit and, Dynamic Invocation with Reflection Emit, Dynamic Invocation with Reflection Emit
dynamic link libraries (see DLLs)
dynamic strings, manipulating, Manipulating Dynamic Strings, Manipulating Dynamic Strings

E

early binding, Importing the COM .DLL to .NET
elements (array), Accessing Array Elements , Initializing Array Elements
else statement, If...else statements, Defining Identifiers, C# Keywords
Emacs, compiling programs with, Developing “Hello World”
Empty field, Manipulating Strings
encapsulation, Classes and Objects
encryption technology for strong names, Strong Names
#endif statement, Defining Identifiers
endpoints, Building a Server, Understanding Endpoints, Understanding Endpoints
EndRead( ) method, Asynchronous I/O
EndsWith( ) method, Manipulating Strings
Enqueue( ) method, Queues
EnsureCapacity( ) method, Manipulating Dynamic Strings
Enter( ) method, using monitors, Using Monitors
EntryPoint parameter, P/Invoke
Enum attribute target, Attribute Targets
enum type, Working with Built-in Types, Enumerations, C# Keywords
default values of, Constructors
Enumerable class, The IEnumerable Interface
enumerations, Constants, Enumerations
equal to (==) relational operator, If...else statements, Relational Operators, Logical Pairs
conversion operators and, Conversion Operators
precedence of, Operator Precedence
strings, manipulating, Manipulating Strings
Equals( ) method, The Root of all Classes: Object, The Equals Operator, Conversion Operators, Manipulating Strings
string class and, Manipulating Strings
testing equality of two strings, Manipulating Strings
errors, Handling Exceptions
escape characters, Choosing a built-in type , Creating Strings
Event attribute target, Attribute Targets
event keyword, C# Keywords
event-driven programming, Delegates and Events
EventArgs class, Events and Delegates
events, The C# Language, Events, Decoupling Publishers from Subscribers
arguments, Web Form Events
copy button, implementing, Implementing the Copy Button Event, Sorting the list of selected files
delegates and, Events and Delegates, Events and Delegates
delete button, handling, Handling the Delete Button Event, XML Documentation Comments
handlers, Events and Delegates, Web Form Events
publishing/subscribing, Publishing and Subscribing
Web Forms, Web Form Events
ExactSpelling parameter, P/Invoke
Excel, Building Windows Applications
exceptions, Handling Exceptions
catch statements and, The catch Statement, Creating dedicated catch statements
custom, Custom Exceptions, Custom Exceptions
finally statement and, The finally Statement, The finally Statement
objects, Exception Objects, Exception Objects
rethrowing, Rethrowing Exceptions
throwing and catching, Throwing and Catching Exceptions, The finally Statement
Exchange 2000, The .NET Platform
EXE (executable), Compilation and the MSIL, The C# Language, Creating a Web Form
assemblies and, Assemblies and Versioning
JIT compilation and, Compiling and Running “Hello World”
multi-module assemblies and, Multi-Module Assemblies
ExecuteAssembly( ) method, Application Domains
Exists property, Working with Files
Exists( ) method, Working with Directories
Exit( ) method, using monitors, Using Monitors
explicit conversions, Conversion Operators, Conversion Operators, C# Keywords
explicit interface implementation, Explicit Interface Implementation, Accessing Sealed Classes and Value Types
expressions, Expressions
Extensible Markup Language (XML)
ADO.NET and, ADO.NET and XML
using documentation comments, XML Documentation Comments, XML Documentation Comments
Extension property, Working with Directories, Working with Files
extern methods, C# Keywords

F

f(x) operator, precedence of, Operator Precedence
false keyword, C# Keywords
false values, Working with Built-in Types, The while loop
relational operators, Relational Operators
FCL (Framework Class Library), The .NET Framework, Using Notepad, Understanding Web Forms
namespaces and, Namespaces
Field attribute target, Attribute Targets
fields, Classes and Objects
FIFO (first- in, first-out) collections, Queues
File class, Reading and Writing Data
file transfers, Events
FileInfo class, Reading and Writing Data
files, Files and Directories, Reading and Writing Data
.cab, Deployment Projects
binary, Binary Files, Binary Files
deployment locations for applications, Deployment Locations
modifying, Modifying Files, Reading and Writing Data
special folders, adding, Adding Special Folders
test, working with, Working with Text Files, Working with Text Files
types, registering, Registering file types
working with, Working with Files, Working with Files
FileStream class, Reading and Writing Data
Finalize( ) method, Destroying Objects , The Root of all Classes: Object
vs. dispose, Finalize Versus Dispose
finally blocks, Handling Exceptions, C# Keywords
finally statement, The finally Statement, The finally Statement
FindMembers method, Finding particular type members
findString( ), Indexing on Other Values
first-in, first-out (FIFO) collections, Queues
fixed statement, C# Keywords
FixedSize( ) method, Array Lists
float datatype, Working with Built-in Types, Method Arguments, C# Keywords
Flush( ), performing a binary read, Binary Files
folders, Files and Directories
Font object, The using Statement
for statement, The for loop, The for loop, C# Keywords
signaling loops and iteration statements, Statements
foreach loop, Type Discovery
foreach statement, The foreach statement, The foreach Statement, System.Array , C# Keywords
IEnumerable interface, supporting, The IEnumerable Interface
signaling loops and iteration statements, Statements
foreign keys, Tables, Records, and Columns, Combining Data Tables
forever loops, Handling Multiple Connections, Aysnchronous Network File Streaming
form feed escape character (\\f), Choosing a built-in type
Form object, Using Notepad
Format( ) method, Manipulating Strings
formatters, Marshaling and Remoting, Understanding marshaling with proxies
using for serializing data, Using a Formatter, Deserializing the object
Fraction class, Conversion Operators
Framework Class Library (FCL), The .NET Framework, Using Notepad, Understanding Web Forms
namespaces and, Namespaces
FriendlyName property, Application Domains
FullName property, Recursing through the subdirectories, Working with Directories, Working with Files
Func1( ), Unwinding the call stack
Func2( ), Unwinding the call stack
functions, Methods
branching statements, Unconditional Branching Statements

G

GAC (Global Assembly Cache), Shared Assemblies, The Global Assembly Cache
Gamma (Design Patterns), Publishing and Subscribing
garbage collector, Working with Built-in Types
objects, destroying, Destroying Objects
throwing exceptions and, The finally Statement
generalization of classes and objects, Specialization and Generalization
get accessor, The get Accessor
get keyword, C# Keywords
get( ) method, indexing, Indexers
GetAttributes( ) method, Working with Files
GetChanges( ) method, Changing Database Records
GetCreationTime( ) method, Working with Directories, Working with Files
GetCurrentDirectory( ) method, Working with Directories
GetCurrentThreadID( ) method, Application Domains
GetData( ) method, Application Domains
GetDirectories( ) method, Working with Directories
GetDirectoryRoot( ) method, Working with Directories
GetEnumerator( ) method, Arrays, The IEnumerable Interface, Array Lists, Queues
hashtables and, Hashtables
stacks and, Stacks
GetFiles( ) method, Working with Directories, Working with Files
GetFileSystemInfos( ) method, Working with Directories
GetHashCode( ) method, The Root of all Classes: Object, Hashtables
GetLastAccessTime( ) method, Working with Directories, Working with Files
GetLastWriteTime( ) method, Working with Directories, Working with Files
GetLength( ) method, Arrays
GetLogicalDrives( ) method, Working with Directories
GetLowerBound( ) method, Arrays
GetMembers( ) method, Finding all type members
GetObjectData( ) method, Hashtables
GetParent( ) method, Working with Directories
GetRange( ) method, Array Lists
GetResponse( ) method, Web Streams
GetString( ) method, Accessing Sealed Classes and Value Types , Pointers
GetType( ) method, The Root of all Classes: Object, Reflecting on a Type
servers, building, Building a Server
GetUpperBound( ) method, Arrays
.gif files, Assemblies and Versioning
Global Assembly Cache (GAC), Shared Assemblies, The Global Assembly Cache
goto statements, Unconditional Branching Statements, Switch statements: an alternative to nested ifs, The goto statement, C# Keywords
Graphical User Interfaces (see GUIs)
greater than (>) relational operator, If...else statements, Relational Operators
greater than (\>) relational operator, Logical Pairs
precedence of, Operator Precedence
GridLayout mode, adding controls to Web Forms, Adding Controls
GUIs (Graphical User Interfaces), Delegates and Events
events, Events

H

handlers (event), Events and Delegates, Web Form Events
handles (object), Creating and Using App Domains
hashtables, Hashtables
heaps, Working with Built-in Types
Hejlsberg, Anders (developer), The C# Language
Hello World program, Getting Started:"Hello World”, Using the Visual Studio .NET Debugger
HelpLink property, Exception Objects
horizontal tab escape character (\\t), Choosing a built-in type
HTML (Hypertext Markup Language)
Web Forms and, Understanding Web Forms, Web Form Life Cycle
controls, adding, Adding Controls, Adding Controls
creating, Creating a Web Form, Creating a Web Form
databases, connecting to, Connecting to the Database, Responding to Postback Events
WSDL contract, viewing with, Viewing the WSDL Contract
HTML (Hypertext Markup Language), using XSLT files, XML Documentation Comments
HTTP-Get, Creating the Proxy
HTTP-Post, Creating the Proxy
Hypertext Markup Language (see HTML)

I

ICalc interface, Building the Client
ICloneable interface, Strings
ICollection interface, Collection Interfaces, The ICollection Interface
IComparable interface, Strings
implementing, Implementing IComparable, Implementing IComparable
IComparer interface, Collection Interfaces, The IComparer Interface
implementing, Implementing IComparer, Implementing IComparer
icons, Delegates and Events
IConvertible interface, Strings
IDE (Integrated Development Environment), Developing “Hello World”, Using Notepad
identifiers, Identifiers
defining, Defining Identifiers
undefining, Undefining Identifiers
IDictionary interface, Collection Interfaces, IDictionary, The Keys and Values Collections
IDictionaryEnumerator interface, Collection Interfaces, IDictionaryEnumerator Interface
IDL (Interface Definition Language), The C# Language, Applying Attributes
IEnumerable interface, Collection Interfaces, The IEnumerable Interface
#if statement, Defining Identifiers
if statements, If...else statements, Switch statements: an alternative to nested ifs, The is Operator, C# Keywords
nesting, Nested if statements
switch statements and, Switch statements: an alternative to nested ifs
Iformatter interface, Using a Formatter
IL files (see MSIL files)
IList interface, Collection Interfaces
immutable sequences, Strings
implements relationship, Interfaces
implicit operator, Conversion Operators, C# Keywords
in keyword, signaling loops and iteration statements, Statements
in operator, C# Keywords
increment (++) operator, Operator Precedence
Increment method, Using Interlocked
increment operators, Increment and Decrement Operators
indexers, Indexers, Indexing on Other Values
assignment and, Indexers and Assignment
operator ([ ]) for, Indexers, IDictionary
strings, Manipulating Strings
IndexOf( ) method, Arrays, Array Lists, Manipulating Strings
inheritance, Classes and Objects, Inheritance and Polymorphism, Nesting Classes
implementing, Inheritance, Controlling Access
structs, supporting, Defining Structs
initializaters, Initializers, Initializers
initialize phase of Web Form life cycles, Web Form Life Cycle
Initialize( ) method, Arrays
InitializeComponent( ) method, Using the Visual Studio.Net Designer
InnerException property, Rethrowing Exceptions
Insert( ) method, Array Lists, Manipulating Strings , Manipulating Dynamic Strings
InsertRange( ) method, Array Lists
instances (see objects)
int integral type, Working with Built-in Types, C# Keywords
conversion operators and, Conversion Operators
defining classes with, Defining Classes, Method Arguments
get accessor and, The get Accessor
rectangular arrays and, Rectangular arrays
Integrated Development Environment (see IDE)
Interface attribute target, Attribute Targets
Interface Definition Language (IDL), The C# Language, Applying Attributes
interface keyword, Interfaces
interfaces, The C# Language, Interfaces, Accessing Sealed Classes and Value Types
combining, Combining Interfaces, Combining Interfaces
implementing, Implementing an Interface, Combining Interfaces
explicit, Explicit Interface Implementation, Accessing Sealed Classes and Value Types
more than one, Implementing More Than One Interface
overriding, Overriding Interface Implementations, Overriding Interface Implementations
methods, accessing, Accessing Interface Methods, Interface Versus Abstract Class
methods, exposing, Selectively Exposing Interface Methods
servers, specifying, Specifying a Server with an Interface
types, C# Keywords
vs. abstract classes, Interface Versus Abstract Class
Interlocked class, Using Interlocked
Intern( ) method, Manipulating Strings
internal access modifier, Access Modifiers, C# Keywords
internal protected keyword, Controlling Access
Internet Explorer, ProgrammingWeb Applications with Web Forms
Internet, programming Web Services, Programming Web Services, Creating the Proxy
Interrupt( ) method, killing threads, Killing Threads
intrinsic attributes, Intrinsic Attributes
intrinsic types, Using the Visual Studio .NET Debugger, Types
(also see built-in types), Types
InvokeMember( ) method, Dynamic Invocation with InvokeMember( ), Dynamic Invocation with InvokeMember( )
is operator, Operator Precedence, The is Operator, The is Operator, C# Keywords
vs. as operator, The is Operator Versus the as Operator
is-a relationship
inheriting for an abstract class, Interfaces
IsFixedSize property, Arrays, Array Lists
IsInterned( ) method, Manipulating Strings
isolated storage, Isolated Storage, Isolated Storage
IsReadOnly property, Arrays, Array Lists, Queues
hashtable methods and, Hashtables
stack methods and, Stacks
IsSynchronized property
ArrayList methods and, Array Lists
Hashtable methods and, Hashtables
Queue methods and, Queues
Stack methods and, Stacks
System.Array methods and, Arrays
Item( ) method, Array Lists, Hashtables
iteration statements, Iteration Statements, The continue and break statements

J

jagged arrays, Jagged arrays, Jagged arrays
Java language, C# and the .NET Framework
JIT (Just In Time) compiler, Compilation and the MSIL, Compiling and Running “Hello World”
using, Compiling and Running “Hello World”
Join( ) method, Manipulating Strings , Race Conditions
jump statements, Unconditional Branching Statements
Just In Time (JIT) compiler, Compilation and the MSIL, Compiling and Running “Hello World”

K

Keys property, Dictionaries
keywords for C#, C# Keywords, C# Keywords

L

LAN (local-area network), Building Windows Applications
language attribute, Creating a Web Form
Last In First Out (LIFO) collection, Stacks
LastAccessTime property, Working with Directories, Working with Files
LastIndexOf( ) method, Arrays, Array Lists, Manipulating Strings
LastWriteTime property, Working with Directories, Working with Files
late binding, Late Binding, Importing the COM .DLL to .NET
reflection and, Using Late Binding and Reflection, Exporting .NET Components
Length property, Arrays, Working with Files
Length( ) method, Manipulating Strings , Manipulating Dynamic Strings
less than (<) relational operator, If...else statements, Relational Operators, Logical Pairs
precedence of, Operator Precedence
libraries (types), Importing the Type Library, Creating a Type Library
life cycle of Web Forms, Web Form Life Cycle
LIFO (Last In First Out) collection, Stacks
LinearLayout mode, adding controls to Web Forms, Adding Controls
list (enumerator), Enumerations
ListChanged event, Events
literals, Regular Expressions
constants, Constants
null keyword, C# Keywords
Load event, Web Form Life Cycle
load factors, Hashtables
Load( ) method, Application Domains
LoadPostData( ) method, Web Form Life Cycle
LoadViewState( ) method, Web Form Life Cycle
local-area network (LAN), Building Windows Applications
Locals window, Using the Visual Studio .NET Debugger
Location struct, Defining Structs
lock statement, C# Keywords
locks, synchronizing threads, Using Locks
logical AND (&) operator, Operator Precedence
logical operators, using with conditionals, Use of Logical Operators with Conditionals
long integral type, Working with Built-in Types, Choosing a built-in type , C# Keywords
conversion operators and, Conversion Operators

M

Main( ), Methods, Conversion Operators
asynchronous I/O and, Asynchronous I/O
building a server using, Building a Server
call stack, unwinding, Unwinding the call stack, Unwinding the call stack
console applications and, Console Applications
constructors, defining with, Constructors
defining classes with, Defining Classes
endpoints and, Understanding Endpoints
IEnumerable interface and, The IEnumerable Interface
indexing with, Indexing on Other Values
interface methods, accessing with, Accessing Interface Methods
parameters, passing with, Passing by Reference
SingleCall, using, Using SingleCall
static keyword and, The static Keyword
static methods, invoking, Invoking Static Methods
structs, creating, Structs as Value Types
throw statement and, The throw Statement
managed providers (ADO), Using ADO Managed Providers, Using ADO Managed Providers
manifests, Manifests, Other Required Assemblies
modules, Modules in the Manifest
Marshal( ) method, Understanding Endpoints
marshaling, Marshaling and Remoting, Understanding Endpoints
app domain and, Marshaling Across App Domain Boundaries, Specifying the marshaling method
contexts and, Marshaling Across Context Boundaries
methods, specifying, Specifying the marshaling method, Specifying the marshaling method
with proxies, Understanding marshaling with proxies
mathematical operators, Mathematical Operators, The modulus operator (%) to return remainders
MaxCapacity( ) method, Manipulating Dynamic Strings
member access (-\>) operator, Pointers
member access (.) operator, The Dot Operator (.)
writing text to the monitor, Console Applications
member functions, Methods
MemberFilter parameter, Finding particular type members
members, Classes and Objects
hiding, Member Hiding
MemberTypes parameter, Finding particular type members
MemberwiseClone( ), The Root of all Classes: Object
MemoryStream class, Reading and Writing Data
menu selections, Delegates and Events, Events
Merge Module in Visual Studio .NET, Deployment Projects, Setup Project
Message property, Exception Objects
metacharacters, Regular Expressions
metadata, Metadata, Attributes and Reflection
method arguments, Method Arguments
Method attribute target, Attribute Targets
methods, Methods
Appdomain class, Application Domains
base class, calling, Calling Base Class Methods
constructors and, Constructors
delegates and, Delegates , Multicasting
using to specify at runtime, Using Delegates to Specify Methods at Runtime, Using Delegates to Specify Methods at Runtime
explicit implementation and, Explicit Interface Implementation
interface, Accessing Interface Methods, Interface Versus Abstract Class
interfaces, exposing, Selectively Exposing Interface Methods
marshaling, specifying, Specifying the marshaling method, Specifying the marshaling method
overloading, Overloading Methods and Constructors , Overloading Methods and Constructors
polymorphic, creating, Creating Polymorphic Methods
System.Array, Arrays
Microsoft Intermediate Language files (see MSIL)
Module attribute target, Attribute Targets
modules, PE Files
manifests, Modules in the Manifest
multi assemblies, Multi-Module Assemblies, Loading the assembly
modulus (%) operator, The for loop
precedence of, Operator Precedence
returning remainders, Simple arithmetical operators (+, -, *, /), The modulus operator (%) to return remainders
monitors, synchronizing threads, Using Monitors, Using Monitors
Move( ) method, Working with Directories, Working with Files
MoveFile( ) method, P/Invoke
MoveTo( ) method, Working with Directories, Working with Files
P/Invoke and, P/Invoke
mscorlib assembly, Manifests
MSIL (Microsoft Intermediate Language) files, Compilation and the MSIL
JIT compilation and, Compiling and Running “Hello World”
Mult( ) method, Building a Web Service
multi-module assemblies, Multi-Module Assemblies, Loading the assembly
building, Building a Multi-Module Assembly, Loading the assembly
testing, Testing the assembly
multicasting, Multicasting , Multicasting
multidimensional arrays, Multidimensional Arrays, Jagged arrays
multiple connections, handling, Handling Multiple Connections, Handling Multiple Connections
multiplication (*) operator, Simple arithmetical operators (+, -, *, /)
operator precedence of, Operator Precedence
My Documents folder, Entries in My Documents

N

name method, Dynamic Invocation with InvokeMember( )
Name property, Working with Directories, Working with Files
named parameter, constructing an attribute, Constructing an Attribute
namespace keyword, C# Keywords
namespaces, Namespaces, Namespaces, Building a Web Service
naming conventions for variable names, Identifiers
nested classes, Nesting Classes
.NET
ActiveX controls, importing, Importing ActiveX Controls, Adding a control to the Visual Studio toolbox
components, exporting, Exporting .NET Components
controls, importing, Importing a Control in .NET, Adding a control to the Visual Studio toolbox
importing DLL to, Importing the COM .DLL to .NET
programming, Programming .NET and COM, Pointers
.NET framework, C# and the .NET Framework, The C# Language
Netscape Navigator, ProgrammingWeb Applications with Web Forms
network I/O, Network I/O, Aysnchronous Network File Streaming
network streaming server, creating, Creating a Network Streaming Server, Creating a Streaming Network Client
NetworkStream class, Reading and Writing Data
new class, Events and Delegates
new keyword, C# Keywords
base class constructors, calling, Calling Base Class Constructors
versioning with, Versioning with the new and override Keywords
new operator, Operator Precedence
structs, creating without, Creating Structs Without new
New Project window in Visual Studio .NET, Using the Visual Studio.Net Designer
newline escape character (\\n), Choosing a built-in type
newlines (whitespace), Whitespace
Next( ) method, Implementing IComparable
non-postback events, Postback versus non-postback events
normalization, Tables, Records, and Columns
not (!) operator, Use of Logical Operators with Conditionals
precedence of, Operator Precedence
not equal (!=) operator, Relational Operators, Logical Pairs
precedence of, Operator Precedence
notation (camel/Pascal), naming variables, Identifiers
Notepad
compiling programs with, Developing “Hello World”
Web Forms, running, Understanding Web Forms
widgets, creating with, Using Notepad
Windows Form, creating with, Using Notepad, Using the Visual Studio.Net Designer
null (0), using escape characters, Choosing a built-in type
numeric types, default values of, Constructors
nvokeAttr argument, Dynamic Invocation with InvokeMember( )

O

Õ (single quotes), using escape characters, Choosing a built-in type
object class
hashtables and, Hashtables
object models, The ADO.Net Object Model, The DataAdapter Object
Object parameter, Finding particular type members
object type, C# Keywords
object-graph, serializing objects, Serialization
object-oriented programming, using types, Classes, Objects, and Types
objects, Classes, Objects, and Types, The static Keyword, Classes and Objects, Readonly Fields
ADO.NET, The ADO.Net Object Model, The DataAdapter Object
data-bound objects, Working with Data-Bound Controls
buffered stream, Buffered Streams
creating, Creating Objects, The this Keyword
delegates and, Using Delegates to Specify Methods at Runtime
destroying, Destroying Objects , The using Statement
exceptions, Exception Objects, Exception Objects
handles, Creating and Using App Domains
methods for, The Root of all Classes: Object
overloading, Overloading Methods and Constructors , Overloading Methods and Constructors
properties, encapsulating data with, Encapsulating Data with Properties, Readonly Fields
publishing/subscribing events, Publishing and Subscribing
serializing, Serialization, Handling Transient Data
deserializing, Deserializing the object
server types, understanding, Understanding Server Object Types
synchronizing of threads and, Synchronization, Using Monitors
TreeNode, TreeNode objects, TreeNode objects
Web Form events and, Web Form Events
xt-bound and xt-agile, Context-Bound and Context-Agile Objects
OCX standard, Importing ActiveX Controls
OnDeserialization( ) method, Hashtables, Handling Transient Data
OnLoad method, Web Form Life Cycle
Open( ) method, Working with Files
OpenRead( ) method, Working with Files
opening binary files, Binary Files
OpenText( ) method, Working with Files
OpenWrite( ) method, Working with Files
opening binary files, Binary Files
operator keyword, C# Keywords
operators, Operators, The Ternary Operator
assignment, The Assignment Operator (=)
C pointers, supported by C#, Pointers
common programming mistakes with, Nested if statements
conversion, Conversion Operators
creating, Creating Useful Operators
increment/decrement, Increment and Decrement Operators
mathematical, Mathematical Operators, The modulus operator (%) to return remainders
operator keyword and, Using the operator Keyword
overloading, Operator Overloading, Conversion Operators
precedence, Operator Precedence
relational, Relational Operators
or (||) operator, Use of Logical Operators with Conditionals, Operator Precedence
out modifier, C# Keywords
outer classes, Nesting Classes
Outlook, Building Windows Applications
overloaded assignment operator (=), Manipulating Strings
override class, Events and Delegates
override keyword, Creating Polymorphic Methods, C# Keywords
versioning with, Versioning with the new and override Keywords

P

P/Invoke (platform invoke facility), P/Invoke, Pointers
P2P (peer to peer, Network I/O
PadLeft( ) method, Manipulating Strings
PadRight( ) method, Manipulating Strings
pageLayout property, Adding Controls
Parameter attribute target, Attribute Targets
parameters, Method Arguments
definite assignments, passing out with, Passing Out Parameters with Definite Assignment , Passing Out Parameters with Definite Assignment
naming, Using the operator Keyword
passing, Passing Parameters
params keyword, The params Keyword
params parameter modifiers, C# Keywords
Parent property, Working with Directories
parentheses (( )), Regular Expressions
methods, using, Methods
Pascal notation, naming variables, Identifiers
Passport services for Project Hailstorm, Programming Web Services
PE (Portable Executable) files, PE Files
Peek( ) method, Queues, Stacks
peer to peer (P2P), Network I/O
Perl5 (regexp), Using Regular Expressions: Regex
pinning buffers, Pointers
plus sign (+)
as an addition operator, Simple arithmetical operators (+, -, *, /)
precedence of, Operator Precedence
as a concatenation operator, Manipulating Strings
pointer types, Types
pointers, Pointers, Pointers
polymorphism, Classes and Objects, Inheritance and Polymorphism, Nesting Classes
creating types, Polymorphism
methods, creating, Creating Polymorphic Methods, Creating Polymorphic Methods
Pop( ) method, Stacks
adding to or removing from stacks, Stacks
Portable Executable (PE) files, PE Files
ports (application IDs), Network I/O
positional parameter, constructing an attribute, Constructing an Attribute
postback events, Postback versus non-postback events
responding to, Responding to Postback Events
postfix operators, The prefix and postfix operators
pound sign (#), examining special preprocessor directives, Preprocessor Directives
Pow( ) method, Building a Web Service, Creating the Proxy
prefix operators, The prefix and postfix operators
preprocessor, Preprocessor Directives, #region
prerender phase in life cycle of Web Forms, Web Form Life Cycle
primary keys, Tables, Records, and Columns, Combining Data Tables
Primary Output in Visual Studio .NET, Deployment Projects
private access modifiers, Access Modifiers, C# Keywords
private assemblies, Private Assemblies
private constructors, using, Using Private Constructors
private keys, Strong Names
probing, loading applications by AssemblyResolver, Loading the assembly
process postback data, Web Form Life Cycle
processes, Marshaling and Remoting
application domains, Application Domains, Specifying the marshaling method
ProcessExit event, Application Domains
ProgCS namespace, Building a Multi-Module Assembly
ProgCSharp parameter, Creating and Using App Domains
Project Hailstorm, Programming Web Services
Project Output menu in Visual Studio .NET, Deployment Projects, Setup Project
properties, The C# Language, Classes and Objects
data binding, Setting Initial Properties
delegates as, Delegates as Properties
encapsulating data with, Encapsulating Data with Properties, Readonly Fields
Properties window in Visual Studio .NET, Deployment Locations
Property attribute target, Attribute Targets
protected access modifier, Access Modifiers, C# Keywords
proxies, Client-side Support
creating, Creating the Proxy, Creating the Proxy
public access modifier, Access Modifiers
public keys, Strong Names
tokens, Step 1: Create a strong name
public keyword, Defining Classes
public properties
AppDomain class, Application Domains
Arraylist, Array Lists
FileInfo class and, Working with Files
Hashtable, Hashtables
Queue, Queues
stacks, Stacks
System.Array, Arrays
public static fields, for string class, Manipulating Strings
public static methods, Queues
ArrayList, Array Lists
Hashtable, Hashtables
stacks, Stacks
System.Array, Arrays
threads, suspending, Suspending Threads
publishers, Publishing and Subscribing
buttons, creating, Using Notepad
decoupling from subscribers, Decoupling Publishers from Subscribers
Pulse( ) method, using monitors, Using Monitors
Push( ) method, Stacks
adding to or removing from stacks, Stacks

Q

queues, Queues, Queues

R

race conditions, synchronizing threads, Race Conditions
RAD (Rapid Application Development), Creating a Simple Windows Form, ProgrammingWeb Applications with Web Forms
RaisePostDataChangedEvent( ) method, Web Form Life Cycle
Rank property, Arrays
Rapid Application Development (RAD), Creating a Simple Windows Form, ProgrammingWeb Applications with Web Forms
RCW (Runtime Class Wrapper), Importing the Type Library
Read( ) method, Pointers
binary files and, Binary Files
implementing an interface, Implementing an Interface
explicit, Explicit Interface Implementation
overriding, Overriding Interface Implementations, Overriding Interface Implementations
ReadFile( ) method, Pointers
ReadLine( ) method, working with text files, Working with Text Files
readonly delegates, Static Delegates
readonly field modifiers, Readonly Fields, C# Keywords
ReadOnly( ) method, Array Lists
records for databases, Tables, Records, and Columns, Changing Database Records, Creating New Records
creating, Creating New Records, Creating New Records
deleting, Deleting a Record
updating, Updating a Record, Updating a Record
rectangular arrays, Rectangular arrays, Rectangular arrays
ref modifier, C# Keywords
reference types, Types, Constructors
stacks and heaps, using, Working with Built-in Types
reference types, default values of, Constructors
reflection, Attributes and Reflection, Reflection, Dynamic Invocation with Reflection Emit
emit (see reflection emit)
late binding and, Using Late Binding and Reflection, Exporting .NET Components
reflection emit, Reflection Emit, Dynamic Invocation with Reflection Emit
dynamic invocation, with, Dynamic Invocation with Reflection Emit, Dynamic Invocation with Reflection Emit
Refresh( ) method, Working with Directories
Regasm tool, exporting .NET components, Exporting .NET Components
regex, Using Regular Expressions: Regex, Using Regular Expressions: Regex
groups, Using Regex Groups , Using Regex Groups
match collections, using, Using Regex Match Collections
regexp, Using Regular Expressions: Regex
#region preprocessor, #region
RegisterWellKnownServiceType() method, Understanding RegisterWellKnownServiceType
Registry window in Visual Studio .NET, making changes to, Making changes to the Registry
regular expressions, Regular Expressions, Using CaptureCollection
regex, using, Using Regular Expressions: Regex, Using Regular Expressions: Regex
RegularExpressions namespace, Using Regex Match Collections
RejectChanges( ) method, Changing Database Records
relational databases, Relational Databases and SQL, SQL
relational operators, Relational Operators
Remote Deploy Wizard in Visual Studio .NET, Deployment Projects
remoting, Marshaling and Remoting, Remoting, Understanding Endpoints
server object types, Understanding Server Object Types
RemotingConfiguration class, Building a Server
Remove( ) method
ArrayList methods and, Array Lists
Hashtable methods and, Hashtables
string class and, Manipulating Strings
StringBuilder methods and, Manipulating Dynamic Strings
RemoveAt( ) method, Array Lists
RemoveRange( ) method, Array Lists
Repeat( ) method, Array Lists
Replace( ) method, Manipulating Dynamic Strings
Reset( ) method, The IEnumerable Interface
ResourceResolve event, Application Domains
return statement, Unconditional Branching Statements, Iteration Statements, C# Keywords
ReturnValue attribute target, Attribute Targets
Reverse( ) method, Arrays, Array Lists
Root property, Working with Directories
Rows collection, Rows
Run( ) method, Events and Delegates, Aysnchronous Network File Streaming
asynchronous I/O and, Asynchronous I/O
Runtime Class Wrapper (RCW), Importing the Type Library

S

SaveViewState( ) method, Web Form Life Cycle
sbyte integral type, Working with Built-in Types, C# Keywords
screen scraping, Web Streams
sealed classes, Inheritance and Polymorphism, Sealed Class, C# Keywords
sealed structs, Defining Structs
security boundaries, Security Boundary
semicolons (;)
abstract classes and, Abstract Classes
ending statements with, Statements
Serializable attribute, Marshaling Across Context Boundaries
serialization, Serialization, Handling Transient Data
formatters, using, Using a Formatter, Deserializing the object
objects, creating a stream of data, Streams
working with, Working with Serialization, Deserializing the object
server-side support, Server-side Support
servers
building, Building a Server, Building a Server
interfaces, specifying, Specifying a Server with an Interface
network streaming, creating, Creating a Network Streaming Server, Creating a Streaming Network Client
object types, Understanding Server Object Types
set accessor, The set Accessor
set keyword, C# Keywords
set( ) method, indexing, Indexers
SetAppDomainPolicy( ) method, Application Domains
SetAttributes( ) method, Working with Files
SetCreationTime( ) method, Working with Directories, Working with Files
SetCurrentDirectory( ) method, Working with Directories
SetData( ) method, Application Domains
SetLastAccessTime( ) method, Working with Directories, Working with Files
SetLastError parameter, P/Invoke
SetLastWriteTime( ) method, Working with Directories, Working with Files
SetRange( ) method, Array Lists
Setup Project in Visual Studio .NET, Deployment Projects, Setup Project
building, Building the Setup Project
Setup Wizard in Visual Studio .NET, Deployment Projects
SetValue( ) method, Arrays
Shape class, Specifying the marshaling method
shared assemblies, Private Assemblies, Step 2: Put the shared assembly in the GAC
building, Building a Shared Assembly
DLL Hell and, The End of DLL Hell
versions, Versions
short integral type, C# Keywords
short type, Working with Built-in Types, Choosing a built-in type
Side-by-side versioning, Versions
signatures (digital), Strong Names
signatures of methods, Overloading Methods and Constructors
signing the assembly, Strong Names
Simple Object Access Protocol (SOAP), SOAP, WSDL, and Discovery, Understanding marshaling with proxies, Using a Formatter
single quotes (Õ), using escape characters, Choosing a built-in type
single-call objects, Understanding Server Object Types
single-module assembly, Multi-Module Assemblies
SingleCall, Using SingleCall
singleton objects, Understanding Server Object Types
sinks, Marshaling and Remoting
marshaling with proxies, Understanding marshaling with proxies
sizeof operator, C# Keywords
precedence of, Operator Precedence
slash marks (ÚÚ), using for comments, Comments
XML documentation, XML Documentation Comments
Sleep public static method, Suspending Threads
.sln files, Creating a Web Form
SOAP (Simple Object Access Protocol), SOAP, WSDL, and Discovery, Understanding marshaling with proxies, Using a Formatter
SoapFormatter, Using a Formatter
sockets, Network I/O
multiple connections, handling, Handling Multiple Connections
Solution Explorer in Visual Studio .NET, Deployment Projects
Sort( ) method, Versioning with the new and override Keywords, Arrays, Array Lists
copy button, implementing events, Sorting the list of selected files
delegates and, Using Delegates to Specify Methods at Runtime
IComparable, implementing, Implementing IComparable
IComparer, implementing, Implementing IComparer
spaces (whitespace), Whitespace
specialization of classes and objects, Specialization and Generalization
Split( ) method, Manipulating Strings , Using Regular Expressions: Regex
SQL (Structured Query Language), The .NET Framework, Connecting to the Database
Managed Provider, Using ADO Managed Providers
relational databases and, Relational Databases and SQL, SQL
SQL Server 2000, The .NET Platform
square brackets ([ ])
declaring arrays, Declaring Arrays
for indexing, Indexers
for indexing, IDictionary
in strings, Manipulating Strings
jagged arrays and, Jagged arrays
Stack( ) method, adding or removing from stacks, Stacks
stackalloc operator, C# Keywords
stacks, Working with Built-in Types, Stacks, Stacks
call, Exception Objects
catch statements and, Unwinding the call stack
Start( ) method, Network I/O
StartRead( ) method, Handling Multiple Connections, Aysnchronous Network File Streaming
StartsWith( ) method, Manipulating Strings
state objects, Asynchronous I/O
state of web applications, State
statement blocks, If...else statements
statements, Statements, The continue and break statements
catch, The catch Statement, Creating dedicated catch statements
conditional branching, Conditional Branching Statements, Switch on string statements
finally, The finally Statement, The finally Statement
iteration, Iteration Statements, The continue and break statements
switching on string, Switch on string statements
throw, The throw Statement
unconditional branching, Statements
static class, Events and Delegates
static keyword, The static Keyword, C# Keywords
static members
constructors, using, Using Static Constructors
fields, using, Using Static Fields
invoking, Invoking Static Methods
using, Using Static Members, Using Static Fields
Stream class, Reading and Writing Data, P/Invoke
streaming servers, creating, Creating a Network Streaming Server, Creating a Streaming Network Client
StreamReader class
text files, working with, Working with Text Files
streams, Streams, Isolated Storage
asynchronous I/O, Asynchronous I/O, Asynchronous I/O
asynchronous network file streaming, Aysnchronous Network File Streaming, Aysnchronous Network File Streaming
binary files and, Binary Files, Binary Files
buffered, Buffered Streams, Buffered Streams
isolated storage, Isolated Storage, Isolated Storage
multiple connections, handling, Handling Multiple Connections, Handling Multiple Connections
network client, creating, Creating a Streaming Network Client, Creating a Streaming Network Client
network I/O, Network I/O, Aysnchronous Network File Streaming
network server, creating, Creating a Network Streaming Server, Creating a Streaming Network Client
reading and writing data, Reading and Writing Data, Working with Text Files
transient data, handling, Handling Transient Data, Handling Transient Data
web, Web Streams, Web Streams
StreamWriter classes
text files, working with, Working with Text Files
string type, C# Keywords
switching, Switch on string statements
StringBuilder class, Manipulating Dynamic Strings, Manipulating Dynamic Strings
StringReader class, Reading and Writing Data
strings, Strings, Strings and Regular Expressions, Using CaptureCollection
creating, Creating Strings
dynamic, manipulating, Manipulating Dynamic Strings, Manipulating Dynamic Strings
manipulating, Manipulating Strings
substrings, finding, Finding Substrings , Finding Substrings
StringWriter class, Reading and Writing Data
strong names for assemblies, Shared Assemblies, Strong Names
Struct attribute target, Attribute Targets
struct keyword, Working with Built-in Types, Defining Structs , C# Keywords
structs, The C# Language, Structs, Calling the Default Constructor
creating, Creating Structs, Calling the Default Constructor
defining, Defining Structs , Defining Structs
Structured Query Language (see SQL)
style comments in C++, Comments
Sub( ) method, Building a Web Service
Subscribe method, Events and Delegates
subscribers, Publishing and Subscribing
decoupling from publishers, Decoupling Publishers from Subscribers
SubString( ) method, Manipulating Strings
substrings, finding, Finding Substrings , Finding Substrings
subtraction (-) operator, Simple arithmetical operators (+, -, *, /)
precedence of, Operator Precedence
.suo files, Creating a Web Form
switch statements, Switch statements: an alternative to nested ifs, C# Keywords
symbolic constants, Constants
synchronization of threads, Synchronization, Using Monitors
Interlocked method, using, Using Interlocked
locks, using, Using Locks
Synchronized( ) method, Array Lists, Queues, Stacks, Hashtables
synchronous I/O, Asynchronous I/O
SyncRoot property, Arrays, Array Lists, Queues, Stacks, Hashtables
System arrays, System.Array , System.Array
System namespace
dot operator, using, The Dot Operator (.)
using keyword and, The using Keyword
System.Array type, Arrays
System.Drawing.Point object, Using Notepad
System.Exception object, Exception Objects
System.Reflection namespace, Viewing MetaData
System.Runtime.Remoting.Synchronization attribute, Marshaling Across Context Boundaries
System.String class, Strings and Regular Expressions
System.Text.RegularExpressions namespace, Using Regular Expressions: Regex
System.Threading namespace, Events and Delegates
System.Web namespace, Understanding Web Forms
System.Web.Services.WebService namespace for server-side support, Server-side Support
System.Web.UI namespace, Understanding Web Forms
SystemEventArgs object, Using Notepad

T

tables, Tables, Records, and Columns, Combining Data Tables
(see also data tables)
TablesCollection, The ADO.Net Object Model
tabs (whitespace), Whitespace
target object, Dynamic Invocation with InvokeMember( )
targets (attribute), Attribute Targets
TCP/IP connections, Network I/O
streaming network client, creating, Creating a Streaming Network Client
TcpClient class, Creating a Streaming Network Client
ternary (?:) operator, Operator Precedence
Tester class, Creating Structs
text editors, compiling programs with, Developing “Hello World”
text files, working with, Working with Text Files, Working with Text Files
text read, Binary Files
TextReader class, Reading and Writing Data
TextWriter class, Reading and Writing Data
this keyword, The this Keyword, C# Keywords
Thread class, Events and Delegates, Starting Threads
ThreadInterruptedException exception, Killing Threads
threads, Threads and Synchronization, Deadlock
creating, Starting Threads, Starting Threads
deadlocks, Race Conditions
joining, Joining Threads
killing, Killing Threads, Killing Threads
race conditions, Race Conditions
suspending, Suspending Threads
synchronizing, Synchronization, Using Monitors
Interlocked class, using, Using Interlocked
locks, using, Using Locks
monitors, using, Using Monitors, Using Monitors
throw statement, Unconditional Branching Statements, The throw Statement, C# Keywords
TlbImp.exe, importing the type library, Importing the Type Library
ToArray( ) method, Array Lists, Queues, Stacks
ToCharArray( ) method, Manipulating Strings
tokens (public key), Step 1: Create a strong name
ToLower( ) method, Manipulating Strings
Toolbox window in Visual Studio .NET, Using the Visual Studio.Net Designer
Basic UI form, creating, Creating the Basic UI Form
ToString( ) method, The Root of all Classes: Object, Conversion Operators, The ToString Method
accessing array elements, Accessing Array Elements
delegates and, Using Delegates to Specify Methods at Runtime
structs, creating, Structs as Value Types
ToUpper( ) method, Manipulating Strings
TP (transparent proxy), Understanding marshaling with proxies
transient data, handling, Handling Transient Data, Handling Transient Data
transparent proxy (TP), Understanding marshaling with proxies
TreeView controls, Populating the TreeView Controls, Getting the files in the directory
clear button event, handling, Handling the Clear button event
handling, Handling TreeView Events, Handling the Clear button event
Trim( ) method, Manipulating Strings
TrimEnd( ) method, Manipulating Strings
TrimStart( ) method, Manipulating Strings
TrimToSize( ) method, Array Lists
true keyword, C# Keywords
true values, Working with Built-in Types, The while loop
relational operators and, Relational Operators
try block, Unwinding the call stack
try statement, C# Keywords
Turbo Pascal, The C# Language
Type class, Building a Server
type discovery, Type Discovery
typeof (type retrieval) operator, Viewing MetaData, C# Keywords
precedence of, Operator Precedence
types, Classes, Objects, and Types, The static Keyword, Types, Converting built-in types
creating new, Defining Classes
libraries, Importing the Type Library, Creating a Type Library
reflecting on, Reflecting on a Type, Finding particular type members

U

Ú (division) operator, Simple arithmetical operators (+, -, *, /), Operator Precedence
Ú* ... *Ú (C-Style comments), Comments
Ú= assignment operator, Calculate and reassign operators, Operator Precedence
UI (user interface), Understanding Web Forms
design tools, Console Applications
forms, Creating the Basic UI Form
managing during Setup process, Managing the UI during Setup
uint integral type, Working with Built-in Types, C# Keywords
ulong integral type, Working with Built-in Types, Choosing a built-in type , C# Keywords
UML (Unified modeling Language), Specialization and Generalization
unboxing types, Boxing and Unboxing Types
unchecked (arithmetic check off) operator, C# Keywords
precedence of, Operator Precedence
unconditional branching statements, Statements
Unicode characters, using char type, Choosing a built-in type
Unified Modeling Language (UML), Specialization and Generalization
Uniform Resource Identifier (URI), Web Streams
Unload( ) method, Application Domains
unsafe modifier, C# Keywords
URI (Uniform Resource Identifier), Building the Client, Web Streams
user interface (UI), Understanding Web Forms
design tools, Console Applications
forms, Creating the Basic UI Form
managing during Setup process, Managing the UI during Setup
user_defined types, Types
ushort type, Working with Built-in Types, Choosing a built-in type , C# Keywords
using keyword, The using Keyword, The using Statement, C# Keywords
identifiers, defining with, Defining Identifiers
using System statement, The using Keyword
ÚÚ (slash marks), using for comments, Comments
XML documentation, XML Documentation Comments

V

value keyword, C# Keywords
value types, Types, Converting built-in types
sealed classes, accessing, Accessing Sealed Classes and Value Types , Accessing Sealed Classes and Value Types
stacks and heaps, using, Working with Built-in Types
structs as, Structs as Value Types
Values property, Dictionaries
variables, Variables and Constants, Identifiers, Defining Classes
increment/decrement operators and, Increment and Decrement Operators
VB (Visual Basic), C# and the .NET Framework, Creating a Simple Windows Form
VB6 CDbl function, Creating an ActiveX Control
verbatim string literals (@), Creating Strings
Directory Info object, creating, Creating a DirectoryInfo Object
version numbers for shared assemblies, Versions
versioning, Assemblies and Versioning, Step 2: Put the shared assembly in the GAC
vertical bar (|), Regular Expressions
vertical tab escape character (\\v), Choosing a built-in type
View menu in Visual Studio .NET, Setup Project, Other View Windows
ViewState property, Web Form Life Cycle
virtual keyword, Events and Delegates, C# Keywords
Visual Basic (VB), C# and the .NET Framework, Creating a Simple Windows Form
Visual Studio .NET
ActiveX controls, importing, Importing ActiveX Controls, Importing a Control in .NET, Adding a control to the Visual Studio toolbox
applications, deploying, Deploying an Application, Building the Setup Project
creating console applications, Editing “Hello World”
debuggers, using, Using the Visual Studio .NET Debugger, Using the Visual Studio .NET Debugger
Web Forms, creating, Understanding Web Forms
Windows applications, creating, Using the Visual Studio.Net Designer, Using the Visual Studio.Net Designer
XML files and, XML Documentation Comments
void keyword, Methods, C# Keywords

W

Wait( ) method, using monitors, Using Monitors
web applications, ProgrammingWeb Applications with Web Forms, ASP.NET and C#
Web Forms
controls, adding, Adding Controls, Adding Controls
creating, Creating a Web Form, Creating a Web Form
data binding for, Data Binding, Responding to Postback Events
events, Web Form Events
life cycle of, Web Form Life Cycle
postback events, responding to, Responding to Postback Events
understanding, Understanding Web Forms, Web Form Life Cycle
web applications, programming, ProgrammingWeb Applications with Web Forms, ASP.NET and C#
Web Service Description Language (WSDL), SOAP, WSDL, and Discovery, Building a Web Service
contract, viewing, Viewing the WSDL Contract
files, creating a proxy, Creating the Proxy
Web Services, Programming Web Services, Creating the Proxy
building, Building a Web Service, Viewing the WSDL Contract
testing, Testing Your Web Service
Web Setup Project in Visual Studio .NET, Deployment Projects
web streams, Web Streams, Web Streams
while loop statement, The while loop, The continue and break statements, C# Keywords
signaling loops and iteration statements, Statements
whitespace, Whitespace, The for loop
widgets, Events
Notepad, creating with, Using Notepad
Wiltamuth, Scott (developer), The C# Language
WindowClass, Using the Visual Studio .NET Debugger
Windows applications, building, Building Windows Applications , Building the Setup Project
Forms, Creating a Simple Windows Form, XML Documentation Comments
ADO.NET, using for, Getting Started with ADO.NET, Using ADO Managed Providers
Basic UI, creating, Creating the Basic UI Form
with Notepad, Using Notepad, Using the Visual Studio.Net Designer
TreeView controls, populating, Populating the TreeView Controls, Getting the files in the directory
Visual Studio .NET designer, using, Using the Visual Studio.Net Designer, Using the Visual Studio.Net Designer
Windows.Forms namespace, Using Notepad
Write( ) method
binary files and, Binary Files
implementing an interface, Implementing an Interface
overriding, Overriding Interface Implementations, Overriding Interface Implementations
WriteLine( ) method, The Dot Operator (.), Nesting Classes, Accessing Sealed Classes and Value Types
structs, creating, Structs as Value Types
without new operator, Creating Structs Without new
working with text files, Working with Text Files
writing text to the monitor, Console Applications, Variables and Constants
WSDL (Web Service Description Language), SOAP, WSDL, and Discovery, Building a Web Service
contract, viewing, Viewing the WSDL Contract
files, creating a proxy, Creating the Proxy

X

XML (Extensible Markup Language)
ADO.NET and, ADO.NET and XML
documentation comments for, XML Documentation Comments, XML Documentation Comments
SOAP, advantages of being based on, SOAP, WSDL, and Discovery
XSLT file, translating XML to HTML, XML Documentation Comments
xt-bound/agile objects, Context-Bound and Context-Agile Objects
..................Content has been hidden....................

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