Úplné zobrazení záznamu

Toto je statický export z katalogu ze dne 14.11.2020. Zobrazit aktuální podobu v katalogu.

Bibliografická citace

.
0 (hodnocen0 x )
(1) Půjčeno:1x 
BK
Příručka
Eighth edition
New York : Apress, [2017]
lxv, 1372 stran : ilustrace ; 26 cm

objednat
ISBN 978-1-4842-3017-6 (brožováno)
Obsahuje rejstřík
001463424
Contents at a Glance // About the Authors... li // About the Technical Reviewers... liii // Acknowledgments...Iv // Introduction... Ivii // ¦Part I: Introducing C# and the .NET Platform... 1 // ¦Chapter 1: The Philosophy of .NET...3 // ¦Chapter 2: Building C# Applications...35 // ¦Part II: Core C# Programing... 53 // ¦Chapter 3: Core C# Programming Constructs, Part I...55 // ¦Chapter 4: Core C# Programming Constructs, Part II... Ill // ¦Part III: Object-Oriented Programming with C#... 159 // ¦Chapter 5: Understanding Encapsulation...161 // ¦Chapter 6: Understanding Inheritance and Polymorphism...213 // ¦Chapter 7: Understanding Structured Exception Handling... 255 // ¦Chapter 8: Working with Interfaces...283 // ¦Part IV: Advanced C# Programming...323 // ¦Chapter 9: Collections and Generics... 325 // ¦Chapter 10: Delegates, Events, and Lambda Expressions...365 // ¦Chapter 11: Advanced C# Language Features...407 // ¦Chapter 12: LINQ to Objects... 445 // ¦Chapter 13: Understanding Object Lifetime...479 // CONTENTS AT A GLANCE // ¦Part V: Programming with .NET Assemblies...507 // ¦Chapter 14: Building and Configuring Class Libraries...509 // ¦Chapter 15: Type Reflection, Late Binding, and Attribute-Based Programming... 561 // ¦Chapter 16: Dynamic Types and the Dynamic Language Runtime...609 // ¦Chapter 17: Processes, AppDomains, and Object Contexts...631 // ¦Chapter 18: Understanding CIL and the Role of Dynamic Assemblies...657 // ¦Part VI: Introducing the
.NET Base Class Libraries...699 // ¦Chapter 19: Multithreaded, Parallel, and Async Programming...701 // ¦Chapter 20: File I/O and Object Serialization...755 // ¦Chapter 21: Data Access with AD0.NET...803 // ¦Chapter 22: Introducing Entity Framework 6...857 // ¦Chapter 23: Introducing Windows Communication Foundation...907 // ¦Part VII: Windows Presentation Foundation...963 // ¦Chapter 24: Introducing Windows Presentation Foundation and XAML...965 // ¦Chapter 25: WPF Controls, Layouts, Events, and Data Binding...1003 // ¦Chapter 26: WPF Graphics Rendering Services...1061 // ¦Chapter 27: WPF Resources, Animations, Styles, and Templates...1095 // ¦Chapter 28: WPF Notifications, Validations, Commands, and MVVM...1137 // ¦Part Vili: ASP.NET...1177 // ¦Chapter 29: Introducing ASP.NET MVC...1179 // ¦Chapter 30: Introducing ASP.NET Web API...1223 // ¦Part IX: .NET CORE...1243 // ¦Chapter 31: The Philosophy of .NET Core...1245 // ¦Chapter 32: Introducing Entity Framework Core...1255 // ¦Chapter 33: Introducing ASP.NET Core Web Applications...1279 // ¦Chapter 34: Introducing ASP.NET Core Service Applications...1329 // Index // 1353 // Contents // About the Authors... li // About the Technical Reviewers...liii // Acknowledgments...Iv // Introduction... Ivii // ¦Part I: Introducing C# and the .NET Platform...1 // ¦Chapter 1: The Philosophy of .NET...3 // An Initial Look at the .NET Platform...3 // Some Key Benefits of the .NET Platform...4 // Introducing the Building
Blocks of the .NET Platform (the CLR, GTS, and CIS)...4 // The Role of the Base Class Libraries...5 // What C# Brings to the Table...5 // Managed vs. Unmanaged Code...8 // Additional .NET-Aware Programming Languages...8 // Life in a Multilanguage World...9 // An Overview of .NET Assemblies...9 // The Role of the Common Intermediate Language...10 // Benefits of CIL...13 // Compiling CIL to Platform-Specific Instructions...13 // The Role of .NET Type Metadata...13 // The Role of the Assembly Manifest...14 // Understanding the Common Type System...15 // CTS Class Types...15 // CTS Interface Types...16 // vii // ¦ CONTENTS // CTS Structure Types... // CTS Enumeration Types...17 // CTS Delegate Types... // CTS Type Members...17 // Intrinsic CTS Data Types...1 e // Understanding the Common Language Specification...19 // Ensuring CIS Compliance...20 // Understanding the Common Language Runtime...20 // The Assembly/Namespace/Type Distinction...22 // The Role of the Microsoft Root Namespace...25 // Accessing a Namespace Programmatically...25 // Referencing External Assemblies...26 // Exploring an Assembly Using ildasm.exe...27 // Viewing CIL Code...28 // Viewing Type Metadata...29 // Viewing Assembly Metadata (aka the Manifest)...30 // The Platform-Independent Nature of .NET...30 // The Mono Project...32 // Xamarin... // Microsoft .NET Core...32 // Summary...33 // Chapter 2: Building C# Applications...35 // Building .NET Applications on Windows...35 // Installing Visual Studio 2017...36
// Taking Visual Studio 2017 for a Test-Drive...38 // Visual Studio 2017 Professional...50 // Visual Studio 2017 Enterprise...50 // The .NET Framework Documentation System...50 // Building.NET Applications on a Non-Windows OS...52 // Summary...52 // viii // CONTENTS // ¦Part II: Core C# Programing...53 // ¦Chapter 3: Core C# Programming Constructs, Part 1...55 // The Anatomy of a Simple C# Program...55 // Variations on the Main( ) Method...57 // Specifying an Application Error Code...58 // Processing Command-Line Arguments...59 // Specifying Command-Line Arguments with Visual Studio...61 // An Interesting Aside: Some Additional Members of the System.Environment Class...61 // The System.Console Class...63 // Basic Input and Output with the Console Class...63 // Formatting Console Output...65 // Formatting Numerical Data...65 // Formatting Numerical Data Beyond Console Applications...67 // System Data Types and Corresponding C# Keywords...68 // Variable Declaration and Initialization...69 // Intrinsic Data Types and the new Operator...71 // The Data Type Class Hierarchy...72 // Members of Numerical Data Types...73 // Members of System.Boolean...74 // Members of System.Char...74 // Parsing Values from String Data...75 // Using TryParse to Parse Values from String Data...75 // System.DateTime and System.TimeSpan...76 // The System.Numerics.dll Assembly...76 // Digit Separators (New)...78 // Binary Literals (New)...78 // Working with String Data...79 // Basic String Manipulation...80
// String Concatenation...80 // Escape Characters...81 // ix // CONTENTS // Defining Verbatim Strings...82 // Strings and Equality...82 // Strings Are Immutable...85 // The System.Text.StringBuilder Type...86 // String Interpolation...87 // Narrowing and Widening Data Type Conversions...88 // The checked Keyword...91 // Setting Project-wide Overflow Checking...93 // The unchecked Keyword...93 // Understanding Implicitly Typed Local Variables...94 // Restrictions on Implicitly Typed Variables...95 // Implicit Typed Data Is Strongly Typed Data...96 // Usefulness of Implicitly Typed Local Variables...97 // C# Iteration Constructs...98 // The for Loop...98 // The foreach Loop...99 // Use of Implicit Typing Within foreach Constructs...99 // The while and do/while Looping Constructs...100 // Decision Constructs and the Relational/Equality Operators...101 // The if/else Statement...101 // Equality and Relational Operators...101 // The Conditional Operator...102 // Logical Operators...103 // The switch Statement...103 // Using Pattern Matching in Switch Statements (New)...106 // Summary...109 // ¦Chapter 4: Core C# Programming Constructs, Part II... Ill // Understanding C# Arrays...111 // C# Array Initialization Syntax...112 // Implicitly Typed Local Arrays...113 // CONTENTS // Defining an Array of Objects...114 // Working with Multidimensional Arrays...115 // Arrays As Arguments or Return Values...116 // The System.Array Base Class...117 // Methods and Parameter Modifiers...118 // Return
Values and Expression Bodied Members (Updated)...119 // Method Parameter Modifiers...119 // Discards...120 // The Default by Value Parameter-Passing Behavior...120 // The out Modifier (Updated)...121 // The ref Modifier...123 // ref Locals and Returns (New)...124 // The params Modifier...126 // Defining Optional Parameters...127 // Invoking Methods Using Named Parameters...129 // Understanding Method Overloading...131 // Local Functions (New)...133 // Understanding the enum Type...134 // Controlling the Underlying Storage for an enum...135 // Declaring enum Variables...136 // The System.Enum Type...137 // Dynamically Discovering an enum’s Name-Value Pairs...137 // Understanding the Structure (aka Value Type)...139 // Creating Structure Variables...141 // Understanding Value Types and Reference Types...142 // Value Types, References Types, and the Assignment Operator...143 // Value Types Containing Reference Types...145 // Passing Reference Types by Value...147 // Passing Reference Types by Reference...149 // Final Details Regarding Value Types and Reference Types...150 // xi // CONTENTS // Understanding C# Nullable Types...150 // Working with Nullable Types...152 // The Null Coalescing Operator...153 // The Null Conditional Operator...153 // Tuples (New)...154 // Getting Started with Tuples...155 // Inferred Variable Names (C# 7.1)...156 // Tuples As Method Return Values...156 // Discards with Tuples...157 // Deconstructing Tuples...157 // Summary...158 // ¦Part III: Object-Oriented
Programming with C#...159 // ¦Chapter 5: Understanding Encapsulation...161 // Introducing the C# Class Type...161 // Allocating Objects with the new Keyword...164 // Understanding Constructors...165 // The Role of the Default Constructor...165 // Defining Custom Constructors...166 // The Default Constructor Revisited...167 // The Role of the this Keyword...169 // Chaining Constructor Calls Using this...170 // Observing Constructor Flow...173 // Revisiting Optional Arguments...174 // Understanding the static Keyword...176 // Defining Static Field Data...176 // Defining Static Methods...178 // Defining Static Constructors...179 // Defining Static Classes...182 // Importing Static Members via the C# using Keyword...183 // xii // CONTENTS // Defining the Pillars of OOP...184 // The Role of Encapsulation...184 // The Role of Inheritance...184 // The Role of Polymorphism...186 // C# Access Modifiers...188 // The Default Access Modifiers...188 // Access Modifiers and Nested Types...189 // The First Pillar: C#’s Encapsulation Services...190 // Encapsulation Using Traditional Accessors and Mutators...191 // Encapsulation Using .NET Properties...193 // Using Properties Within a Class Definition...196 // Read-Only and Write-Only Properties...198 // Revisiting the static Keyword: Defining Static Properties...199 // Understanding Automatic Properties...199 // Interacting with Automatic Properties...201 // Automatic Properties and Default Values...201 // Initialization of Automatic Properties...203
// Understanding Object Initialization Syntax...204 // Calling Custom Constructors with Initialization Syntax...205 // Initializing Data with Initialization Syntax...207 // Working with Constant Field Data...208 // Understanding Read-Only Fields...209 // Static Read-Only Fields...210 // Understanding Partial Classes...211 // Use Cases for Partial Classes?...212 // Summary...212 // ¦Chapter 6: Understanding Inheritance and Polymorphism...213 // The Basic Mechanics of Inheritance...213 // Specifying the Parent Class of an Existing Class...214 // Regarding Multiple Base Classes...216 // The sealed Keyword...216 // xiii // CONTENTS // Revisiting Visual Studio Class Diagrams...218 // The Second Pillar of OOP: The Details of Inheritance...220 // Controlling Base Class Creation with the base Keyword...221 // Keeping Family Secrets: The protected Keyword...223 // Adding a Sealed Class...224 // Programming for Containment/Delegation...225 // Understanding Nested Type Definitions... ...226 // The Third Pillar of OOP: C#’s Polymorphic Support...228 // The virtual and override Keywords...229 // Overriding Virtual Members Using the Visual Studio IDE...231 // Sealing Virtual Members...233 // Understanding Abstract Classes...233 // Understanding the Polymorphic Interface...236 // Understanding Member Shadowing...240 // Understanding Base Class/Derived Class Casting Rules...241 // The C#as Keyword...243 // The C# is Keyword (Updated)...245 // Pattern Matching Revisited (New)...246 // The Master
Parent Class: System.Object...247 // Overriding System.Object.ToStringQ...250 // Overriding System.Object.Equals()...250 // Overriding System.Object.GetHashCodeQ...251 // Testing Your Modified Person Class...252 // The Static Members of System.Object...253 // Summary...254 // ¦Chapter 7: Understanding Structured Exception Handling...255 // Ode to Errors, Bugs, and Exceptions...255 // The Role of .NET Exception Handling...256 // The Building Blocks of .NET Exception Handling... 257 // The System.Exception Base Class...257 // xiv // CONTENTS // The Simplest Possible Example... 259 // Throwing a General Exception (Updated)...261 // Catching Exceptions...262 // Configuring the State of an Exception...264 // The TargetSite Property...264 // The StackTrace Property...265 // The HelpLink Property...265 // The Data Property...266 // System-Level Exceptions (System.SystemException)...268 // Application-Level Exceptions (System.ApplicationException)...268 // Building Custom Exceptions, Take 1... 269 // Building Custom Exceptions, Take 2...271 // Building Custom Exceptions, Take 3...272 // Processing Multiple Exceptions...273 // General catch Statements...276 // Rethrowing Exceptions...276 // Inner Exceptions...277 // The finally Block...278 // Exception Filters...279 // Debugging Unhandled Exceptions Using Visual Studio...280 // Summary...281 // ¦Chapter 8: Working with Interfaces...283 // Understanding Interface Types...283 // Interface Types vs. Abstract Base Classes...284 // Defining
Custom Interfaces...286 // Implementing an Interface...288 // Invoking Interface Members at the Object Level...290 // Obtaining Interface References: The as Keyword...291 // Obtaining Interface References: The is Keyword (Updated)...292 // CONTENTS // Interfaces As Parameters...293 // Interfaces As Return Values...295 // Arrays of Interface Types...296 // Implementing Interfaces Using Visual Studio...297 // Explicit Interface Implementation...299 // Designing Interface Hierarchies...301 // Multiple Inheritance with Interface Types...303 // The (Enumerable and (Enumerator Interfaces...305 // Building Iterator Methods with the yield Keyword...308 // Building a Named Iterator...310 // The ICIoneable Interface...311 // A More Elaborate Cloning Example...313 // The IComparable Interface...316 // Specifying Multiple Sort Orders with (Comparer...319 // Custom Properties and Custom Sort Types...320 // Summary...321 // ¦Part IV: Advanced C# Programming...323 // ¦Chapter 9: Collections and Generics...325 // The Motivation for Collection Classes...325 // The System.Collections Namespace...327 // A Survey of System.Collections.Specialized Namespace...329 // The Problems of Nongeneric Collections...330 // The Issue of Performance...330 // The Issue of Type Safety...333 // A First Look at Generic Collections...336 // The Role of Generic Type Parameters...337 // Specifying Type Parameters for Generic Classes/Structures...339 // Specifying Type Parameters for Generic Members...340 // Specifying
Type Parameters for Generic Interfaces...340 // xvi // CONTENTS // The System.Collections.Generic Namespace...342 // Understanding Collection Initialization Syntax...343 // Working with the List<T> Class...345 // Working with the Stack<T> Class...346 // Working with the Queue<T> Class...347 // Working with the SortedSet<T> Class...348 // Working with the Dictionary<TKey,TValue> Class...350 // The System.Collections.ObjectModel Namespace...351 // Working with ObservableCollection<T>...352 // Creating Custom Generic Methods...354 // Inference of Type Parameters...356 // Creating Custom Generic Structures and Classes...357 // The default Keyword in Generic Code...358 // Constraining Type Parameters...360 // Examples Using the where Keyword...360 // The Lack of Operator Constraints...362 // Summary...363 // ¦Chapter 10: Delegates, Events, and Lambda Expressions...365 // Understanding the .NET Delegate Type...365 // Defining a Delegate Type in C#...366 // The System.MulticastDelegate and System.Delegate Base Classes...369 // The Simplest Possible Delegate Example...370 // Investigating a Delegate Object...372 // Sending Object State Notifications Using Delegates...373 // Enabling Multicasting...376 // Removing Targets from a Delegate’s Invocation List...378 // Method Group Conversion Syntax...379 // Understanding Generic Delegates...380 // The Generic Actiono and Funco Delegates...382 // xvii // CONTENTS // Understanding C# Events...384 // The C# event Keyword...386 // Events Under
the Hood...387 // Listening to Incoming Events...388 // Simplifying Event Registration Using Visual Studio...389 // Cleaning Up Event Invocation Using the C# 6.0 Null-Conditional Operator...391 // Creating Custom Event Arguments...392 // The Generic EventHandler<T> Delegate...393 // Understanding C# Anonymous Methods...394 // Accessing Local Variables...396 // Understanding Lambda Expressions...397 // Dissecting a Lambda Expression...400 // Processing Arguments Within Multiple Statements...401 // Lambda Expressions with Multiple (or Zero) Parameters...403 // Retrofitting the CarEvents Example Using Lambda Expressions...404 // Lambdas and Expression-Bodied Members (Updated)...404 // Summary...406 // ¦Chapter 11: Advanced C# Language Features...407 // Understanding Indexer Methods...407 // Indexing Data Using String Values...409 // Overloading Indexer Methods...411 // Indexers with Multiple Dimensions...411 // Indexer Definitions on Interface Types...412 // Understanding Operator Overloading...412 // Overloading Binary Operators...413 // And What of the += and -= Operators?...416 // Overloading Unary Operators...416 // Overloading Equality Operators...417 // Overloading Comparison Operators...418 // Final Thoughts Regarding Operator Overloading...418 // xviii // CONTENTS // Understanding Custom Type Conversions...419 // Recall: Numerical Conversions...419 // Recall: Conversions Among Related Class Types...419 // Creating Custom Conversion Routines...420 // Additional Explicit Conversions
for the Square Type...423 // Defining Implicit Conversion Routines...424 // Understanding Extension Methods...425 // Defining Extension Methods...426 // Invoking Extension Methods...427 // Importing Extension Methods...428 // The IntelliSense of Extension Methods...428 // Extending Types Implementing Specific Interfaces...429 // Understanding Anonymous Types...431 // Defining an Anonymous Type...431 // The Internal Representation of Anonymous Types...432 // The Implementation of ToStringQ and GetHashCodeQ...434 // The Semantics of Equality for Anonymous Types...434 // Anonymous Types Containing Anonymous Types...436 // Working with Pointer Types...436 // The unsafe Keyword...438 // Working with the * and

Zvolte formát: Standardní formát Katalogizační záznam Zkrácený záznam S textovými návěštími S kódy polí MARC