book

C# 5.0 in a Nutshell, 5th Edition

by Joseph Albahari, Ben Albahari

June 2012

Intermediate to advanced

1064 pages

28h 34m

English

O'Reilly Media, Inc.

Read now

Unlock full access

C# 5.0 in a Nutshell
Preface
Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgmentsJoseph AlbahariBen Albahari
1. Introducing C# and the .NET Framework
Object OrientationType SafetyMemory ManagementPlatform SupportC#’s Relationship with the CLRThe CLR and .NET FrameworkC# and Windows RuntimeWhat’s New in C# 5.0What’s New in C# 4.0What’s New in C# 3.0
2. C# Language Basics
A First C# ProgramCompilationSyntaxIdentifiers and KeywordsAvoiding conflictsContextual keywordsLiterals, Punctuators, and OperatorsCommentsType BasicsPredefined Type ExamplesCustom Type ExamplesMembers of a typeSymmetry of predefined types and custom typesConstructors and instantiationInstance versus static membersThe public keywordConversionsValue Types Versus Reference TypesValue typesReference typesNullStorage overheadPredefined Type TaxonomyNumeric TypesNumeric LiteralsNumeric literal type inferenceNumeric suffixesNumeric ConversionsIntegral to integral conversionsFloating-point to floating-point conversionsFloating-point to integral conversionsDecimal conversionsArithmetic OperatorsIncrement and Decrement OperatorsSpecialized Integral OperationsIntegral divisionIntegral overflowIntegral arithmetic overflow check operatorsOverflow checking for constant expressionsBitwise operators8- and 16-Bit IntegralsSpecial Float and Double Valuesdouble Versus decimalReal Number Rounding ErrorsBoolean Type and OperatorsBool ConversionsEquality and Comparison OperatorsConditional OperatorsStrings and CharactersChar ConversionsString TypeString concatenationString comparisonsArraysDefault Element InitializationValue types versus reference typesMultidimensional ArraysRectangular arraysJagged arraysSimplified Array Initialization ExpressionsBounds CheckingVariables and ParametersThe Stack and the HeapStackHeapDefinite AssignmentDefault ValuesParametersPassing arguments by valueThe ref modifierThe out modifierImplications of passing by referenceThe params modifierOptional parametersNamed argumentsvar—Implicitly Typed Local VariablesExpressions and OperatorsPrimary ExpressionsVoid ExpressionsAssignment ExpressionsOperator Precedence and AssociativityPrecedenceLeft-associative operatorsRight-associative operatorsOperator TableStatementsDeclaration StatementsLocal variablesExpression StatementsSelection StatementsThe if statementThe else clauseChanging the flow of execution with bracesThe switch statementIteration Statementswhile and do-while loopsfor loopsforeach loopsJump StatementsThe break statementThe continue statementThe goto statementThe return statementThe throw statementMiscellaneous StatementsNamespacesThe using DirectiveRules Within a NamespaceName scopingName hidingRepeated namespacesNested using directiveAliasing Types and NamespacesAdvanced Namespace FeaturesExternNamespace alias qualifiers
3. Creating Types in C#
ClassesFieldsThe readonly modifierField initializationDeclaring multiple fields togetherMethodsOverloading methodsPass-by-value versus pass-by-referenceInstance ConstructorsOverloading constructorsImplicit parameterless constructorsConstructor and field initialization orderNonpublic constructorsObject InitializersThe this ReferencePropertiesRead-only and calculated propertiesAutomatic propertiesget and set accessibilityCLR property implementationIndexersImplementing an indexerCLR indexer implementationConstantsStatic ConstructorsStatic constructors and field initialization orderStatic ClassesFinalizersPartial Types and MethodsPartial methodsInheritancePolymorphismCasting and Reference ConversionsUpcastingDowncastingThe as operatorThe is operatorVirtual Function MembersAbstract Classes and Abstract MembersHiding Inherited Membersnew versus overrideSealing Functions and ClassesThe base KeywordConstructors and InheritanceImplicit calling of the parameterless base-class constructorConstructor and field initialization orderOverloading and ResolutionThe object TypeBoxing and UnboxingCopying semantics of boxing and unboxingStatic and Runtime Type CheckingThe GetType Method and typeof OperatorThe ToString MethodObject Member ListingStructsStruct Construction SemanticsAccess ModifiersExamplesFriend AssembliesAccessibility CappingRestrictions on Access ModifiersInterfacesExtending an InterfaceExplicit Interface ImplementationImplementing Interface Members VirtuallyReimplementing an Interface in a SubclassAlternatives to interface reimplementationInterfaces and BoxingEnumsEnum ConversionsFlags EnumsEnum OperatorsType-Safety IssuesNested TypesGenericsGeneric TypesWhy Generics ExistGeneric MethodsDeclaring Type Parameterstypeof and Unbound Generic TypesThe default Generic ValueGeneric ConstraintsSubclassing Generic TypesSelf-Referencing Generic DeclarationsStatic DataType Parameters and ConversionsCovarianceClassesArraysInterfacesContravarianceC# Generics Versus C++ Templates
4. Advanced C#
DelegatesWriting Plug-in Methods with DelegatesMulticast DelegatesMulticast delegate exampleInstance Versus Static Method TargetsGeneric Delegate TypesThe Func and Action DelegatesDelegates Versus InterfacesDelegate CompatibilityType compatibilityParameter compatibilityReturn type compatibilityGeneric delegate type parameter varianceEventsStandard Event PatternEvent AccessorsEvent ModifiersLambda ExpressionsExplicitly Specifying Lambda Parameter TypesCapturing Outer VariablesCapturing iteration variablesAnonymous Methodstry Statements and ExceptionsThe catch ClauseThe finally BlockThe using statementThrowing ExceptionsRethrowing an exceptionKey Properties of System.ExceptionCommon Exception TypesThe TryXXX Method PatternAlternatives to ExceptionsEnumeration and IteratorsEnumerationCollection InitializersIteratorsIterator Semanticsyield breakIterators and try/catch/finally blocksComposing SequencesNullable TypesNullable <T> StructImplicit and explicit nullable conversionsBoxing and unboxing nullable valuesOperator LiftingEquality operators (== and !=)Relational operators (<, <=, >=, >)All other operators (+, −, *, /, %, &, |, ^, <<, >>, +, ++, --, !, ~)Mixing nullable and non-nullable operatorsbool? with & and | OperatorsNull Coalescing OperatorScenarios for Nullable TypesAlternatives to Nullable TypesOperator OverloadingOperator FunctionsOverloading Equality and Comparison OperatorsCustom Implicit and Explicit ConversionsOverloading true and falseExtension MethodsExtension Method ChainingAmbiguity and ResolutionNamespacesExtension methods versus instance methodsExtension methods versus extension methodsAnonymous TypesDynamic BindingStatic Binding Versus Dynamic BindingCustom BindingLanguage BindingRuntimeBinderExceptionRuntime Representation of DynamicDynamic Conversionsvar Versus dynamicDynamic ExpressionsDynamic Calls without Dynamic ReceiversStatic Types in Dynamic ExpressionsUncallable FunctionsAttributesAttribute ClassesNamed and Positional Attribute ParametersAttribute TargetsSpecifying Multiple AttributesCaller Info Attributes (C# 5)Unsafe Code and PointersPointer BasicsUnsafe CodeThe fixed StatementThe Pointer-to-Member OperatorArraysThe stackalloc keywordFixed-size buffersvoid*Pointers to Unmanaged CodePreprocessor DirectivesConditional AttributesPragma WarningXML DocumentationStandard XML Documentation TagsUser-Defined TagsType or Member Cross-References
5. Framework Overview
The CLR and Core FrameworkSystem TypesText ProcessingCollectionsQueriesXMLDiagnostics and Code ContractsConcurrency and AsynchronyStreams and I/ONetworkingSerializationAssemblies, Reflection, and AttributesDynamic ProgrammingSecurityAdvanced ThreadingParallel ProgrammingApplication DomainsNative and COM InteroperabilityApplied TechnologiesUser Interface TechnologiesASP.NETSilverlightMetroWindows Presentation Foundation (WPF)Windows FormsBackend TechnologiesADO.NETWindows WorkflowCOM+ and MSMQDistributed System TechnologiesWindows Communication Foundation (WCF)Remoting and .ASMX Web ServicesCardSpace
6. Framework Fundamentals
String and Text HandlingCharStringConstructing stringsNull and empty stringsAccessing characters within a stringSearching within stringsManipulating stringsSplitting and joining stringsString.Format and composite format stringsComparing StringsOrdinal versus culture comparisonString equality comparisonString order comparisonStringBuilderText Encodings and UnicodeObtaining an Encoding objectEncoding for file and stream I/OEncoding to byte arraysUTF-16 and surrogate pairsDates and TimesTimeSpanDateTime and DateTimeOffsetChoosing between DateTime and DateTimeOffsetConstructing a DateTimeConstructing a DateTimeOffsetThe current DateTime/DateTimeOffsetWorking with dates and timesFormatting and parsingNull DateTime and DateTimeOffset valuesDates and Time ZonesDateTime and Time ZonesDateTimeOffset and Time ZonesTimeZone and TimeZoneInfoTimeZoneTimeZoneInfoDaylight Saving Time and DateTimeFormatting and ParsingToString and ParseFormat ProvidersFormat providers and CultureInfoUsing NumberFormatInfo or DateTimeFormatInfoComposite formattingParsing with format providersIFormatProvider and ICustomFormatterStandard Format Strings and Parsing FlagsNumeric Format StringsNumberStylesDate/Time Format StringsParsing and misparsing DateTimesDateTimeStylesEnum Format StringsOther Conversion MechanismsConvertRounding real to integral conversionsParsing numbers in base 2, 8, and 16Dynamic conversionsBase 64 conversionsXmlConvertType ConvertersBitConverterGlobalizationGlobalization ChecklistTestingWorking with NumbersConversionsMathBigIntegerComplexRandomEnumsEnum ConversionsEnum to integral conversionsIntegral to enum conversionsString conversionsEnumerating Enum ValuesHow Enums WorkTuplesComparing TuplesThe Guid StructEquality ComparisonValue Versus Referential EqualityStandard Equality Protocols== and !=The virtual Object.Equals methodThe static object.Equals methodThe static object.ReferenceEquals methodThe IEquatable<T> interfaceWhen Equals and == are not equalEquality and Custom TypesChanging the meaning of equalitySpeeding up equality comparisons with structsHow to override equality semanticsOverriding GetHashCodeOverriding EqualsOverloading == and !=Implementing IEquatable<T>An example: The Area structPluggable equality comparersOrder ComparisonIComparableIComparable versus Equals< and >Implementing the IComparable InterfacesUtility ClassesConsoleEnvironmentProcess
7. Collections
EnumerationIEnumerable and IEnumeratorIEnumerable<T> and IEnumerator<T>IEnumerable<T> and IDisposableImplementing the Enumeration InterfacesThe ICollection and IList InterfacesICollection<T> and ICollectionIList<T> and IListIReadOnlyList<T>The Array ClassConstruction and IndexingEnumerationLength and RankSearchingSortingReversing ElementsCopyingConverting and ResizingLists, Queues, Stacks, and SetsList<T> and ArrayListLinkedList<T>Queue<T> and QueueStack<T> and StackBitArrayHashSet<T> and SortedSet<T>DictionariesIDictionary<TKey,TValue>IDictionaryDictionary<TKey,TValue> and HashtableOrderedDictionaryListDictionary and HybridDictionarySorted DictionariesCustomizable Collections and ProxiesCollection<T> and CollectionBaseCollectionBaseKeyedCollection<TKey,TItem> and DictionaryBaseDictionaryBaseReadOnlyCollection<T>Plugging in Equality and OrderIEqualityComparer and EqualityComparerEqualityComparer<T>.DefaultIComparer and ComparerStringComparerIStructuralEquatable and IStructuralComparable
8. LINQ Queries
Getting StartedFluent SyntaxChaining Query OperatorsWhy extension methods are importantComposing Lambda ExpressionsLambda expressions and Func signaturesLambda expressions and element typingNatural OrderingOther OperatorsQuery ExpressionsRange VariablesQuery Syntax Versus SQL SyntaxQuery Syntax Versus Fluent SyntaxMixed Syntax QueriesDeferred ExecutionReevaluationCaptured VariablesHow Deferred Execution WorksChaining DecoratorsHow Queries Are ExecutedSubqueriesSubqueries and Deferred ExecutionComposition StrategiesProgressive Query BuildingThe into KeywordScoping rulesWrapping QueriesProjection StrategiesObject InitializersAnonymous TypesThe let KeywordInterpreted QueriesHow Interpreted Queries WorkExecutionCombining Interpreted and Local QueriesAsEnumerableLINQ to SQL and Entity FrameworkLINQ to SQL Entity ClassesEntity Framework Entity ClassesDataContext and ObjectContextTyped contextsObject trackingAssociationsDeferred Execution with L2S and EFDataLoadOptionsSpecifying a filter in advanceEager loadingEager Loading in Entity FrameworkUpdatesAPI Differences Between L2S and EFBuilding Query ExpressionsDelegates Versus Expression TreesCompiling expression treesAsQueryableExpression TreesThe Expression DOM

9. LINQ Operators
OverviewSequence→SequenceFilteringProjectingJoiningOrderingGroupingSet operatorsConversion methods: ImportConversion methods: ExportSequence→Element or ValueElement operatorsAggregation methodsQuantifiersVoid→SequenceGeneration methodsFilteringWhereQuery syntaxEnumerable.Where implementationOverviewIndexed filteringSQL LIKE comparisons in LINQ to SQL and EF< and > string comparisons in LINQ to SQL and EFWHERE x IN (..., ..., ...) in LINQ to SQL and EFTake and SkipTakeWhile and SkipWhileDistinctProjectingSelectQuery syntaxEnumerable implementationOverviewIndexed projectionSelect subqueries and object hierarchiesSubqueries and joins in LINQ to SQL and EFProjecting into concrete typesSelectManyQuery syntaxEnumerable implementationOverviewMultiple range variablesThinking in query syntaxJoining with SelectManySelectMany in LINQ to SQL and EFOuter joins with SelectManyJoiningJoin and GroupJoinJoin argumentsGroupJoin argumentsQuery syntaxOverviewJoinJoining on multiple keysJoining in fluent syntaxGroupJoinFlat outer joinsJoining with lookupsEnumerable implementationsThe Zip OperatorOrderingOrderBy, OrderByDescending, ThenBy, and ThenByDescendingOrderBy and OrderByDescending argumentsThenBy and ThenByDescending argumentsQuery syntaxOverviewComparers and collationsIOrderedEnumerable and IOrderedQueryableGroupingGroupByQuery syntaxOverviewGroupBy in LINQ to SQL and EFGrouping by multiple keysCustom equality comparersSet OperatorsConcat and UnionIntersect and ExceptConversion MethodsOfType and CastToArray, ToList, ToDictionary, and ToLookupAsEnumerable and AsQueryableElement OperatorsFirst, Last, and SingleElementAtDefaultIfEmptyAggregation MethodsCount and LongCountMin and MaxSum and AverageAggregateUnseeded aggregationsTraps with unseeded aggregationsQuantifiersContains and AnyAll and SequenceEqualGeneration MethodsEmptyRange and Repeat
10. LINQ to XML
Architectural OverviewWhat Is a DOM?The LINQ to XML DOMX-DOM OverviewLoading and ParsingSaving and SerializingInstantiating an X-DOMFunctional ConstructionSpecifying ContentAutomatic Deep CloningNavigating and QueryingChild Node NavigationFirstNode, LastNode, and NodesRetrieving elementsRetrieving a single elementRetrieving descendantsParent NavigationPeer Node NavigationAttribute NavigationUpdating an X-DOMSimple Value UpdatesUpdating Child Nodes and AttributesUpdating through the ParentRemoving a sequence of nodes or attributesWorking with ValuesSetting ValuesGetting ValuesValues and Mixed Content NodesAutomatic XText ConcatenationDocuments and DeclarationsXDocumentXML DeclarationsWriting a declaration to a stringNames and NamespacesNamespaces in XMLPrefixesAttributesSpecifying Namespaces in the X-DOMThe X-DOM and Default NamespacesPrefixesAnnotationsProjecting into an X-DOMEliminating Empty ElementsStreaming a ProjectionTransforming an X-DOMAdvanced transformations
11. Other XML Technologies
XmlReaderReading NodesReading ElementsOptional elementsRandom element orderEmpty elementsOther ReadXXX methodsReading AttributesAttribute nodesNamespaces and PrefixesXmlWriterWriting AttributesWriting Other Node TypesNamespaces and PrefixesPatterns for Using XmlReader/XmlWriterWorking with Hierarchical DataMixing XmlReader/XmlWriter with an X-DOMUsing XmlReader with XElementUsing XmlWriter with XElementXmlDocumentLoading and Saving an XmlDocumentTraversing an XmlDocumentInnerText and InnerXmlCreating and Manipulating NodesNamespacesXPathCommon XPath OperatorsXPathNavigatorQuerying with NamespacesXPathDocumentXSD and Schema ValidationPerforming Schema ValidationValidating with an XmlReaderValidating an X-DOM or XmlDocumentXSLT
12. Disposal and Garbage Collection
IDisposable, Dispose, and CloseStandard Disposal SemanticsClose and StopWhen to DisposeOpt-in DisposalClearing Fields in DisposalAutomatic Garbage CollectionRootsGarbage Collection and WinRTFinalizersCalling Dispose from a FinalizerResurrectionGC.ReRegisterForFinalizeHow the Garbage Collector WorksOptimization TechniquesGenerational collectionThe large object heapConcurrent and background collectionGC notifications (server CLR)Forcing Garbage CollectionMemory PressureManaged Memory LeaksTimersDiagnosing Memory LeaksWeak ReferencesWeak References and CachingWeak References and Events
13. Diagnostics and Code Contracts
Conditional CompilationConditional Compilation Versus Static Variable FlagsThe Conditional AttributeAlternatives to the Conditional attributeDebug and Trace ClassesFail and AssertTraceListenerFlushing and Closing ListenersCode Contracts OverviewWhy Use Code Contracts?Contract PrinciplesCompilationThe binary rewriterAsserting versus throwing on failurePurityPreconditionsContract.RequiresContract.Requires<TException>Contract.EndContractBlockPreconditions and Overridden MethodsPostconditionsContract.EnsuresContract.EnsuresOnThrow<TException>Contract.Result<T> and Contract.ValueAtReturn<T>Contract.OldValue<T>Postconditions and Overridden MethodsAssertions and Object InvariantsAssertionsContract.AssertContract.AssumeObject InvariantsContracts on Interfaces and Abstract MethodsDealing with Contract FailureThe ContractFailed EventExceptions Within Contract ConditionsSelectively Enforcing ContractsContracts in Release BuildsCall-Site CheckingStatic Contract CheckingThe ContractVerification AttributeBaselinesThe SuppressMessage AttributeDebugger IntegrationAttaching and BreakingDebugger AttributesProcesses and Process ThreadsExamining Running ProcessesExamining Threads in a ProcessStackTrace and StackFrameWindows Event LogsWriting to the Event LogReading the Event LogMonitoring the Event LogPerformance CountersEnumerating the Available CountersReading Performance Counter DataCreating Counters and Writing Performance DataThe Stopwatch Class
14. Concurrency & Asynchrony
IntroductionThreadingCreating a ThreadJoin and SleepBlockingI/O-bound versus compute-boundBlocking versus spinningLocal Versus Shared StateLocking and Thread SafetyPassing Data to a ThreadLambda expressions and captured variablesException HandlingCentralized exception handlingForeground Versus Background ThreadsThread PrioritySignalingThreading in Rich Client ApplicationsSynchronization ContextsThe Thread PoolEntering the thread poolHygiene in the thread poolTasksStarting a TaskWaitLong-running tasksReturning valuesExceptionsExceptions and autonomous tasksContinuationsTaskCompletionSourceTask.DelayPrinciples of AsynchronySynchronous Versus Asynchronous OperationsWhat is Asynchronous Programming?Asynchronous Programming and ContinuationsWhy Language Support is ImportantAsynchronous Functions in C# 5.0AwaitingCapturing local stateAwaiting in a UIComparison to course-grained concurrencyWriting Asynchronous FunctionsReturning Task<TResult>Asynchronous call graph executionParallelismAsynchronous Lambda ExpressionsAsynchronous Methods in WinRTAsynchrony and Synchronization ContextsException postingOperationStarted and OperationCompletedOptimizationsCompleting synchronouslyAvoiding excessive bouncingAsynchronous PatternsCancellationProgress ReportingIProgress<T> and Progress<T>The Task-based Asynchronous Pattern (TAP)Task CombinatorsWhenAnyWhenAllCustom combinatorsObsolete PatternsAsynchronous Programming Model (APM)Asynchronous delegatesEvent-Based Asynchronous Pattern (EAP)BackgroundWorker
15. Streams and I/O
Stream ArchitectureUsing StreamsReading and WritingSeekingClosing and FlushingTimeoutsThread SafetyBacking Store StreamsFileStreamConstructing a FileStreamSpecifying a filenameSpecifying a FileModeAdvanced FileStream featuresMemoryStreamPipeStreamNamed pipesAnonymous pipesBufferedStreamStream AdaptersText AdaptersStreamReader and StreamWriterCharacter encodingsStringReader and StringWriterBinary AdaptersClosing and Disposing Stream AdaptersCompression StreamsCompressing in MemoryWorking with Zip FilesFile and Directory OperationsThe File ClassCompression and encryption attributesFile securityThe Directory ClassFileInfo and DirectoryInfoPathSpecial FoldersQuerying Volume InformationCatching Filesystem EventsFile I/O in Windows RuntimeWorking with DirectoriesWorking with FilesIsolated Storage in Metro AppsMemory-Mapped FilesMemory-Mapped Files and Random File I/OMemory-Mapped Files and Shared MemoryWorking with View AccessorsIsolated StorageIsolation TypesReading and Writing Isolated StorageStore LocationEnumerating Isolated Storage
16. Networking
Network ArchitectureAddresses and PortsURIsClient-Side ClassesWebClientWebRequest and WebResponseHttpClientGetAsync and response messagesSendAsync and request messagesUploading data and HttpContentHttpMessageHandlerUnit testing and mockingChaining handlers with DelegatingHandlerProxiesAuthenticationCredentialCacheAuthenticating via headers with HttpClientException HandlingWorking with HTTPHeadersQuery StringsUploading Form DataCookiesForms AuthenticationSSLWriting an HTTP ServerUsing FTPUsing DNSSending Mail with SmtpClientUsing TCPConcurrency with TCPReceiving POP3 Mail with TCPTCP in Windows Runtime
17. Serialization
Serialization ConceptsSerialization EnginesWhy three engines?The data contract serializerThe binary serializerXmlSerializerIXmlSerializableFormattersExplicit Versus Implicit SerializationThe Data Contract SerializerDataContractSerializer Versus NetDataContractSerializerUsing the SerializersSpecifying a binary formatterSerializing SubclassesObject ReferencesPreserving object referencesVersion ToleranceRequired membersMember OrderingNull and Empty ValuesData Contracts and CollectionsSubclassed Collection ElementsCustomizing Collection and Element NamesExtending Data ContractsSerialization and Deserialization HooksInteroperating with [Serializable]Interoperating with IXmlSerializableThe Binary SerializerGetting StartedBinary Serialization Attributes[NonSerialized][OnDeserializing] and [OnDeserialized][OnSerializing] and [OnSerialized][OptionalField] and VersioningBinary Serialization with ISerializableSubclassing Serializable ClassesXML SerializationGetting Started with Attribute-Based SerializationAttributes, names, and namespacesXML element orderSubclasses and Child ObjectsSubclassing the root typeSerializing child objectsSubclassing child objectsSerializing CollectionsWorking with subclassed collection elementsIXmlSerializable
18. Assemblies
What’s in an AssemblyThe Assembly ManifestSpecifying assembly attributesThe Application ManifestDeploying an .NET application manifestModulesThe Assembly ClassStrong Names and Assembly SigningHow to Strongly Name an AssemblyDelay SigningAssembly NamesFully Qualified NamesThe AssemblyName ClassAssembly Informational and File VersionsAuthenticode SigningHow to Sign with AuthenticodeObtaining and installing a certificateSigning with signtool.exeTime stampingVerifying that a program has been signedAuthenticode ValidationThe Global Assembly CacheHow to Install Assemblies to the GACGAC and VersioningResources and Satellite AssembliesDirectly Embedding Resources.resources Files.resx FilesCreating a .resx file at the command lineReading .resources filesCreating a pack URI resource in Visual StudioSatellite AssembliesBuilding satellite assembliesTesting satellite assembliesVisual Studio designer supportCultures and SubculturesResolving and Loading AssembliesAssembly and Type Resolution RulesAssemblyResolveLoading AssembliesLoading from a filenameStatically referenced types and LoadFrom/LoadFileLocation versus CodeBaseDeploying Assemblies Outside the Base FolderPacking a Single-File ExecutableSelective PatchingWorking with Unreferenced Assemblies
19. Reflection and Metadata
Reflecting and Activating TypesObtaining a TypeTypeInfo and Metro applicationsObtaining array typesObtaining nested typesType NamesNested type namesGeneric type namesArray and pointer type namesref and out parameter type namesBase Types and InterfacesInstantiating TypesGeneric TypesReflecting and Invoking MembersMember TypesC# Members Versus CLR MembersGeneric Type MembersDynamically Invoking a MemberMethod ParametersDealing with ref and out parametersRetrieving and invoking generic methodsUsing Delegates for PerformanceAccessing Nonpublic MembersThe BindingFlags enumGeneric MethodsAnonymously Calling Members of a Generic InterfaceReflecting AssembliesLoading an Assembly into a Reflection-Only ContextModulesWorking with AttributesAttribute BasicsThe AttributeUsage AttributeDefining Your Own AttributeRetrieving Attributes at RuntimeRetrieving Attributes in the Reflection-Only ContextDynamic Code GenerationGenerating IL with DynamicMethodThe Evaluation StackPassing Arguments to a Dynamic MethodGenerating Local VariablesBranchingInstantiating Objects and Calling Instance MethodsException HandlingEmitting Assemblies and TypesSaving Emitted AssembliesThe Reflection.Emit Object ModelEmitting Type MembersEmitting MethodsGenerating instance methodsHideBySigEmitting Fields and PropertiesEmitting ConstructorsCalling base constructorsAttaching AttributesEmitting Generic Methods and TypesDefining Generic MethodsDefining Generic TypesAwkward Emission TargetsUncreated Closed GenericsCircular DependenciesParsing ILWriting a Disassembler
20. Dynamic Programming
The Dynamic Language RuntimeNumeric Type UnificationDynamic Member Overload ResolutionSimplifying the Visitor PatternVariationsAnonymously Calling Members of a Generic TypeImplementing Dynamic ObjectsDynamicObjectExpandoObjectInteroperating with Dynamic LanguagesPassing State Between C# and a Script
21. Security
PermissionsCodeAccessPermission and PrincipalPermissionIPermissionPermissionSetDeclarative Versus Imperative SecurityCode Access Security (CAS)How Code Access Security Is AppliedTesting for Full TrustAllowing Partially Trusted CallersElevation of PrivilegeAPTCA and [SecurityTransparent]The Transparency ModelHow the Transparency Model WorksTransparent codeSettings the transparency default for an assemblyHow to Write APTCA Libraries with TransparencySecuring unsafe methodsP/Invokes and [SuppressUnmanagedSecurity]Transparency in Full-Trust ScenariosSandboxing Another AssemblyAsserting PermissionsOperating System SecurityRunning in a Standard User AccountAdministrative Elevation and VirtualizationIdentity and Role SecurityAssigning Users and RolesCryptography OverviewWindows Data ProtectionHashingSymmetric EncryptionEncrypting in MemoryChaining Encryption StreamsDisposing Encryption ObjectsKey ManagementPublic Key Encryption and SigningThe RSA ClassDigital Signing
22. Advanced Threading
Synchronization OverviewExclusive LockingThe lock StatementMonitor.Enter and Monitor.ExitThe lockTaken overloadsTryEnterChoosing the Synchronization ObjectWhen to LockLocking and AtomicityNested LockingDeadlocksPerformanceMutexLocking and Thread SafetyThread Safety and .NET Framework TypesLocking around thread-safe objectsStatic membersRead-only thread safetyThread Safety in Application ServersImmutable ObjectsNon-Exclusive LockingSemaphoreReader/Writer LocksUpgradeable locksLock recursionSignaling with Event Wait HandlesAutoResetEventTwo-way signalingManualResetEventCountdownEventCreating a Cross-Process EventWaitHandleWait Handles and ContinuationsConverting Wait Handles to TasksWaitAny, WaitAll, and SignalAndWaitAlternatives to WaitAll and SignalAndWaitThe Barrier ClassLazy InitializationLazy<T>LazyInitializerThread-Local Storage[ThreadStatic]ThreadLocal<T>ThreadLocal<T> and instance fieldsGetData and SetDataInterrupt and AbortSuspend and ResumeTimersMultithreaded TimersSingle-Threaded Timers
23. Parallel Programming
Why PFX?PFX ConceptsPFX ComponentsWhen to Use PFXPLINQParallel Execution BallisticsPLINQ and OrderingPLINQ LimitationsExample: Parallel SpellcheckerUsing ThreadLocal<T>Functional PuritySetting the Degree of ParallelismChanging the degree of parallelismCancellationOptimizing PLINQOutput-side optimizationInput-side optimizationOptimizing custom aggregationsThe Parallel ClassParallel.InvokeParallel.For and Parallel.ForEachOuter versus inner loopsIndexed Parallel.ForEachParallelLoopState: Breaking early out of loopsOptimization with local valuesTask ParallelismCreating and Starting TasksSpecifying a state objectTaskCreationOptionsChild tasksWaiting on Multiple TasksCanceling TasksContinuationsContinuations and Task<TResult>Continuations and exceptionsContinuations and child tasksConditional continuationsContinuations with multiple antecedentsMultiple continuations on a single antecedentTask SchedulersTaskFactoryCreating your own task factoriesWorking with AggregateExceptionFlatten and HandleFlattenHandleConcurrent CollectionsIProducerConsumerCollection<T>ConcurrentBag<T>BlockingCollection<T>Writing a Producer/Consumer QueueLeveraging Tasks
24. Application Domains
Application Domain ArchitectureCreating and Destroying Application DomainsUsing Multiple Application DomainsUsing DoCallBackMonitoring Application DomainsDomains and ThreadsSharing Data Between DomainsSharing Data via SlotsIntra-Process RemotingIsolating Types and AssembliesType discovery
25. Native and COM Interoperability
Calling into Native DLLsType MarshalingMarshaling Common TypesMarshaling Classes and StructsIn and Out MarshalingCallbacks from Unmanaged CodeSimulating a C UnionShared MemoryMapping a Struct to Unmanaged Memoryfixed and fixed {...}COM InteroperabilityThe Purpose of COMThe Basics of the COM Type SystemIUnknown and IDispatchCalling a COM Component from C#Optional Parameters and Named ArgumentsImplicit ref ParametersIndexersDynamic BindingEmbedding Interop TypesType EquivalencePrimary Interop AssembliesExposing C# Objects to COM
26. Regular Expressions
Regular Expression BasicsCompiled Regular ExpressionsRegexOptionsCharacter EscapesCharacter SetsQuantifiersGreedy Versus Lazy QuantifiersZero-Width AssertionsLookahead and LookbehindAnchorsWord BoundariesGroupsNamed GroupsReplacing and Splitting TextMatchEvaluator DelegateSplitting TextCookbook Regular ExpressionsRecipesMatching U.S. Social Security number/phone numberExtracting “name = value” pairs (one per line)Strong password validationLines of at least 80 charactersParsing dates/times (N/N/N H:M:S AM/PM)Matching Roman numeralsRemoving repeated wordsWord countMatching a GuidParsing an XML/HTML tagSplitting a camel-cased wordObtaining a legal filenameEscaping Unicode characters for HTMLUnescaping characters in an HTTP query stringParsing Google search terms from a web stats logRegular Expressions Language Reference
Index
About the Authors
Colophon
Copyright

Content preview from C# 5.0 in a Nutshell, 5th Edition

Chapter 1. Introducing C# and the .NET Framework

C# is a general-purpose, type-safe, object-oriented programming language. The goal of the language is programmer productivity. To this end, the language balances simplicity, expressiveness, and performance. The chief architect of the language since its first version is Anders Hejlsberg (creator of Turbo Pascal and architect of Delphi). The C# language is platform-neutral, but it was written to work well with the Microsoft .NET Framework.

Object Orientation

C# is a rich implementation of the object-orientation paradigm, which includes encapsulation, inheritance, and polymorphism. Encapsulation means creating a boundary around an object, to separate its external (public) behavior from its internal (private) implementation details. The distinctive features of C# from an object-oriented perspective are:

Unified type system: The fundamental building block in C# is an encapsulated unit of data and functions called a type. C# has a unified type system, where all types ultimately share a common base type. This means that all types, whether they represent business objects or are primitive types such as numbers, share the same basic set of functionality. For example, an instance of any type can be converted to a string by calling its ToString method.
Classes and interfaces: In a traditional object-oriented paradigm, the only kind of type is a class. In C#, there are several other kinds of types, one of which is an interface. An interface is like a ...

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

Publisher Resources

ISBN: 9781449334192Errata

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# 5.0 in a Nutshell, 5th Edition

by Joseph Albahari, Ben Albahari

Chapter 1. Introducing C# and the .NET Framework

Object Orientation

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.