book

C# 4.0 in a Nutshell, 4th Edition

by Joseph Albahari, Ben Albahari

February 2010

Intermediate to advanced

1043 pages

28h 24m

English

O'Reilly Media, Inc.

Read now

Unlock full access

C# 4.0 in a Nutshell
A Note Regarding Supplemental Files
Preface
Intended AudienceHow This Book Is OrganizedWhat You Need to Use This BookConventions Used in This BookUsing Code ExamplesWe’d Like to Hear from YouSafari® Books OnlineAcknowledgmentsJoseph AlbahariBen Albahari
1. Introducing C# and the .NET Framework
Object OrientationType SafetyMemory ManagementPlatform SupportC#’s Relationship with the CLRThe CLR and .NET FrameworkWhat’s New in C# 4.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 parameters (C# 4.0)Named arguments (C# 4.0)var—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 variance (C# 4.0)EventsStandard 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 TypesCommon PatternsThe TryXXX method patternThe atomicity 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 (== !=)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 methodsExtension Methods on InterfacesAnonymous 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 AttributesUnsafe 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 ContractsStreams and I/ONetworkingSerializationAssemblies, Reflection, and AttributesDynamic ProgrammingSecurityThreading and Parallel ProgrammingApplication DomainsNative and COM InteroperabilityApplied TechnologiesUser Interface TechnologiesASP.NETSilverlightWindows Presentation Foundation (WPF)Windows FormsBackend TechnologiesADO.NETWindows WorkflowCOM+ and MSMQDistributed System TechnologiesWindows Communication Foundation (WCF)Remoting and 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 IListThe Array ClassConstruction and IndexingEnumerationLength and RankSearchingSortingReversing ElementsCopying, Converting, 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 operatorsZip operatorConversion methods: ImportConversion methods: ExportSequence→Element or ScalarElement 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 implementationOverviewOuter 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 implementationsOrderingOrderBy, 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 ExceptThe Zip OperatorConversion 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 elementRecursive functionsParent 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 CollectionRootsFinalizersCalling 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. 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 AdaptersFile and Directory OperationsThe File ClassCompression and encryption attributesFile securityThe Directory ClassFileInfo and DirectoryInfoPathSpecial FoldersQuerying Volume InformationCatching Filesystem EventsMemory-Mapped FilesMemory-Mapped Files and Random File I/OMemory-Mapped Files and Shared MemoryWorking with View AccessorsCompressionCompressing in MemoryIsolated StorageIsolation TypesReading and Writing Isolated StorageStore LocationEnumerating Isolated Storage
15. Networking
Network ArchitectureAddresses and PortsURIsRequest/Response ArchitectureWebClientWebRequest and WebResponseProxiesAuthenticationCredentialCacheConcurrencyException HandlingHTTP-Specific SupportHeadersQuery StringsUploading Form DataCookiesForms AuthenticationSSLWriting an HTTP ServerUsing FTPUsing DNSSending Mail with SmtpClientUsing TCPConcurrencyReceiving POP3 Mail with TCP
16. 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
17. Assemblies
What’s in an Assembly?The Assembly ManifestSpecifying assembly attributesThe Application ManifestDeploying an 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 filenameDeploying Assemblies Outside the Base FolderPacking a Single-File ExecutableSelective PatchingWorking with Unreferenced Assemblies
18. Reflection and Metadata
Reflecting and Activating TypesObtaining a TypeObtaining 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
19. 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
20. 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 Model in CLR 4.0How 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
21. Threading
Threading’s Uses and MisusesGetting StartedPassing Data to a ThreadLambda expressions and captured variablesSharing Data Between ThreadsForeground and Background ThreadsThread PriorityException HandlingThread PoolingEntering the Thread Pool via TPLEntering the Thread Pool Without TPLQueueUserWorkItemAsynchronous delegatesOptimizing the Thread PoolSynchronizationBlockingBlocking Versus SpinningLockingMonitor.Enter and Monitor.ExitThe lockTaken overloadsTryEnterChoosing the Synchronization ObjectWhen to LockLocking and AtomicityNested LockingDeadlocksPerformanceMutexSemaphoreThread SafetyThread Safety and .NET Framework TypesLocking around thread-safe objectsStatic methodsRead-only thread safetyThread Safety in Application ServersRich Client Applications and Thread AffinityWorker threads versus UI threadsImmutable ObjectsNonblocking SynchronizationMemory Barriers and VolatilityFull fencesThe volatile keywordVolatileRead and VolatileWriteMemory barriers and lockingInterlockedSignaling with Event Wait HandlesAutoResetEventTwo-way signalingManualResetEventCountdownEventCreating a Cross-Process EventWaitHandleWait Handles and the Thread PoolWaitAny, WaitAll, and SignalAndWaitAlternatives to WaitAll and SignalAndWaitSignaling with Wait and PulseHow to Use Wait and PulseProducer/Consumer QueueWait TimeoutsSimulating Wait HandlesThe Barrier ClassThe Event-Based Asynchronous PatternBackgroundWorkerUsing BackgroundWorkerInterrupt and AbortInterruptAbortSafe CancellationCancellation TokensLazy InitializationLazy<T>LazyInitializerThread-Local Storage[ThreadStatic]ThreadLocal<T>ThreadLocal<T> and instance fieldsGetData and SetDataReader/Writer LocksUpgradeable Locks and RecursionLock recursionTimersMultithreaded TimersSingle-Threaded Timers
22. Parallel Programming
Why PFX?PFX ConceptsPFX ComponentsWhen to Use PFXPLINQParallel Execution BallisticsPLINQ and OrderingPLINQ LimitationsExample: Parallel SpellcheckerUsing ThreadLocal<T>Functional PurityCalling Blocking or I/O-Intensive FunctionsChanging 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 TasksException-Handling TasksCanceling TasksContinuationsContinuations and Task<TResult>Continuations and exceptionsContinuations and child tasksConditional continuationsContinuations with multiple antecedentsMultiple continuations on a single antecedentTask Schedulers and UIsTaskFactoryCreating your own task factoriesTaskCompletionSourceWorking with AggregateExceptionFlatten and HandleFlattenHandleConcurrent CollectionsIProducerConsumerCollection<T>ConcurrentBag<T>BlockingCollection<T>Leveraging TaskCompletionSourceSpinLock and SpinWaitSpinLockSpinWaitWhy we need SpinWaitHow to use SpinWaitHow SpinWait worksLock-free updates with SpinWait and Interlocked.CompareExchange
23. Asynchronous Methods
Why Asynchronous Methods ExistAsynchronous Method SignaturesIAsyncResultAsynchronous Methods Versus Asynchronous DelegatesUsing Asynchronous MethodsAsynchronous Methods and TasksWriting Asynchronous MethodsFake Asynchronous MethodsAlternatives to Asynchronous Methods
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
A. C# Keywords
Index
About the Authors
Colophon
Copyright

Content preview from C# 4.0 in a Nutshell, 4th Edition

Chapter 26. Regular Expressions

The regular expressions language identifies character patterns. The .NET types supporting regular expressions are based on Perl 5 regular expressions and support both search and search/replace functionality.

Regular expressions are used for tasks such as:

Validating text input such as passwords and phone numbers (ASP.NET provides the RegularExpressionValidator control just for this purpose)
Parsing textual data into more structured forms (e.g., extracting data from an HTML page for storage in a database)
Replacing patterns of text in a document (e.g., whole words only)

This chapter is split into both conceptual sections teaching the basics of regular expressions in .NET and reference sections describing the regular expressions language.

All regular expression types are defined in System.Text.RegularExpressions.

Note

For more on regular expressions, http://regular-expressions.info is a good online reference with lots of examples, and Mastering Regular Expressions by Jeffrey E. F. Friedl, is invaluable for the serious.

The samples in this chapter are all preloaded into LINQPad. There is also an interactive utility available called Expresso, which assists in building and visualizing regular expressions, and comes with its own expression library.

Regular Expression Basics

One of the most common regular expression operators is a quantifier. ? is a quantifier that matches the preceding item 0 or 1 time. In other words, ? means optional. An item is either a single ...

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: 9781449379629Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design