Muutke küpsiste eelistusi

Essential C# 8.0 7th edition [Pehme köide]

  • Formaat: Paperback / softback, 1088 pages, kõrgus x laius x paksus: 230x180x30 mm, kaal: 1328 g
  • Sari: Addison-Wesley Microsoft Technology Series
  • Ilmumisaeg: 07-Jan-2021
  • Kirjastus: Addison Wesley
  • ISBN-10: 0135972264
  • ISBN-13: 9780135972267
  • Formaat: Paperback / softback, 1088 pages, kõrgus x laius x paksus: 230x180x30 mm, kaal: 1328 g
  • Sari: Addison-Wesley Microsoft Technology Series
  • Ilmumisaeg: 07-Jan-2021
  • Kirjastus: Addison Wesley
  • ISBN-10: 0135972264
  • ISBN-13: 9780135972267
The Comprehensive, Expert Guide to C# 8.0 for Programmers at All Levels "Welcome to one of the most venerable and trusted franchises you could dream of in the world of C# books -- and probably far beyond! . . . Mark is super smart, insists on understanding everything to the core, and has phenomenal insight into how things affect real developers. . . . He goes right to the essence and communicates with great integrity -- no sugarcoating -- and has a keen eye for practical value and real-world problems." -- From the Foreword by Mads Torgersen, C# Lead Designer, Microsoft Essential C# 8.0 is a well-organized, no-fluff guide to C# 8.0 for programmers at all levels of experience. This edition retains all the valuable content of prior editions and adds discussions of null reference types, indices and ranges, enhanced pattern matching, asynchronous stream, and more. World-class C# expert Mark Michaelis presents a comprehensive tutorial and reference for the entire language, providing an accelerated learning opportunity to achieve expert C# programming skills. He includes key C# 8.0 enhancements, succinct examples to illustrate central constructs, and updated coding guidelines for minimizing bugs and writing code that's easier to evolve. To help you quickly find what you need, there are version-specific indexes of C# 6.0, 7.0, and 8.0 topics and visual icons that identify when each language innovation was introduced.







Use structured programming constructs to write functioning code immediately Learn both the complexities and solutions to nullable reference types Thoroughly master C# object constructs, including classes, inheritance, and interfaces Reduce code redundancy with generics, delegates, lambda expressions, and events Take full advantage of collections, including the new standard query operator collection API Make the most of reflection, attributes, and the declarative programming paradigm Improve multithreading with the task-based async pattern and C# 8.0 asynchronous streams Enhance performance through the parallel processing of data and multithreading tasks Program complex types with enhanced pattern matching syntax Interoperate with unmanaged code written in other languages, including C-based APIs Explore the relationship between C# programs and the underlying CLI runtime

Register your product for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.
Figures
xvii
Tables
xix
Foreword xxi
Preface xxiii
Acknowledgments xxxv
About the Author xxxvii
1 Introducing C#
1(44)
Hello, World
2(11)
C# Syntax Fundamentals
13(9)
Working with Variables
22(4)
Console Input and Output
26(8)
Managed Execution and the Common Language Infrastructure
34(5)
Multiple NET Frameworks
39(6)
2 Data Types
45(36)
Fundamental Numeric Types
46(9)
More Fundamental Types
55(17)
Conversions between Data Types
72(9)
3 More with Data Types
81(40)
Categories of Types
81(3)
Declaring Types That Allow null
84(5)
Implicitly Typed Local Variables
89(3)
Tuples
92(6)
Arrays
98(23)
4 Operators and Flow Control
121(74)
Operators
122(16)
Introducing Flow Control
138(6)
Code Blocks ({})
144(3)
Code Blocks, Scopes, and Declaration Spaces
147(2)
Boolean Expressions
149(6)
Programming with null
155(7)
Bitwise Operators (<<, >>, I, &, ˆ, ~)
162(6)
Control Flow Statements, Continued
168(12)
Jump Statements
180(6)
C# Preprocessor Directives
186(7)
Summary
193(2)
5 Methods and Parameters
195(60)
Calling a Method
196(7)
Declaring a Method
203(6)
The using Directive
209(5)
Returns and Parameters on Main()
214(3)
Advanced Method Parameters
217(12)
Recursion
229(2)
Method Overloading
231(3)
Optional Parameters
234(5)
Basic Error Handling with Exceptions
239(14)
Summary
253(2)
6 Classes
255(80)
Declaring and Instantiating a Class
259(3)
Instance Fields
262(3)
Instance Methods
265(1)
Using the this Keyword
266(8)
Access Modifiers
274(2)
Properties
276(17)
Constructors
293(10)
Non-Nullable Reference Type Properties with Constructors
303(3)
Nullable Attributes
306(3)
Deconstructors
309(2)
Static Members
311(10)
Extension Methods
321(2)
Encapsulating the Data
323(3)
Nested Classes
326(3)
Partial Classes
329(4)
Summary
333(2)
7 Inheritance
335(42)
Derivation
336(10)
Overriding the Base Class
346(11)
Abstract Classes
357(6)
All Classes Derive from System.Object
363(2)
Pattern Matching with the is Operator
365(6)
Pattern Matching within a switch Expression
371(2)
Avoid Pattern Matching When Polymorphism Is Possible
373(1)
Summary
374(3)
8 Interfaces
377(40)
Introducing Interfaces
378(2)
Polymorphism through Interfaces
380(4)
Interface Implementation
384(6)
Converting between the Implementing Class and Its Interfaces
390(1)
Interface Inheritance
390(3)
Multiple Interface Inheritance
393(1)
Extension Methods on Interfaces
394(2)
Versioning
396(15)
Extension Methods versus Default Interface Members
411(2)
Interfaces Compared with Abstract Classes
413(2)
Interfaces Compared with Attributes
415(2)
9 Value Types
417(34)
Structs
422(6)
Boxing
428(9)
Enums
437(10)
Summary
447(4)
10 Well-Formed Types
451(60)
Overriding object Members
451(13)
Operator Overloading
464(8)
Referencing Other Assemblies
472(7)
Encapsulation of Types
479(2)
Defining Namespaces
481(4)
XML Comments
485(4)
Garbage Collection
489(4)
Resource Cleanup
493(15)
Lazy Initialization
508(2)
Summary
510(1)
11 Exception Handling
511(22)
Multiple Exception Types
511(3)
Catching Exceptions
514(3)
Rethrowing an Existing Exception
517(1)
General Catch Block
518(1)
Guidelines for Exception Handling
519(4)
Defining Custom Exceptions
523(4)
Rethrowing a Wrapped Exception
527(3)
Summary
530(3)
12 Generics
533(54)
C# without Generics
534(5)
Introducing Generic Types
539(14)
Constraints
553(15)
Generic Methods
568(5)
Covariance and Contravariance
573(7)
Generic Internals
580(5)
Summary
585(2)
13 Delegates and Lambda Expressions
587(38)
Introducing Delegates
588(4)
Declaring Delegate Types
592(8)
Lambda Expressions
600(1)
Statement Lambdas
601(5)
Anonymous Methods
606(2)
Delegates Do Not Have Structural Equality
608(3)
Outer Variables
611(5)
Expression Trees
616(7)
Summary
623(2)
14 Events
625(28)
Coding the Publish--Subscribe Pattern with Multicast Delegates
626(15)
Understanding Events
641(10)
Summary
651(2)
15 Collection Interfaces with Standard Query Operators
653(52)
Collection Initializers
654(3)
What Makes a Class a Collection: IEnumerable
657(6)
Standard Query Operators
663(32)
Anonymous Types with LINQ
695(9)
Summary
704(1)
16 LINQ with Query Expressions
705(22)
Introducing Query Expressions
706(18)
Query Expressions Are Just Method Invocations
724(2)
Summary
726(1)
17 Building Custom Collections
727(42)
More Collection Interfaces
728(3)
Primary Collection Classes
731(19)
Providing an Indexer
750(3)
Returning null or an Empty Collection
753(1)
Iterators
753(15)
Summary
768(1)
18 Reflection, Attributes, and Dynamic Programming
769(44)
Reflection
770(11)
Name of Operator
781(2)
Attributes
783(17)
Programming with Dynamic Objects
800(11)
Summary
811(2)
19 Introducing Multithreading
813(40)
Multithreading Basics
815(7)
Asynchronous Tasks
822(21)
Canceling a Task
843(7)
Working with System. Threading
850(1)
Summary
851(2)
20 Programming the Task-Based Asynchronous Pattern
853(42)
Synchronously Invoking a High-Latency Operation
854(2)
Asynchronously Invoking a High-Latency Operation Using the TPL
856(5)
The Task-Based Asynchronous Pattern with async and await
861(6)
Introducing Asynchronous Return of ValueTask<T>
867(3)
Asynchronous Streams
870(4)
IAsyncDisposable and the await using Declaration and Statement
874(1)
Using LINQ with IAsyncEnumerable
875(2)
Returning void from an Asynchronous Method
877(4)
Asynchronous Lambdas and Local Functions
881(6)
Task Schedulers and the Synchronization Context
887(3)
async/await with the Windows UI
890(3)
Summary
893(2)
21 Iterating in Parallel
895(18)
Executing Loop Iterations in Parallel
895(10)
Running LINQ Queries in Parallel
905(6)
Summary
911(2)
22 Thread Synchronization
913(34)
Why Synchronization?
914(29)
Timers
943(2)
Summary
945(2)
23 Platform Interoperability and Unsafe Code
947(26)
Platform Invoke
948(12)
Pointers and Addresses
960(11)
Executing Unsafe Code via a Delegate
971(1)
Summary
972(1)
24 The Common Language Infrastructure
973(22)
Defining the Common Language Infrastructure
974(1)
CLI Implementations
975(3)
.NET Standard
978(1)
Base Class Library
979(1)
C# Compilation to Machine Code
979(3)
Runtime
982(4)
Assemblies, Manifests, and Modules
986(3)
Common Intermediate Language
989(1)
Common Type System
990(1)
Common Language Specification
991(1)
Metadata
991(2)
.NET Native and Ahead of Time Compilation
993(1)
Summary
993(2)
Index 995(44)
Index of 8.0 Topics 1039(2)
Index of 7.0 Topics 1041(2)
Index of 6.0 Topics 1043
Mark Michaelis is the founder of IntelliTect, an innovative software architecture and development firm where he serves as the chief technical architect and trainer. He has also written numerous articles and books, is an adjunct professor at Eastern Washington University, founder of the Spokane .NET Users Group, and co-organizer of the annual TEDx Coeur dAlene events. Mark has been a Microsoft Regional Director since 2007 and a Microsoft MVP for more than 25 years.