book

C# 4.0 The Complete Reference

Name: C# 4.0 The Complete Reference
Author: Herbert Schildt
ISBN: 9780071741170

by Herbert Schildt

April 2010

Intermediate to advanced

976 pages

23h 2m

English

McGraw-Hill

Read now

Unlock full access

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 TreeC: The Beginning of the Modern Age of ProgrammingThe Creation of OOP and C++The Internet and Java EmergeThe Creation of C#The Evolution of C#How C# Relates to the .NET FrameworkWhat Is the .NET Framework?How the Common Language Runtime WorksManaged vs. Unmanaged CodeThe Common Language Specification
2 An Overview of C#
Object-Oriented ProgrammingEncapsulationPolymorphismInheritanceA First Simple ProgramUsing csc.exe, the C# Command-Line CompilerUsing the Visual Studio IDEThe First Sample Program, Line by LineHandling Syntax ErrorsA Small VariationA Second Simple ProgramAnother Data TypeTwo Control StatementsThe if StatementThe for LoopUsing Code BlocksSemicolons, Positioning, and IndentationThe C# KeywordsIdentifiersThe .NET Framework Class Library
3 Data Types, Literals, and Variables
Why Data Types Are ImportantC#’s Value TypesIntegersFloating-Point TypesThe decimal TypeCharactersThe bool TypeSome Output OptionsLiteralsHexadecimal LiteralsCharacter Escape SequencesString LiteralsA Closer Look at VariablesInitializing a VariableDynamic InitializationImplicitly Typed VariablesThe Scope and Lifetime of VariablesType Conversion and CastingAutomatic ConversionsCasting Incompatible TypesType Conversion in ExpressionsUsing Casts in Expressions

4 Operators
Arithmetic OperatorsIncrement and DecrementRelational and Logical OperatorsShort-Circuit Logical OperatorsThe Assignment OperatorCompound AssignmentsThe Bitwise OperatorsThe Bitwise AND, OR, XOR, and NOT OperatorsThe Shift OperatorsBitwise Compound AssignmentsThe ? OperatorSpacing and ParenthesesOperator Precedence
5 Program Control Statements
The if StatementNested ifsThe if-else-if LadderThe switch StatementNested switch StatementsThe for LoopSome Variations on the for LoopThe while LoopThe do-while LoopThe foreach LoopUsing break to Exit a LoopUsing continuereturnThe goto
6 Introducing Classes and Objects
Class FundamentalsThe General Form of a ClassDefine a ClassHow Objects Are CreatedReference Variables and AssignmentMethodsAdd a Method to the Building ClassReturn from a MethodReturn a ValueUse ParametersAdd a Parameterized Method to BuildingAvoiding Unreachable CodeConstructorsParameterized ConstructorsAdd a Constructor to the Building ClassThe new Operator RevisitedUsing new with Value TypesGarbage Collection and DestructorsDestructorsThe this Keyword
7 Arrays and Strings
ArraysOne-Dimensional ArraysMultidimensional ArraysTwo-Dimensional ArraysArrays of Three or More DimensionsInitializing Multidimensional ArraysJagged ArraysAssigning Array ReferencesUsing the Length PropertyUsing Length with Jagged ArraysImplicitly Typed ArraysThe foreach LoopStringsConstructing StringsOperating on StringsArrays of StringsStrings Are ImmutableStrings Can Be Used in switch Statements
8 A Closer Look at Methods and Classes
Controlling Access to Class MembersC#’s Access ModifiersApplying Public and Private AccessControlling Access: A Case StudyPass References to MethodsHow Arguments Are PassedUse ref and out ParametersUse refUse outUse ref and out on ReferencesUse a Variable Number of ArgumentsReturn ObjectsReturn an ArrayMethod OverloadingOverload ConstructorsInvoke an Overloaded Constructor Through thisObject InitializersOptional ArgumentsOptional Arguments vs. OverloadingOptional Arguments and AmbiguityA Practical Example of Optional ArgumentsNamed ArgumentsThe Main( ) MethodReturn Values from Main( )Pass Arguments to Main( )RecursionUnderstanding staticStatic ConstructorsStatic Classes
9 Operator Overloading
Operator Overloading FundamentalsOverloading Binary OperatorsOverloading Unary OperatorsHandling Operations on C# Built-in TypesOverloading the Relational OperatorsOverloading true and falseOverloading the Logical OperatorsA Simple Approach to Overloading the Logical OperatorsEnabling the Short-Circuit OperatorsConversion OperatorsOperator Overloading Tips and RestrictionsAnother Example of Operator Overloading
10 Indexers and Properties
IndexersCreating One-Dimensional IndexersIndexers Can Be OverloadedIndexers Do Not Require an Underlying ArrayMultidimensional IndexersPropertiesAuto-Implemented PropertiesUse Object Initializers with PropertiesProperty RestrictionsUse Access Modifiers with AccessorsUsing Indexers and Properties
11 Inheritance
Inheritance BasicsMember Access and InheritanceUsing Protected AccessConstructors and InheritanceCalling Base Class ConstructorsInheritance and Name HidingUsing base to Access a Hidden NameCreating a Multilevel HierarchyWhen Are Constructors Called?Base Class References and Derived ObjectsVirtual Methods and OverridingWhy Overridden Methods?Applying Virtual MethodsUsing Abstract ClassesUsing sealed to Prevent InheritanceThe object ClassBoxing and UnboxingIs object a Universal Data Type?
12 Interfaces, Structures, and Enumerations
InterfacesImplementing InterfacesUsing Interface ReferencesInterface PropertiesInterface IndexersInterfaces Can Be InheritedName Hiding with Interface InheritanceExplicit ImplementationsChoosing Between an Interface and an Abstract ClassThe .NET Standard InterfacesStructuresWhy Structures?EnumerationsInitialize an EnumerationSpecify the Underlying Type of an EnumerationUse Enumerations
13 Exception Handling
The System.Exception ClassException-Handling FundamentalsUsing try and catchA Simple Exception ExampleA Second Exception ExampleThe Consequences of an Uncaught ExceptionExceptions Let You Handle Errors GracefullyUsing Multiple catch ClausesCatching All ExceptionsNesting try BlocksThrowing an ExceptionRethrowing an ExceptionUsing finallyA Closer Look at the Exception ClassCommonly Used ExceptionsDeriving Exception ClassesCatching Derived Class ExceptionsUsing checked and unchecked
14 Using I/O
C#’s I/O Is Built Upon StreamsByte Streams and Character StreamsThe Predefined StreamsThe Stream ClassesThe Stream ClassThe Byte Stream ClassesThe Character Stream Wrapper ClassesBinary StreamsConsole I/OReading Console InputUsing ReadKey( )Writing Console OutputFileStream and Byte-Oriented File I/OOpening and Closing a FileReading Bytes from a FileStreamWriting to a FileUsing FileStream to Copy a FileCharacter-Based File I/OUsing StreamWriterUsing a StreamReaderRedirecting the Standard StreamsReading and Writing Binary DataBinaryWriterBinaryReaderDemonstrating Binary I/ORandom Access FilesUsing MemoryStreamUsing StringReader and StringWriterThe File ClassUsing Copy( ) to Copy a FileUsing Exists( ) and GetLastAccessTime( )Converting Numeric Strings to Their Internal Representation
15 Delegates, Events, and Lambda Expressions
DelegatesDelegate Method Group ConversionUsing Instance Methods as DelegatesMulticastingCovariance and ContravarianceSystem.DelegateWhy DelegatesAnonymous FunctionsAnonymous MethodsPass Arguments to an Anonymous MethodReturn a Value from an Anonymous MethodUse Outer Variables with Anonymous MethodsLambda ExpressionsThe Lambda OperatorExpression LambdasStatement LambdasEventsA Multicast Event ExampleInstance Methods vs. Static Methods as Event HandlersUsing Event AccessorsMiscellaneous Event FeaturesUse Anonymous Methods and Lambda Expressions with Events.NET Event GuidelinesUse EventHandler<TEventArgs> and EventHandlerApplying Events: A Case Study
16 Namespaces, the Preprocessor, and Assemblies
NamespacesDeclaring a NamespaceNamespaces Prevent Name ConflictsusingA Second Form of usingNamespaces Are AdditiveNamespaces Can Be NestedThe Global NamespaceUsing the :: Namespace Alias QualifierThe Preprocessor#define#if and #endif#else and #elif#undef#error#warning#line#region and #endregion#pragmaAssemblies and the internal Access ModifierThe internal Access Modifier
17 Runtime Type ID, Reflection, and Attributes
Runtime Type IdentificationTesting a Type with isUsing asUsing typeofReflectionThe Reflection Core: System.TypeUsing ReflectionObtaining Information About MethodsCalling Methods Using ReflectionObtaining a Type’s ConstructorsObtaining Types from AssembliesFully Automating Type DiscoveryAttributesAttribute BasicsPositional vs. Named ParametersThree Built-in AttributesAttributeUsageThe Conditional AttributeThe Obsolete Attribute
18 Generics
What Are Generics?A Simple Generics ExampleGeneric Types Differ Based on Their Type ArgumentsHow Generics Improve Type SafetyA Generic Class with Two Type ParametersThe General Form of a Generic ClassConstrained TypesUsing a Base Class ConstraintUsing an Interface ConstraintUsing the new( ) Constructor ConstraintThe Reference Type and Value Type ConstraintsUsing a Constraint to Establish a Relationship Between Two Type ParametersUsing Multiple ConstraintsCreating a Default Value of a Type ParameterGeneric StructuresCreating a Generic MethodUsing Explicit Type Arguments to Call a Generic MethodUsing a Constraint with a Generic MethodGeneric DelegatesGeneric InterfacesComparing Instances of a Type ParameterGeneric Class HierarchiesUsing a Generic Base ClassA Generic Derived ClassOverriding Virtual Methods in a Generic ClassOverloading Methods That Use Type ParametersCovariance and Contravariance in Generic Type ParametersUsing Covariance in a Generic InterfaceUsing Contravariance in a Generic InterfaceVariant DelegatesHow Generic Types Are InstantiatedSome Generic RestrictionsFinal Thoughts on Generics
19 LINQ
LINQ FundamentalsA Simple QueryA Query Can Be Executed More Than OnceHow the Data Types in a Query RelateThe General Form of a QueryFilter Values with whereSort Results with orderbyA Closer Look at selectUse Nested from ClausesGroup Results with groupUse into to Create a ContinuationUse let to Create a Variable in a QueryJoin Two Sequences with joinAnonymous TypesCreate a Group JoinThe Query MethodsThe Basic Query MethodsCreate Queries by Using the Query MethodsQuery Syntax vs. Query MethodsMore Query-Related Extension MethodsDeferred vs. Immediate Query ExecutionExpression TreesExtension MethodsPLINQ
20 Unsafe Code, Pointers, Nullable Types, Dynamic Types, and Miscellaneous Topics
Unsafe CodePointer BasicsUsing unsafeUsing fixedAccessing Structure Members Through a PointerPointer ArithmeticPointer ComparisonsPointers and ArraysPointers and StringsMultiple IndirectionArrays of PointersstackallocCreating Fixed-Size BuffersNullable TypesNullable BasicsNullable Objects in ExpressionsThe ?? OperatorNullable Objects and the Relational and Logical OperatorsPartial TypesPartial MethodsCreate a Dynamic Type with dynamicCOM InteroperabilityFriend AssembliesMiscellaneous Keywordslockreadonlyconst and volatileThe using Statementextern
Part II Exploring the C# Library
21 Exploring the System Namespace
The Members of SystemThe Math ClassThe .NET Structures Corresponding to the Built-in Value TypesThe Integer StructuresThe Floating-Point StructuresDecimalCharThe Boolean StructureThe Array ClassSorting and Searching ArraysReversing an ArrayCopying an ArrayUsing a PredicateUsing an ActionBitConverterGenerating Random Numbers with RandomMemory Management and the GC ClassObjectTupleThe IComparable and IComparable<T> InterfacesThe IEquatable<T> InterfaceThe IConvertible InterfaceThe ICloneable InterfaceIFormatProvider and IFormattableIObservable<T> and IObserver<T>
22 Strings and Formatting
Strings in C#The String ClassThe String ConstructorsThe String Field, Indexer, and PropertyThe String OperatorsThe String MethodsPadding and Trimming StringsInserting, Removing, and ReplacingChanging CaseUsing the Substring( ) MethodThe String Extension MethodsFormattingFormatting OverviewThe Numeric Format SpecifiersUnderstanding Argument NumbersUsing String.Format( ) and ToString( ) to Format DataUsing String.Format( ) to Format ValuesUsing ToString( ) to Format DataCreating a Custom Numeric FormatThe Custom Format Placeholder CharactersFormatting Date and TimeCreating a Custom Date and Time FormatFormatting Time SpansFormatting Enumerations
23 Multithreaded Programming, Part One
Multithreading FundamentalsThe Thread ClassCreating and Starting a ThreadSome Simple ImprovementsCreating Multiple ThreadsDetermining When a Thread EndsPassing an Argument to a ThreadThe IsBackground PropertyThread PrioritiesSynchronizationAn Alternative ApproachThe Monitor Class and lockThread Communication Using Wait( ), Pulse( ), and PulseAll( )An Example That Uses Wait( ) and Pulse( )Deadlock and Race ConditionsUsing MethodImplAttributeUsing a Mutex and a SemaphoreThe MutexThe SemaphoreUsing EventsThe Interlocked ClassSynchronization Classes Added by .NET 4.0Terminating a Thread Via Abort( )An Abort( ) AlternativeCanceling Abort( )Suspending and Resuming a ThreadDetermining a Thread’s StateUsing the Main ThreadAdditional Multithreading Features Added by .NET 4.0Multithreading TipsStarting a Separate Task
24 Multithreading, Part Two: Exploring the Task Parallel Library and PLINQ
Two Approaches to Parallel ProgrammingThe Task ClassCreating a TaskUse a Task IDUsing Wait MethodsCalling Dispose( )Using TaskFactory to Start a TaskUse a Lambda Expression as a TaskCreate a Task ContinuationReturning a Value from a TaskCancelling a Task and Using AggregateExceptionSome Other Task FeaturesThe Parallel ClassParallelizing Tasks via Invoke( )Using the For( ) MethodUsing the ForEach( ) MethodExploring PLINQParallelEnumerableParallelizing a Query with AsParallel( )Using AsOrdered( )Cancelling a Parallel QueryOther PLINQ FeaturesPLINQ Efficiency Concerns
25 Collections, Enumerators, and Iterators
Collections OverviewThe Non-Generic CollectionsThe Non-Generic InterfacesThe DictionaryEntry StructureThe Non-Generic Collection ClassesStoring Bits with BitArrayThe Specialized CollectionsThe Generic CollectionsThe Generic InterfacesThe KeyValuePair<TKey, TValue> StructureThe Generic Collection ClassesThe Concurrent CollectionsStoring User-Defined Classes in CollectionsImplementing IComparableImplementing IComparable for Non-Generic CollectionsImplementing IComparable<T> for Generic CollectionsUsing an IComparerUsing a Non-Generic IComparerUsing a Generic IComparer<T>Using StringComparerAccessing a Collection via an EnumeratorUsing an EnumeratorUsing IDictionaryEnumeratorImplementing IEnumerable and IEnumeratorUsing IteratorsStopping an IteratorUsing Multiple yield DirectivesCreating a Named IteratorCreating a Generic IteratorCollection Initializers
26 Networking Through the Internet Using System.Net
The System.Net MembersUniform Resource IdentifiersInternet Access FundamentalsWebRequestWebResponseHttpWebRequest and HttpWebResponseA Simple First ExampleHandling Network ErrorsExceptions Generated by Create( )Exceptions Generated by GetReponse( )Exceptions Generated by GetResponseStream( )Using Exception HandlingThe URI ClassAccessing Additional HTTP Response InformationAccessing the HeaderAccessing CookiesUsing the LastModified PropertyMiniCrawler: A Case StudyUsing WebClient
A Documentation Comment Quick Reference
The XML Comment TagsCompiling Documentation CommentsAn XML Documentation Example
Index

Content preview from C# 4.0 The Complete Reference

CHAPTER 9Operator Overloading

C# allows you to define the meaning of an operator relative to a class that you create. This process is called operator overloading. By overloading an operator, you expand its usage to your class. The effects of the operator are completely under your control and may differ from class to class. For example, a class that defines a linked list might use the + operator to add an object to the list. A class that implements a stack might use the + to push an object onto the stack. Another class might use the + operator in an entirely different way.

When an operator is overloaded, none of its original meaning is lost. It is simply that a new operation, relative to a specific class, is added. Therefore, overloading the ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

C# 6.0 and the .NET 4.6 Framework, Seventh Edition

Publisher Resources

ISBN: 9780071741163

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills