book

Programming C#, 4th Edition

Name: Programming C#, 4th Edition
Author: Jesse Liberty
ISBN: 9780596006990

by Jesse Liberty

February 2005

Intermediate to advanced

666 pages

16h 49m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Programming C#, 4th Edition
A Note Regarding Supplemental Files
Preface
About This BookWhat You Need To Use This BookHow the Book Is OrganizedPart I, The C# LanguagePart II, Programming with C#Part III, The CLR and the .NET FrameworkWho This Book Is ForC# 2.0 Versus C# 1.1C# Versus Visual Basic .NETC# Versus JavaC# Versus C and C++Conventions Used in This BookSupportWe’d Like to Hear from YouSafari EnabledAcknowledgments
I. The C# Language
1. C# and the .NET Framework
1.1. The .NET Platform1.2. The .NET Framework1.3. Compilation and the MSIL1.4. The C# Language
2. Getting Started: “Hello World”
2.1. Classes, Objects, and Types2.1.1. Methods2.1.2. Comments2.1.3. Console Applications2.1.4. Namespaces2.1.5. The Dot Operator (.)2.1.6. The using Keyword2.1.7. Case Sensitivity2.1.8. The static Keyword2.2. Developing “Hello World”2.2.1. Editing “Hello World”2.2.2. Compiling and Running “Hello World”2.3. Using the Visual Studio .NET Debugger
3. C# Language Fundamentals
3.1. Types3.1.1. Working with Built-in Types3.1.1.1. Choosing a built-in type3.1.1.2. Converting built-in types3.2. Variables and Constants3.2.1. Definite Assignment3.2.2. Constants3.2.3. Enumerations3.2.4. Strings3.2.5. Identifiers3.3. Expressions3.4. Whitespace3.5. Statements3.5.1. Unconditional Branching Statements3.5.2. Conditional Branching Statements3.5.2.1. if...else statements3.5.2.2. Nested if statements3.5.2.3. switch statements: an alternative to nested ifs3.5.2.4. Switch on string statements3.5.3. Iteration Statements3.5.3.1. The goto statement3.5.3.2. The while loop3.5.3.3. The do...while loop3.5.3.4. The for loop3.5.3.5. The foreach statement3.5.3.6. The continue and break statements3.6. Operators3.6.1. The Assignment Operator (=)3.6.2. Mathematical Operators3.6.2.1. Simple arithmetical operators (+, -, *, /)3.6.2.2. The modulus operator (%) to return remainders3.6.3. Increment and Decrement Operators3.6.3.1. Calculate and reassign operators3.6.3.2. The prefix and postfix operators3.6.4. Relational Operators3.6.5. Use of Logical Operators with Conditionals3.6.6. Operator Precedence3.6.7. The Ternary Operator3.7. Preprocessor Directives3.7.1. Defining Identifiers3.7.2. Undefining Identifiers3.7.3. #if, #elif, #else, and #endif3.7.4. #region
4. Classes and Objects
4.1. Defining Classes4.1.1. Access Modifiers4.1.2. Method Arguments4.2. Creating Objects4.2.1. Constructors4.2.2. Initializers4.2.3. The ICloneable Interface4.2.4. The this Keyword4.3. Using Static Members4.3.1. Invoking Static Methods4.3.2. Using Static Constructors4.3.3. Static Classes4.3.4. Using Static Fields4.4. Destroying Objects4.4.1. The C# Destructor4.4.2. Destructors Versus Dispose4.4.3. Implementing the Close( ) Method4.4.4. The using Statement4.5. Passing Parameters4.5.1. Passing by Reference4.5.2. Overcoming Definite Assignment with out Parameters4.6. Overloading Methods and Constructors4.7. Encapsulating Data with Properties4.7.1. The get Accessor4.7.2. The set Accessor4.7.3. Property Access Modifiers4.8. readonly Fields
5. Inheritance and Polymorphism
5.1. Specialization and Generalization5.2. Inheritance5.2.1. Implementing Inheritance5.3. Polymorphism5.3.1. Creating Polymorphic Types5.3.2. Creating Polymorphic Methods5.3.3. Calling Base Class Constructors5.3.4. Controlling Access5.3.5. Versioning with the new and override Keywords5.4. Abstract Classes5.4.1. Limitations of Abstract5.4.2. Sealed Class5.5. The Root of All Classes: Object5.6. Boxing and Unboxing Types5.6.1. Boxing Is Implicit5.6.2. Unboxing Must Be Explicit5.7. Nesting Classes
6. Operator Overloading
6.1. Using the operator Keyword6.2. Supporting Other .NET Languages6.3. Creating Useful Operators6.4. Logical Pairs6.5. The Equality Operator6.6. Conversion Operators

7. Structs
7.1. Defining Structs7.2. Creating Structs7.2.1. Structs as Value Types7.2.2. Creating Structs Without new
8. Interfaces
8.1. Defining and Implementing an Interface8.1.1. Implementing More Than One Interface8.1.2. Extending Interfaces8.1.3. Combining Interfaces8.1.3.1. Casting to extended interfaces8.2. Accessing Interface Methods8.2.1. Casting to an Interface8.2.2. The is Operator8.2.3. The as Operator8.2.4. The is Operator Versus the as Operator8.2.5. Interface Versus Abstract Class8.3. Overriding Interface Implementations8.4. Explicit Interface Implementation8.4.1. Selectively Exposing Interface Methods8.4.2. Member Hiding8.4.3. Accessing Sealed Classes and Value Types
9. Arrays, Indexers, and Collections
9.1. Arrays9.1.1. Declaring Arrays9.1.2. Understanding Default Values9.1.3. Accessing Array Elements9.2. The foreach Statement9.2.1. Initializing Array Elements9.2.2. The params Keyword9.2.3. Multidimensional Arrays9.2.3.1. Rectangular arrays9.2.3.2. Jagged arrays9.2.4. Array Bounds9.2.5. Array Conversions9.2.6. Sorting Arrays9.3. Indexers9.3.1. Indexers and Assignment9.3.2. Indexing on Other Values9.4. Collection Interfaces9.4.1. The IEnumerable<T> Interface9.5. Constraints9.6. List<T>9.6.1. Implementing IComparable9.6.2. Implementing IComparer9.7. Queues9.8. Stacks9.9. Dictionaries9.9.1. IDictionary<K,V>
10. Strings and Regular Expressions
10.1. Strings10.1.1. Creating Strings10.1.2. The ToString() Method10.1.3. Manipulating Strings10.1.4. Finding Substrings10.1.5. Splitting Strings10.1.6. Manipulating Dynamic Strings10.2. Regular Expressions10.2.1. Using Regular Expressions: Regex10.2.2. Using Regex Match Collections10.2.3. Using Regex Groups10.2.4. Using CaptureCollection
11. Handling Exceptions
11.1. Throwing and Catching Exceptions11.1.1. The throw Statement11.1.2. The catch Statement11.1.2.1. Taking corrective action11.1.2.2. Unwinding the call stack11.1.2.3. Creating dedicated catch statements11.1.3. The finally Statement11.2. Exception Objects11.3. Custom Exceptions11.4. Rethrowing Exceptions
12. Delegates and Events
12.1. Delegates12.1.1. Using Delegates to Specify Methods at Runtime12.1.2. Delegates and Instance Methods12.1.3. Static Delegates12.1.4. Delegates as Properties12.2. Multicasting12.3. Events12.3.1. Publishing and Subscribing12.3.2. Events and Delegates12.3.3. Solving Delegate Problems with Events12.3.4. The event Keyword12.4. Using Anonymous Methods12.5. Retrieving Values from Multicast Delegates12.5.1. Invoking Events Asynchronously12.5.2. Callback Methods
II. Programming with C#
13. Building Windows Applications
13.1. Creating a Simple Windows Form13.1.1. Using the Visual Studio Designer13.2. Creating a Windows Forms Application13.2.1. Creating the Basic UI Form13.2.2. Populating the TreeView Controls13.2.2.1. TreeNode objects13.2.2.2. Recursing through the subdirectories13.2.2.3. Getting the files in the directory13.2.3. Handling TreeView Events13.2.3.1. Clicking the source TreeView13.2.3.2. Expanding a directory13.2.3.3. Clicking the target TreeView13.2.3.4. Handling the Clear button event13.2.4. Implementing the Copy Button Event13.2.4.1. Getting the selected files13.2.4.2. Sorting the list of selected files13.2.5. Handling the Delete Button Event13.3. XML Documentation Comments
14. Accessing Data with ADO.NET
14.1. Relational Databases and SQL14.1.1. Tables, Records, and Columns14.1.2. Normalization14.1.3. Declarative Referential Integrity14.1.4. SQL14.2. The ADO.NET Object Model14.2.1. DataTables and DataColumns14.2.2. DataRelations14.2.3. Rows14.2.4. Data Adapter14.2.5. DBCommand and DBConnection14.2.6. DataAdapter14.2.7. DataReader14.3. Getting Started with ADO.NET14.4. Using OLE DB Managed Providers14.5. Working with Data-Bound Controls14.5.1. Populating a DataGrid Programmatically14.5.2. Customizing the DataSet
15. Programming ASP.NET Applications and Web Services
15.1. Understanding Web Forms15.1.1. Web Form Events15.1.1.1. Postback versus nonpostback events15.1.1.2. State15.1.2. Web Form Life Cycle15.2. Creating a Web Form15.2.1. Code-Behind Files15.3. Adding Controls15.3.1. Server Controls15.4. Data Binding15.4.1. Examining the Code15.4.2. Adding Controls and Events15.5. Web Services15.6. SOAP, WSDL, and Discovery15.6.1. Server-Side Support15.6.2. Client-Side Support15.7. Building a Web Service15.7.1. Testing Your Web Service15.7.2. Viewing the WSDL Contract15.8. Creating the Proxy15.8.1. Testing the Web Service
16. Putting It All Together
16.1. The Overall Design16.2. Creating the Web Services Client16.2.1. Creating the Amazon proxy16.2.1.1. Creating the desktop application16.3. Displaying the Output16.3.1. Implementing the Grid16.3.2. Handling the RowDataBound Event16.4. Searching by Category
III. The CLR and the .NET Framework
17. Assemblies and Versioning
17.1. PE Files17.2. Metadata17.3. Security Boundary17.4. Manifests17.5. Multimodule Assemblies17.5.1. Building a Multimodule Assembly17.5.1.1. Testing the assembly17.5.1.2. Loading the assembly17.6. Private Assemblies17.7. Shared Assemblies17.7.1. The End of DLL Hell17.7.2. Versions17.7.3. Strong Names17.7.4. The Global Assembly Cache17.7.5. Building a Shared Assembly17.7.5.1. Step 1: Create a strong name17.7.5.2. Step 2: Put the shared assembly in the GAC17.7.6. Other Required Assemblies
18. Attributes and Reflection
18.1. Attributes18.1.1. Attributes18.1.1.1. Attribute targets18.1.1.2. Applying attributes18.1.2. Custom Attributes18.1.2.1. Declaring an attribute18.1.2.2. Naming an attribute18.1.2.3. Constructing an attribute18.1.2.4. Using an attribute18.2. Reflection18.2.1. Viewing Metadata18.2.2. Type Discovery18.2.3. Reflecting on a Type18.2.3.1. Finding all type members18.2.3.2. Finding type methods18.2.3.3. Finding particular type members18.2.4. Late Binding
19. Marshaling and Remoting
19.1. Application Domains19.1.1. Creating and Using App Domains19.1.2. Marshaling Across App Domain Boundaries19.1.2.1. Understanding marshaling with proxies19.1.2.2. Specifying the marshaling method19.2. Context19.2.1. Context-Bound and Context-Agile Objects19.2.2. Marshaling Across Context Boundaries19.3. Remoting19.3.1. Understanding Server Object Types19.3.2. Specifying a Server with an Interface19.3.3. Building a Server19.3.4. Building the Client19.3.5. Using SingleCall19.3.6. Understanding RegisterWellKnownServiceType19.3.7. Understanding Endpoints
20. Threads and Synchronization
20.1. Threads20.1.1. Starting Threads20.1.2. Joining Threads20.1.3. Blocking Threads with Sleep20.1.4. Killing Threads20.2. Synchronization20.2.1. Using Interlocked20.2.2. Using Locks20.2.3. Using Monitors20.3. Race Conditions and Deadlocks20.3.1. Race Conditions20.3.2. Deadlock
21. Streams
21.1. Files and Directories21.1.1. Working with Directories21.1.2. Creating a DirectoryInfo Object21.1.3. Working with Files21.1.4. Modifying Files21.2. Reading and Writing Data21.2.1. Binary Files21.2.2. Buffered Streams21.2.3. Working with Text Files21.3. Asynchronous I/O21.4. Network I/O21.4.1. Creating a Network Streaming Server21.4.2. Creating a Streaming Network Client21.4.3. Handling Multiple Connections21.4.4. Asynchronous Network File Streaming21.5. Web Streams21.6. Serialization21.6.1. Using a Formatter21.6.2. Working with Serialization21.6.2.1. Serializing the object21.6.2.2. Deserializing the object21.6.3. Handling Transient Data21.7. Isolated Storage
22. Programming .NET and COM
22.1. Importing ActiveX Controls22.1.1. Creating an ActiveX Control22.1.2. Importing a Control in .NET22.1.2.1. Importing a control22.1.2.2. Manually importing the control22.1.2.3. Adding the control to the form22.2. Importing COM Components22.2.1. Coding the COMTestForm Program22.2.2. Importing the COM .DLL to .NET22.2.3. Importing the Type Library22.2.4. Importing Manually22.2.5. Creating a Test Program22.2.6. Using Late Binding and Reflection22.3. Exporting .NET Components22.3.1. Creating a Type Library22.4. P/Invoke22.5. Pointers
A. C# Keywords
Index
Colophon
Copyright

Content preview from Programming C#, 4th Edition

Chapter 22. Programming .NET and COM

Programmers love a clean slate. Although it would be nice if we could throw away all the code we’ve ever written and start over, this typically isn’t a viable option for most companies. Over the past decade, many development organizations have made a substantial investment in developing and purchasing COM components and ActiveX controls. Microsoft has made a commitment to ensure that these legacy components are usable from within .NET applications, and (perhaps less important) .NET components are easily callable from COM.

This chapter describes the support .NET provides for importing ActiveX controls and COM components into your application, for exposing .NET classes to COM-based applications, and for making direct calls to Win32 APIs. You will also learn about C# pointers and keywords for accessing memory directly, a technique that may be crucial in some applications.

Importing ActiveX Controls

ActiveX controls are COM components typically dropped into a form, which might or might not have a user interface. When Microsoft developed the OCX standard, which allowed developers to build ActiveX controls in VB and use them with C++ (and vice versa), the ActiveX control revolution began. Over the past few years, thousands of such controls have been developed, sold, and used. They are small, easy to work with, and an effective example of binary reuse.

Importing ActiveX controls into .NET is surprisingly easy, considering how different COM objects are ...

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: 0596006993Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming C#, 4th Edition

by Jesse Liberty

Chapter 22. Programming .NET and COM

Importing ActiveX Controls

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.