book

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

Name: C# 6.0 and the .NET 4.6 Framework, Seventh Edition
ISBN: 9781484213322

by Andrew Troelsen, Philip Japikse

December 2015

Intermediate to advanced

1704 pages

43h 12m

English

Apress

Read now

Unlock full access

Cover
Title
Copyright
Dedication
Contents at a Glance
Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction

Part I: Introducing C# and the .NET Platform
Chapter 1: The Philosophy of .NET
An Initial Look at the .NET PlatformSome Key Benefits of the .NET PlatformIntroducing the Building Blocks of the .NET Platform (the CLR, CTS, and CLS)The Role of the Base Class LibrariesWhat C# Brings to the TableManaged vs. Unmanaged CodeAdditional .NET-Aware Programming LanguagesLife in a Multilanguage WorldAn Overview of .NET AssembliesThe Role of the Common Intermediate LanguageBenefits of CILCompiling CIL to Platform-Specific InstructionsThe Role of .NET Type MetadataThe Role of the Assembly ManifestUnderstanding the Common Type SystemCTS Class TypesCTS Interface TypesCTS Structure TypesCTS Enumeration TypesCTS Delegate TypesCTS Type MembersIntrinsic CTS Data TypesUnderstanding the Common Language SpecificationEnsuring CLS ComplianceUnderstanding the Common Language RuntimeThe Assembly/Namespace/Type DistinctionThe Role of the Microsoft Root NamespaceAccessing a Namespace ProgrammaticallyReferencing External AssembliesExploring an Assembly Using ildasm.exeViewing CIL CodeViewing Type MetadataViewing Assembly Metadata (aka the Manifest)The Platform-Independent Nature of .NETThe Mono ProjectMicrosoft .NET CoreSummary
Chapter 2: Building C# Applications
Building C# Applications on the Windows OSThe Visual Studio Express Family of IDEsThe Visual Studio Community Edition IDEThe Visual Studio 2015 Professional IDEThe .NET Framework Documentation SystemBuilding .NET Applications Beyond the Windows OSThe Role of Xamarin StudioSummary
Part II: Core C# Programming
Chapter 3: Core C# Programming Constructs, Part I
The Anatomy of a Simple C# ProgramVariations on the Main( ) MethodSpecifying an Application Error CodeProcessing Command-Line ArgumentsSpecifying Command-Line Arguments with Visual StudioAn Interesting Aside: Some Additional Members of the System.Environment ClassThe System.Console ClassBasic Input and Output with the Console ClassFormatting Console OutputFormatting Numerical DataFormatting Numerical Data Beyond Console ApplicationsSystem Data Types and Corresponding C# KeywordsVariable Declaration and InitializationIntrinsic Data Types and the new OperatorThe Data Type Class HierarchyMembers of Numerical Data TypesMembers of System.BooleanMembers of System.CharParsing Values from String DataSystem.DateTime and System.TimeSpanThe System.Numerics.dll AssemblyWorking with String DataBasic String ManipulationString ConcatenationEscape CharactersDefining Verbatim StringsStrings and EqualityStrings Are ImmutableThe System.Text.StringBuilder TypeString InterpolationNarrowing and Widening Data Type ConversionsThe checked KeywordSetting Project-wide Overflow CheckingThe unchecked KeywordUnderstanding Implicitly Typed Local VariablesRestrictions on Implicitly Typed VariablesImplicit Typed Data Is Strongly Typed DataUsefulness of Implicitly Typed Local VariablesC# Iteration ConstructsThe for LoopThe foreach LoopUse of Implicit Typing Within foreach ConstructsThe while and do/while Looping ConstructsDecision Constructs and the Relational/Equality OperatorsThe if/else StatementEquality and Relational OperatorsConditional OperatorsThe switch StatementSummary
Chapter 4: Core C# Programming Constructs, Part II
Methods and Parameter ModifiersThe Default by Value Parameter-Passing BehaviorThe out ModifierThe ref ModifierThe params ModifierDefining Optional ParametersInvoking Methods Using Named ParametersUnderstanding Method OverloadingUnderstanding C# ArraysC# Array Initialization SyntaxImplicitly Typed Local ArraysDefining an Array of ObjectsWorking with Multidimensional ArraysArrays As Arguments or Return ValuesThe System.Array Base ClassUnderstanding the enum TypeControlling the Underlying Storage for an enumDeclaring enum VariablesThe System.Enum TypeDynamically Discovering an enum’s Name/Value PairsUnderstanding the Structure (aka Value Type)Creating Structure VariablesUnderstanding Value Types and Reference TypesValue Types, References Types, and the Assignment OperatorValue Types Containing Reference TypesPassing Reference Types by ValuePassing Reference Types by ReferenceFinal Details Regarding Value Types and Reference TypesUnderstanding C# Nullable TypesWorking with Nullable TypesThe Null Coalescing OperatorThe Null Conditional OperatorSummary
Part III: Object-Oriented Programming with C#
Chapter 5: Understanding Encapsulation
Introducing the C# Class TypeAllocating Objects with the new KeywordUnderstanding ConstructorsThe Role of the Default ConstructorDefining Custom ConstructorsThe Default Constructor RevisitedThe Role of the this KeywordChaining Constructor Calls Using thisObserving Constructor FlowRevisiting Optional ArgumentsUnderstanding the static KeywordDefining Static Field DataDefining Static MethodsDefining Static ConstructorsDefining Static ClassesImporting Static Members via the C# using KeywordDefining the Pillars of OOPThe Role of EncapsulationThe Role of InheritanceThe Role of PolymorphismC# Access ModifiersThe Default Access ModifiersAccess Modifiers and Nested TypesThe First Pillar: C#’s Encapsulation ServicesEncapsulation Using Traditional Accessors and MutatorsEncapsulation Using .NET PropertiesUsing Properties Within a Class DefinitionRead-Only and Write-Only PropertiesRevisiting the static Keyword: Defining Static PropertiesUnderstanding Automatic PropertiesInteracting with Automatic PropertiesAutomatic Properties and Default ValuesInitialization of Automatic PropertiesUnderstanding Object Initialization SyntaxCalling Custom Constructors with Initialization SyntaxInitializing Data with Initialization SyntaxWorking with Constant Field DataUnderstanding Read-Only FieldsStatic Read-Only FieldsUnderstanding Partial ClassesUse Cases for Partial Classes?Summary
Chapter 6: Understanding Inheritance and Polymorphism
The Basic Mechanics of InheritanceSpecifying the Parent Class of an Existing ClassRegarding Multiple Base ClassesThe sealed KeywordRevising Visual Studio Class DiagramsThe Second Pillar of OOP: The Details of InheritanceControlling Base Class Creation with the base KeywordKeeping Family Secrets: The protected KeywordAdding a Sealed ClassProgramming for Containment/DelegationUnderstanding Nested Type DefinitionsThe Third Pillar of OOP: C#’s Polymorphic SupportThe virtual and override KeywordsOverriding Virtual Members Using the Visual Studio IDESealing Virtual MembersUnderstanding Abstract ClassesUnderstanding the Polymorphic InterfaceUnderstanding Member ShadowingUnderstanding Base Class/Derived Class Casting RulesThe C# as KeywordThe C# is KeywordThe Master Parent Class: System.ObjectOverriding System.Object.ToString()Overriding System.Object.Equals()Overriding System.Object.GetHashCode()Testing Your Modified Person ClassThe Static Members of System.ObjectSummary
Chapter 7: Understanding Structured Exception Handling
Ode to Errors, Bugs, and ExceptionsThe Role of .NET Exception HandlingThe Building Blocks of .NET Exception HandlingThe System.Exception Base ClassThe Simplest Possible ExampleThrowing a General ExceptionCatching ExceptionsConfiguring the State of an ExceptionThe TargetSite PropertyThe StackTrace PropertyThe HelpLink PropertyThe Data PropertySystem-Level Exceptions (System.SystemException)Application-Level Exceptions (System.ApplicationException)Building Custom Exceptions, Take 1Building Custom Exceptions, Take 2Building Custom Exceptions, Take 3Processing Multiple ExceptionsGeneral catch StatementsRethrowing ExceptionsInner ExceptionsThe finally BlockException FiltersDebugging Unhandled Exceptions Using Visual StudioSummary
Chapter 8: Working with Interfaces
Understanding Interface TypesInterface Types vs. Abstract Base ClassesDefining Custom InterfacesImplementing an InterfaceInvoking Interface Members at the Object LevelObtaining Interface References: The as KeywordObtaining Interface References: The is KeywordInterfaces As ParametersInterfaces As Return ValuesArrays of Interface TypesImplementing Interfaces Using Visual StudioExplicit Interface ImplementationDesigning Interface HierarchiesMultiple Inheritance with Interface TypesThe IEnumerable and IEnumerator InterfacesBuilding Iterator Methods with the yield KeywordBuilding a Named IteratorThe ICloneable InterfaceA More Elaborate Cloning ExampleThe IComparable InterfaceSpecifying Multiple Sort Orders with IComparerCustom Properties and Custom Sort TypesSummary
Part IV: Advanced C# Programming
Chapter 9: Collections and Generics
The Motivation for Collection ClassesThe System.Collections NamespaceA Survey of System.Collections.Specialized NamespaceThe Problems of Nongeneric CollectionsThe Issue of PerformanceThe Issue of Type SafetyA First Look at Generic CollectionsThe Role of Generic Type ParametersSpecifying Type Parameters for Generic Classes/StructuresSpecifying Type Parameters for Generic MembersSpecifying Type Parameters for Generic InterfacesThe System.Collections.Generic NamespaceUnderstanding Collection Initialization SyntaxWorking with the List<T> ClassWorking with the Stack<T> ClassWorking with the Queue<T> ClassWorking with the SortedSet<T> ClassWorking with the Dictionary<TKey, TValue> ClassThe System.Collections.ObjectModel NamespaceWorking with ObservableCollection<T>Creating Custom Generic MethodsInference of Type ParametersCreating Custom Generic Structures and ClassesThe default Keyword in Generic CodeConstraining Type ParametersExamples Using the where KeywordThe Lack of Operator ConstraintsSummary
Chapter 10: Delegates, Events, and Lambda Expressions
Understanding the .NET Delegate TypeDefining a Delegate Type in C#The System.MulticastDelegate and System.Delegate Base ClassesThe Simplest Possible Delegate ExampleInvestigating a Delegate ObjectSending Object State Notifications Using DelegatesEnabling MulticastingRemoving Targets from a Delegate’s Invocation ListMethod Group Conversion SyntaxUnderstanding Generic DelegatesThe Generic Action<> and Func<> DelegatesUnderstanding C# EventsThe C# event KeywordEvents Under the HoodListening to Incoming EventsSimplifying Event Registration Using Visual StudioCleaning Up Event Invocation Using the C# 6.0 Null-Conditional OperatorCreating Custom Event ArgumentsThe Generic EventHandler<T> DelegateUnderstanding C# Anonymous MethodsAccessing Local VariablesUnderstanding Lambda ExpressionsDissecting a Lambda ExpressionProcessing Arguments Within Multiple StatementsLambda Expressions with Multiple (or Zero) ParametersRetrofitting the CarEvents Example Using Lambda ExpressionsLambdas and Single Statement Member ImplementationsSummary
Chapter 11: Advanced C# Language Features
Understanding Indexer MethodsIndexing Data Using String ValuesOverloading Indexer MethodsIndexers with Multiple DimensionsIndexer Definitions on Interface TypesUnderstanding Operator OverloadingOverloading Binary OperatorsAnd What of the += and –+ Operators?Overloading Unary OperatorsOverloading Equality OperatorsOverloading Comparison OperatorsFinal Thoughts Regarding Operator OverloadingUnderstanding Custom Type ConversionsRecall: Numerical ConversionsRecall: Conversions Among Related Class TypesCreating Custom Conversion RoutinesAdditional Explicit Conversions for the Square TypeDefining Implicit Conversion RoutinesUnderstanding Extension MethodsDefining Extension MethodsInvoking Extension MethodsImporting Extension MethodsThe IntelliSense of Extension MethodsExtending Types Implementing Specific InterfacesUnderstanding Anonymous TypesDefining an Anonymous TypeThe Internal Representation of Anonymous TypesThe Implementation of ToString() and GetHashCode()The Semantics of Equality for Anonymous TypesAnonymous Types Containing Anonymous TypesWorking with Pointer TypesThe unsafe KeywordWorking with the * and & OperatorsAn Unsafe (and Safe) Swap FunctionField Access via Pointers (the -> Operator)The stackalloc KeywordPinning a Type via the fixed KeywordThe sizeof KeywordSummary
Chapter 12: LINQ to Objects
LINQ-Specific Programming ConstructsImplicit Typing of Local VariablesObject and Collection Initialization SyntaxLambda ExpressionsExtension MethodsAnonymous TypesUnderstanding the Role of LINQLINQ Expressions Are Strongly TypedThe Core LINQ AssembliesApplying LINQ Queries to Primitive ArraysOnce Again, Without LINQReflecting over a LINQ Result SetLINQ and Implicitly Typed Local VariablesLINQ and Extension MethodsThe Role of Deferred ExecutionThe Role of Immediate ExecutionReturning the Result of a LINQ QueryReturning LINQ Results via Immediate ExecutionApplying LINQ Queries to Collection ObjectsAccessing Contained SubobjectsApplying LINQ Queries to Nongeneric CollectionsFiltering Data Using OfType<T>( )Investigating the C# LINQ Query OperatorsBasic Selection SyntaxObtaining Subsets of DataProjecting New Data TypesObtaining Counts Using EnumerableReversing Result SetsSorting ExpressionsLINQ As a Better Venn Diagramming ToolRemoving DuplicatesLINQ Aggregation OperationsThe Internal Representation of LINQ Query StatementsBuilding Query Expressions with Query Operators (Revisited)Building Query Expressions Using the Enumerable Type and Lambda ExpressionsBuilding Query Expressions Using the Enumerable Type and Anonymous MethodsBuilding Query Expressions Using the Enumerable Type and Raw DelegatesSummary
Chapter 13: Understanding Object Lifetime
Classes, Objects, and ReferencesThe Basics of Object LifetimeThe CIL of newSetting Object References to nullThe Role of Application RootsUnderstanding Object GenerationsConcurrent Garbage Collection Prior to .NET 4.0Background Garbage Collection Under .NET 4.0 and BeyondThe System.GC TypeForcing a Garbage CollectionBuilding Finalizable ObjectsOverriding System.Object.Finalize()Detailing the Finalization ProcessBuilding Disposable ObjectsReusing the C# using KeywordBuilding Finalizable and Disposable TypesA Formalized Disposal PatternUnderstanding Lazy Object InstantiationCustomizing the Creation of the Lazy DataSummary
Part V: Programming with .NET Assemblies
Chapter 14: Building and Configuring Class Libraries
Defining Custom NamespacesResolving Name Clashes with Fully Qualified NamesResolving Name Clashes with AliasesCreating Nested NamespacesThe Default Namespace of Visual StudioThe Role of .NET AssembliesAssemblies Promote Code ReuseAssemblies Establish a Type BoundaryAssemblies are Versionable UnitsAssemblies are Self-DescribingAssemblies are ConfigurableUnderstanding the Format of a .NET AssemblyThe Windows File HeaderThe CLR File HeaderCIL Code, Type Metadata, and the Assembly ManifestOptional Assembly ResourcesBuilding and Consuming Custom Class LibraryExploring the ManifestExploring the CILExploring the Type MetadataBuilding a C# Client ApplicationBuilding a Visual Basic Client ApplicationCross-Language Inheritance in ActionUnderstanding Private AssembliesThe Identity of a Private AssemblyUnderstanding the Probing ProcessConfiguring Private AssembliesThe Role of the App.Config FileUnderstanding Shared AssembliesThe Global Assembly CacheUnderstanding Strong NamesGenerating Strong Names at the Command LineGenerating Strong Names Using Visual StudioInstalling Strongly Named Assemblies to the GACConsuming a Shared AssemblyExploring the Manifest of SharedCarLibClientConfiguring Shared AssembliesFreezing the Current Shared AssemblyBuilding a Shared Assembly Version 2.0.0.0Dynamically Redirecting to Specific Versions of a Shared AssemblyUnderstanding Publisher Policy AssembliesDisabling Publisher PolicyUnderstanding the <codeBase> ElementThe System.Configuration NamespaceThe Configuration File Schema DocumentationSummary
Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming
The Necessity of Type MetadataViewing (Partial) Metadata for the EngineState EnumerationViewing (Partial) Metadata for the Car TypeExamining a TypeRefDocumenting the Defining AssemblyDocumenting Referenced AssembliesDocumenting String LiteralsUnderstanding ReflectionThe System.Type ClassObtaining a Type Reference Using System.Object.GetType()Obtaining a Type Reference Using typeof()Obtaining a Type Reference Using System.Type.GetType()Building a Custom Metadata ViewerReflecting on MethodsReflecting on Fields and PropertiesReflecting on Implemented InterfacesDisplaying Various Odds and EndsImplementing Main()Reflecting on Generic TypesReflecting on Method Parameters and Return ValuesDynamically Loading AssembliesReflecting on Shared AssembliesUnderstanding Late BindingThe System.Activator ClassInvoking Methods with No ParametersInvoking Methods with ParametersUnderstanding the Role of .NET AttributesAttribute ConsumersApplying Attributes in C#C# Attribute Shorthand NotationSpecifying Constructor Parameters for AttributesThe Obsolete Attribute in ActionBuilding Custom AttributesApplying Custom AttributesNamed Property SyntaxRestricting Attribute UsageAssembly-Level AttributesThe Visual Studio AssemblyInfo.cs FileReflecting on Attributes Using Early BindingReflecting on Attributes Using Late BindingPutting Reflection, Late Binding, and Custom Attributes in PerspectiveBuilding an Extendable ApplicationBuilding CommonSnappableTypes.dllBuilding the C# Snap-InBuilding the Visual Basic Snap-InBuilding an Extendable Windows Forms ApplicationSummary
Chapter 16: Dynamic Types and the Dynamic Language Runtime
The Role of the C# dynamic KeywordCalling Members on Dynamically Declared DataThe Role of the Microsoft.CSharp.dll AssemblyThe Scope of the dynamic KeywordLimitations of the dynamic KeywordPractical Uses of the dynamic KeywordThe Role of the Dynamic Language RuntimeThe Role of Expression TreesThe Role of the System.Dynamic NamespaceDynamic Runtime Lookup of Expression TreesSimplifying Late-Bound Calls Using Dynamic TypesLeveraging the dynamic Keyword to Pass ArgumentsSimplifying COM Interoperability Using Dynamic DataThe Role of Primary Interop AssembliesEmbedding Interop MetadataCommon COM Interop Pain PointsCOM Interop Using C# Dynamic DataCOM interop Without C# Dynamic DataSummary
Chapter 17: Processes, AppDomains, and Object Contexts
The Role of a Windows ProcessThe Role of ThreadsInteracting with Processes Under the .NET PlatformEnumerating Running ProcessesInvestigating a Specific ProcessInvestigating a Process’s Thread SetInvestigating a Process’s Module SetStarting and Stopping Processes ProgrammaticallyControlling Process Startup Using the ProcessStartInfo ClassUnderstanding .NET Application DomainsThe System.AppDomain ClassInteracting with the Default Application DomainEnumerating Loaded AssembliesReceiving Assembly Load NotificationsCreating New Application DomainsLoading Assemblies into Custom Application DomainsProgrammatically Unloading AppDomainsUnderstanding Object Context BoundariesContext-Agile and Context-Bound TypesDefining a Context-Bound ObjectInspecting an Object’s ContextSummarizing Processes, AppDomains, and ContextSummary
Chapter 18: Understanding CIL and the Role of Dynamic Assemblies
Motivations for Learning the Grammar of CILExamining CIL Directives, Attributes, and OpcodesThe Role of CIL DirectivesThe Role of CIL AttributesThe Role of CIL OpcodesThe CIL Opcode/CIL Mnemonic DistinctionPushing and Popping: The Stack-Based Nature of CILUnderstanding Round-Trip EngineeringThe Role of CIL Code LabelsInteracting with CIL: Modifying an *.il FileCompiling CIL Code Using ilasm.exeThe Role of peverify.exeUnderstanding CIL Directives and AttributesSpecifying Externally Referenced Assemblies in CILDefining the Current Assembly in CILDefining Namespaces in CILDefining Class Types in CILDefining and Implementing Interfaces in CILDefining Structures in CILDefining Enums in CILDefining Generics in CILCompiling the CILTypes.il file.NET Base Class Library, C#, and CIL Data Type MappingsDefining Type Members in CILDefining Field Data in CILDefining Type Constructors in CILDefining Properties in CILDefining Member ParametersExamining CIL OpcodesThe .maxstack DirectiveDeclaring Local Variables in CILMapping Parameters to Local Variables in CILThe Hidden this ReferenceRepresenting Iteration Constructs in CILBuilding a .NET Assembly with CILBuilding CILCars.dllBuilding CILCarClient.exeUnderstanding Dynamic AssembliesExploring the System.Reflection.Emit NamespaceThe Role of the System.Reflection.Emit.ILGeneratorEmitting a Dynamic AssemblyEmitting the Assembly and Module SetThe Role of the ModuleBuilder TypeEmitting the HelloClass Type and the String Member VariableEmitting the ConstructorsEmitting the SayHello() MethodUsing the Dynamically Generated AssemblySummary
Part VI: Introducing the .NET Base Class Libraries
Chapter 19: Multithreaded, Parallel, and Async Programming
The Process/AppDomain/Context/Thread RelationshipThe Problem of ConcurrencyThe Role of Thread SynchronizationA Brief Review of the .NET DelegateThe Asynchronous Nature of DelegatesThe BeginInvoke() and EndInvoke() MethodsThe System.IAsyncResult InterfaceInvoking a Method AsynchronouslySynchronizing the Calling ThreadThe Role of the AsyncCallback DelegateThe Role of the AsyncResult ClassPassing and Receiving Custom State DataThe System.Threading NamespaceThe System.Threading.Thread ClassObtaining Statistics About the Current Thread of ExecutionThe Name PropertyThe Priority PropertyManually Creating Secondary ThreadsWorking with the ThreadStart DelegateWorking with the ParameterizedThreadStart DelegateThe AutoResetEvent ClassForeground Threads and Background ThreadsThe Issue of ConcurrencySynchronization Using the C# lock KeywordSynchronization Using the System.Threading.Monitor TypeSynchronization Using the System.Threading.Interlocked TypeSynchronization Using the [Synchronization] AttributeProgramming with Timer CallbacksUnderstanding the CLR ThreadPoolParallel Programming Using the Task Parallel LibraryThe System.Threading.Tasks NamespaceThe Role of the Parallel ClassData Parallelism with the Parallel ClassAccessing UI Elements on Secondary ThreadsThe Task ClassHandling Cancellation RequestTask Parallelism Using the Parallel ClassParallel LINQ Queries (PLINQ)Opting in to a PLINQ QueryCancelling a PLINQ QueryAsynchronous Calls with the async KeywordA First Look at the C# async and await KeywordsNaming Conventions for Async MethodsAsync Methods Returning VoidAsync Methods with Multiple AwaitsRetrofitting the AddWithThreads Example Using Asycn/AwaitSummary
Chapter 20: File I/O and Object Serialization
Exploring the System.IO NamespaceThe Directory(Info) and File(Info) TypesThe Abstract FileSystemInfo Base ClassWorking with the DirectoryInfo TypeEnumerating Files with the DirectoryInfo TypeCreating Subdirectories with the DirectoryInfo TypeWorking with the Directory TypeWorking with the DriveInfo Class TypeWorking with the FileInfo ClassThe FileInfo.Create() MethodThe FileInfo.Open() MethodThe FileInfo.OpenRead() and FileInfo.OpenWrite() MethodsThe FileInfo.OpenText() MethodThe FileInfo.CreateText() and FileInfo.AppendText() MethodsWorking with the File TypeAdditional File-Centric MembersThe Abstract Stream ClassWorking with FileStreamsWorking with StreamWriters and StreamReadersWriting to a Text FileReading from a Text FileDirectly Creating StreamWriter/StreamReader TypesWorking with StringWriters and StringReadersWorking with BinaryWriters and BinaryReadersWatching Files ProgrammaticallyUnderstanding Object SerializationThe Role of Object GraphsConfiguring Objects for SerializationDefining Serializable TypesPublic Fields, Private Fields, and Public PropertiesChoosing a Serialization FormatterThe IFormatter and IRemotingFormatter InterfacesType Fidelity Among the FormattersSerializing Objects Using the BinaryFormatterDeserializing Objects Using the BinaryFormatterSerializing Objects Using the SoapFormatterSerializing Objects Using the XmlSerializerControlling the Generated XML DataSerializing Collections of ObjectsCustomizing the Soap/Binary Serialization ProcessA Deeper Look at Object SerializationCustomizing Serialization Using ISerializableCustomizing Serialization Using AttributesSummary
Chapter 21: ADO.NET Part I: The Connected Layer
A High-Level Definition of ADO.NETThe Three Faces of ADO.NETUnderstanding ADO.NET Data ProvidersThe Microsoft-Supplied ADO.NET Data ProvidersA Word Regarding System.Data.OracleClient.dllObtaining Third-Party ADO.NET Data ProvidersAdditional ADO.NET NamespacesThe Types of the System.Data NamespaceThe Role of the IDbConnection InterfaceThe Role of the IDbTransaction InterfaceThe Role of the IDbCommand InterfaceThe Role of the IDbDataParameter and IDataParameter InterfacesThe Role of the IDbDataAdapter and IDataAdapter InterfacesThe Role of the IDataReader and IDataRecord InterfacesAbstracting Data Providers Using InterfacesIncreasing Flexibility Using Application Configuration FilesCreating the AutoLot DatabaseCreating the Inventory TableAdding Test Records to the Inventory TableAuthoring the GetPetName() Stored ProcedureCreating the Customers and Orders TablesCreating Table Relationships in Visual StudioThe ADO.NET Data Provider Factory ModelA Complete Data Provider Factory ExampleA Potential Drawback with the Data Provider Factory ModelThe <connectionStrings> ElementUnderstanding the Connected Layer of ADO.NETWorking with Connection ObjectsWorking with ConnectionStringBuilder ObjectsWorking with Command ObjectsWorking with Data ReadersObtaining Multiple Result Sets Using a Data ReaderBuilding a Reusable Data Access LibraryAdding the Connection LogicAdding the Insertion LogicAdding the Deletion LogicAdding the Update LogicAdding the Selection LogicWorking with Parameterized Command ObjectsSpecifying Parameters Using the DbParameter TypeExecuting a Stored ProcedureCreating a Console UI–Based Front EndImplementing the Main() MethodImplementing the ShowInstructions(?) MethodImplementing the ListInventory(?) MethodImplementing the DeleteCar() MethodImplementing the InsertNewCar() MethodImplementing the UpdateCarPetName() MethodImplementing LookUpPetName()Understanding Database TransactionsKey Members of an ADO.NET Transaction ObjectAdding a CreditRisks Table to the AutoLot DatabaseAdding a Transaction Method to InventoryDALTesting Your Database TransactionSummary
Chapter 22: ADO.NET Part II: The Disconnected Layer
Understanding the Disconnected Layer of ADO.NETUnderstanding the Role of the DataSetKey Properties of the DataSetKey Methods of the DataSetBuilding a DataSetWorking with DataColumnsBuilding a DataColumnEnabling Autoincrementing FieldsAdding DataColumn Objects to a DataTableWorking with DataRowsUnderstanding the RowState PropertyUnderstanding the DataRowVersion PropertyWorking with DataTablesInserting DataTables into DataSetsObtaining Data in a DataSetProcessing DataTable Data Using DataTableReader ObjectsSerializing DataTable/DataSet Objects As XMLSerializing DataTable/DataSet Objects in a Binary FormatBinding DataTable Objects to Windows Forms GUIsHydrating a DataTable from a Generic List<T>Deleting Rows from a DataTableSelecting Rows Based on Filter CriteriaUpdating Rows Within a DataTableWorking with the DataView TypeWorking with Data AdaptersA Simple Data Adapter ExampleMapping Database Names to Friendly NamesAdding Disconnected Functionality to AutoLotDAL.dllDefining the Initial Class TypeConfiguring the Data Adapter Using the SqlCommandBuilderImplementing GetAllInventory()Implementing UpdateInventory()Setting Your Version NumberTesting the Disconnected FunctionalityMultitabled DataSet Objects and Data RelationshipsPrepping the Data AdaptersBuilding the Table RelationshipsUpdating the Database TablesNavigating Between Related TablesThe Windows Forms Database Designer ToolsVisually Designing the DataGridViewThe Generated App.config FileExamining the Strongly Typed DataSetExamining the Strongly Typed DataTableExamining the Strongly Typed DataRowExamining the Strongly Typed Data AdapterCompleting the Windows Forms ApplicationIsolating Strongly Typed Database Code into a Class LibraryViewing the Generated CodeSelecting Data with the Generated CodeInserting Data with the Generated CodeDeleting Data with the Generated CodeInvoking a Stored Procedure Using the Generated CodeProgramming with LINQ to DataSetThe Role of the DataSet Extensions LibraryObtaining a LINQ-Compatible DataTableThe Role of the DataRowExtensions.Field<T>() Extension MethodHydrating New DataTables from LINQ QueriesSummary
Chapter 23: ADO.NET Part III: Entity Framework
Understanding the Role of the Entity FrameworkThe Role of EntitiesThe Building Blocks of the Entity FrameworkCode First from an Existing DatabaseGenerating the ModelWhat Did That Do?Changing the Default MappingsAdding to the Generated Model ClassesUsing the Model Classes in CodeInserting a RecordSelecting RecordsThe Role of Navigation PropertiesDeleting a RecordUpdating a RecordHandling Database ChangesAutoLotDAL Version 4Entity Framework Data AnnotationsAdding or Updating the Model ClassesAdding the DbContextAdding the RepositoriesInitializing the DatabaseTest-Driving AutoLotDALPrinting All Inventory RecordsAdding Inventory RecordsEditing RecordsUsing Navigation PropertiesMultitable Actions/Implicit TransactionsEntity Framework MigrationsUpdating the ModelTesting the AppEntering EF MigrationsCreating the Baseline MigrationSeeding the DatabaseRevisiting the Transaction TestConcurrencyCorrecting the RepositoriesTesting ConcurrencyInterceptionThe IDbCommandInterceptor InterfaceAdding Interception to AutoLotDALRegistering the InterceptorAdding the DatabaseLogger InterceptorObjectMaterialized and SavingChanges EventsAccessing the Object ContextObjectMaterializedSavingChangesDeploying to SQL ServerSummary
Chapter 24: Introducing LINQ to XML
A Tale of Two XML APIsLINQ to XML As a Better DOMVB Literal Syntax As a Better LINQ to XMLMembers of the System.Xml.Linq NamespaceThe LINQ to XML Axis MethodsThe Oddness of XName (and XNamespace)Working with XElement and XDocumentGenerating Documents from Arrays and ContainersLoading and Parsing XML ContentManipulating an In-Memory XML DocumentBuilding the UI of the LINQ to XML AppImport the Inventory.xml FileDefining a LINQ to XML Helper ClassAttaching the UI to Your Helper ClassSummary
Chapter 25: Introducing Windows Communication Foundation
A Potpourri of Distributed Computing APIsThe Role of DCOMThe Role of COM+/Enterprise ServicesThe Role of MSMQThe Role of .NET RemotingThe Role of XML Web ServicesWeb Service StandardsThe Role of WCFAn Overview of WCF FeaturesAn Overview of Service-Oriented ArchitectureTenet 1: Boundaries are ExplicitTenet 2: Services are AutonomousTenet 3: Services Communicate via Contract, Not ImplementationTenet 4: Service Compatibility is Based on PolicyWCF: The Bottom LineInvestigating the Core WCF AssembliesThe Visual Studio WCF Project TemplatesThe WCF Service Web Site Project TemplateThe Basic Composition of a WCF ApplicationThe ABCs of WCFUnderstanding WCF ContractsUnderstanding WCF BindingsHTTP-Based BindingsTCP-Based BindingsMSMQ-Based BindingsUnderstanding WCF AddressesBuilding a WCF ServiceThe [ServiceContract] AttributeThe [OperationContract] AttributeService Types As Operational ContractsHosting the WCF ServiceEstablishing the ABCs Within an App.config FileCoding Against the ServiceHost TypeSpecifying Base AddressesDetails of the ServiceHost TypeDetails of the <system.serviceModel> ElementEnabling Metadata ExchangeBuilding the WCF Client ApplicationGenerating Proxy Code Using svcutil.exeGenerating Proxy Code Using Visual StudioConfiguring a TCP-Based BindingSimplifying Configuration SettingsLeveraging Default EndpointsExposing a Single WCF Service Using Multiple BindingsChanging Settings for a WCF BindingLeveraging the Default MEX Behavior ConfigurationRefreshing the Client Proxy and Selecting the BindingUsing the WCF Service Library Project TemplateBuilding a Simple Math ServiceTesting the WCF Service with WcfTestClient.exeAltering Configuration Files Using SvcConfigEditor.exeHosting the WCF Service Within a Windows ServiceSpecifying the ABCs in CodeEnabling MEXCreating a Windows Service InstallerInstalling the Windows ServiceInvoking a Service Asynchronously from the ClientDesigning WCF Data ContractsUsing the Web-centric WCF Service Project TemplateImplementing the Service ContractThe Role of the *.svc FileExamining the Web.config FileTesting the ServiceSummary
Part VII: Windows Presentation Foundation
Chapter 26: Introducing Windows Presentation Foundation and XAML
The Motivation Behind WPFUnifying Diverse APIsProviding a Separation of Concerns via XAMLProviding an Optimized Rendering ModelSimplifying Complex UI ProgrammingThe Various Flavors of WPFTraditional Desktop ApplicationsNavigation-Based WPF ApplicationsXBAP ApplicationsThe WPF/Silverlight RelationshipInvestigating the WPF AssembliesThe Role of the Application ClassConstructing an Application ClassEnumerating the Windows CollectionThe Role of the Window ClassBuilding a WPF Application Without XAMLCreating a Strongly Typed WindowCreating a Simple User InterfaceInteracting with Application-Level DataHandling the Closing of a Window ObjectIntercepting Mouse EventsIntercepting Keyboard EventsBuilding a WPF Application Using Only XAMLDefining a Window Object in XAMLDefining the Application Object in XAMLProcessing the XAML Files Using msbuild.exeTransforming Markup into a .NET AssemblyMapping the Window XAML Markup to C# CodeThe Role of BAMLMapping the Application XAML Markup to C# CodeXAML-to-Assembly Process SummaryUnderstanding the Syntax of WPF XAMLIntroducing KaxamlXAML XML Namespaces and XAML “Keywords”Controlling Class and Member Variable VisibilityXAML Elements, XAML Attributes, and Type ConvertersUnderstanding XAML Property-Element SyntaxUnderstanding XAML Attached PropertiesUnderstanding XAML Markup ExtensionsBuilding a WPF Application Using Code-Behind FilesAdding a Code File for the MainWindow ClassAdding a Code File for the MyApp ClassProcessing the Code Files with msbuild.exeBuilding WPF Applications Using Visual StudioThe WPF Project TemplatesThe Toolbox and XAML Designer/EditorSetting Properties Using the Properties WindowHandling Events Using the Properties WindowHandling Events in the XAML EditorThe Document Outline WindowViewing the Autogenerated Code FilesBuilding a Custom XAML Editor with Visual StudioDesigning the GUI of Your WindowImplementing the Loaded EventImplementing the Button’s Click EventImplementing the Closed EventTesting Your ApplicationExploring the WPF DocumentationSummary
Chapter 27: Programming with WPF Controls
A Survey of the Core WPF ControlsThe WPF Ink ControlsThe WPF Document ControlsWPF Common Dialog BoxesThe Details Are in the DocumentationA Brief Review of the Visual Studio WPF DesignerWorking with WPF Controls Using Visual StudioWorking with the Document Outline EditorControlling Content Layout Using PanelsPositioning Content Within Canvas PanelsPositioning Content Within WrapPanel PanelsPositioning Content Within StackPanel PanelsPositioning Content Within Grid PanelsGrids with GridSplitter TypesPositioning Content Within DockPanel PanelsEnabling Scrolling for Panel TypesConfiguring Panels Using the Visual Studio DesignersBuilding a Window’s Frame Using Nested PanelsBuilding the Menu SystemBuilding Menus VisuallyBuilding the ToolBarBuilding the StatusBarFinalizing the UI DesignImplementing the MouseEnter/MouseLeave Event HandlersImplementing the Spell Checking LogicUnderstanding WPF CommandsThe Intrinsic Command ObjectsConnecting Commands to the Command PropertyConnecting Commands to Arbitrary ActionsWorking with the Open and Save CommandsUnderstanding Routed EventsThe Role of Routed Bubbling EventsContinuing or Halting BubblingThe Role of Routed Tunneling EventsA Deeper Look at WPF APIs and ControlsWorking with the TabControlBuilding the Ink API TabDesigning the ToolBarThe RadioButton ControlHandling Events for the Ink API TabThe InkCanvas ControlThe ComboBox ControlSaving, Loading, and Clearing InkCanvas DataIntroducing the Documents APIBlock Elements and Inline ElementsDocument Layout ManagersBuilding the Documents TabPopulating a FlowDocument Using CodeEnabling Annotations and Sticky NotesSaving and Loading a Flow DocumentIntroducing the WPF Data-Binding ModelBuilding the Data Binding TabEstablishing Data Bindings Using Visual StudioThe DataContext PropertyData Conversion Using IValueConverterEstablishing Data Bindings in CodeBuilding the DataGrid TabUnderstanding the Role of Dependency PropertiesExamining an Existing Dependency PropertyImportant Notes Regarding CLR Property WrappersBuilding a Custom Dependency PropertyAdding a Data Validation RoutineResponding to the Property ChangeSummary
Chapter 28: WPF Graphics Rendering Services
Understanding WPF’s Graphical Rendering ServicesWPF Graphical Rendering OptionsRendering Graphical Data Using ShapesAdding Rectangles, Ellipses, and Lines to a CanvasRemoving Rectangles, Ellipses, and Lines from a CanvasWorking with Polylines and PolygonsWorking with PathsWPF Brushes and PensConfiguring Brushes Using Visual StudioConfiguring Brushes in CodeConfiguring PensApplying Graphical TransformationsA First Look at TransformationsTransforming Your Canvas DataWorking with the Visual Studio Transform EditorBuilding the Initial LayoutApplying Transformations at Design TimeTransforming the Canvas in CodeRendering Graphical Data Using Drawings and GeometriesBuilding a DrawingBrush Using GeometriesPainting with the DrawingBrushContaining Drawing Types in a DrawingImageWorking with Vector ImagesConverting a Sample Vector Graphic File into XAMLImporting the Graphical Data into a WPF ProjectInteracting with the SignRendering Graphical Data Using the Visual LayerThe Visual Base Class and Derived Child ClassesA First Look at Using the DrawingVisual ClassRendering Visual Data to a Custom Layout ManagerResponding to Hit-Test OperationsSummary
Chapter 29: WPF Resources, Animations, Styles, and Templates
Understanding the WPF Resource SystemWorking with Binary ResourcesWorking with Object (Logical) ResourcesThe Role of the Resources PropertyDefining Window-Wide ResourcesThe {StaticResource} Markup ExtensionThe {DynamicResource} Markup ExtensionApplication-Level ResourcesDefining Merged Resource DictionariesDefining a Resource-Only AssemblyUnderstanding WPF’s Animation ServicesThe Role of the Animation Class TypesThe To, From, and By PropertiesThe Role of the Timeline Base ClassAuthoring an Animation in C# CodeControlling the Pace of an AnimationReversing and Looping an AnimationAuthoring Animations in XAMLThe Role of StoryboardsThe Role of Event TriggersAnimation Using Discrete Key FramesUnderstanding the Role of WPF StylesDefining and Applying a StyleOverriding Style SettingsLimiting Application of a Style with TargetTypeAutomatically Applying a Style with TargetTypeSubclassing Existing StylesDefining Styles with TriggersDefining Styles with Multiple TriggersAnimated StylesAssigning Styles ProgrammaticallyLogical Trees, Visual Trees, and Default TemplatesProgrammatically Inspecting a Logical TreeProgrammatically Inspecting a Visual TreeProgrammatically Inspecting a Control’s Default TemplateBuilding a Control Template with the Trigger FrameworkTemplates as ResourcesIncorporating Visual Cues Using TriggersThe Role of the {TemplateBinding} Markup ExtensionThe Role of ContentPresenterIncorporating Templates into StylesSummary
Chapter 30: Notifications, Commands, Validation, and MVVM
Introducing Model-View-ViewModelModelViewViewModelAnemic Models or ViewModelsThe WPF Binding Notification SystemObservable Models and CollectionsAdding Bindings and DataProgrammatically Changing the Vehicle DataObservable ModelsObservable CollectionsValidationUpdating the Sample for the Validation ExamplesThe Validation ClassValidation OptionsUsing Data AnnotationsAdding Data AnnotationsChecking for Data Annotation-Based Validation ErrorsCustomizing the ErrorTemplateCreating Custom CommandsImplementing the ICommand InterfaceUpdating MainWindow.xaml.csUpdating MainWindow.xamlAttaching Command to the CommandManagerTesting the ApplicationAdding the Remaining CommandsFully Implementing MVVMMoving the Data Source Out of the ViewMoving the Commands to the ViewModelUpdating AutoLotDAL for MVVMUpdating the AutoLotDAL ModelsFull MVVM ExampleUsing ObjectMaterialized with Entity FrameworkSummary
Part VIII: ASP.NET
Chapter 31: Introducing ASP.NET Web Forms
The Role of HTTPThe HTTP Request/Response CycleHTTP Is a Stateless ProtocolUnderstanding Web Applications and Web ServersThe Role of IIS Virtual DirectoriesIIS ExpressThe Role of HTMLHTML Document StructureThe Role of an HTML FormThe Visual Studio HTML Designer ToolsBuilding an HTML FormThe Role of Client-Side ScriptingA Client-Side Scripting ExamplePosting Back to the Web ServerPostbacks Under Web FormsAn Overview of the Web Forms APIMajor Features of Web Forms 2.0 and HigherMajor Features of Web Forms 3.5 (and .NET 3.5 SP1) and HigherMajor Features of Web Forms 4.0Major Features of Web Forms 4.5 and 4.6Building a Single-File Web Forms Web AppReferencing AutoLotDAL.dllDesigning the UIAdding the Data Access LogicThe Role of ASP.NET DirectivesAnalyzing the “Script” BlockAnalyzing the ASP.NET Control DeclarationsBuilding an ASP.NET Web Page Using Code FilesReference the AutoLotDAL ProjectUpdating the Code FileDebugging and Tracing ASP.NET PagesASP.NET Web Sites vs. ASP.NET Web ApplicationsEnabling C# 6 For ASP.NET Web SitesThe ASP.NET Web Site Directory StructureReferencing AssembliesThe Role of the App_Code FolderThe Inheritance Chain of the Page TypeInteracting with the Incoming HTTP RequestObtaining Browser StatisticsAccess to Incoming Form DataThe IsPostBack PropertyInteracting with the Outgoing HTTP ResponseEmitting HTML ContentRedirecting UsersThe Life Cycle of an ASP.NET Web PageThe Role of the AutoEventWireup AttributeThe Error EventThe Role of the Web.config FileThe ASP.NET Web Site Administration UtilitySummary
Chapter 32: ASP.NET Web Controls, Master Pages, and Themes
Understanding the Nature of Web ControlsUnderstanding Server-Side Event HandlingThe AutoPostBack PropertyThe Control and WebControl Base ClassesEnumerating Contained ControlsDynamically Adding and Removing ControlsInteracting with Dynamically Created ControlsFunctionality of the WebControl Base ClassMajor Categories of Web Forms ControlsA Brief Word Regarding System.Web.UI.HtmlControlsWeb Control DocumentationBuilding the Web Forms Cars Web SiteWorking with Web Forms Master PagesConfiguring the TreeView Control Site Navigation LogicEstablishing Breadcrumbs with the SiteMapPath TypeConfiguring the AdRotator ControlDefining the Default Content PageDesigning the Inventory Content PageAdding AutoLotDAL and Entity Framework to AspNetCarsSiteFilling the GridView with DataEnabling In-Place EditingEnabling Sorting and PagingEnabling FilteringDesigning the Build-a-Car Content PageThe Role of the Validation ControlsEnabling Client-Side JavaScript Validation SupportThe RequiredFieldValidatorThe RegularExpressionValidatorThe RangeValidatorThe CompareValidatorCreating Validation SummariesDefining Validation GroupsValidation with Data AnnotationsWorking with ThemesUnderstanding *.skin FilesApplying Site-Wide ThemesApplying Themes at the Page LevelThe SkinID PropertyAssigning Themes ProgrammaticallySummary
Chapter 33: ASP.NET State Management Techniques
The Issue of StateASP.NET State Management TechniquesUnderstanding the Role of ASP.NET View StateDemonstrating View StateAdding Custom View State DataThe Role of the Global.asax FileThe Global Last-Chance Exception Event HandlerThe HttpApplication Base ClassUnderstanding the Application/Session DistinctionMaintaining Application-Level State DataModifying Application DataHandling Web Application ShutdownWorking with the Application CacheFun with Data CachingModifying the *.aspx FileMaintaining Session DataAdditional Members of HttpSessionStateUnderstanding CookiesCreating CookiesReading Incoming Cookie DataThe Role of the <sessionState> ElementStoring Session Data in the ASP.NET Session State ServerStoring Session Data in a Dedicated DatabaseIntroducing the ASP.NET Profile APIThe ASPNETDB.mdf DatabaseDefining a User Profile Within web.configAccessing Profile Data ProgrammaticallyGrouping Profile Data and Persisting Custom ObjectsSummary
Chapter 34: ASP.NET MVC and Web API
Introducing the MVC PatternThe ModelThe ViewThe ControllerWhy MVC?Enter ASP.NET MVCBuilding Your First ASP.NET MVC ApplicationThe New Project WizardThe Components of a Base MVC ProjectUpdating NuGet Packages to Current VersionsTest-Drive Your SiteRoutingURL PatternsCreating Routes for the Contact and About PagesRedirecting Users Using RoutingAdding AutoLotDALControllers and ActionsAdding the Inventory ControllerExamine the Scaffolded ViewsMVC ControllersMVC ViewsThe Razor View EngineLayoutsPartial ViewsSending Data to the ViewThe Index ViewThe Details ViewThe Create ViewThe Delete ViewThe Edit ViewValidationFinishing the UIThe Final Word on ASP.NET MVCIntroducing ASP.NET Web APIAdding the Web API ProjectExamining the Web API ProjectConfiguring the ProjectA Note About JSONAdding a ControllerUpdating CarLotMVC to Use CarLotWebAPISummary
Index

Overview

This new 7th edition of Pro C# 6.0 and the .NET 4.6 Platform has been completely revised and rewritten to reflect the latest changes to the C# language specification and new advances in the .NET Framework. You'll find new chapters covering all the important new features that make .NET 4.6 the most comprehensive release yet, including:

A Refined ADO.NET Entity Framework Programming Model

Numerous IDE and MVVM Enhancements for WPF Desktop Development

Numerous updates to the ASP.NET Web APIs

This comes on top of award winning coverage of core C# features, both old and new, that have made the previous editions of this book so popular. Readers will gain a solid foundation of object-oriented development techniques, attributes and reflection, generics and collections as well as numerous advanced topics not found in other texts (such as CIL opcodes and emitting dynamic assemblies).

The mission of this book is to provide you with a comprehensive foundation in the C# programming language and the core aspects of the .NET platform plus overviews of technologies built on top of C# and .NET (ADO.NET and Entity Framework, Windows Communication Foundation [WCF], Windows Presentation Foundation [WPF], and ASP.NET [WebForms, MVC, WebAPI]). Once you digest the information presented in these chapters, you’ll be in a perfect position to apply this knowledge to your specific programming assignments, and you’ll be well equipped to explore the .NET universe on your own terms.

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 C# 2010 and the .NET 4 Platform, Fifth Edition

Publisher Resources

ISBN: 9781484213322Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills