book

The C# Type System

Name: The C# Type System
Author: Steve Love
ISBN: 9781718501584

by Steve Love

October 2023

Intermediate to advanced

344 pages

9h 52m

English

No Starch Press

Read now

Unlock full access

Title Page
Copyright
Dedication
About the Author and Technical Reviewer
Acknowledgments
Introduction
Who Should Read This BookOrganization and RequirementsModern FeaturesWhy Value Types?
1. Making the Most of the Type System
The Value of Good NamesAdding Clarity Through TypesNamed ArgumentsCustom TypesEncapsulationImmutabilityValue ValidationTestingRefactoringReplacing Magic Numbers with Named ConstantsSimplifying Properties and ValuesOverloading Arithmetic OperatorsDetermining a Need for New TypesEncoding UnitsItemizing Units with enumsStatic Creation MethodsSymmetry in DesignMaking Units ExplicitChoosing the Most Natural UsageReturning Types Implied by UnitsA Fully Formed Encapsulated ValueDeciding Whether to Abstract TypesSummary
2. Value and Reference Types
User-Defined TypesStructs and ClassesRecords and Record StructsInheritanceType Instance LifetimesVariablesVariables vs. ValuesDefinite AssignmentInstances and StorageEmbedded ValuesBoxed ValuesSemantics and TypeThe Common Type SystemCopy SemanticsRecords, Structs, and Value SemanticsConstruction and InitializationDefault InitializationInstance ConstructorsField InitializersObject Initializersnull Values and Default ValuesGenerics and nullGenerics and Default ValuesNullable Value TypesNullable Reference TypesThe Null-Forgiving OperatorSummary
3. Reference and Value Parameters
Method Parameters and ArgumentsReference Types vs. By-Reference ParametersValue Types and ParametersThe Value of a ReferenceReference Variables and AliasingMutable By-Reference ParametersPassing References by ReferencePassing Values by ReferenceWorking with Output ParametersLimitations of By-Reference ParametersProperty ValuesOverloading on By-Reference ParametersUsing FieldsExtension MethodsSide Effects and Direct EffectsMutation vs. CreationDeclarative Code and PerformanceRead-Only References and Returning by ReferenceReturning Values by ReferencePreventing Modifications to DataKeeping By-Reference Variables Within ScopeConsidering Performance vs. SimplicityFinal Word on Mutable By-Reference ParametersSummary
4. Implicit and Explicit Copying
Copying by Simple AssignmentValue Copy BehaviorRead-Only Properties vs. Immutable TypesCreating New ObjectsOverwriting a ValueConstructing Value TypesCopying Records Like Value TypesIdentifying Unnecessary BoxingTo an InterfaceIn Method CallsMethod Parameters and ArgumentsPassing and Returning by ValueAccessing PropertiesUsing Expressions with OperatorsModifying Return Type InstancesReference Type PropertiesInstance Methods and MutabilityProperties as Arguments for Read-Only ParametersDefensive CopiesMutable Value Types and in ParametersAutomatic vs. Nonautomatic PropertiesRead-Only Reference VariablesRead-Only FieldsDefending Against MutationRead-Only Accessors and MethodsRead-Only TypesSummary

5. Types of Equality
Built-in EqualityWhole NumbersFloating-Point ValuesReference EqualityStrings and Value EqualityCustom Equality for ClassesDefining Equality OperatorsHandling Comparisons with nullMaking Type-Safe ComparisonsWorking with Hash CodesStructs and EqualityOverriding Equals for StructsBoxing Values and Comparing by IdentityComparing Generic VariablesGeneric Code and the Equals MethodThe IEquatable<T> InterfaceCompiler-Generated EqualityRecords and Record StructsEquality for Nullable ValuesValue Tuples and EqualitySummary
6. The Nature of Values
Value vs. Reference SemanticsCopying and Equality Comparison BehaviorMutabilityMechanics vs. SemanticsObject RelationshipsKinds of ObjectsObject CharacteristicsDesign Refinement to Model Object RolesAbstraction and VocabularyEncapsulation and CohesionEliminating DuplicationEstablishing Class InvariantsClarifying with SymmetryEncapsulation and the Public InterfaceExtending the InterfaceReducing the Internal InterfaceComposing AbstractionsChoosing Between Value and Reference SemanticsAvoiding the Pitfalls of Default VariablesImplementing Custom vs. Generated BehaviorOverriding Generated MethodsComparison for OrderingEquivalence vs. EqualityThe Contract for ComparisonsOther Kinds of OrderingThe Perils of Uniformity and ConsistencyArithmetic and Nonarithmetic TypesNonstandard Operator BehaviorSummary
7. Value Types and Polymorphism
Why Value Types Are SealedImplementation InheritanceValue-Based Equality for ClassesEquality Behavior in Derived ClassesEquality Comparisons and Type SubstitutionInclusion Polymorphism and SubtypingWorking with Input and Output Types of Virtual MethodsUpholding a Type’s ContractInheriting Record TypesAvoiding Implementation InheritanceContaining Instead of Inheriting TypesParametric Polymorphism with GenericsGeneric Constraints and Protocol InterfacesGeneric Method Parameters and Type DeductionParameterized TypesAd Hoc Polymorphism with OverloadingSymbolic Polymorphism with Overloaded OperatorsGeneric Delegates for PolymorphismCoercion Polymorphism Using ConversionsWidening vs. Narrowing ConversionsFor RepresentationFor PurposeSummary
8. Performance and Efficiency
Measuring and Optimizing PerformanceThe JIT CompilerPerformance BenchmarksThe ProfilerMeasuring Basic Performance with EqualsHidden Costs of SimplicityThe ValueType.Equals MethodThe ValueType.GetHashCode MethodThe HashCode.Combine MethodOptimizing EqualityThe Effect of IEquatable<T>Property AccessesThe Equality OperatorsHow Type Affects PerformanceMeasuring the Cost of CopyingCopying Large InstancesWeighing Object Construction CostsMeasuring the Compiler-Generated Equals MethodHow Common Idioms and Practices Affect PerformanceLooping and IterationPattern Matching and SelectionSummary
Afterword
Appendix: Further Reading
Index

Content preview from The C# Type System

`7` `VALUE TYPES AND POLYMORPHISM`

As an object-oriented programming (OOP) language, C# has good support for features that allow us to capture complex ideas and express them intuitively, such as classes, virtual methods, and inheritance. However, the language support for inheritance doesn’t extend to value types. Structs and record structs implicitly derive from the ValueType class, which is derived directly from object,

but they can’t inherit any other type and can’t themselves be inherited; that is, structs and record structs are implicitly sealed. Inheritance is a central feature of OOP that enables us to treat a reference to a derived class ...

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

Pro .NET Framework with the Base Class Library: Understanding the Virtual Execution System and the Common Type System

Publisher Resources

ISBN: 9781098168537

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The C# Type System

by Steve Love

`7` `VALUE TYPES AND POLYMORPHISM`

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.