C# 4.0 The Complete Reference

Name: C# 4.0 The Complete Reference
Brand: McGraw-Hill
Price: 111.09 EUR
Availability: OnlineOnly

Herbert Schildt(Autor*in)

McGraw-Hill (Verlag)

1. Auflage

Erschienen am 27. April 2010

1013 Seiten

E-Book

ePUB mit Adobe-DRM

Systemvoraussetzungen

978-0-07-174117-0 (ISBN)

111,09 €inkl. 7% MwSt.

Systemvoraussetzungen

für ePUB mit Adobe-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

Cover Page
C# 4.0: The Complete Reference
Copyright Page
Contents
Special Thanks
Preface
Part I The C# Language
1 The Creation of C#
C#'s Family Tree
C: The Beginning of the Modern Age of Programming
The Creation of OOP and C++
The Internet and Java Emerge
The Creation of C#
The Evolution of C#
How C# Relates to the .NET Framework
What Is the .NET Framework?
How the Common Language Runtime Works
Managed vs. Unmanaged Code
The Common Language Specification
2 An Overview of C#
Object-Oriented Programming
Encapsulation
Polymorphism
Inheritance
A First Simple Program
Using csc.exe, the C# Command-Line Compiler
Using the Visual Studio IDE
The First Sample Program, Line by Line
Handling Syntax Errors
A Small Variation
A Second Simple Program
Another Data Type
Two Control Statements
The if Statement
The for Loop
Using Code Blocks
Semicolons, Positioning, and Indentation
The C# Keywords
Identifiers
The .NET Framework Class Library
3 Data Types, Literals, and Variables
Why Data Types Are Important
C#'s Value Types
Integers
Floating-Point Types
The decimal Type
Characters
The bool Type
Some Output Options
Literals
Hexadecimal Literals
Character Escape Sequences
String Literals
A Closer Look at Variables
Initializing a Variable
Dynamic Initialization
Implicitly Typed Variables
The Scope and Lifetime of Variables
Type Conversion and Casting
Automatic Conversions
Casting Incompatible Types
Type Conversion in Expressions
Using Casts in Expressions
4 Operators
Arithmetic Operators
Increment and Decrement
Relational and Logical Operators
Short-Circuit Logical Operators
The Assignment Operator
Compound Assignments
The Bitwise Operators
The Bitwise AND, OR, XOR, and NOT Operators
The Shift Operators
Bitwise Compound Assignments
The ? Operator
Spacing and Parentheses
Operator Precedence
5 Program Control Statements
The if Statement
Nested ifs
The if-else-if Ladder
The switch Statement
Nested switch Statements
The for Loop
Some Variations on the for Loop
The while Loop
The do-while Loop
The foreach Loop
Using break to Exit a Loop
Using continue
return
The goto
6 Introducing Classes and Objects
Class Fundamentals
The General Form of a Class
Define a Class
How Objects Are Created
Reference Variables and Assignment
Methods
Add a Method to the Building Class
Return from a Method
Return a Value
Use Parameters
Add a Parameterized Method to Building
Avoiding Unreachable Code
Constructors
Parameterized Constructors
Add a Constructor to the Building Class
The new Operator Revisited
Using new with Value Types
Garbage Collection and Destructors
Destructors
The this Keyword
7 Arrays and Strings
Arrays
One-Dimensional Arrays
Multidimensional Arrays
Two-Dimensional Arrays
Arrays of Three or More Dimensions
Initializing Multidimensional Arrays
Jagged Arrays
Assigning Array References
Using the Length Property
Using Length with Jagged Arrays
Implicitly Typed Arrays
The foreach Loop
Strings
Constructing Strings
Operating on Strings
Arrays of Strings
Strings Are Immutable
Strings Can Be Used in switch Statements
8 A Closer Look at Methods and Classes
Controlling Access to Class Members
C#'s Access Modifiers
Applying Public and Private Access
Controlling Access: A Case Study
Pass References to Methods
How Arguments Are Passed
Use ref and out Parameters
Use ref
Use out
Use ref and out on References
Use a Variable Number of Arguments
Return Objects
Return an Array
Method Overloading
Overload Constructors
Invoke an Overloaded Constructor Through this
Object Initializers
Optional Arguments
Optional Arguments vs. Overloading
Optional Arguments and Ambiguity
A Practical Example of Optional Arguments
Named Arguments
The Main( ) Method
Return Values from Main( )
Pass Arguments to Main( )
Recursion
Understanding static
Static Constructors
Static Classes
9 Operator Overloading
Operator Overloading Fundamentals
Overloading Binary Operators
Overloading Unary Operators
Handling Operations on C# Built-in Types
Overloading the Relational Operators
Overloading true and false
Overloading the Logical Operators
A Simple Approach to Overloading the Logical Operators
Enabling the Short-Circuit Operators
Conversion Operators
Operator Overloading Tips and Restrictions
Another Example of Operator Overloading
10 Indexers and Properties
Indexers
Creating One-Dimensional Indexers
Indexers Can Be Overloaded
Indexers Do Not Require an Underlying Array
Multidimensional Indexers
Properties
Auto-Implemented Properties
Use Object Initializers with Properties
Property Restrictions
Use Access Modifiers with Accessors
Using Indexers and Properties
11 Inheritance
Inheritance Basics
Member Access and Inheritance
Using Protected Access
Constructors and Inheritance
Calling Base Class Constructors
Inheritance and Name Hiding
Using base to Access a Hidden Name
Creating a Multilevel Hierarchy
When Are Constructors Called?
Base Class References and Derived Objects
Virtual Methods and Overriding
Why Overridden Methods?
Applying Virtual Methods
Using Abstract Classes
Using sealed to Prevent Inheritance
The object Class
Boxing and Unboxing
Is object a Universal Data Type?
12 Interfaces, Structures, and Enumerations
Interfaces
Implementing Interfaces
Using Interface References
Interface Properties
Interface Indexers
Interfaces Can Be Inherited
Name Hiding with Interface Inheritance
Explicit Implementations
Choosing Between an Interface and an Abstract Class
The .NET Standard Interfaces
Structures
Why Structures?
Enumerations
Initialize an Enumeration
Specify the Underlying Type of an Enumeration
Use Enumerations
13 Exception Handling
The System.Exception Class
Exception-Handling Fundamentals
Using try and catch
A Simple Exception Example
A Second Exception Example
The Consequences of an Uncaught Exception
Exceptions Let You Handle Errors Gracefully
Using Multiple catch Clauses
Catching All Exceptions
Nesting try Blocks
Throwing an Exception
Rethrowing an Exception
Using finally
A Closer Look at the Exception Class
Commonly Used Exceptions
Deriving Exception Classes
Catching Derived Class Exceptions
Using checked and unchecked
14 Using I/O
C#'s I/O Is Built Upon Streams
Byte Streams and Character Streams
The Predefined Streams
The Stream Classes
The Stream Class
The Byte Stream Classes
The Character Stream Wrapper Classes
Binary Streams
Console I/O
Reading Console Input
Using ReadKey( )
Writing Console Output
FileStream and Byte-Oriented File I/O
Opening and Closing a File
Reading Bytes from a FileStream
Writing to a File
Using FileStream to Copy a File
Character-Based File I/O
Using StreamWriter
Using a StreamReader
Redirecting the Standard Streams
Reading and Writing Binary Data
BinaryWriter
BinaryReader
Demonstrating Binary I/O
Random Access Files
Using MemoryStream
Using StringReader and StringWriter
The File Class
Using Copy( ) to Copy a File
Using Exists( ) and GetLastAccessTime( )
Converting Numeric Strings to Their Internal Representation
15 Delegates, Events, and Lambda Expressions
Delegates
Delegate Method Group Conversion
Using Instance Methods as Delegates
Multicasting
Covariance and Contravariance
System.Delegate
Why Delegates
Anonymous Functions
Anonymous Methods
Pass Arguments to an Anonymous Method
Return a Value from an Anonymous Method
Use Outer Variables with Anonymous Methods
Lambda Expressions
The Lambda Operator
Expression Lambdas
Statement Lambdas
Events
A Multicast Event Example
Instance Methods vs. Static Methods as Event Handlers
Using Event Accessors
Miscellaneous Event Features
Use Anonymous Methods and Lambda Expressions with Events
.NET Event Guidelines
Use EventHandler&TEventArgs& and EventHandler
Applying Events: A Case Study
16 Namespaces, the Preprocessor, and Assemblies
Namespaces
Declaring a Namespace
Namespaces Prevent Name Conflicts
using
A Second Form of using
Namespaces Are Additive
Namespaces Can Be Nested
The Global Namespace
Using the :: Namespace Alias Qualifier
The Preprocessor
#define
#if and #endif
#else and #elif
#undef
#error
#warning
#line
#region and #endregion
#pragma
Assemblies and the internal Access Modifier
The internal Access Modifier
17 Runtime Type ID, Reflection, and Attributes
Runtime Type Identification
Testing a Type with is
Using as
Using typeof
Reflection
The Reflection Core: System.Type
Using Reflection
Obtaining Information About Methods
Calling Methods Using Reflection
Obtaining a Type's Constructors
Obtaining Types from Assemblies
Fully Automating Type Discovery
Attributes
Attribute Basics
Positional vs. Named Parameters
Three Built-in Attributes
AttributeUsage
The Conditional Attribute
The Obsolete Attribute
18 Generics
What Are Generics?
A Simple Generics Example
Generic Types Differ Based on Their Type Arguments
How Generics Improve Type Safety
A Generic Class with Two Type Parameters
The General Form of a Generic Class
Constrained Types
Using a Base Class Constraint
Using an Interface Constraint
Using the new( ) Constructor Constraint
The Reference Type and Value Type Constraints
Using a Constraint to Establish a Relationship Between Two Type Parameters
Using Multiple Constraints
Creating a Default Value of a Type Parameter
Generic Structures
Creating a Generic Method
Using Explicit Type Arguments to Call a Generic Method
Using a Constraint with a Generic Method
Generic Delegates
Generic Interfaces
Comparing Instances of a Type Parameter
Generic Class Hierarchies
Using a Generic Base Class
A Generic Derived Class
Overriding Virtual Methods in a Generic Class
Overloading Methods That Use Type Parameters
Covariance and Contravariance in Generic Type Parameters
Using Covariance in a Generic Interface
Using Contravariance in a Generic Interface
Variant Delegates
How Generic Types Are Instantiated
Some Generic Restrictions
Final Thoughts on Generics
19 LINQ
LINQ Fundamentals
A Simple Query
A Query Can Be Executed More Than Once
How the Data Types in a Query Relate
The General Form of a Query
Filter Values with where
Sort Results with orderby
A Closer Look at select
Use Nested from Clauses
Group Results with group
Use into to Create a Continuation
Use let to Create a Variable in a Query
Join Two Sequences with join
Anonymous Types
Create a Group Join
The Query Methods
The Basic Query Methods
Create Queries by Using the Query Methods
Query Syntax vs. Query Methods
More Query-Related Extension Methods
Deferred vs. Immediate Query Execution
Expression Trees
Extension Methods
PLINQ
20 Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
Unsafe Code
Pointer Basics
Using unsafe
Using fixed
Accessing Structure Members Through a Pointer
Pointer Arithmetic
Pointer Comparisons
Pointers and Arrays
Pointers and Strings
Multiple Indirection
Arrays of Pointers
stackalloc
Creating Fixed-Size Buffers
Nullable Types
Nullable Basics
Nullable Objects in Expressions
The ?? Operator
Nullable Objects and the Relational and Logical Operators
Partial Types
Partial Methods
Create a Dynamic Type with dynamic
COM Interoperability
Friend Assemblies
Miscellaneous Keywords
lock
readonly
const and volatile
The using Statement
extern
Part II Exploring the C# Library
21 Exploring the System Namespace
The Members of System
The Math Class
The .NET Structures Corresponding to the Built-in Value Types
The Integer Structures
The Floating-Point Structures
Decimal
Char
The Boolean Structure
The Array Class
Sorting and Searching Arrays
Reversing an Array
Copying an Array
Using a Predicate
Using an Action
BitConverter
Generating Random Numbers with Random
Memory Management and the GC Class
Object
Tuple
The IComparable and IComparable&T& Interfaces
The IEquatable&T& Interface
The IConvertible Interface
The ICloneable Interface
IFormatProvider and IFormattable
IObservable&T& and IObserver&T&
22 Strings and Formatting
Strings in C#
The String Class
The String Constructors
The String Field, Indexer, and Property
The String Operators
The String Methods
Padding and Trimming Strings
Inserting, Removing, and Replacing
Changing Case
Using the Substring( ) Method
The String Extension Methods
Formatting
Formatting Overview
The Numeric Format Specifiers
Understanding Argument Numbers
Using String.Format( ) and ToString( ) to Format Data
Using String.Format( ) to Format Values
Using ToString( ) to Format Data
Creating a Custom Numeric Format
The Custom Format Placeholder Characters
Formatting Date and Time
Creating a Custom Date and Time Format
Formatting Time Spans
Formatting Enumerations
23 Multithreaded Programming, Part One
Multithreading Fundamentals
The Thread Class
Creating and Starting a Thread
Some Simple Improvements
Creating Multiple Threads
Determining When a Thread Ends
Passing an Argument to a Thread
The IsBackground Property
Thread Priorities
Synchronization
An Alternative Approach
The Monitor Class and lock
Thread Communication Using Wait( ), Pulse( ), and PulseAll( )
An Example That Uses Wait( ) and Pulse( )
Deadlock and Race Conditions
Using MethodImplAttribute
Using a Mutex and a Semaphore
The Mutex
The Semaphore
Using Events
The Interlocked Class
Synchronization Classes Added by .NET 4.0
Terminating a Thread Via Abort( )
An Abort( ) Alternative
Canceling Abort( )
Suspending and Resuming a Thread
Determining a Thread's State
Using the Main Thread
Additional Multithreading Features Added by .NET 4.0
Multithreading Tips
Starting a Separate Task
24 Multithreading, Part Two: Exploring the Task Parallel Library and PLINQ
Two Approaches to Parallel Programming
The Task Class
Creating a Task
Use a Task ID
Using Wait Methods
Calling Dispose( )
Using TaskFactory to Start a Task
Use a Lambda Expression as a Task
Create a Task Continuation
Returning a Value from a Task
Cancelling a Task and Using AggregateException
Some Other Task Features
The Parallel Class
Parallelizing Tasks via Invoke( )
Using the For( ) Method
Using the ForEach( ) Method
Exploring PLINQ
ParallelEnumerable
Parallelizing a Query with AsParallel( )
Using AsOrdered( )
Cancelling a Parallel Query
Other PLINQ Features
PLINQ Efficiency Concerns
25 Collections, Enumerators, and Iterators
Collections Overview
The Non-Generic Collections
The Non-Generic Interfaces
The DictionaryEntry Structure
The Non-Generic Collection Classes
Storing Bits with BitArray
The Specialized Collections
The Generic Collections
The Generic Interfaces
The KeyValuePair&TKey, TValue& Structure
The Generic Collection Classes
The Concurrent Collections
Storing User-Defined Classes in Collections
Implementing IComparable
Implementing IComparable for Non-Generic Collections
Implementing IComparable&T& for Generic Collections
Using an IComparer
Using a Non-Generic IComparer
Using a Generic IComparer&T&
Using StringComparer
Accessing a Collection via an Enumerator
Using an Enumerator
Using IDictionaryEnumerator
Implementing IEnumerable and IEnumerator
Using Iterators
Stopping an Iterator
Using Multiple yield Directives
Creating a Named Iterator
Creating a Generic Iterator
Collection Initializers
26 Networking Through the Internet Using System.Net
The System.Net Members
Uniform Resource Identifiers
Internet Access Fundamentals
WebRequest
WebResponse
HttpWebRequest and HttpWebResponse
A Simple First Example
Handling Network Errors
Exceptions Generated by Create( )
Exceptions Generated by GetReponse( )
Exceptions Generated by GetResponseStream( )
Using Exception Handling
The URI Class
Accessing Additional HTTP Response Information
Accessing the Header
Accessing Cookies
Using the LastModified Property
MiniCrawler: A Case Study
Using WebClient
A Documentation Comment Quick Reference
The XML Comment Tags
Compiling Documentation Comments
An XML Documentation Example
Index

Systemvoraussetzungen

Als PDF speichern Als Link merken