Contents at a Glance

1. Chapter 1: Showing Some Class
   1. A Quick Overview of Object-Oriented Programming
   2. Defining a Class and an Object
   3. Accessing the Members of an Object
   4. Working with Object-Based Code
   5. Discriminating between Objects
   6. Can You Give Me References?
   7. Classes That Contain Classes Are the Happiest Classes in the World
   8. Generating Static in Class Members
   9. Defining const and readonly Data Members
2. Chapter 2: We Have Our Methods
   1. Defining and Using a Method
   2. Method Examples for Your Files
   3. Having Arguments with Methods
   4. Using the Call-by-Reference Feature
   5. Defining a Method with No Return Value
   6. Returning Multiple Values Using Tuples
3. Chapter 3: Let Me Say This about this
   1. Passing an Object to a Method
   2. Comparing Static and Instance Methods
   3. Accessing the Current Object
   4. Using Local Functions
4. Chapter 4: Holding a Class Responsible
   1. Restricting Access to Class Members
   2. Why You Should Worry about Access Control
   3. Defining Class Properties
   4. Using Target Typing for Your Convenience
   5. Dealing with Covariant Return Types
   6. Getting Your Objects Off to a Good Start — Constructors
   7. Using Expression-Bodied Members
5. Chapter 5: Inheritance: Is That All I Get?
   1. Why You Need Inheritance
   2. Inheriting from a BankAccount Class (a More Complex Example)
   3. IS_A versus HAS_A — I’m So Confused_A
   4. Other Features That Support Inheritance
6. Chapter 6: Poly-what-ism?
   1. Overloading an Inherited Method
   2. Polymorphism
   3. C# During Its Abstract Period
   4. Sealing a Class
7. Chapter 7: Interfacing with the Interface
   1. Introducing CAN_BE_USED_AS
   2. Knowing What an Interface Is
   3. Using an Interface
   4. Using the C# Predefined Interface Types
   5. Looking at a Program That CAN_BE_USED_AS an Example
   6. Unifying Class Hierarchies
   7. Hiding Behind an Interface
   8. Inheriting an Interface
   9. Using Interfaces to Manage Change in Object-Oriented Programs
8. Chapter 8: Delegating Those Important Events
   1. E.T., Phone Home — The Callback Problem
   2. Defining a Delegate
   3. Pass Me the Code, Please — Examples
   4. A More Real-World Example
   5. Shh! Keep It Quiet — Anonymous Methods
   6. Stuff Happens — C# Events
9. Chapter 9: Can I Use Your Namespace in the Library?
   1. Dividing a Single Program into Multiple Source Files
   2. Working with Global using Statements
   3. Dividing a Single Program into Multiple Assemblies
   4. Putting Your Classes into Class Libraries
   5. Going Beyond Public and Private: More Access Keywords
   6. Putting Classes into Namespaces
   7. Working with Partial Methods
10. Chapter 10: Improving Productivity with Named and Optional Parameters
    1. Exploring Optional Parameters
    2. Looking at Named Parameters
    3. Using Alternative Methods to Return Values
    4. Dealing with null Parameters
11. Chapter 11: Interacting with Structures
    1. Comparing Structures to Classes
    2. Creating Structures
    3. Working with Read-only Structures
    4. Working with Reference Structures
    5. Using Structures as Records
    6. Using the New Record Type