| help | account  


C# 3.0 Pocket Reference, 2nd Edition
View Larger Image
Ben Albahari, Joseph Albahari
O'Reilly Media, Paperback, 2nd edition, Published February 2008, 240 pages, ISBN 0596519222
List Price: $14.99
Our Price: $7.95
You Save: $7.04 (47% Off)


FREE Shipping on Orders over $40!*
Availability: In-Stock

Be the First to Write a Review and tell the world about this title!

People who purchase this book frequently purchase:

Books on similar topics, in best-seller order:Books from the same publisher, in best-seller order:

This book is for busy programmers who want a succinct and yet readable guide to C# 3.0 and LINQ. C# 3.0 Pocket Reference tells you exactly what you need to know, without long introductions or bloated samples.

Despite its conciseness, this book doesn't skimp on depth or detail, and embraces the conceptual challenges in learning C# 3.0 and LINQ. Tightly focused and highly practical, this pocket reference covers more ground than many of the big books on C#.

C# 3.0 Pocket Reference includes plenty of illustrations and code examples to explain:
  • Features new to C# 3.0, such as lambda expressions, anonymous types, automatic properties, and more
  • All aspects of C# syntax, predefined types, expressions, and operators
  • Creating classes, structs, delegates and events, enums, generics and constraints, exception handling, and iterators
  • The subtleties of boxing, operating overloading, delegate covariance, extension method resolution, interface reimplementation, nullable types, and operating lifting
  • LINQ, starting with the principles of sequences, deferred execution and standard query operators, and finishing with a complete reference to query syntax-including multiple generators, joining, grouping, and query continuations
  • Consuming, writing, and reflecting on custom attributes

You'll also find chapters on unsafe code and pointers, preprocessor directives, XML documentation, and a framework overview. If you're already familiar with Java, C++, or an earlier version of C#, C# 3.0 Pocket Reference is an ideal choice. No other book or online resource can get you up to speed so quickly.

 

Table of Contents

What's New in C# 3.0

A First C# Program

Compilation

Syntax

Identifiers and Keywords

Literals, Punctuators, and Operators

Comments

Type Basics

Predefined Type Examples

Custom Type Examples

Conversions

Value Types Versus Reference Types

Predefined Type Taxonomy

Numeric Types

Numeric Literals

Numeric Conversions

Arithmetic Operators

Increment and Decrement Operators

Specialized Integral Operations

8- and 16-Bit Integrals

Special Float and Double Values

double Versus decimal

Real Number Rounding Errors

Boolean Type and Operators

Equality and Comparison Operators

Conditional Operators

Strings and Characters

Char Conversions

String Type

Arrays

Default Element Initialization

Multidimensional Arrays

Simplified Array Initialization Expressions

Bounds Checking

Variables and Parameters

The Stack and the Heap

Definite Assignment

Default Values

Parameters

var: Implicitly Typed Local Variables (C# 3.0)

Expressions and Operators

Primary Expressions

Void Expressions

Assignment Expressions

Operator Precedence and Associativity

Operator Table

Statements

Declaration Statements

Expression Statements

Selection Statements

Iteration Statements

Jump Statements

Miscellaneous Statements

Namespaces

The using Directive

Rules Within a Namespace

Aliasing Types and Namespaces

Classes

Fields

Methods

Instance Constructors

Object Initializers (C# 3.0)

The this Reference

Properties

Indexers

Constants

Static Constructors

Static Classes

Finalizers

Partial Classes and Methods

Inheritance

Polymorphism

Casting

Virtual Function Members

Abstract Classes and Abstract Members

Hiding Inherited Members

Sealing Functions and Classes

The base Keyword

Constructors and Inheritance

Overloading and Resolution

The object Type

Boxing and Unboxing

Static and Dynamic Type Checking

Object Member Listing

GetType( ) and typeof

Equals, ReferenceEquals, and GetHashCode

The ToString Method

Structs

Struct Construction Semantics

Access Modifiers

Examples

Accessibility Capping

Restrictions on Access Modifiers

Interfaces

Extending an Interface

Explicit Interface Implementation

Implementing Interface Members Virtually

Reimplementing an Interface in a Subclass

Enums

Enum Conversions

Flags Enumerations

Enum Operators

Nested Types

Generics

Generic Types

Why Generics Exist

Generic Methods

Declaring Generic Parameters

typeof and Generics

The default Generic Value

Generic Constraints

Generics and Covariance

Subclassing Generic Types

Self-Referencing Generic Declarations

Static Data

Generic Collection Initialization

Delegates

Writing Plug-in Methods with Delegates

Multicast Delegates

Instance Versus Static Method Targets

Generic Delegate Types

Delegate Compatibility

Events

Standard Event Pattern

Event Accessors

Event Modifiers

Lambda Expressions (C# 3.0)

Explicitly Specifying Lambda Parameter Types

Generic Lambda Expressions and the Func Delegates

Outer Variables

Anonymous Methods

try Statements and Exceptions

The catch Clause

The finally Block

Throwing Exceptions

Key Properties of System.Exception

Common Exception Types

Enumeration and Iterators

Enumeration

Iterators

Iterator Semantics

Composing Sequences

Nullable Types

Null Basics

Lifted Operators

bool?

Null Coalescing Operator

Operator Overloading

Operator Functions

Overloading Equality and Comparison Operators

Custom Implicit and Explicit Conversions

Extension Methods (C# 3.0)

Extension Method Chaining

Ambiguity and Resolution

Anonymous Types (C# 3.0)

LINQ (C# 3.0)

LINQ Fundamentals

Deferred Execution

Standard Query Operators

Chaining Query Operators

Query Syntax

The let Keyword

Query Continuations

Multiple Generators

Joining

Ordering

Grouping

OfType and Cast

Attributes

Attribute Classes

Named and Positional Parameters

Attribute Targets

Specifying Multiple Attributes

Writing Custom Attributes

Retrieving Attributes at Runtime

Unsafe Code and Pointers

Pointer Basics

Unsafe Code

The fixed Statement

The Pointer-to-Member Operator

Arrays

void*

Pointers to Unmanaged Code

Preprocessor Directives

Conditional Attributes

Pragma Warning

XML Documentation

Standard XML Documentation Tags

Framework Overview

The Core Framework

User Interface Technologies

Backend Technologies

Distributed System Technologies

Index




Forgot your password?
FAQs
Shipping Options
Returns
Your Orders
Your Account