book

Professional C# 2005

Name: Professional C# 2005
ISBN: 9780764575341

by Christian Nagel, Bill Evjen, Jay Glynn, Karli Watson, Morgan Skinner, Allen Jones

November 2005

Intermediate to advanced

1586 pages

43h 15m

English

Wrox

Read now

Unlock full access

Copyright
About the Authors
Christian NagelChristian NagelBill EvjenJay GlynnKarli WatsonMorgan SkinnerAllen Jones
Credits
Introduction
The Significance of .NET and C#Advantages of .NETWhat's New in the .NET Framework 2.0SQL Server integration64-Bit supportGenericsAnonymous methodsNullable typesIteratorsPartial ClassesWhere C# Fits InWhat You Need to Write and Run C# CodeWhat This Book CoversPart I: The C# LanguagePart II: The .NET EnvironmentPart III: DataPart IV: Windows ApplicationsPart V: Web ApplicationsPart VI: CommunicationPart VII: InteropPart VIII: Windows Base ServicesPart IX: Appendices (Web Site Only)ConventionsSource CodeErratap2p.wrox.com
I. The C# Language
1. .NET Architecture
1.1. The Relationship of C# to .NET1.2. The Common Language Runtime1.2.1. Advantages of Managed Code1.2.1.1. Platform independence1.2.1.2. Performance improvement1.2.1.3. Language interoperability1.2.1.3.1. Visual Basic 20051.2.1.3.2. Visual C++ 20051.2.1.3.3. Visual J# 20051.2.1.3.4. Scripting languages1.2.1.3.5. COM and COM+1.3. A Closer Look at Intermediate Language1.3.1. Support for Object Orientation and Interfaces1.3.2. Distinct Value and Reference Types1.3.3. Strong Data Typing1.3.3.1. The importance of strong data typing for language interoperability1.3.3.1.1. Common Type System1.3.3.1.2. Common Language Specification1.3.3.2. Garbage collection1.3.3.3. Security1.3.3.4. Application domains1.3.4. Error Handling with Exceptions1.3.5. Use of Attributes1.4. Assemblies1.4.1. Private Assemblies1.4.2. Shared Assemblies1.4.3. Reflection1.5. .NET Framework Classes1.6. Namespaces1.7. Creating .NET Applications Using C#1.7.1. Creating ASP.NET Applications1.7.1.1. Features of ASP.NET1.7.1.2. Web Forms1.7.1.2.1. Web server controls1.7.1.3. XML Web services1.7.2. Creating Windows Forms1.7.3. Windows Controls1.7.4. Windows Services1.8. The Role of C# in the .NET Enterprise Architecture1.9. Summary
2. C# Basics
2.1. Before We Start2.2. Your First C# Program2.2.1. The Code2.2.2. Compiling and Running the Program2.2.3. A Closer Look2.3. Variables2.3.1. Initialization of Variables2.3.2. Variable Scope2.3.2.1. Scope clashes for local variables2.3.2.2. Scope clashes for fields and local variables2.3.3. Constants2.4. Predefined Data Types2.4.1. Value Types and Reference Types2.4.2. CTS Types2.4.3. Predefined Value Types2.4.3.1. Integer types2.4.3.2. Floating-point types2.4.3.3. The decimal type2.4.3.4. The Boolean type2.4.3.5. The character type2.4.4. Predefined Reference Types2.4.4.1. The object type2.4.4.2. The string type2.5. Flow Control2.5.1. Conditional Statements2.5.1.1. The if statement2.5.1.2. The switch statement2.5.2. Loops2.5.2.1. The for loop2.5.2.2. The while loop2.5.2.3. The do...while loop2.5.2.4. The foreach loop2.5.3. Jump Statements2.5.3.1. The goto statement2.5.3.2. The break statement2.5.3.3. The continue statement2.5.3.4. The return statement2.6. Enumerations2.7. Arrays2.8. Namespaces2.8.1. The using Statement2.8.2. Namespace Aliases2.9. The Main() Method2.9.1. Multiple Main() Methods2.9.2. Passing Arguments to Main()2.10. More on Compiling C# Files2.11. Console I/O2.12. Using Comments2.12.1. Internal Comments Within the Source Files2.12.2. XML Documentation2.13. The C# Preprocessor Directives2.13.1. #define and #undef2.13.2. #if, #elif, #else, and #endif2.13.3. #warning and #error2.13.4. #region and #endregion2.13.5. #line2.13.6. #pragma2.14. C# Programming Guidelines2.14.1. Rules for Identifiers2.14.2. Usage Conventions2.14.2.1. Naming conventions2.14.2.1.1. Casing of names2.14.2.1.2. Name styles2.14.2.1.3. Namespace names2.14.2.1.4. Names and keywords2.14.2.2. Use of properties and methods2.14.2.3. Use of fields2.15. Summary
3. Objects and Types
3.1. Classes and Structs3.2. Class Members3.2.1. Data Members3.2.2. Function Members3.2.2.1. Methods3.2.2.1.1. Declaring methods3.2.2.1.2. Invoking methods3.2.2.1.3. Passing parameters to methods3.2.2.1.4. ref parameters3.2.2.1.5. out parameters3.2.2.1.6. Method overloading3.2.2.2. Properties3.2.2.2.1. Read-only and write-only properties3.2.2.2.2. Access modifiers for properties3.2.2.2.3. A note about inlining3.2.2.3. Constructors3.2.2.3.1. Static constructors3.2.2.3.2. Calling constructors from other constructors3.2.3. readonly Fields3.3. Structs3.3.1. Structs Are Value Types3.3.2. Structs and Inheritance3.3.3. Constructors for Structs3.4. Partial Classes3.5. Static Classes3.6. The Object Class3.6.1. System.Object Methods3.6.2. The ToString() Method3.7. Summary
4. Inheritance
4.1. Types of Inheritance4.1.1. Implementation Versus Interface Inheritance4.1.2. Multiple Inheritance4.1.3. Structs and Classes4.2. Implementation Inheritance4.2.1. Virtual Methods4.2.2. Hiding Methods4.2.3. Calling Base Versions of Functions4.2.4. Abstract Classes and Functions4.2.5. Sealed Classes and Methods4.2.6. Constructors of Derived Classes4.2.6.1. Adding a no-parameter constructor in a hierarchy4.2.6.2. Adding constructors with parameters to a hierarchy4.3. Modifiers4.3.1. Visibility Modifiers4.3.2. Other Modifiers4.4. Interfaces4.4.1. Defining and Implementing Interfaces4.4.2. Derived Interfaces4.5. Summary
5. Operators and Casts
5.1. Operators5.1.1. Operator Shortcuts5.1.2. The Ternary Operator5.1.3. The checked and unchecked Operators5.1.4. The is Operator5.1.5. The as Operator5.1.6. The sizeof Operator5.1.7. The typeof Operator5.1.8. Nullable Types and Operators5.1.9. The Null Coalescing Operator5.1.10. Operator Precedence5.2. Type Safety5.2.1. Type Conversions5.2.1.1. Implicit conversions5.2.1.2. Explicit conversions5.2.2. Boxing and Unboxing5.3. Comparing Objects for Equality5.3.1. Comparing Reference Types for Equality5.3.1.1. The ReferenceEquals() method5.3.1.2. The virtual Equals() method5.3.1.3. The static Equals() method5.3.1.4. Comparison operator (==)5.3.2. Comparing Value Types for Equality5.4. Operator Overloading5.4.1. How Operators Work5.4.2. Operator Overloading Example: The Vector Struct5.4.2.1. Adding more overloads5.4.2.2. Overloading the comparison operators5.4.3. Which Operators Can You Overload?5.5. User-Defined Casts5.5.1. Implementing User-Defined Casts5.5.1.1. Casts between classes5.5.1.2. Casts between base and derived classes5.5.1.3. Boxing and unboxing casts5.5.2. Multiple Casting5.6. Summary

6. Delegates and Events
6.1. Delegates6.1.1. Declaring Delegates in C#6.1.2. Using Delegates in C#6.2. Anonymous Methods6.2.1. SimpleDelegate Example6.2.2. BubbleSorter Example6.2.3. Multicast Delegates6.3. Events6.3.1. The Receiver's View of Events6.3.2. Generating Events6.4. Summary
7. Memory Management and Pointers
7.1. Memory Management under the Hood7.1.1. Value Data Types7.1.2. Reference Data Types7.1.3. Garbage Collection7.2. Freeing Unmanaged Resources7.2.1. Destructors7.2.2. The IDisposable Interface7.2.3. Implementing IDisposable and a Destructor7.3. Unsafe Code7.3.1. Pointers7.3.1.1. Writing unsafe code7.3.1.2. Pointer syntax7.3.1.3. Casting pointers to integer types7.3.1.4. Casting between pointer types7.3.1.5. void pointers7.3.1.6. Pointer arithmetic7.3.1.7. The sizeof operator7.3.1.8. Pointers to structs: The pointer member access operator7.3.1.9. Pointers to class members7.3.2. Pointer Example: PointerPlayaround7.3.3. Using Pointers to Optimize Performance7.3.3.1. Creating stack-based arrays7.3.3.2. QuickArray example7.4. Summary
8. Strings and Regular Expressions
8.1. System.String8.1.1. Building Strings8.1.2. StringBuilder Members8.1.3. Format Strings8.1.3.1. How the string is formatted8.1.3.2. The FormattableVector example8.2. Regular Expressions8.2.1. Introduction to Regular Expressions8.2.2. The RegularExpressionsPlayaround Example8.2.3. Displaying Results8.2.4. Matches, Groups, and Captures8.3. Summary
9. Collections
9.1. Examining Groups of Objects9.1.1. Collections9.1.1.1. What is a collection?9.1.1.2. Adding collection support to the Vector struct9.1.2. Array Lists9.1.3. The Stack Class9.1.4. The Queue Class9.1.5. The SortedList Class9.1.6. Dictionaries and Hashtables9.1.6.1. Dictionaries in real life9.1.6.2. Dictionaries in .NET9.1.6.3. How the dictionary works9.1.6.4. The MortimerPhonesEmployees example9.1.7. Generics9.2. Summary
10. Generics
10.1. Overview10.1.1. Performance10.1.2. Type Safety10.1.3. Binary Code Reuse10.1.4. Code Bloat10.1.5. Naming Guidelines10.2. Generic Collection Classes10.2.1. Generic Collections Overview10.2.2. Using the List<T> Class10.2.2.1. Finding elements10.2.2.2. Performing some action10.2.2.3. Sorting10.2.2.4. Type conversion10.2.3. Using the Queue<T> Class10.2.4. Using the LinkedList<T>10.3. Creating Custom Generic Classes10.3.1. Default Values10.3.2. Constraints10.4. Generic Methods10.5. Generic Delegates10.6. Other Generic Framework Types10.6.1. Nullable<T>10.6.2. EventHandler<TEventArgs>10.6.3. ArraySegment<T>10.7. Summary
11. Reflection
11.1. Custom Attributes11.1.1. Writing Custom Attributes11.1.1.1. AttributeUsage attribute11.1.1.2. Specifying attribute parameters11.1.1.3. Specifying optional attribute parameters11.1.2. Custom Attribute Example: WhatsNewAttributes11.1.2.1. The WhatsNewAttributes library assembly11.1.2.2. The VectorClass assembly11.2. Reflection11.2.1. The System.Type Class11.2.1.1. Type properties11.2.1.2. Methods11.2.2. The TypeView Example11.2.3. The Assembly Class11.2.3.1. Finding out about types defined in an assembly11.2.3.2. Finding out about custom attributes11.2.4. Completing the WhatsNewAttributes Example11.3. Summary
12. Errors and Exceptions
12.1. Looking into Errors and Exception Handling12.1.1. Exception Classes12.1.1.1. Base class exception classes12.1.2. Catching Exceptions12.1.2.1. Implementing multiple catch blocks12.1.2.2. Catching exceptions from other code12.1.2.3. System.Exception properties12.1.2.4. What happens if an exception isn't handled?12.1.2.5. Nested try blocks12.1.2.5.1. Modifying the type of exception12.1.2.5.2. Handling different exceptions in different places12.1.3. User-Defined Exception Classes12.1.3.1. Catching the user-defined exceptions12.1.3.2. Throwing the user-defined exceptions12.1.3.3. Defining the exception classes12.2. Summary
13. Threading
13.1. Threading13.2. Applications with Multiple Threads13.3. Manipulating Threads13.3.1. The ThreadPlayaround Sample13.3.2. Thread Priorities13.3.3. Synchronization13.3.3.1. What is synchronization?13.3.3.2. Synchronization issues13.3.3.2.1. Don't overuse synchronization13.3.3.2.2. Deadlocks13.3.3.2.3. Race conditions13.4. Creating Threads Using ThreadPool13.5. Summary
II. The .NET Environment
14. Visual Studio 2005
14.1. Working with Visual Studio 200514.1.1. Creating a Project14.1.1.1. Selecting a project type14.1.1.2. The newly created console project14.1.1.3. Other files created14.1.2. Solutions and Projects14.1.2.1. Adding another project to the solution14.1.2.2. Setting the startup project14.1.3. Windows Application Code14.1.4. Reading in Visual Studio 6 Projects14.1.5. Exploring and Coding a Project14.1.5.1. The folding editor14.1.5.2. Other windows14.1.5.2.1. The Design View window14.1.5.2.2. The Properties window14.1.5.2.3. The Class View window14.1.5.2.4. The Object Browser window14.1.5.2.5. The Server Explorer window14.1.5.3. Pin buttons14.1.6. Building a Project14.1.6.1. Building, compiling, and making14.1.6.2. Debug and release builds14.1.6.2.1. Optimization14.1.6.2.2. Debugger symbols14.1.6.2.3. Extra source code debugging commands14.1.6.3. Selecting a configuration14.1.6.4. Editing configurations14.1.7. Debugging14.1.7.1. Breakpoints14.1.7.2. Watches14.1.7.3. Exceptions14.2. Refactoring14.3. Summary
15. Assemblies
15.1. What Are Assemblies?15.1.1. The Answer to DLL Hell15.1.2. Features of Assemblies15.1.3. Application Domains and Assemblies15.2. Assembly Structure15.2.1. Assembly Manifests15.2.2. Namespaces, Assemblies, and Components15.2.3. Private and Shared Assemblies15.2.4. Viewing Assemblies15.2.4.1. ildasm symbols15.2.5. Building Assemblies15.2.5.1. Creating modules and assemblies15.2.5.2. Creating assemblies using Visual Studio15.3. Cross-Language Support15.3.1. The CTS and the CLS15.3.2. Language Independence in Action15.3.2.1. Writing the C++/CLI class15.3.2.2. Writing the Visual Basic class15.3.2.3. Writing the C# class15.3.3. CLS Requirements15.3.3.1. The CLSCompliant attribute15.3.3.2. CLS rules15.4. Global Assembly Cache15.4.1. Native Image Generator15.4.2. Global Assembly Cache Viewer15.4.3. Global Assembly Cache Utility (gacutil.exe)15.5. Creating Shared Assemblies15.5.1. Shared Assembly Names15.5.1.1. Public key cryptography15.5.1.2. Integrity using strong names15.5.2. Creating a Shared Assembly15.5.2.1. Create a strong name15.5.2.2. Install the shared assembly15.5.2.3. Using the shared assembly15.5.2.4. Delayed signing of assemblies15.5.2.5. References15.6. Configuration15.6.1. Configuration Categories15.6.2. Versioning15.6.2.1. Version numbers15.6.2.2. Getting the version programmatically15.6.2.3. Application configuration files15.6.2.4. Publisher policy files15.6.2.4.1. Create a publisher policy file15.6.2.4.2. Create a publisher policy assembly15.6.2.4.3. Add the publisher policy assembly to the global assembly cache15.6.2.4.4. Overriding publisher policies15.6.2.5. Runtime version15.6.3. Configuring Directories15.6.3.1. <codeBase>15.6.3.2. <probing>15.7. Summary
16. .NET Security
16.1. Code Access Security16.1.1. Code Groups16.1.1.1. caspol.exe—The Code Access Security Policy tool16.1.1.2. Viewing an assembly's code groups16.1.2. Code Access Permissions and Permissions Sets16.1.2.1. Viewing an assembly's permissions16.1.3. Policy Levels: Machine, User, and Enterprise16.2. Support for Security in the Framework16.2.1. Demanding Permissions16.2.2. Requesting Permissions16.2.3. Implicit Permission16.2.4. Denying Permissions16.2.5. Asserting Permissions16.2.6. Creating Code Access Permissions16.2.7. Declarative Security16.3. Managing Security Policies16.3.1. The Security Configuration File16.3.2. Managing Code Groups and Permissions16.3.3. Turning Security On and Off16.3.4. Resetting Security Policy16.3.5. Creating a Code Group16.3.6. Deleting a Code Group16.3.7. Changing a Code Group's Permissions16.3.8. Creating and Applying Permissions Sets16.3.9. Distributing Code Using a Strong Name16.3.10. Distributing Code Using Certificates16.3.11. Managing Zones16.4. Role-Based Security16.4.1. The Principal16.4.2. Windows Principal16.4.3. Roles16.4.4. Declarative Role-Based Security16.5. Summary
17. Localization
17.1. Namespace System.Globalization17.1.1. Unicode Issues17.1.2. Cultures and Regions17.1.2.1. Specific, neutral, and invariant cultures17.1.2.2. CurrentCulture and CurrentUICulture17.1.2.3. Number formatting17.1.2.4. Date formatting17.1.3. Cultures in Action17.1.4. Sorting17.2. Resources17.2.1. Creating Resource Files17.2.2. Resource File Generator17.2.3. ResourceWriter17.2.4. Using Resource Files17.2.5. The System.Resources Namespace17.3. Localization Example Using Visual Studio17.3.1. Changing the Culture Programmatically17.3.2. Using Custom Resource Messages17.3.3. Automatic Fallback for Resources17.3.4. Outsourcing Translations17.4. Localization with ASP.NET17.5. A Custom Resource Reader17.5.1. Creating a DatabaseResourceReader17.5.2. Creating a DatabaseResourceSet17.5.3. Creating a DatabaseResourceManager17.5.4. Client Application for DatabaseResourceReader17.6. Creating Custom Cultures17.7. Summary
18. Deployment
18.1. Designing for Deployment18.2. Deployment Options18.2.1. Xcopy18.2.2. Copy Web Tool18.2.3. Publishing Web Sites18.2.4. Deployment Projects18.2.5. ClickOnce18.3. Deployment Requirements18.4. Simple Deployment18.4.1. Xcopy18.4.2. Xcopy and Web Applications18.4.3. Copy Web Tool18.4.4. Publishing a Web Site18.5. Installer Projects18.5.1. What Is Windows Installer?18.5.2. Creating Installers18.5.2.1. Simple Client Application18.5.2.1.1. Same solution project18.5.2.2. Simple Web application18.5.2.3. Client from Web server18.5.2.3.1. No Touch Deployment18.6. ClickOnce18.6.1. ClickOnce Operation18.6.2. Publishing an Application18.6.3. ClickOnce Settings18.6.4. Application Cache18.6.5. Security18.6.6. Advanced Options18.6.6.1. File System Editor18.6.6.2. Registry Editor18.6.6.3. File Types Editor18.6.6.4. User Interface Editor18.6.6.5. Custom Actions Editor18.6.6.6. Launch Conditions Editor18.7. Summary
III. Data
19. Data Access with .NET
19.1. ADO.NET Overview19.1.1. Namespaces19.1.2. Shared Classes19.1.3. Database-Specific Classes19.2. Using Database Connections19.2.1. Managing Connection Strings19.2.2. Using Connections Efficiently19.2.2.1. Option One: try...catch...finally19.2.2.2. Option Two: The using block statement19.2.3. Transactions19.3. Commands19.3.1. Executing Commands19.3.1.1. ExecuteNonQuery()19.3.1.2. ExecuteReader()19.3.1.3. ExecuteScalar()19.3.1.4. ExecuteXmlReader() (SqlClient Provider Only)19.3.2. Calling Stored Procedures19.3.2.1. Calling a stored procedure that returns nothing19.3.2.1.1. Record update19.3.2.1.2. Record deletion19.3.2.2. Calling a stored procedure that returns output parameters19.3.2.2.1. Record insertion19.4. Fast Data Access: The Data Reader19.5. Managing Data and Relationships: The DataSet Class19.5.1. Data Tables19.5.2. Data Columns19.5.2.1. Data rows19.5.2.2. Schema generation19.5.2.2.1. Runtime schema generation19.5.2.2.2. Hand-coded schema19.5.3. Data Relationships19.5.4. Data Constraints19.5.4.1. Setting a primary key19.5.4.2. Setting a foreign key19.5.4.3. Setting Update and Delete constraints19.6. XML Schemas19.6.1. Generating Code with XSD19.7. Populating a DataSet19.7.1. Populating a DataSet Class with a Data Adapter19.7.1.1. Using a stored procedure in a data adapter19.7.2. Populating a DataSet from XML19.8. Persisting DataSet Changes19.8.1. Updating with Data Adapters19.8.1.1. Inserting a new row19.8.1.2. Updating an existing row19.8.1.3. Deleting a row19.8.2. Writing XML Output19.9. Working with ADO.NET19.9.1. Tiered Development19.9.2. Key Generation with SQL Server19.9.3. Naming Conventions19.9.3.1. Conventions for database tables19.9.3.2. Conventions for database columns19.9.3.3. Conventions for constraints19.9.3.4. Stored procedures19.10. Summary
20. .NET Programming with SQL Server 2005
20.1. .NET Runtime Host20.2. Microsoft.SqlServer.Server20.3. User-Defined Types20.3.1. Creating UDTs20.3.2. Using UDTs20.3.3. Using UDTs from Client-Side Code20.4. User-Defined Aggregates20.4.1. Creating User-Defined Aggregates20.4.2. Using User-Defined Aggregates20.5. Stored Procedures20.5.1. Creating Stored Procedures20.5.2. Using Stored Procedures20.6. User-Defined Functions20.6.1. Creating User-Defined Functions20.6.2. Using User-Defined Functions20.7. Triggers20.7.1. Creating Triggers20.7.2. Using Triggers20.8. XML Data Type20.8.1. Tables with XML Data20.8.2. Query of Data20.8.3. XML Data Modification Language (XML DML)20.8.4. XML Indexes20.8.5. Strongly Typed XML20.9. Summary
21. Manipulating XML
21.1. XML Standards Support in .NET21.2. Introducing the System.Xml Namespace21.3. Using MSXML in .NET21.4. Using System.Xml Classes21.5. Reading and Writing Streamed XML21.5.1. Using the XmlReader Class21.5.1.1. Read methods21.5.1.2. Retrieving attribute data21.5.2. Validating with XmlReader21.5.3. Using the XmlWriter Class21.6. Using the DOM in .NET21.6.1. Using the XmlDocument Class21.6.1.1. Inserting nodes21.7. Using XPathNavigators21.7.1. The System.Xml.XPath Namespace21.7.1.1. XPathDocument21.7.1.2. XPathNavigator21.7.1.3. XPathNodeIterator21.7.1.4. Using classes from the XPath namespace21.7.2. The System.Xml.Xsl Namespace21.7.2.1. Transforming XML21.7.2.1.1. Using XsltArgumentList21.8. XML and ADO.NET21.8.1. Converting ADO.NET Data to XML21.8.1.1. Converting relational data21.8.2. Converting XML to ADO.NET Data21.8.3. Reading and Writing a DiffGram21.9. Serializing Objects in XML21.9.1. Serialization without Source Code Access21.10. Summary
22. Working with Active Directory
22.1. The Architecture of Active Directory22.1.1. Features22.1.2. Active Directory Concepts22.1.2.1. Objects22.1.2.2. Schema22.1.2.3. Configuration22.1.2.4. The Active Directory domain22.1.2.5. Domain controller22.1.2.6. Site22.1.2.7. Domain tree22.1.2.8. Forest22.1.2.9. Global catalog22.1.2.10. Replication22.1.3. Characteristics of Active Directory Data22.1.4. Schema22.2. Administration Tools for Active Directory22.2.1. Active Directory Users and Computers22.2.2. ADSI Edit22.3. Programming Active Directory22.3.1. Classes in System.DirectoryServices22.3.2. Binding22.3.2.1. Protocol22.3.2.2. Server name22.3.2.3. Port number22.3.2.4. Distinguished name22.3.2.4.1. Relative distinguished name22.3.2.4.2. Default naming context22.3.2.4.3. Object identifier22.3.2.5. User name22.3.2.5.1. Downlevel logon22.3.2.5.2. Distinguished name22.3.2.5.3. User principal name22.3.2.6. Authentication22.3.2.7. Binding with the DirectoryEntry class22.3.3. Getting Directory Entries22.3.3.1.22.3.3.1.1. Access a property directly by name22.3.4. Object Collections22.3.5. Cache22.3.6. Creating New Objects22.3.7. Updating Directory Entries22.3.8. Accessing Native ADSI Objects22.3.9. Searching in Active Directory22.3.9.1. SearchRoot22.3.9.2. Filter22.3.9.3. PropertiesToLoad22.3.9.4. SearchScope22.3.9.5. Search limits22.4. Searching for User Objects22.4.1. User Interface22.4.2. Get the Schema Naming Context22.4.3. Get the Property Names of the User Class22.4.4. Search for User Objects22.5. DSML22.5.1. Classes in System.DirectoryServices.Protocols22.5.2. Searching for Active Directory Objects with DSML22.6. Summary
IV. Windows Applications
23. Windows Forms
23.1. Creating a Windows Form Application23.1.1. Class Hierarchy23.2. Control Class23.2.1. Size and Location23.2.2. Appearance23.2.3. User Interaction23.2.4. Windows Functionality23.2.5. Miscellaneous Functionality23.3. Standard Controls and Components23.3.1. Button23.3.2. CheckBox23.3.3. RadioButton23.3.4. ComboBox, ListBox, and CheckedListBox23.3.5. DateTimePicker23.3.6. ErrorProvider23.3.7. HelpProvider23.3.8. ImageList23.3.9. Label23.3.10. ListView23.3.11. PictureBox23.3.12. ProgressBar23.3.13. TextBox, RichTextBox and MaskedTextBox23.3.14. Panel23.3.15. FlowLayoutPanel and TableLayoutPanel23.3.16. SplitContainer23.3.17. TabControl and TabPages23.3.18. ToolStrip23.3.19. MenuStrip23.3.20. ContextMenuStrip23.3.21. ToolStripMenuItem23.3.22. ToolStripManager23.3.23. ToolStripContainer23.4. Forms23.4.1. Form Class23.4.1.1. Form instantiation and destruction23.4.1.2. Appearance23.4.2. Multiple Document Interface (MDI)23.4.3. Custom Controls23.4.3.1. Control attributes23.4.3.2. TreeView-based custom control23.4.3.3. User control23.5. Summary
24. Viewing .NET Data
24.1. The DataGridView Control24.1.1. Displaying Tabular Data24.1.2. Data Sources24.1.2.1. Displaying data from an array24.1.2.2. DataTable24.1.2.3. Displaying data from a DataView24.1.2.3.1. Filtering rows by data24.1.2.3.2. Filtering rows on state24.1.2.3.3. Sorting rows24.1.2.4. Displaying data from a DataSet class24.1.2.4.1. Displaying data in a DataViewManager24.1.2.5. IListSource and IList interfaces24.1.2.6. Displaying generic collections24.2. DataGridView Class Hierarchy24.3. Data Binding24.3.1. Simple Binding24.3.2. Data-Binding Objects24.3.2.1. BindingContext24.3.2.2. Binding24.3.2.3. CurrencyManager and PropertyManager24.4. Visual Studio .NET and Data Access24.4.1. Creating a Connection24.4.2. Selecting Data24.4.3. Updating the Data Source24.4.4. Building a Schema24.4.4.1. Adding an element24.4.4.2. Generated DataTable24.4.4.3. Generated DataRow24.4.4.4. Generated EventArgs24.4.5. Other Common Requirements24.4.5.1. Manufactured tables and rows24.4.5.2. Using an attribute24.4.5.3. Dispatching methods24.4.5.4. Getting the selected row24.5. Summary
25. Graphics with GDI+
25.1. Understanding Drawing Principles25.1.1. GDI and GDI+25.1.1.1. GDI+ namespaces25.1.1.2. Device contexts and the Graphics object25.1.2. Drawing Shapes25.1.3. Painting Shapes Using OnPaint()25.1.4. Using the Clipping Region25.2. Measuring Coordinates and Areas25.2.1. Point and PointF25.2.2. Size and SizeF25.2.3. Rectangle and RectangleF25.2.4. Region25.3. A Note about Debugging25.4. Drawing Scrollable Windows25.5. World, Page, and Device Coordinates25.6. Colors25.6.1. Red-Green-Blue (RGB) Values25.6.2. The Named Colors25.6.3. Graphics Display Modes and the Safety Palette25.6.4. The Safety Palette25.7. Pens and Brushes25.7.1. Brushes25.7.2. Pens25.8. Drawing Shapes and Lines25.9. Displaying Images25.10. Issues When Manipulating Images25.11. Drawing Text25.12. Simple Text Example25.13. Fonts and Font Families25.14. Example: Enumerating Font Families25.15. Editing a Text Document: The CapsEditor Sample25.15.1. The Invalidate() Method25.15.2. Calculating Item Sizes and Document Size25.15.3. OnPaint()25.15.4. Coordinate Transforms25.15.5. Responding to User Input25.16. Printing25.16.1. Implementing Print and Print Preview25.17. Summary
V. Web Applications
26. ASP.NET Pages
26.1. ASP.NET Introduction26.1.1. State Management in ASP.NET26.2. ASP.NET Web Forms26.2.1. The ASP.NET Code Model26.2.2. ASP.NET Server Controls26.2.2.1. The control palette26.2.2.1.1. Crystal Reports Web server controls26.2.2.1.2. Standard Web server controls26.2.2.1.3. Data Web server controls26.2.2.1.4. Validation Web server controls26.2.2.1.5. Navigation and Login Web server controls26.2.2.1.6. WebParts Web server controls26.2.2.2. Server control example26.3. ADO.NET and Data Binding26.3.1. Updating the Event-Booking Application26.3.1.1. The database26.3.1.1.1. Attendees26.3.1.1.2. Rooms26.3.1.1.3. Events26.3.1.2. Binding to the database26.3.1.3. Customizing the calendar control26.3.1.4. Adding events to the database26.3.2. More on Data Binding26.3.2.1. Data display with templates26.3.2.2. Using templates26.4. Application Configuration26.5. Summary
27. ASP.NET Development
27.1. Custom Controls27.1.1. User Controls27.1.1.1. A simple user control27.1.2. User Controls in PCSDemoSite27.1.3. Custom Controls27.1.3.1. Custom control sample27.2. Master Pages27.2.1. Master Pages in PCSDemoSite27.3. Site Navigation27.3.1. Navigation in PCSDemoSite27.4. Security27.4.1. Adding Forms Authentication using the Security Wizard27.4.2. Implementing a Login System27.4.3. Login Web Server Controls27.4.4. Securing Directories27.4.5. Security in PCSDemoSite27.5. Themes27.5.1. Applying Themes to Pages27.5.2. Defining Themes27.5.3. Themes in PCSDemoSite27.6. Summary
VI. Communication
28. Web Services
28.1. SOAP28.2. WSDL28.3. Web Services28.3.1. Exposing Web Services28.3.1.1. Types available for Web services28.3.2. Consuming Web Services28.4. Extending the Event-Booking Example28.4.1. The Event-Booking Web Service28.4.2. The Event-Booking Client28.5. Exchanging Data Using SOAP Headers28.6. Summary
29. .NET Remoting
29.1. What Is .NET Remoting?29.1.1. Application Types and Protocols29.1.2. CLR Object Remoting29.2. .NET Remoting Overview29.3. Contexts29.3.1. Activation29.3.2. Attributes and Properties29.3.3. Communication between Contexts29.4. Remote Objects, Clients, and Servers29.4.1. Remote Objects29.4.2. A Simple Server29.4.3. A Simple Client29.5. .NET Remoting Architecture29.5.1. Channels29.5.1.1. Setting channel properties29.5.1.2. Pluggability of a channel29.5.2. Formatters29.5.3. ChannelServices and RemotingConfiguration29.5.3.1. Server for well-known objects29.5.3.2. Server for client-activated objects29.5.4. Object Activation29.5.4.1. Application URL29.5.4.2. Activating well-known objects29.5.4.3. Activating client-activated objects29.5.4.4. Proxy objects29.5.4.4.1. Pluggability of a proxy29.5.4.5. Messages29.5.5. Message Sinks29.5.5.1. Envoy sink29.5.5.2. Server context sink29.5.5.3. Object sink29.5.6. Passing Objects in Remote Methods29.5.6.1. Security and serialized objects29.5.6.2. Directional attributes29.5.7. Lifetime Management29.5.7.1. Lease renewals29.5.7.2. Leasing configuration values29.5.7.3. Classes used for lifetime management29.5.7.4. Getting lease information example29.5.7.5. Changing default lease configurations29.6. Miscellaneous .NET Remoting Features29.6.1. Configuration Files29.6.1.1. Predefined channels29.6.1.2. Server configuration for well-known objects29.6.1.3. Client configuration for well-known objects29.6.1.4. Server configuration for client-activated objects29.6.1.5. Client configuration for client-activated objects29.6.1.6. Server code using configuration files29.6.1.7. Client code using configuration files29.6.1.8. Delayed loading of client channels29.6.1.9. Debugging Configuration29.6.1.10. Lifetime services in configuration files29.6.1.11. Formatter providers29.6.1.12. .NET Framework Configuration tool29.6.2. Hosting Servers in ASP.NET29.6.3. Classes, Interfaces, and Soapsuds29.6.3.1. Interfaces29.6.3.2. Soapsuds29.6.4. Asynchronous Remoting29.6.4.1. Using delegates with .NET Remoting29.6.4.2. OneWay attribute29.6.5. Security with .NET Remoting29.6.6. Remoting and Events29.6.6.1. Remote object29.6.6.2. Event arguments29.6.6.3. Server29.6.6.3.1. Server configuration file29.6.6.4. Event sink29.6.6.5. Client29.6.6.5.1. Client configuration file29.6.6.6. Running programs29.6.7. Call Contexts29.7. Summary
30. Enterprise Services
30.1. Overview30.1.1. History30.1.2. Where to Use Enterprise Services30.1.3. Contexts30.1.4. Automatic Transactions30.1.5. Distributed Transactions30.1.6. Object Pooling30.1.7. Role-based Security30.1.8. Queued Components30.1.9. Loosely Coupled Events30.1.10. Services without Components30.2. Creating a Simple COM+ Application30.2.1. Class ServicedComponent30.2.2. Sign the Assembly30.2.3. Assembly Attributes30.2.4. Creating the Component30.3. Deployment30.3.1. Automatic Deployment30.3.2. Manual Deployment30.3.3. Creating an Installer Package30.4. Component Services Explorer30.5. Client Application30.6. Transactions30.6.1. ACID Properties30.6.2. Transaction Attributes30.6.3. Transaction Results30.7. Sample Application30.7.1. Entity Classes30.7.2. The OrderControl Component30.7.3. The OrderData Component30.7.4. The OrderLineData Component30.7.5. Client Application30.8. Services without Components30.9. Summary
31. Message Queuing
31.1. Overview31.1.1. When to Use Message Queuing31.1.2. Message Queuing Features31.2. Message Queuing Products31.3. Message Queuing Architecture31.3.1. Messages31.3.2. Message Queue31.4. Message Queuing Administrative Tools31.4.1. Creating Message Queues31.4.2. Message Queue Properties31.5. Programming Message Queuing31.5.1. Creating a Message Queue31.5.2. Finding a Queue31.5.3. Opening Known Queues31.5.3.1. Path name31.5.3.2. Format name31.5.4. Sending a Message31.5.4.1. Message formatter31.5.4.2. Sending complex messages31.5.5. Receiving Messages31.5.5.1. Enumerating messages31.5.5.2. Asynchronous read31.6. Course Order Application31.6.1. Course Order Class Library31.6.2. Course Order Message Sender31.6.3. Sending Priority and Recoverable Messages31.6.4. Course Order Message Receiver31.7. Receiving Results31.7.1. Acknowledgement Queues31.7.2. Response Queues31.8. Transactional Queues31.9. Message Queue Installation31.10. Summary
32. Future of Distributed Programming
32.1. Problems Today32.2. Web Services32.2.1. Security32.2.2. Reliability32.2.3. Transactions32.2.4. Performance32.3. WCF Overview32.4. Programming with WCF32.4.1. Contracts32.4.1.1. Service Contract32.4.1.2. Data Contract32.4.1.3. Message Contract32.4.2. Service Implementation32.4.3. Binding32.4.4. Hosting32.4.5. Clients32.5. Preparing for WCF32.5.1. .NET Remoting32.5.2. ASP.NET Web Services32.5.3. Enterprise Services32.5.4. Message Queuing32.6. Summary
VII. Interop
33. COM Interoperability
33.1. .NET and COM33.1.1. Metadata33.1.2. Freeing Memory33.1.3. Interfaces33.1.3.1. Custom interfaces33.1.3.2. Dispatch interfaces33.1.3.3. Dual interfaces33.1.3.4. Casting and QueryInterface33.1.4. Method Binding33.1.5. Data Types33.1.6. Registration33.1.7. Threading33.1.7.1. Single-threaded apartment33.1.7.2. Multi-threaded apartment33.1.8. Error Handling33.1.9. Event Handling33.2. Marshaling33.3. Using a COM Component from a .NET Client33.3.1. Creating a COM Component33.3.2. Creating a Runtime Callable Wrapper33.3.2.1. Primary interop assemblies33.3.3. Threading Issues33.3.4. Adding Connection Points33.3.5. Using ActiveX Controls in Windows Forms33.3.5.1. ActiveX Control Importer33.3.5.2. Creating a Windows Forms application33.3.6. Using COM Objects from within ASP.NET33.4. Using a .NET Component from a COM Client33.4.1. COM Callable Wrapper33.4.2. Creating a .NET Component33.4.3. Creating a Type Library33.4.4. COM Interop Attributes33.4.5. COM Registration33.4.6. Creating a COM Client33.4.7. Adding Connection Points33.4.8. Creating a Client with a Sink Object33.4.9. Running Windows Forms Controls in Internet Explorer33.5. Summary
VIII. Windows Base Services
34. Manipulating Files and the Registry
34.1. Managing the File System34.1.1. .NET Classes That Represent Files and Folders34.1.2. The Path Class34.1.3. Example: A File Browser34.2. Moving, Copying, and Deleting Files34.2.1. Example: FilePropertiesAndMovement34.2.2. Looking at the Code for FilePropertiesAndMovement34.3. Reading and Writing to Files34.3.1. Reading a File34.3.2. Writing to a File34.3.3. Streams34.3.4. Buffered Streams34.3.5. Reading and Writing to Binary Files using FileStream34.3.5.1. The FileStream class34.3.5.2. Example: BinaryFileReader34.3.6. Reading and Writing to Text Files34.3.6.1. The StreamReader class34.3.6.2. The StreamWriter class34.3.6.3. Example: ReadWriteText34.4. Reading Drive Information34.5. File Security34.5.1. Reading ACLs from a File34.5.2. Reading ACLs from a Directory34.5.3. Adding and Removing ACLs from a File34.6. Reading and Writing to the Registry34.6.1. The Registry34.6.2. The .NET Registry Classes34.6.3. Example: SelfPlacingWindow34.7. Summary
35. Accessing the Internet
35.1. The WebClient Class35.1.1. Downloading Files35.1.2. Basic Web Client Example35.1.3. Uploading Files35.2. WebRequest and WebResponse Classes35.2.1. Other WebRequest and WebResponse Features35.2.1.1. HTTP header information35.2.1.2. Authentication35.2.1.3. Asynchronous page requests35.3. Displaying Output as an HTML Page35.3.1. Allowing Simple Web Browsing from Your Applications35.3.2. Launching Internet Explorer Instances35.3.3. Giving Your Application More IE Type Features35.3.4. Showing Documents using the WebBrowser Control35.3.5. Printing using the WebBrowser Control35.3.6. Displaying the Code of a Requested Page35.3.7. The Web Request and Web Response Hierarchy35.4. Utility Classes35.4.1. URIs35.4.2. IP Addresses and DNS Names35.4.2.1. .NET classes for IP addresses35.4.2.1.1. IPAddress35.4.2.1.2. IPHostEntry35.4.2.1.3. Dns35.4.2.2. The DnsLookup example35.5. Lower-Level Protocols35.5.1. Lower-Level Classes35.5.1.1. Using the TCP classes35.5.1.2. The TcpSend and TcpReceive examples35.5.1.3. TCP versus UDP35.5.1.4. The UDP class35.5.1.5. The Socket class35.6. Summary
36. Windows Services
36.1. What Is a Windows Service?36.2. Windows Services Architecture36.2.1. Service Program36.2.1.1. Service Control Manager36.2.1.2. Main function, service-main, and handlers36.2.2. Service Control Program36.2.3. Service Configuration Program36.3. System.ServiceProcess Namespace36.4. Creating a Windows Service36.4.1. A Class Library Using Sockets36.4.2. TcpClient Example36.4.3. Windows Service Project36.4.3.1. The ServiceBase class36.4.3.2. Main function36.4.3.3. Service start36.4.3.4. Handler methods36.4.4. Threading and Services36.4.5. Service Installation36.4.6. Installation Program36.4.6.1. The Installer class36.4.6.2. The ServiceProcessInstaller and ServiceInstaller classes36.4.6.3. The ServiceInstallerDialog class36.4.6.4. installutil36.4.6.5. Client36.5. Monitoring and Controlling the Service36.5.1. MMC Computer Management36.5.2. net.exe36.5.3. sc.exe36.5.4. Visual Studio Server Explorer36.5.5. ServiceController Class36.5.5.1. Monitoring the service36.5.5.2. Controlling the service36.6. Troubleshooting36.6.1. Interactive Services36.6.2. Event Logging36.6.2.1. Event Logging architecture36.6.2.2. Event Logging classes36.6.2.3. Adding event logging36.6.2.4. Adding event logging to other application types36.6.2.5. Adding event logging to the QuoteServer36.6.2.6. Trace36.6.2.7. Creating an event log listener36.6.3. Performance Monitoring36.6.3.1. Performance monitoring classes36.6.3.2. Performance Counter Builder36.6.3.3. Adding PerformanceCounter components36.6.3.4. perfmon.exe36.7. Power Events36.8. Summary
IX. Appendices
A. Principles of Object-Oriented Programming
A.1. A Note for Visual Basic 6 ProgrammersA.2. What Is an Object?A.3. Objects in ProgrammingA.3.1. Class MembersA.3.2. Defining a ClassA.3.3. Access ModifiersA.3.4. Instantiating and Using ObjectsA.3.5. Using Static MembersA.3.5.1. Creating static fieldsA.3.5.2. Creating static methodsA.3.5.3. Accessing static membersA.3.5.4. How instance and static methods are implemented in memoryA.3.6. A Note About Reference TypesA.3.7. Overloading MethodsA.3.7.1. When to Use OverloadingA.3.7.1.1. Optional parametersA.3.7.1.2. Different input typesA.3.7.1.3. Different output typesA.3.8. PropertiesA.3.9. Data EncapsulationA.4. Introducing InheritanceA.4.1. Using Inheritance in C#A.4.2. Adding InheritanceA.4.3. Class Hierarchies and Class DesignA.4.3.1. The object classA.4.3.2. Single and multiple inheritanceA.4.4. Polymorphism and Virtual MembersA.4.5. Method HidingA.4.6. Abstract Functions and Base ClassesA.4.7. Defining an Abstract ClassA.4.8. Sealed Classes and MethodsA.5. InterfacesA.6. Construction and DisposalA.6.1. Creating ConstructorsA.6.1.1. Passing parameters to constructorsA.6.1.2. More uses of constructorsA.7. Summary
B. C# for Visual Basic 6 Developers
B.1. Differences Between C# and Visual BasicB.1.1. ClassesB.1.2. CompilationB.1.3. The .NET Base ClassesB.1.4. ConventionsB.1.5. Example: The Square Root FormB.1.6. SquareRoot Visual Basic VersionB.1.7. SquareRoot C# VersionB.1.8. Basic SyntaxB.1.8.1. C# requires all variables to be declaredB.1.8.2. CommentsB.1.8.3. Statement separation and groupingB.1.8.4. CapitalizationB.1.9. MethodsB.1.10. VariablesB.1.10.1. DeclarationsB.1.10.1.1. No suffixes in C#B.1.10.1.2. No default values for local variablesB.1.10.2. Assigning values to variablesB.1.11. ClassesB.1.12. If StatementsB.1.12.1. Calculating square roots: Another class methodB.1.12.2. StringsB.1.13. Extra Code in C#B.1.14. What Happens When You Run a ProgramB.1.15. The C# Code for the Rest of the ProgramB.1.15.1. NamespacesB.1.15.2. The using directiveB.1.15.3. The class definition: InheritanceB.1.16. Program Entry PointB.1.17. Instantiating ClassesB.1.17.1. C# classesB.1.17.2. Entering the message loopB.1.18. The SquareRootForm ClassB.1.18.1.B.1.18.1.1. Arithmetic assignment operatorsB.2. Example: Employees and ManagersB.2.1. The Visual Basic Employee Class ModuleB.2.1.1. The C# Employee classB.2.1.2. The Employee constructorB.2.1.3. Properties of EmployeeB.2.1.4. Methods of EmployeeB.2.2. Static MembersB.2.3. InheritanceB.2.4. Inheriting from the Employee ClassB.2.5. The Manager ClassB.2.6. Method OverridesB.2.7. The Manager ConstructorsB.2.8. Method OverloadingB.2.9. Using the Employee and Manager ClassesB.2.10. References to Derived ClassesB.3. Arrays of ObjectsB.4. The for LoopB.5. Other C# FeaturesB.5.1. Data TypesB.5.2. Value and Reference TypesB.5.3. OperatorsB.5.4. The ternary operatorB.6. Summary
C. C# for Java Developers
C.1. Starting OutC.1.1. Compiling and Running C# CodeC.1.2. NamespacesC.2. Declaring VariablesC.3. Variable Naming ConventionsC.4. Data TypesC.4.1. Value TypesC.4.1.1. Simple typesC.4.1.1.1. Integer valuesC.4.1.1.2. Character valuesC.4.1.1.3. Boolean valuesC.4.1.1.4. Decimal valuesC.4.1.1.5. Floating-point valuesC.4.1.2. Enumeration typesC.4.1.3. StructuresC.4.1.3.1. Structs and attributesC.4.2. Reference TypesC.4.3. Arrays and CollectionsC.4.4. Type Conversion and CastingC.5. OperatorsC.6. Flow Control and IterationC.7. ClassesC.7.1. Access ModifiersC.7.2. Class MembersC.7.2.1. Passing as reference to methodsC.7.2.2. PropertiesC.7.2.3. DestructorsC.7.3. Class InheritanceC.7.3.1. Abstract classesC.7.3.2. Preventing inheritanceC.7.3.3. Using base class members and base constructorsC.7.3.4. Method overriding and hidingC.8. Input and OutputC.9. Summary
D. C# for C++ Developers
D.1. Conventions for This AppendixD.2. TerminologyD.3. A Comparison of C# and C++D.3.1. DifferencesD.3.2. SimilaritiesD.3.3. New FeaturesD.3.4. New Base Class FeaturesD.4. The Hello World ExampleD.4.1. #include StatementsD.4.2. NamespacesD.4.3. Entry Point: Main() versus main()D.4.4. Displaying the MessageD.5. Topic-by-Topic ComparisonD.5.1. Program ArchitectureD.5.1.1. Program objectsD.5.1.2. File structureD.5.1.3. Program entry pointD.5.2. Language SyntaxD.5.2.1. Forward declarationsD.5.2.2. No separation of definition and declarationD.5.3. Program FlowD.5.3.1. if...elseD.5.3.2. while and do whileD.5.3.3. switchD.5.3.4. foreachD.5.4. VariablesD.5.4.1. Basic data typesD.5.4.2. Basic data types as objectsD.5.4.3. Casting between the basic data typesD.5.4.4. Overflow checkingD.5.4.5. StringsD.5.4.6. Escape sequencesD.5.4.7. Value types and reference typesD.5.4.8. Initialization of variablesD.5.4.9. BoxingD.5.5. Memory ManagementD.5.5.1. The new operatorD.5.5.2. The delete operatorD.5.6. MethodsD.5.6.1. Method parametersD.5.6.2. Method overloadsD.5.7. PropertiesD.5.8. OperatorsD.5.8.1. Assignment operator (=)D.5.8.2. thisD.5.8.3. newD.5.9. Classes and StructsD.5.10. ClassesD.5.10.1. Definition of a classD.5.10.2. Initialization of member fieldsD.5.10.2.1. Instance membersD.5.10.2.2. Static fieldsD.5.10.3. ConstructorsD.5.10.4. Static constructorsD.5.10.5. Default constructorsD.5.10.6. Constructor initialization listsD.5.10.7. DestructorsD.5.10.8. InheritanceD.5.10.9. Virtual and non-virtual functionsD.5.11. StructsD.5.12. ConstantsD.5.12.1. Constants that are associated with a class (static constants)D.5.12.2. Instance constantsD.5.13. Operator OverloadingD.5.13.1. IndexersD.5.13.2. User-defined castsD.5.14. ArraysD.5.14.1. One-dimensional arraysD.5.14.2. Multidimensional arraysD.5.14.3. Bounds checkingD.5.14.4. Resizing arraysD.5.15. EnumerationsD.5.16. ExceptionsD.5.17. Pointers and Unsafe CodeD.5.17.1. Fixing data on the heapD.5.17.2. Declaring arrays on the stackD.5.18. InterfacesD.5.19. DelegatesD.5.20. EventsD.5.21. AttributesD.5.22. Templates and GenericsD.5.23. Preprocessor DirectivesD.6. Summary

Content preview from Professional C# 2005

Chapter 7. Memory Management and Pointers

This chapter looks at various aspects of memory management and memory access. Although the runtime takes much of the responsibility for memory management away from the programmer, it is useful to understand how memory management works and important to know how to work with unmanaged resources efficiently.

If you have a good understanding of memory management and knowledge of the pointer capabilities provided by C#, you are also better positioned to integrate C# code with legacy code and perform efficient memory manipulation in performance-critical systems.

Specifically, this chapter discusses:

How the runtime allocates space on the stack and the heap
How garbage collection works
How to use destructors and the System.IDisposable interface to ensure unmanaged resources are released correctly
The syntax for using pointers in C#
How to use pointers to implement high-performance stack-based arrays

Memory Management under the Hood

One of the advantages of C# programming is that the programmer doesn't need to worry about detailed memory management; in particular, the garbage collector deals with the problem of memory cleanup on your behalf. The result is that you get something that approximates the efficiency of languages like C++ without the complexity of having to handle memory management yourself as you do in C++. However, although you don't have to manage memory manually, if you need to write efficient code, it still pays to understand what is going ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780764575341Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Professional C# 2005

by Christian Nagel, Bill Evjen, Jay Glynn, Karli Watson, Morgan Skinner, Allen Jones

Chapter 7. Memory Management and Pointers

Memory Management under the Hood

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.