Accelerated C# 2008

Accelerated C# 2008

by Weldon W. Nash
Released November 2007
Publisher(s): Apress
ISBN: 9781590598733

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Many books introduce C#, but if you don't have the time to read 1200 pages, Accelerated C# 2008 gives you everything you need to know about C# 2008 in a concentrated 500 pages of must-know information and best practices.

C# 2008 offers powerful new features, and Accelerated C# 2008 is the fastest path to mastery, for both experienced C# programmers moving to C# 2008 and programmers moving to C# from another object-oriented language.

You'll quickly master C# syntax while learning how the CLR simplifies many programming tasks. You'll also learn best practices that ensure your code will be efficient, reusable, and robust. Why spend months or years discovering the best ways to design and code C# when this book will show you how to do things the right way, right from the start?

Table of contents

  1. Accelerated C# 2008
    1. Copyright
    2. Dedication (1/3)
    3. Dedication (2/3)
    4. Dedication (3/3)
    5. Foreword
    6. About the Author
    7. About the Technical Reviewer
    8. Acknowledgments
    9. Introduction
    10. About This Book
    11. Chapter 1: C# Preview
      1. Differences Between C# and C++
      2. Example of a C# Program
      3. Overview of Features Added in C# 2.0
      4. Overview of What's New in C# 3.0
      5. Summary
    12. Chapter 2: C# and the CLR
      1. The JIT Compiler in the CLR
      2. Assemblies and the Assembly Loader
      3. Metadata
      4. Cross-Language Compatibility
      5. Summary
    13. Chapter 3: C# Syntax Overview
      1. C# Is a Strongly Typed Language
      2. Expressions
      3. Statements and Expressions
      4. Types and Variables
      5. Namespaces
      6. Control Flow
      7. Summary
    14. Chapter 4: Classes, Structs, and Objects
      1. Class Definitions (1/7)
      2. Class Definitions (2/7)
      3. Class Definitions (3/7)
      4. Class Definitions (4/7)
      5. Class Definitions (5/7)
      6. Class Definitions (6/7)
      7. Class Definitions (7/7)
      8. Value Type Definitions (1/2)
      9. Value Type Definitions (2/2)
      10. Anonymous Types
      11. Object Initializers
      12. Boxing and Unboxing (1/2)
      13. Boxing and Unboxing (2/2)
      14. System.Object
      15. Creating Objects (1/2)
      16. Creating Objects (2/2)
      17. Destroying Objects
      18. Disposable Objects
      19. Method Parameter Types
      20. Method Overloading
      21. Inheritance and Virtual Methods
      22. Inheritance, Containment, and Delegation
      23. Summary
    15. Chapter 5: Interfaces and Contracts
      1. Interfaces Define Types
      2. Defining Interfaces
      3. Implementing Interfaces (1/2)
      4. Implementing Interfaces (2/2)
      5. Interface Member Matching Rules
      6. Explicit Interface Implementation with Value Types
      7. Versioning Considerations
      8. Contracts
      9. Choosing Between Interfaces and Classes
      10. Summary
    16. Chapter 6: Overloading Operators
      1. Just Because You Can Doesn't Mean You Should
      2. Types and Formats of Overloaded Operators
      3. Operators Shouldn't Mutate Their Operands
      4. Does Parameter Order Matter?
      5. Overloading the Addition Operator
      6. Operators That Can Be Overloaded (1/2)
      7. Operators That Can Be Overloaded (2/2)
      8. Summary
    17. Chapter 7: Exception Handling and Exception Safety
      1. How the CLR Treats Exceptions
      2. Mechanics of Handling Exceptions in C# (1/2)
      3. Mechanics of Handling Exceptions in C# (2/2)
      4. Who Should Handle Exceptions?
      5. Avoid Using Exceptions to Control Flow
      6. Achieving Exception Neutrality
      7. Creating Custom Exception Classes
      8. Working with Allocated Resources and Exceptions
      9. Providing Rollback Behavior
      10. Summary
    18. Chapter 8: Working with Strings
      1. String Overview
      2. String Literals
      3. Format Specifiers and Globalization (1/3)
      4. Format Specifiers and Globalization (2/3)
      5. Format Specifiers and Globalization (3/3)
      6. Working with Strings from Outside Sources
      7. StringBuilder
      8. Searching Strings with Regular Expressions (1/2)
      9. Searching Strings with Regular Expressions (2/2)
      10. Summary
    19. Chapter 9: Arrays, Collection Types, and Iterators
      1. Introduction to Arrays
      2. Multidimensional Rectangular Arrays
      3. Multidimensional Jagged Arrays
      4. Collection Types (1/2)
      5. Collection Types (2/2)
      6. IEnumerable, IEnumerator, IEnumerable, and IEnumerator
      7. Iterators (1/2)
      8. Iterators (2/2)
      9. Collection Initializers
      10. Summary
    20. Chapter 10: Delegates, Anonymous Functions, and Events
      1. Overview of Delegates
      2. Delegate Creation and Use (1/2)
      3. Delegate Creation and Use (2/2)
      4. Events
      5. Anonymous Methods (1/2)
      6. Anonymous Methods (2/2)
      7. The Strategy Pattern
      8. Summary
    21. Chapter 11: Generics
      1. Difference Between Generics and C++ Templates
      2. Efficiency and Type Safety of Generics
      3. Generic Type Definitions and Constructed Types (1/3)
      4. Generic Type Definitions and Constructed Types (2/3)
      5. Generic Type Definitions and Constructed Types (3/3)
      6. Constraints
      7. Generic System Collections
      8. Generic System Interfaces
      9. Select Problems and Solutions (1/3)
      10. Select Problems and Solutions (2/3)
      11. Select Problems and Solutions (3/3)
      12. Summary
    22. Chapter 12: Threading in C#
      1. Threading in C# and .NET
      2. Synchronizing Work Between Threads (1/5)
      3. Synchronizing Work Between Threads (2/5)
      4. Synchronizing Work Between Threads (3/5)
      5. Synchronizing Work Between Threads (4/5)
      6. Synchronizing Work Between Threads (5/5)
      7. Using ThreadPool (1/2)
      8. Using ThreadPool (2/2)
      9. Summary
    23. Chapter 13: In Search of C# Canonical Forms
      1. Reference Type Canonical Forms
      2. Value Type Canonical Forms (1/2)
      3. Value Type Canonical Forms (2/2)
      4. Summary
    24. Chapter 14: Extension Methods
      1. Introduction to Extension Methods
      2. Recommendations for Use
      3. Transforms
      4. Operation Chaining
      5. Custom Iterators (1/2)
      6. Custom Iterators (2/2)
      7. The Visitor Pattern
      8. Summary
    25. Chapter 15: Lambda Expressions
      1. Introduction to Lambda Expressions
      2. Expression Trees
      3. Useful Applications of Lambda Expressions (1/3)
      4. Useful Applications of Lambda Expressions (2/3)
      5. Useful Applications of Lambda Expressions (3/3)
      6. Summary
    26. Chapter 16: linq_colon_language_integrated_query
      1. A Bridge to Data
      2. Standard Query Operators
      3. C# Query Keywords (1/3)
      4. C# Query Keywords (2/3)
      5. C# Query Keywords (3/3)
      6. The Virtues of Being Lazy
      7. Techniques from Functional Programming (1/2)
      8. Techniques from Functional Programming (2/2)
      9. Summary
    27. Appendix A: References
      1. Blogs
    28. Index (1/3)
    29. Index (2/3)
    30. Index (3/3)

Product information

  • Title: Accelerated C# 2008
  • Author(s): Weldon W. Nash
  • Release date: November 2007
  • Publisher(s): Apress
  • ISBN: 9781590598733