Log In
Or create an account -> 
Imperial Library
  • Home
  • About
  • News
  • Upload
  • Forum
  • Help
  • Login/SignUp

Index
Microsoft® Visual C#® 2012 Step by Step Dedication A Note Regarding Supplemental Files Introduction
Who Should Read This Book Who Should Not Read This Book Organization of This Book
Finding Your Best Starting Point in This Book
Conventions and Features in This Book System Requirements Code Samples
Installing the Code Samples Using the Code Samples
Acknowledgments Errata and Book Support We Want to Hear from You Stay in Touch
I. Introducing Microsoft Visual C# and Microsoft Visual Studio 2012
1. Welcome to C#
Beginning Programming with the Visual Studio 2012 Environment Writing Your First Program Using Namespaces Creating a Graphical Application
Examining the Windows Store App Examining the WPF Application Adding Code to the Graphical Application
Summary Chapter 1 Quick Reference
2. Working with Variables, Operators, and Expressions
Understanding Statements Using Identifiers
Identifying Keywords
Using Variables
Naming Variables Declaring Variables
Working with Primitive Data Types
Unassigned Local Variables Displaying Primitive Data Type Values
Using Arithmetic Operators
Operators and Types Examining Arithmetic Operators Controlling Precedence Using Associativity to Evaluate Expressions Associativity and the Assignment Operator
Incrementing and Decrementing Variables
Prefix and Postfix
Declaring Implicitly Typed Local Variables Summary Chapter 2 Quick Reference
3. Writing Methods and Applying Scope
Creating Methods
Declaring a Method Returning Data from a Method Calling Methods
Specifying the Method Call Syntax
Applying Scope
Defining Local Scope Defining Class Scope Overloading Methods
Writing Methods Using Optional Parameters and Named Arguments
Defining Optional Parameters Passing Named Arguments Resolving Ambiguities with Optional Parameters and Named Arguments
Summary Chapter 3 Quick Reference
4. Using Decision Statements
Declaring Boolean Variables Using Boolean Operators
Understanding Equality and Relational Operators Understanding Conditional Logical Operators Short-Circuiting Summarizing Operator Precedence and Associativity
Using if Statements to Make Decisions
Understanding if Statement Syntax Using Blocks to Group Statements Cascading if Statements
Using switch Statements
Understanding switch Statement Syntax Following the switch Statement Rules
Summary Chapter 4 Quick Reference
5. Using Compound Assignment and Iteration Statements
Using Compound Assignment Operators Writing while Statements Writing for Statements
Understanding for Statement Scope
Writing do Statements Summary Chapter 5 Quick Reference
6. Managing Errors and Exceptions
Coping with Errors Trying Code and Catching Exceptions
Unhandled Exceptions Using Multiple catch Handlers Catching Multiple Exceptions Propagating Exceptions
Using Checked and Unchecked Integer Arithmetic
Writing Checked Statements Writing Checked Expressions
Throwing Exceptions Using a finally Block Summary Chapter 6 Quick Reference
II. Understanding the C# Object Model
7. Creating and Managing Classes and Objects
Understanding Classification The Purpose of Encapsulation Defining and Using a Class Controlling Accessibility
Working with Constructors Overloading Constructors
Understanding static Methods and Data
Creating a Shared Field Creating a static Field by Using the const Keyword Understanding static Classes Anonymous Classes
Summary Chapter 7 Quick Reference
8. Understanding Values and References
Copying Value Type Variables and Classes Understanding Null Values and Nullable Types
Using Nullable Types Understanding the Properties of Nullable Types
Using ref and out Parameters
Creating ref Parameters Creating out Parameters
How Computer Memory Is Organized
Using the Stack and the Heap
The System.Object Class Boxing Unboxing Casting Data Safely
The is Operator The as Operator
Summary Chapter 8 Quick Reference
9. Creating Value Types with Enumerations and Structures
Working with Enumerations
Declaring an Enumeration Using an Enumeration Choosing Enumeration Literal Values Choosing an Enumeration’s Underlying Type
Working with Structures
Declaring a Structure Understanding Structure and Class Differences Declaring Structure Variables Understanding Structure Initialization Copying Structure Variables
Summary Chapter 9 Quick Reference
10. Using Arrays
Declaring and Creating an Array
Declaring Array Variables Creating an Array Instance
Populating and Using an Array
Creating an Implicitly Typed Array Accessing an Individual Array Element Iterating Through an Array Passing Arrays as Parameters and Return Values for a Method
Copying Arrays Using Multidimensional Arrays
Creating Jagged Arrays
Summary Chapter 10 Quick Reference
11. Understanding Parameter Arrays
Overloading: A Recap Using Array Arguments
Declaring a params Array Using params object[ ] Using a params Array
Comparing Parameter Arrays and Optional Parameters Summary Chapter 11 Quick Reference
12. Working with Inheritance
What Is Inheritance? Using Inheritance
The System.Object Class Revisited Calling Base Class Constructors Assigning Classes Declaring new Methods Declaring virtual Methods Declaring override Methods Understanding protected Access
Understanding Extension Methods Summary Chapter 12 Quick Reference
13. Creating Interfaces and Defining Abstract Classes
Understanding Interfaces
Defining an Interface Implementing an Interface Referencing a Class Through Its Interface Working with Multiple Interfaces Explicitly Implementing an Interface Interface Restrictions Defining and Using Interfaces
Abstract Classes
Abstract Methods
Sealed Classes
Sealed Methods Implementing and Using an Abstract Class
Summary Chapter 13 Quick Reference
14. Using Garbage Collection and Resource Management
The Life and Times of an Object
Writing Destructors Why Use the Garbage Collector? How Does the Garbage Collector Work? Recommendations
Resource Management
Disposal Methods Exception-Safe Disposal The using Statement and the IDisposable Interface Calling the Dispose Method from a Destructor
Implementing Exception-Safe Disposal Summary Chapter 14 Quick Reference
III. Defining Extensible Types with C#
15. Implementing Properties to Access Fields
Implementing Encapsulation by Using Methods What Are Properties?
Using Properties Read-Only Properties Write-Only Properties Property Accessibility
Understanding the Property Restrictions Declaring Interface Properties
Replacing Methods with Properties
Generating Automatic Properties Initializing Objects by Using Properties Summary Chapter 15 Quick Reference
16. Using Indexers
What Is an Indexer?
An Example That Doesn’t Use Indexers The Same Example Using Indexers Understanding Indexer Accessors Comparing Indexers and Arrays
Indexers in Interfaces Using Indexers in a Windows Application Summary Chapter 16 Quick Reference
17. Introducing Generics
The Problem with the object Type The Generics Solution
Generics vs. Generalized Classes Generics and Constraints
Creating a Generic Class
The Theory of Binary Trees Building a Binary Tree Class by Using Generics
Creating a Generic Method
Defining a Generic Method to Build a Binary Tree
Variance and Generic Interfaces
Covariant Interfaces Contravariant Interfaces
Summary Chapter 17 Quick Reference
18. Using Collections
What Are Collection Classes?
The List<T> Collection Class The LinkedList<T> Collection Class The Queue<T> Collection Class The Stack<T> Collection Class The Dictionary<TKey, TValue> Collection Class The SortedList<TKey, TValue> Collection Class The HashSet<T> Collection Class
Using Collection Initializers The Find Methods, Predicates, and Lambda Expressions Comparing Arrays and Collections
Using Collection Classes to Play Cards
Summary Chapter 18 Quick Reference
19. Enumerating Collections
Enumerating the Elements in a Collection
Manually Implementing an Enumerator Implementing the IEnumerable Interface
Implementing an Enumerator by Using an Iterator
A Simple Iterator Defining an Enumerator for the Tree<TItem> Class by Using an Iterator
Summary Chapter 19 Quick Reference
20. Decoupling Application Logic and Handling Events
Understanding Delegates
Examples of Delegates in the .NET Framework Class Library The Automated Factory Scenario Implementing the Factory Control System Without Using Delegates Implementing the Factory by Using a Delegate Declaring and Using Delegates
Lambda Expressions and Delegates
Creating a Method Adapter The Forms of Lambda Expressions
Enabling Notifications with Events
Declaring an Event Subscribing to an Event Unsubscribing from an Event Raising an Event
Understanding User Interface Events
Using Events
Summary Chapter 20 Quick Reference
21. Querying In-Memory Data by Using Query Expressions
What Is Language-Integrated Query? Using LINQ in a C# Application
Selecting Data Filtering Data Ordering, Grouping, and Aggregating Data Joining Data Using Query Operators Querying Data in Tree<TItem> Objects LINQ and Deferred Evaluation
Summary Chapter 21 Quick Reference
22. Operator Overloading
Understanding Operators
Operator Constraints Overloaded Operators Creating Symmetric Operators
Operators and Language Interoperability
Understanding Compound Assignment Evaluation Declaring Increment and Decrement Operators Comparing Operators in Structures and Classes Defining Operator Pairs Implementing Operators Understanding Conversion Operators
Providing Built-in Conversions Implementing User-Defined Conversion Operators Creating Symmetric Operators, Revisited Writing Conversion Operators
Summary Chapter 22 Quick Reference
IV. Building Professional Windows 8 Applications with C#
23. Improving Throughput by Using Tasks
Why Perform Multitasking by Using Parallel Processing?
The Rise of the Multicore Processor
Implementing Multitasking with the .NET Framework
Tasks, Threads, and the ThreadPool Creating, Running, and Controlling Tasks Using the Task Class to Implement Parallelism Abstracting Tasks by Using the Parallel Class When Not to Use the Parallel Class
Canceling Tasks and Handling Exceptions
The Mechanics of Cooperative Cancellation Using Continuations with Canceled and Faulted Tasks
Summary Chapter 23 Quick Reference
24. Improving Response Time by Performing Asynchronous Operations
Implementing Asynchronous Methods
Defining Asynchronous Methods: The Problem Defining Asynchronous Methods: The Solution Defining Asynchronous Methods That Return Values Asynchronous Methods and the Windows Runtime APIs
Using PLINQ to Parallelize Declarative Data Access
Using PLINQ to Improve Performance While Iterating Through a Collection Canceling a PLINQ Query
Synchronizing Concurrent Access to Data
Locking Data Synchronization Primitives for Coordinating Tasks Cancelling Synchronization The Concurrent Collection Classes Using a Concurrent Collection and a Lock to Implement Thread-Safe Data Access
Summary Quick Reference
25. Implementing the User Interface for a Windows Store App
What Is a Windows Store App? Using the Blank App Template to Build a Windows Store App
Implementing a Scalable User Interface
Implementing a Tabular Layout with a Grid Control Adapting the Layout by Using the Visual State Manager
Applying Styles to a User Interface
Summary Chapter 25 Quick Reference
26. Displaying and Searching for Data in a Windows Store App
Implementing the Model-View-ViewModel Pattern
Displaying Data by Using Data Binding Modifying Data by Using Data Binding Using Data Binding with a ComboBox Control Creating a ViewModel Adding Commands to a ViewModel
Windows 8 Contracts
Implementing the Search Contract Navigating to a Selected Item Starting an Application from the Search Charm
Summary Chapter 26 Quick Reference
27. Accessing a Remote Database in a Windows Store App
Retrieving Data from a Database
Creating an Entity Model Creating and Using a Data Service
Inserting, Updating, and Deleting Data in a Database
Performing Insert, Update, and Delete Operations Through a WCF Data Service Reporting Errors and Updating the User Interface
Summary Chapter 27 Quick Reference
A. About the Author Index About the Author Copyright
  • ← Prev
  • Back
  • Next →
  • ← Prev
  • Back
  • Next →

Chief Librarian: Las Zenow <zenow@riseup.net>
Fork the source code from gitlab
.

This is a mirror of the Tor onion service:
http://kx5thpx2olielkihfyo4jgjqfb7zx7wxr3sd4xzt26ochei4m6f7tayd.onion