Buying Options
C# 3.0 in a Nutshell, Third Edition
Print $49.99
Add to Cart
Print+Ebook $54.99
Add to Cart
Ebook $39.99
(Mobi, PDF, ePub)
Add to Cart
Safari Books Online
Add to Cart
What is this?
Print £38.50
Add to Cart
What is this?

C# 3.0 in a Nutshell, Third Edition

A Desktop Quick Reference

By
Joseph Albahari, Ben Albahari
Publisher:
O'Reilly Media
Released:
September 2007
Pages:
864

Product Editions

Please consider the latest edition.

  1. C# 4.0 in a Nutshell: Rough Cuts Version, Fourth Edition - November 2009
  2. C# 3.0 in a Nutshell, Third Edition - September 2007
  3. C# in a Nutshell, Second Edition - August 2003
  4. C# in a Nutshell - March 2002
Description
A concise yet thorough reference to C# 3.0 programming as implemented in Microsoft's Visual Studio 2008, C# 3.0 in a Nutshell gets right to the point, covering the essentials of language syntax and usage as well as the parts of the .NET base class libraries you need to build working applications. But unlike earlier editions, this book is now organized entirely around concepts and use cases, providing greater depth and readability. Please see the extra chapters available to download COM Integration.
Full Description
Table of Contents

  1. Chapter 1 Introducing C# and the .NET Framework

    1. Object Orientation

    2. Type Safety

    3. Memory Management

    4. Platform Support

    5. C#'s Relationship with the CLR

    6. The CLR and .NET Framework

    7. What's New in C# 3.0

  2. Chapter 2 C# Language Basics

    1. A First C# Program

    2. Syntax

    3. Type Basics

    4. Numeric Types

    5. Boolean Type and Operators

    6. Strings and Characters

    7. Arrays

    8. Variables and Parameters

    9. Expressions and Operators

    10. Statements

    11. Namespaces

  3. Chapter 3 Creating Types in C#

    1. Classes

    2. Inheritance

    3. The object Type

    4. Structs

    5. Access Modifiers

    6. Interfaces

    7. Enums

    8. Nested Types

    9. Generics

  4. Chapter 4 Advanced C#

    1. Delegates

    2. Events

    3. Lambda Expressions (C# 3.0)

    4. Anonymous Methods

    5. try Statements and Exceptions

    6. Enumeration and Iterators

    7. Nullable Types

    8. Operator Overloading

    9. Extension Methods (C# 3.0)

    10. Anonymous Types (C# 3.0)

    11. Attributes

    12. Unsafe Code and Pointers

    13. Preprocessor Directives

    14. XML Documentation

  5. Chapter 5 Framework Overview

    1. The CLR and Core Framework

    2. Applied Technologies

  6. Chapter 6 Framework Fundamentals

    1. String and Text Handling

    2. Dates and Times

    3. Dates and Time Zones

    4. Formatting and Parsing

    5. Standard Format Strings and Parsing Flags

    6. Other Conversion Mechanisms

    7. Working with Numbers

    8. Enums

    9. The Guid Struct

    10. Equality Comparison

    11. Order Comparison

    12. Utility Classes

  7. Chapter 7 Collections

    1. Enumeration

    2. The ICollection and IList Interfaces

    3. The Array Class

    4. Lists, Queues, Stacks, and Sets

    5. Dictionaries

    6. Customizable Collections and Proxies

    7. Plugging in Equality and Order

  8. Chapter 8 LINQ Queries

    1. Getting Started

    2. Lambda Queries

    3. Comprehension Queries

    4. Deferred Execution

    5. Subqueries

    6. Composition Strategies

    7. Projection Strategies

    8. Interpreted Queries

    9. LINQ to SQL

    10. Building Query Expressions

  9. Chapter 9 LINQ Operators

    1. Overview

    2. Filtering

    3. Projecting

    4. Joining

    5. Ordering

    6. Grouping

    7. Set Operators

    8. Conversion Methods

    9. Element Operators

    10. Aggregation Methods

    11. Quantifiers

    12. Generation Methods

  10. Chapter 10 LINQ to XML

    1. Architectural Overview

    2. X-DOM Overview

    3. Instantiating an X-DOM

    4. Navigating and Querying

    5. Updating an X-DOM

    6. Working with Values

    7. Documents and Declarations

    8. Names and Namespaces

    9. Annotations

    10. Projecting into an X-DOM

  11. Chapter 11 Other XML Technologies

    1. XmlReader

    2. XmlWriter

    3. Patterns for Using XmlReader/XmlWriter

    4. XmlDocument

    5. XPath

    6. XSD and Schema Validation

    7. XSLT

  12. Chapter 12 Disposal and Garbage Collection

    1. IDisposable, Dispose, and Close

    2. Garbage Collection and Finalizers

    3. Calling Dispose from a Finalizer

    4. How the Garbage Collector Works

    5. Alternatives to Garbage Collection

  13. Chapter 13 Streams and I/O

    1. Stream Architecture

    2. Using Streams

    3. Stream Adapters

    4. File and Directory Operations

    5. Compression

    6. Isolated Storage

  14. Chapter 14 Networking

    1. Network Architecture

    2. Addresses and Ports

    3. URIs

    4. Request/Response Architecture

    5. HTTP-Specific Support

    6. Writing an HTTP Server

    7. Using FTP

    8. Using DNS

    9. Sending Mail with SmtpClient

    10. Using TCP

    11. Receiving POP3 Mail with TCP

  15. Chapter 15 Serialization

    1. Serialization Concepts

    2. The Data Contract Serializer

    3. Data Contracts and Collections

    4. Extending Data Contracts

    5. The Binary Serializer

    6. Binary Serialization Attributes

    7. Binary Serialization with ISerializable

    8. XML Serialization

  16. Chapter 16 Assemblies

    1. What's in an Assembly

    2. Signing an Assembly

    3. Assembly Names

    4. The Global Assembly Cache

    5. Resources and Satellite Assemblies

    6. Resolving and Loading Assemblies

    7. Deploying Assemblies Outside the Base Folder

    8. Packing a Single-File Executable

    9. Working with Unreferenced Assemblies

  17. Chapter 17 Reflection and Metadata

    1. Reflecting and Activating Types

    2. Reflecting and Invoking Members

    3. Reflecting Assemblies

    4. Working with Attributes

    5. Dynamic Code Generation

    6. Emitting Assemblies and Types

    7. Emitting Type Members

    8. Emitting Generic Methods and Types

    9. Awkward Emission Targets

    10. Parsing IL

  18. Chapter 18 Security

    1. Permissions

    2. Code Access Security

    3. Running in a Sandbox

    4. Sandboxing Another Assembly

    5. Operating System Security

    6. Identity and Role Security

    7. Cryptography Overview

    8. Windows Data Protection

    9. Hashing

    10. Symmetric Encryption

    11. Public Key Encryption and Signing

  19. Chapter 19 Threading

    1. Threading's Uses and Misuses

    2. Getting Started

    3. Asynchronous Delegates

    4. Synchronization

    5. Locking

    6. Thread Safety

    7. Nonblocking Synchronization

    8. Signaling with Event Wait Handles

    9. Signaling with Wait and Pulse

    10. Interrupt and Abort

    11. Local Storage

    12. BackgroundWorker

    13. ReaderWriterLockSlim

    14. Timers

  20. Chapter 20 Asynchronous Methods

    1. Why Asynchronous Methods Exist

    2. Asynchronous Method Signatures

    3. Asynchronous Methods Versus Asynchronous Delegates

    4. Using Asynchronous Methods

    5. Writing Asynchronous Methods

    6. Fake Asynchronous Methods

    7. Alternatives to Asynchronous Methods

    8. Asynchronous Events

  21. Chapter 21 Application Domains

    1. Application Domain Architecture

    2. Creating and Destroying Application Domains

    3. Using Multiple Application Domains

    4. Using DoCallBack

    5. Domains and Threads

    6. Sharing Data Between Domains

  22. Chapter 22 Integrating with Native DLLs

    1. Calling into DLLs

    2. Marshaling Common Types

    3. Marshaling Classes and Structs

    4. In and Out Marshaling

    5. Callbacks from Unmanaged Code

    6. Simulating a C Union

    7. Shared Memory

    8. Mapping a Struct to Unmanaged Memory

    9. Interop Attribute Reference

  23. Chapter 23 Diagnostics

    1. Conditional Compilation

    2. Debug and Trace Classes

    3. Debugger Integration

    4. Processes and Process Threads

    5. StackTrace and StackFrame

    6. Windows Event Logs

    7. Performance Counters

    8. The Stopwatch Class

  24. Chapter 24 Regular Expressions

    1. Regular Expression Basics

    2. Quantifiers

    3. Zero-Width Assertions

    4. Groups

    5. Replacing and Splitting Text

    6. Cookbook Regular Expressions

    7. Regular Expressions Language Reference

  1. Appendix A C# Keywords

  2. Appendix B Namespace-to-Assembly Reference

  3. Colophon

View Full Table of Contents
Check out Related Content
Product Details
Title:
C# 3.0 in a Nutshell, Third Edition
By:
Joseph Albahari, Ben Albahari
Publisher:
O'Reilly Media
Formats:
  • Print
  • Ebook
  • Safari Books Online
Print Release:
September 2007
Ebook Release:
February 2009
Pages:
864
Print ISBN:
978-0-596-52757-0
| ISBN 10:
0-596-52757-8
Ebook ISBN:
978-0-596-10264-7
| ISBN 10:
0-596-10264-X
Customer Reviews
About the Authors

  1. Joseph Albahari

    Joe Albahari is the developer of LINQPad (http://www.linqpad.net/) and other C# tools, and he writes about C# at www.albahari.com/nutshell/. He is the former core C# design architect at Egton Services and coauthor of the fourth edition of C# in a Nutshell. He has been developing large-scale enterprise applications for more than 17 years.

    View Joseph Albahari's full profile page.

  2. Ben Albahari

    Ben Albahari is a former Program Manager at Microsoft, where he worked on several projects, including the .NET Compact Framework and ADO.NET. He was the cofounder of Genamics, a provider of tools for C# and J++ programmers, as well as software for DNA and protein sequence analysis. He is a coauthor of C# Essentials, the first C# book from O'Reilly, and of previous editions of C# in a Nutshell. He is the founder of TakeOnIt, a website for comparing opinions of experts, leaders and organizations

    View Ben Albahari's full profile page.

  • Book cover of C# 3.0 in a Nutshell
Got a Question?
icons
Favicon Service and support by Satisfaction