Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

! (exclamation mark)
!= (inequality) operator, Declaring Boolean variables, Summarizing operator precedence and associativity, Following the switch statement rules
implementing overloaded version, Implementing operators
pairing with == operator, Defining operator pairs
logical NOT operator, Short-circuiting, Using nullable types
" (quotation marks, double), Following the switch statement rules
% (percent sign)
%= (modulus and assignment) operator, Using compound assignment operators
modulus operator, Operators and types, Examining arithmetic operators, Examining arithmetic operators, Short-circuiting, Writing do statements
& (ampersand)
&& (logical AND) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
address-of operator, The as operator
bitwise AND operator, An example that doesn’t use indexers
' (quotation marks, single), Following the switch statement rules
( ) (parentheses)
enclosing parameters in lambda expressions, The Find methods, predicates, and lambda expressions
in method calls, Specifying the method call syntax
using to override operator precedence, Examining arithmetic operators, Short-circuiting
* (asterisk)
*= (multiplication and assignment) operator, Using compound assignment operators
in pointers, The as operator
multiplication operator, Using arithmetic operators, Examining arithmetic operators, Short-circuiting
associativity, Using associativity to evaluate expressions
overloading, Implementing operators
+ (plus sign)
++ (increment) operator, Associativity and the assignment operator, Short-circuiting, Using compound assignment operators
declaring your own version, Declaring increment and decrement operators
in classes versus structures, Comparing operators in structures and classes
+= (addition and assignment) operator, Using compound assignment operators, Writing do statements, Quick reference
evaluation, understanding, Creating symmetric operators
using with delegates, Implementing the factory control system without using delegates, Implementing the factory by using a delegate
using with events, Declaring an event
addition operator, Using arithmetic operators, Examining arithmetic operators, Summarizing operator precedence and associativity, Using compound assignment and iteration statements, Overloaded operators
overloading, Implementing operators
string concatenation operator, Using arithmetic operators
unary + operator, Short-circuiting
, (comma), separating multiple initializations and updates in for loops, Writing for Statements
- (minus sign)
-- (decrement) operator, Associativity and the assignment operator, Short-circuiting, Using compound assignment operators
declaring your own version, Declaring increment and decrement operators
-= (subtraction and assignment) operator, Using compound assignment operators, Quick reference
removing methods from delegates, Implementing the factory by using a delegate
unsubscribing from an event, Subscribing to an event
negation operator, Short-circuiting
subtraction operator, Using arithmetic operators, Examining arithmetic operators, Examining arithmetic operators, Summarizing operator precedence and associativity
overloading, Implementing operators
. (dot notation), Understanding extension methods, The life and times of an object
.csproj files, Displaying primitive data type values
.NET Framework
and compatibility with WinRT on Windows 8 and 8.1, Implementing and using an abstract class
class library, split into assemblies, Using namespaces
CLR (Common Language Runtime), Copying structure variables
collection classes, Using collections
in System.Collections namespace, What are collection classes?
in System.Collections.Generic namespace, Using collections
in System.Collections.Generic.Concurrent namespace, What are collection classes?
concurrent collection classes, Cancelling synchronization
delegates, examples in class library, Understanding delegates
events, The forms of lambda expressions
exception classes, Throwing exceptions
exception types, Using multiple catch handlers
FileInfo class, Writing while statements
GUI classes and controls, events, Raising an event
HttpClient class, Creating and using a REST web service
HttpResponseMessage class, Creating and using a REST web service
IAsyncResult design pattern in earlier versions, Asynchronous methods and the Windows Runtime APIs
IEnumerable and IEnumerator interfaces, Enumerating the elements in a collection
IEnumerable<T> and IEnumerator<T> interfaces, Enumerating the elements in a collection
implementing multitasking by using, Implementing multitasking by using the Microsoft .NET Framework
interfaces exhibiting covariance, Covariant interfaces
libraries or assemblies, Beginning programming with the Visual Studio 2013 environment
PLINQ extensions, Using PLINQ to parallelize declarative data access
primitive types and equivalents in C#, Working with structures
synchronization primitives, Locking data
synchronizing data access across tasks, Improving response time by performing asynchronous operations
System.Collections.Generics namespace, The generics solution
TextReader class, Writing while statements
.sln files, Displaying primitive data type values
/ (slash)
/* and */ surrounding multiline comments, Writing your first program
// preceding comments, Writing your first program
///, beginning comments in XAML files, Examining the Windows Store app
/= (division and assignment) operator, Using compound assignment operators, Writing do statements
division operator, Using arithmetic operators, Examining arithmetic operators, Examining arithmetic operators, Short-circuiting
associativity, Using associativity to evaluate expressions
overloading, Implementing operators
; (semicolon)
ending statements, Working with variables, operators, and expressions
variable declarations, Naming variables
in lambda expressions, The Find methods, predicates, and lambda expressions
replacing method body in interface method declarations, Understanding interfaces
separating initialization, Boolean expression, and update control variable in for loops, Writing for Statements
< > (angle brackets)
< (less than) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
< operator and > operator, pairing, Defining operator pairs
<< (left-shift) operator, An example that doesn’t use indexers
<= (less than or equal to) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
<= and >= operators, pairing, Defining operator pairs
> (greater than) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
>= (greater than or equal to) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
>> right-shift operator, An example that doesn’t use indexers
= (equal sign)
== (equal to) operator, Declaring Boolean variables, Summarizing operator precedence and associativity, Following the switch statement rules
implementing overloaded version, Implementing operators
pairing with !+ operator, Comparing operators in structures and classes
=> operator, The Find methods, predicates, and lambda expressions
assignment operator, Using associativity to evaluate expressions, Summarizing operator precedence and associativity, Using compound assignment and iteration statements
using properties to simulate, Understanding operators
confusing = and == in if statement, Understanding if statement syntax
using with on clause of LINQ expression, Using query operators
? (question mark)
indicating that enumeration is nullable, Declaring an enumeration
indicating that structure in nullable, Declaring structure variables
indicating that value type is nullable, Understanding null values and nullable types, Summary
[ ] (square brackets), Examining arithmetic operators
array size in, Declaring array variables
in indexers, The same example using indexers
signifying array variables, Using arrays
using indexers to simulate [ ] operator, Understanding operators
(backslash), escape character in C#, Following the switch statement rules
(newline character), Writing while statements
^ (caret), bitwise XOR operator, An example that doesn’t use indexers, Understanding indexer accessors
_ (underscore), beginning names of private fields, Controlling accessibility
{ } (braces or curly brackets), Examining arithmetic operators
code block enclosed in, life span of variables defined in, How computer memory is organized
enclosing code blocks, Understanding if statement syntax
in lambda expressions, The Find methods, predicates, and lambda expressions
use in intializing array elements to specific values, Creating an array instance
| (pipe symbol)
bitwise OR operator, An example that doesn’t use indexers
|| (logical OR) operator, Understanding equality and relational operators, Summarizing operator precedence and associativity, Following the switch statement rules
~ (tilde)
in destructor syntax, Writing destructors
NOT operator, An example that doesn’t use indexers

A

abstract classes, Defining and using interfaces, Quick reference
abstract methods, Abstract classes
implementing and using (exercise), Sealed methods
abstract modifier
abstract keyword, Abstract classes, Summary
inapplicable to operators, Overloaded operators
access modifiers
for properties, Write-only properties
not applicable for destructors, Writing destructors
not defined for interface methods, Interface restrictions
accessor methods., Implementing encapsulation by using methods
(see also properties)
Action delegate types, Examples of delegates in the .NET Framework class library
Action<T, …> delegate, Examples of delegates in the .NET Framework class library
registering with task’s cancellation token, The mechanics of cooperative cancellation
using with tasks, Tasks, threads, and the ThreadPool
adapter methods, Lambda expressions and delegates
Add New Project dialog box, templates displayed in, Implementing the IEnumerable interface
Add Scaffold wizard, Creating an entity model
addition operator. (see + (plus sign), under Symbols)
address-of operator (&), The as operator
ADO.NET, Retrieving data from a database
ADO.NET Entity Data Model template, Creating an entity model
AggregateException class, The mechanics of cooperative cancellation, Quick reference
aggregating data, Ordering, grouping, and aggregating data, Using query operators
All WPF Controls section (Windows 7 and 8), Creating a graphical application
All XAML Controls section (Windows 8.1), Creating a graphical application
Allow Unsafe Code option, The as operator
animations in Windows Store apps, What is a Windows Store app?
visual state transitions, Adapting the layout by using the Visual State Manager
anonymous classes, Understanding static classes
anonymous methods, lambda expressions and, The forms of lambda expressions
anonymous types, arrays of, Populating and using an array
app bars, Adding commands to a ViewModel
adding Next and Previous buttons, Adding commands to a ViewModel
App object, defined in App.xaml file of WPF application, Examining the WPF application
App.config file, Beginning programming with the Visual Studio 2013 environment
App.xaml file, Examining the Windows Store app
examining XAML description for WPF application, Examining the WPF application
App.xaml.cs file, examining in Solution Explorer, Examining the Windows Store app
AppBar control, Adding commands to a ViewModel
AppBarButton controls, Adding commands to a ViewModel
apps., Creating a graphical application
(see also Windows Store apps)
AppStyles.xaml file, Applying styles to a UI
referencing in global resource dictionary, Applying styles to a UI
ArgumentOutOfRangeException class, Throwing exceptions
arguments
inability to modify original argument through changes in parameter, Understanding the properties of nullable types
passing named arguments, Defining optional parameters
writing method that modifies, using ref and out keywords, Understanding the properties of nullable types
arithmetic operators, Using arithmetic operators
controlling precedence, Examining arithmetic operators
data types used with, Using arithmetic operators
implementing overloaded versions in Complex class, Implementing operators
using on int values, Operators and types
arithmetic overflow checking, Propagating exceptions, Summary
turning on or off in Visual Studio 2013, Using checked and unchecked integer arithmetic
arithmetic, performing on enumerations, Choosing an enumeration’s underlying type
Array class, Creating an implicitly typed array
Clone method, Copying arrays
Copy method, Copying arrays
CopyTo method, Copying arrays
array notation
referencing existing element in List<T>, What are collection classes?
using to access values in dictionary collections, Using collection initializers
using with Dictionary<TKey, TValue>, The Dictionary<TKey, TValue> collection class
arrays, Using arrays
comparison to collections, The Find methods, predicates, and lambda expressions
comparison to indexers, Understanding indexer accessors
properties, arrays, and indexers, Comparing indexers and arrays
copying, Passing arrays as parameters and return values for a method
declaring and creating, Using arrays
creating array instance, Declaring array variables, Summary
declaring array variables, Using arrays, Summary
implementing IEnumerable interface, Enumerating collections
in Dictionary<TKey, TValue> class, The Stack<T> collection class
limitations of, Using collections
List<T> class versus, What are collection classes?
listing elements with foreach statement, Enumerating collections
parameter. (see parameter arrays)
populating and using, Creating an array instance, Summary
accessing individual array element, Creating an implicitly typed array
creating implicitly typed array, Populating and using an array
initializing array elements to specific values, Creating an array instance
iterating through an array, Creating an implicitly typed array
passing arrays as method parameters and return values, Passing arrays as parameters and return values for a method
using multidimensional arrays, Copying arrays, Quick reference
creating a jagged array, Creating jagged arrays, Quick reference
using arrays to implement a card game, Creating jagged arrays
as operator, The as operator
performing cast and testing if result is null, Quick reference
ASP.NET Web API Client Libraries, installing, Creating and using a REST web service
ASP.NET Web API template, Creating an entity model
Entity Framework version referenced, Creating an entity model
web service created with, Creating and using a REST web service
ASP.NET Web API, model supporting inserting, updating, and deleting data, Creating and using a REST web service
AsParallel extension method, Using PLINQ to parallelize declarative data access
assemblies
for System.Windows and Windows.UI namespaces, Implementing and using an abstract class
namespaces and, Using namespaces
assignment of values to variables, Naming variables, Declaring variables
assignment operator. (see See = (equal sign), under Symbols; + (equal sign), under Symbols)
assignment operators, compound, Using compound assignment and iteration statements, Quick reference
understanding compound assignment evaluation, Creating symmetric operators
associative arrays, The Stack<T> collection class
associativity, Using associativity to evaluate expressions, Operator overloading
assignment operator and, Using associativity to evaluate expressions
summary of operator associativity, Short-circuiting
async modifier
implementing asynchronous method, Defining asynchronous methods: the solution
misconceptions about, Defining asynchronous methods: the solution
no await statement in async method, Defining asynchronous methods: the solution
prefixing delegates, Defining asynchronous methods: the solution
asynchronous operations, Improving response time by performing asynchronous operations
IAsyncResult design pattern in earlier versions of .NET Framework, Asynchronous methods and the Windows Runtime APIs
implementing asynchronous methods, Improving response time by performing asynchronous operations, Summary
asynchronous methods and Windows Runtime APIs, Defining asynchronous methods that return values
defining asynchronous methods that return values, Defining asynchronous methods that return values
defining asynchronous methods, problem, Improving response time by performing asynchronous operations
defining asynchronous methods, solution, Defining asynchronous methods: the problem
using asynchronous methods in GraphDemo application, Defining asynchronous methods: the solution
synchronizing concurrent access to data, Synchronizing concurrent access to data
cancelling synchronization, Synchronization primitives for coordinating tasks
concurrent collection classes, Cancelling synchronization
locking data, Synchronizing concurrent access to data
synchronization primitives to coordinate tasks, Locking data
using concurrent collection and lock for safe data access, The concurrent collection classes
using PLINQ to parallelize declarative data access, Using PLINQ to parallelize declarative data access
canceling a PLINQ query, Using PLINQ to improve performance while iterating through a collection
improving performance while iterating over collections, Using PLINQ to parallelize declarative data access
web service requests, Creating and using a REST web service
attached properties, Implementing a tabular layout by using a Grid control
await keyword, outside of async methods, Defining asynchronous methods: the solution
await operator, Defining asynchronous methods: the problem, Defining asynchronous methods: the solution
important points about, Defining asynchronous methods: the solution
invoking asynchronous method that returns a value, Defining asynchronous methods that return values
awaitable objects, Defining asynchronous methods: the solution

B

background image for page or control, Applying styles to a UI
Barrier class, Synchronization primitives for coordinating tasks
base class, What is inheritance?
calling base class constructors, Using inheritance
calling original implementation of method in, Declaring virtual methods
methods, Declaring new methods
protected members, access to, Understanding protected access
BasicCollection<T> class, Implementing an enumerator by using an iterator
bin and obj folders, Writing your first program
binary operators, Understanding operators
explicit arguments, Overloaded operators
binary trees, Creating a generic class
building binary tree class using generics, Building a binary tree class by using generics
creating enumerator for, Manually implementing an enumerator
defining a generic method to build, Creating a generic method
defining enumerator for Tree<TItem> class using an iterator, A simple iterator
querying data in Tree<TItem> objects, Using query operators
testing Tree<TItem> class, Building a binary tree class by using generics
bitwise operators, An example that doesn’t use indexers
Blank App template, Creating a graphical application
Blank App template., Using the Blank App template to build a Windows Store app
(see also Windows Store apps)
blocks. (see code blocks)
bool type, Declaring variables
Boolean expressions
creating, Following the switch statement rules
in for statements, Writing while statements
in if statements, Understanding if statement syntax
in while statements, Writing while statements
Boolean operators, Declaring Boolean variables
conditional logical operators, Understanding equality and relational operators
equality and relational operators, Declaring Boolean variables
Boolean variables, declaring, Using decision statements, Following the switch statement rules
boxing and unboxing, Boxing, Quick reference
performance and, Unboxing, The problem with the object type
break statements, Following the switch statement rules, Writing do statements
mandatory for each case in switch statement, Following the switch statement rules
busy indicator, adding to Customer form, Creating and using a REST web service
Button class, Raising an event
Button controls
adding to forms, Creating a graphical application
adding to views in Windows Store apps, Adding commands to a ViewModel
binding to commands provided by ViewModel, Summary

C

C#
as an evolving language, Reporting errors and updating the UI
case-sensitivity, Beginning programming with the Visual Studio 2013 environment
code for page in Windows Store app, displaying, Examining the Windows Store app
keywords, Understanding statements
source file, Program.cs, Beginning programming with the Visual Studio 2013 environment
white space in, Understanding statements
C/C++
array declarations, Declaring array variables
copy behavior of structure variables in C++, Copying structure variables
delete operator in C++, nonexistent in C#, The life and times of an object
function pointers in C++, similarity to delegates, Understanding delegates
functions or subroutines, similarity of methods to, Writing methods and applying scope
global methods, Declaring a method
hidden this parameter for operators in C++, Overloaded operators
inheritance in C++, Using inheritance
integer expressions in if statements, Understanding if statement syntax
new operation in C++, The life and times of an object
operator overloads in C++, Creating symmetric operators
params as type-safe equivalent to varargs macros, Declaring a params Array
pointers and unsafe code, The as operator
public and private keywords in C++, Controlling accessibility
remainder operator, Operators and types
structures in C++, no member functions, Copying structure variables
switch fall-through, differences in C#, Following the switch statement rules
unassigned local variables, Declaring variables
unassigned variables, Declaring Boolean variables
cached evaluation (LINQ), LINQ and deferred evaluation
camelCase naming scheme, Controlling accessibility
camelCase notation, Naming variables
canceled tasks, The mechanics of cooperative cancellation
using continuations with, The mechanics of cooperative cancellation
CancellationToken object, The mechanics of cooperative cancellation, Using PLINQ to improve performance while iterating through a collection, Quick reference
ThrowIfCancellationRequested method, The mechanics of cooperative cancellation, Quick reference
CancellationTokenSource object, The mechanics of cooperative cancellation, Quick reference, Using PLINQ to improve performance while iterating through a collection, Quick reference
Cancel method, The mechanics of cooperative cancellation
CanExecute method, Creating a ViewModel
Command class, implementing, Adding commands to a ViewModel
CanExecuteChanged event, Adding commands to a ViewModel
adding Command class to, Adding commands to a ViewModel
adding timer to raise the event, Adding commands to a ViewModel
raising too frequently, Adding commands to a ViewModel
card game
using arrays to implement, Creating jagged arrays
using collection classes, The Find methods, predicates, and lambda expressions
case
case-sensitivity in C#, Beginning programming with the Visual Studio 2013 environment
in variable names, Naming variables
case keyword, Using switch statements
case labels in switch statements, Understanding switch statement syntax
casting
converting between objects and strings, Variance and generic interfaces
explicit casts and object type, The problem with the object type
safely casting data, Unboxing, Quick reference
as operator, The as operator
is operator, Unboxing
using in unboxing, Unboxing
catch handlers, Coping with errors, Summary
catching an exception, Throwing exceptions
catching unhandled exceptions, Throwing exceptions
using multiple, Unhandled Exceptions
char type, Declaring variables
character sets, Writing do statements
checked expressions, writing, Writing checked expressions
checked keyword, Using checked and unchecked integer arithmetic, Summary
checked statements, writing, Using checked and unchecked integer arithmetic
CIL (Common Intermediate Language), Copying structure variables
Circle class, Understanding classification, Controlling accessibility
copying reference types and data privacy, Copying value type variables and classes
class members
drop-down list in Code and Text Editor, Displaying primitive data type values
IntelliSense icons for, Writing your first program
class methods. (see static methods and data)
classes, Creating and managing classes and objects
abstract, Defining and using interfaces
implementing and using, Sealed methods
anonymous, Understanding static classes
arrays of, Declaring array variables
assigning in inheritance hierarchy, Calling base class constructors
consumed by unmanaged applications through WinRT, Implementing and using an abstract class
controlling accessibility, Controlling accessibility
constructors, Controlling accessibility
naming and accessibility, Controlling accessibility
overloading constructors, Overloading constructors
partial classes, Overloading constructors
declaring, Quick reference
defining and using, Understanding classification
defining in namespaces, Using namespaces
defining scope, Defining local scope
encapsulation, Understanding classification
implementing interface property in, Quick reference
inheritance. (see inheritance)
instance methods, Overloading constructors
IntelliSense icon for, Writing your first program
keywords used in defining methods, Implementing and using an abstract class
objects versus, Defining and using a class
operators in, Comparing operators in structures and classes
referencing a class through its interface, Implementing an interface
sealed, Abstract classes
static, Creating a shared field
structures versus, Declaring a structure
comparing copy behavior of class and structure, Copying structure variables
understanding classification, Creating and managing classes and objects
value type, Understanding values and references
writing constructors and creating objects, Overloading constructors
Clone method, Copying value type variables and classes
Array class, Copying arrays
using to copy arrays, Comparing indexers and arrays
Close method, Recommendations
CLR (Common Language Runtime), Writing methods, Copying structure variables
managing threads to implement concurrent tasks, Tasks, threads, and the ThreadPool
WinRT and, Implementing and using an abstract class
Code and Text Editor window, Beginning programming with the Visual Studio 2013 environment, Displaying primitive data type values
finding and replacing code, Displaying primitive data type values
Program.cs file in, Beginning programming with the Visual Studio 2013 environment
code blocks
grouping if statements in, Understanding if statement syntax
life span of variables defined in, How computer memory is organized
using with for statements, Writing for Statements
using with while statements, Writing while statements
collections, Using collections
adding or removing items, Quick reference
collection classes, Using collections
Dictionary<TKey, TValue>, The Stack<T> collection class
HashSet<T>, The HashSet<T> collection class
LinkedList<T>, The List<T> collection class
List<T>, What are collection classes?
most commonly used, What are collection classes?
nongeneric, in System.Collections, What are collection classes?
Queue<T>, The Queue<T> collection class
SortedList<TKey, TValue>, The Dictionary<TKey, TValue> collection class
Stack<T>, The Stack<T> collection class
comparison to arrays, The Find methods, predicates, and lambda expressions
using collection classes to play cards, The Find methods, predicates, and lambda expressions
concurrent collection classes, Cancelling synchronization
creating, Quick reference
enumerating, Enumerating collections, Using LINQ in a C# application, Using LINQ in a C# application
elements in a collection, Enumerating collections
implementing enumerator using an iterator, Implementing an enumerator by using an iterator
Find methods, predicates, and lambda expressions, Using collection initializers
finding number of elements in, Quick reference
improving performance while iterating through, using PLINQ, Using PLINQ to parallelize declarative data access
in memory, vs. tables in relational database, Joining data
iterating through, Quick reference
locating an item in, Quick reference
using collection initializers, The HashSet<T> collection class
ColumnarHeaderStyle style, Applying styles to a UI
ColumnarLayout state, Adapting the layout by using the Visual State Manager
ComboBox controls
adding to Windows Store app, Implementing a scalable user interface
adding ComboBoxItem, Implementing a scalable user interface
implementing data binding for title ComboBox controls, Using data-binding with a ComboBox control
using data binding with, Modifying data by using data binding
ComboBoxItem controls, Implementing a scalable user interface
CommandManager object, Adding commands to a ViewModel
commands, Summary
adding to a ViewModel, Creating a ViewModel
buttons bound to commands in ViewModel, Adding commands to a ViewModel
implementing Command class, Adding commands to a ViewModel
comments
/* and */ surrounding multiline comments, Writing your first program
// (forward slashes) preceding, Writing your first program
///, beginning comments in XAML files, Examining the Windows Store app
TODO comments, use by developers, Overloading constructors
Common Intermediate Language (CIL), Copying structure variables
Common Language Runtime. (see CLR)
Common WPF Controls, Creating a graphical application
Common XAML Controls, Creating a graphical application
Compare method, Contravariant interfaces
complex numbers, developing class that simulates, Implementing operators
adding conversion operators, Creating symmetric operators, revisited
creating Complex class and implementing arithmetic operators, Implementing operators
implementing equality operators, Implementing operators
Component Object Model (COM), Writing methods
compound assignment operators. (see assignment operators, compound)
compound operators, controlling using checked and unchecked keywords, Writing checked expressions
concurrency
issues to consider in implementing, Implementing multitasking by using the Microsoft .NET Framework
synchronizing concurrent access to data, Synchronizing concurrent access to data
concurrent collections
classes, Cancelling synchronization
using with lock for safe data access, The concurrent collection classes
ConcurrentBag<T> class, Cancelling synchronization
ConcurrentDictionary<TKey, TValue> class, Cancelling synchronization
ConcurrentQueue<T> class, Cancelling synchronization
ConcurrentStack<T> class, The concurrent collection classes
conditional logical operators, Understanding equality and relational operators
short-circuiting, Short-circuiting
Connect To Server dialog box, Retrieving data from a database
Connection Properties dialog box, Creating an entity model
console applications, Welcome to C#
creating using Visual Studio 2013, Welcome to C#, Summary
steps in process, Beginning programming with the Visual Studio 2013 environment
writing Hello World application, Beginning programming with the Visual Studio 2013 environment
Console class, Writing your first program
Console.WriteLine method, Writing your first program
calling ToString method automatically, Working with structures
classic example of overloading in C#, Understanding parameter arrays
overload to support format string argument containing placeholders, Using params object[ ]
const keyword, creating a static field with, Creating a shared field, Quick reference
constructed types, The generics solution
constructors, Controlling accessibility
calling base class constructor from derived class constructor, Using inheritance, Understanding extension methods
declaring and calling, Quick reference
default, Working with constructors
for static classes, Creating a shared field
for structures, Declaring a structure, Declaring structure variables
not defined in interfaces, Interface restrictions
object initializers and, Initializing objects by using properties
overloading, Overloading constructors
public and private, Working with constructors
writing, Overloading constructors
Content property, changing for Button controls, Creating a graphical application
continuations, Creating, running, and controlling tasks
specified by await operator, Defining asynchronous methods: the solution, Defining asynchronous methods: the solution
using with canceled and faulted tasks, The mechanics of cooperative cancellation
continue statements, Writing do statements
ContinueWith method, Task object, Creating, running, and controlling tasks, The mechanics of cooperative cancellation
parameters specifying additional items, Creating, running, and controlling tasks
contracts, What is a Windows Store app?, Adding commands to a ViewModel
implementing Search contract, Windows 8.1 contracts
contravariant interfaces, Contravariant interfaces
controller classes, REST web service
creating additional, Creating and using a REST web service
incoming web requests handled by, Creating and using a REST web service
controls
applying styles to, in Windows Store app, Adapting the layout by using the Visual State Manager, Summary
attached properties, Implementing a tabular layout by using a Grid control
binding commands to, Adding commands to a ViewModel
dragging from Toolbox to forms, Implementing a scalable user interface
hierarchy of, on complex forms, Examining arithmetic operators
conversion operators, Implementing operators
built-in conversions for built-in types, Providing built-in conversions
creating symmetric operators, Creating symmetric operators, revisited
defining, Quick reference
user-defined, implementing, Implementing user-defined conversion operators
writing, Creating symmetric operators, revisited
Copy method, Array class, Copying arrays
CopyTo method, Array class, Copying arrays
Count property
finding number of elements in collections, Quick reference
List<T> class, The List<T> collection class
Count, Max, Min and other summary methods, Ordering, grouping, and aggregating data
invoking Count, Using query operators
CountdownEvent class, Synchronization primitives for coordinating tasks
covariant interfaces, Variance and generic interfaces, Quick reference
Created status, tasks, The mechanics of cooperative cancellation
Current property, IEnumerator interface, Enumerating the elements in a collection

D

data binding, Summary
associating same piece of data to multiple controls, Adapting the layout by using the Visual State Manager
displaying data using, Displaying data by using data binding
implementing for title ComboBox controls, Using data-binding with a ComboBox control
modifying data using, Displaying data by using data binding
using with ComboBox control, Modifying data by using data binding
data types
array elements, Declaring array variables, Populating and using an array
casting, using as operator, The as operator
conversions, Implementing operators
built-in conversions for built-in types, Providing built-in conversions
implementing user-defined conversion operators, Implementing user-defined conversion operators
declaring implicitly typed local variables, Prefix and postfix
numeric types and infinite values, Operators and types
operators and, Using arithmetic operators
primitive, Declaring variables
primitive types in C# and equivalents in .NET Framework, Working with structures
specifying for variables, Naming variables
switch statement use on, Understanding switch statement syntax
ToString method, Displaying primitive data type values
variables created with var keyword, Understanding static classes
verifying type of an object with is operator, Unboxing
database, remote, accessing from Windows Store app, Accessing a remote database from a Windows Store app
inserting, updating, and deleting data through REST web service, Creating and using a REST web service
implementing add and edit functionality in ViewModel, Inserting, updating, and deleting data through a REST web service
integrating add and edit functionality into Cutsomers form, Reporting errors and updating the UI
reporting errors and updating the UI, Inserting, updating, and deleting data through a REST web service
testing the Customers app, Reporting errors and updating the UI
retrieving data from a database, Accessing a remote database from a Windows Store app
creating an entity model, Retrieving data from a database
creating and using a REST web service, Creating an entity model
installing AdventureWorks database, Retrieving data from a database
DataContext property, MainPage object, Creating a ViewModel
dates and time
comparing dates in method using cascading if statement, Cascading if statements
comparing dates in real-world applications, Cascading if statements
creating and using structure to represent a date, Understanding structure initialization
DbContext class, Creating an entity model
DbSet generic type, Creating an entity model
Debug folder, Writing your first program
Debug menu
Start Debugging, Writing your first program
Start Without Debugging, Writing your first program
Debug mode, Writing your first program
Windows Store app in Windows 8.1, Creating a graphical application
debugger
exception handling and Visual Studio debugger, Writing checked expressions
stepping through methods with Visual Studio 2013 debugger, Writing methods
debugging Windows Store apps, Creating a graphical application
decimal type, Declaring variables
decision statements, Using decision statements
declaring Boolean variables, Using decision statements
if statements, Summarizing operator precedence and associativity
switch statements, Cascading if statements
using Boolean operators, Declaring Boolean variables
declarations, variable, Naming variables, Prefix and postfix
implicitly typed, Declaring implicitly typed local variables
decrement operator. (see - (minus sign), under Symbols)
decrementing variables, Associativity and the assignment operator
prefix and postfix, Associativity and the assignment operator
deep copying, Copying value type variables and classes, Copying arrays
default constructor, Working with constructors
writing your own constructor and, Overloading constructors
default keyword, Using switch statements
initializing variable defined with a type parameter, Manually implementing an enumerator
deferred evaluation, LINQ and, Querying data in Tree<TItem> objects
definite assignment rule, Declaring variables
delegates, Decoupling application logic and handling events
Action and Func type, using with Command class, Adding commands to a ViewModel
adapter methods, Lambda expressions and delegates
async modifier with, Defining asynchronous methods: the solution
attaching to events, Subscribing to an event
declaring a delegate type, Quick reference
declaring and using (exercise), Declaring and using delegates
creating CheckoutController component, Declaring and using delegates
examining Wide World Importers application, Declaring and using delegates
testing the application, Declaring and using delegates
detaching from events, Subscribing to an event
examples in .NET Framework class library, Understanding delegates
factory control system implemented without, Examples of delegates in the .NET Framework class library
for events, Raising an event
implementing factory control system using, Implementing the factory control system without using delegates
delegate referring to multiple methods, Implementing the factory by using a delegate
invoking a delegate, Implementing the factory by using a delegate
removing methods from delegate, Implementing the factory by using a delegate
IntelliSense icon for, Writing your first program
invoking, Quick reference
lambda expressions, Lambda expressions and delegates
registering Action delegate with task’s cancellation token, The mechanics of cooperative cancellation
understanding, Decoupling application logic and handling events
use with Dispatcher object, Invoke method, Defining asynchronous methods: the problem
using to mimic function call as an operator, Understanding operators
DELETE requests, Creating and using a REST web service
derived classes, What is inheritance?
creating from base class, Understanding extension methods
methods masking base class methods, Declaring new methods
protected members, Understanding protected access
Design View window, Creating a graphical application
expanding/contracting elements in XAML pane, Adapting the layout by using the Visual State Manager
using to add form controls, Creating a graphical application
XAML form description changes and, Creating a graphical application
zooming in and out, Displaying primitive data type values
destructors
calling Dispose method from, The using statement and the IDisposable interface, Implementing exception-safe disposal
creating simple class that uses, Calling the Dispose method from a destructor
not defined in interfaces, Interface restrictions
not running until objects are garbage collected, Why use the garbage collector?
writing, The life and times of an object, Quick reference
restrictions on destructors, Writing destructors
development environment settings, Beginning programming with the Visual Studio 2013 environment
Device Window (on the Design menu), Creating a graphical application
dictionary-oriented collections
adding or removing an item, Quick reference
ConcurrentDictionary<TKey, TValue> class, Cancelling synchronization
finding a value and accessing it, Using collection initializers
locating an item in, Quick reference
Dictionary<TKey, TValue> class, What are collection classes?, The Stack<T> collection class
Dispatcher object, Defining asynchronous methods: the problem
DispatcherTimer class, Adding commands to a ViewModel
disposal methods, Recommendations, Quick reference
defined, Recommendations
exception-safe disposal, Exception-safe disposal
Dispose method, The using statement and the IDisposable interface, Implementing exception-safe disposal
calling from a destructor, The using statement and the IDisposable interface, Implementing exception-safe disposal
thread safety and, Implementing exception-safe disposal
Distinct method, Ordering, grouping, and aggregating data, Using query operators, Querying data in Tree<TItem> objects
DivideByZeroException, The mechanics of cooperative cancellation
division operator. (see / (slash), under Symbols)
do statements, Understanding for statement scope, Quick reference
stepping through, Writing do statements
writing, Writing do statements
Document Outline window, Examining arithmetic operators
pinning in place with Audo Hide button, Examining arithmetic operators
Documents folder, Beginning programming with the Visual Studio 2013 environment
dot notation (.), Understanding extension methods, The life and times of an object
double type, Declaring variables
duplicates, eliminating from query results, Ordering, grouping, and aggregating data, Using query operators

E

else statements., Summarizing operator precedence and associativity
(see also if statements)
encapsulation, Understanding classification
implementing by using methods, Implementing properties to access fields
Entity Data Model Wizard, Creating an entity model
Entity Framework, Retrieving data from a database
mapping layer between relational database and your app, Creating an entity model
T4 templates, security warning about, Creating an entity model
versions, Creating an entity model
Entity Model editor, Creating an entity model
entity model, creating, Retrieving data from a database, Quick reference
AdventureWorks entity model, Creating an entity model
entity sets, Creating an entity model
enum keyword, Declaring an enumeration
enum types. (see enumerations)
Enumerable class, Using LINQ in a C# application
Count, Max, Min and other summary methods, Ordering, grouping, and aggregating data
GroupBy method, Ordering, grouping, and aggregating data
Join method, Ordering, grouping, and aggregating data
OrderBy method, Filtering data
OrderByDescending method, Ordering, grouping, and aggregating data
Select method, Selecting data
definition of, Selecting data
ThenBy or ThenByDescending method, Ordering, grouping, and aggregating data
Where method, Selecting data
enumerable collections, Enumerating collections, Using LINQ in a C# application
implementing IEnumerable interface, Manually implementing an enumerator
making a collection class enumerable, Quick reference
projecting specified fields from, Quick reference
enumerations, Creating value types with enumerations and structures
arrays of, Declaring array variables
casting to int, Creating jagged arrays
choosing enumeration literal values, Using an enumeration
choosing enumeration’s underlying values, Choosing an enumeration’s underlying type
declaring, Declaring an enumeration, Copying structure variables
using, Declaring an enumeration
enumerators, Enumerating the elements in a collection
defining by using an iterator, Quick reference
defining for Tree<TItem> class using an iterator, A simple iterator
implementing by using an iterator, Implementing an enumerator by using an iterator
implementing manually, Manually implementing an enumerator
implementing without using an iterator, Quick reference
enums, IntelliSense icon for, Writing your first program
equality operators, Declaring Boolean variables, Following the switch statement rules
associativity and precedence, Summarizing operator precedence and associativity
implementing overloaded versions, Implementing operators
overriding == and != operators, Comparing operators in structures and classes
Equals method
overriding in Complex class, Implementing operators
overriding in System.Object or System.ValueType, Defining operator pairs
structures, Declaring a structure
equi-joins, LINQ support for, Using query operators
Error List window, Writing your first program, Implementing operators
error reporting, adding to ViewModel class, Inserting, updating, and deleting data through a REST web service
errors and exceptions, Managing errors and exceptions
coping with errors, Managing errors and exceptions
ensuring exception-safe disposal, Exception-safe disposal, Quick reference
exception handling and Visual Studio debugger, Writing checked expressions
exceptions, Writing methods
implementing exception-safe disposal (exercise), Calling the Dispose method from a destructor
task exceptions
canceled tasks, The mechanics of cooperative cancellation
continuations with canceled or faulted tasks, Using continuations with canceled and faulted tasks
handling with AggregateException class, The mechanics of cooperative cancellation, Quick reference
throwing exceptions, Throwing exceptions
trying code and catching exceptions, Coping with errors
catching multiple exceptions, Using multiple catch handlers
propagating exceptions, Catching multiple exceptions
unhandled exceptions, Trying code and catching exceptions
using multiple catch handlers, Unhandled Exceptions
using a finally block, Throwing exceptions
using checked and unchecked integer arithmetic, Propagating exceptions
writing checked expressions, Writing checked expressions
writing checked statements, Using checked and unchecked integer arithmetic
Event Handlers for the Selected Element button, Adding code to the graphical application
EventArgs class, Understanding user interface events
events, Decoupling application logic and handling events
declaring, Quick reference
enabling notifications by using, The forms of lambda expressions
declaring an event, Declaring an event
raising an event, Subscribing to an event
subscribing to an event, Declaring an event
IntelliSense icon for, Writing your first program
security feature, Raising an event
subscribing to, Quick reference
tasks waiting for, Locking data
UI (user interface) events, Raising an event
adding event to CheckoutController class (exercise), Understanding user interface events
unsubscribing from, Quick reference
Exception class, Using multiple catch handlers
catch handler for all exceptions, Summary
catchall handler to trap Exception exceptions, Throwing exceptions
exceptions. (see errors and exceptions)
executable version of a program, Writing your first program
Execute method, Adding commands to a ViewModel
explicit and implicit keywords, Implementing user-defined conversion operators
explicit conversions, Providing built-in conversions
explicit interface implementation, Defining an interface, Explicitly implementing an interface
implementing an indexer, Indexers in interfaces, Quick reference
Extensible Application Markup Language. (see XAML)
extension methods, Understanding extension methods
creating (exercise), Understanding extension methods
defining for a type, Quick reference
Enumerable.Select, Selecting data
IntelliSense icon for, Writing your first program

F

F (type suffix), Displaying primitive data type values
factory control system, Examples of delegates in the .NET Framework class library
implementing by using a delegate, Implementing the factory control system without using delegates
implementing without using delegates, Examples of delegates in the .NET Framework class library
faulted tasks, Creating, running, and controlling tasks, The mechanics of cooperative cancellation
using continuations with, The mechanics of cooperative cancellation
fields, Defining and using a class
implementing encapsulation by using methods, Implementing properties to access fields
implementing properties to access. (see properties)
initialization, Controlling accessibility
names of, warning about property names and, What are properties?
naming conventions, Controlling accessibility
not defined in interfaces, Explicitly implementing an interface
private or public, Controlling accessibility
readonly, Creating jagged arrays
static, Overloading constructors
creating a shared field, Understanding static methods and data
structure, Declaring a structure
file input/output (I/O), source of slow operations, Asynchronous methods and the Windows Runtime APIs
File Open Picker contract, Adding commands to a ViewModel
FileInfo class, Writing while statements
filename extensions, solution and project files, Displaying primitive data type values
FileOpenPicker class, asynchronous processing in, Asynchronous methods and the Windows Runtime APIs
filtering data, Selecting data, Quick reference
using where operator, Using query operators
Finalize method, Writing destructors
finally blocks, Throwing exceptions
Find method, generic collections, Using collection initializers
List<T> class, Understanding delegates
first-in, first-out (FIFO) model, Introducing generics, What are collection classes?
float type, Declaring variables
floating-point arithmetic, checked and unchecked keywords and, Writing checked expressions
FontSize property, changing for TextBlock control, Creating a graphical application
FontStyle style, Applying styles to a UI
For method, Parallel class, Abstracting tasks by using the Parallel class, Synchronizing concurrent access to data
canceling, The mechanics of cooperative cancellation
general rule for using, When not to use the Parallel class
for statements, Writing while statements, Quick reference
continue statement in, Writing do statements
iterating through an array, Creating an implicitly typed array, Summary
iterating through collections, Quick reference
multiple initializations and updates in, Writing for Statements
omitting initialization, Boolean expression, or update control variable, Writing for Statements
scope, Understanding for statement scope
foreach statements
iterating through an array, Iterating through an array, Summary, Enumerating collections
iterating through collections, Quick reference
iterating through List<T> collections, The List<T> collection class
ForEach<T> method, Parallel class, Abstracting tasks by using the Parallel class
canceling, The mechanics of cooperative cancellation
general rule for using, When not to use the Parallel class
forms, Creating a graphical application, Decoupling application logic and handling events
locating and selecting controls with Document Outline window, Examining arithmetic operators
resizing of WPF forms, Creating a graphical application
Windows Forms and WPF applications, Creating a graphical application
frame rate, tracking for Windows Store apps, Creating a graphical application
from operator, Joining data, Querying data in Tree<TItem> objects, Quick reference
Func delegate types, Examples of delegates in the .NET Framework class library
Func<T, …> delegate, Examples of delegates in the .NET Framework class library
functional programming languages, Using collection initializers
functions
defined, Lambda expressions and delegates
in Visual Basic, Declaring a method
similarity of methods to, Writing methods and applying scope

G

garbage collection, The life and times of an object
allowing CLR to manage, Implementing exception-safe disposal
forcing, Quick reference
GC class providing access to, Implementing exception-safe disposal
how the garbage collector works, How does the garbage collector work?
invoking the garbage collector, Why use the garbage collector?
reasons to use garbage collector, Writing destructors
stopping from calling destructor on an object, Calling the Dispose method from a destructor
writing destructors, The life and times of an object
GC class, Implementing exception-safe disposal
GC.Collect method, Why use the garbage collector?
GC.SuppressFinalize method, Calling the Dispose method from a destructor, Implementing exception-safe disposal
Generate Method Stub Wizard, Writing methods
generics, Introducing generics
binary trees, theory of, Creating a generic class
building binary tree class using generics, Building a binary tree class by using generics
testing Tree<TItem> class, Building a binary tree class by using generics
collection classes, Using collections
creating a generic class, Creating a generic class
creating a generic method, Creating a generic method
defining method to build a binary tree, Creating a generic method
generic method, Select<TSource, TResult>, Selecting data
problems with object type, Introducing generics
solution to problems with object type, The generics solution
using constraints, The generics solution
variance and generic interfaces, Defining a generic method to build a binary tree
versus generalized classes, The generics solution
gestures, What is a Windows Store app?
get and set accessors., Write-only properties
(see also properties)
for indexers, The same example using indexers
understanding, Understanding indexer accessors
for properties, Implementing encapsulation by using methods
restrictions on, Property accessibility
GetAwaiter method, awaitable objects, Defining asynchronous methods: the solution
GetHashCode method, Contravariant interfaces
overriding in Complex class, Implementing operators
overriding in System.Object or System.ValueType, Defining operator pairs
globally unique identifiers (GUIDs), Inserting, updating, and deleting data through a REST web service
graphical application, creating, Creating a graphical application
adding code, Examining the WPF application
C# and XAML files created by Visual Studio, Creating a graphical application
on Windows 7 or 8, Creating a graphical application
greater than operator. (see < > (angle brackets), under Symbols)
greater than or equal to operator. (see < > (angle brackets), under Symbols)
Grid App template, Using the Blank App template to build a Windows Store app, Summary
Grid control
for Windows Store app, Implementing a scalable user interface
implementing tablular layout using, Implementing a scalable user interface
modifying layout to scale to different form factors and orientations, Implementing a tabular layout by using a Grid control
Grid.Row attribute, Implementing a tabular layout by using a Grid control
GridStyle style, Applying styles to a UI
group by operator, Quick reference
group operator, Using query operators
GroupBy method, Ordering, grouping, and aggregating data, Querying data in Tree<TItem> objects, Quick reference
GUIDs (globally unique identifiers), Inserting, updating, and deleting data through a REST web service

H

HashSet<T> class, What are collection classes?, The HashSet<T> collection class
SortedSet<T> and, The HashSet<T> collection class
Haskell programming language, Using collection initializers
HasValue property, nullable types, Using nullable types
HeaderStyle style, Applying styles to a UI
modifying with additional property Setter elements, Applying styles to a UI
heap, How computer memory is organized
arrays on, Declaring array variables
automatic copying of items from stack (boxing), Boxing
class instances on, Understanding structure and class differences
expense of boxing and unboxing, Unboxing
multiple variables referring to same object, Using the stack and the heap
organization by the runtime, How computer memory is organized
using, How computer memory is organized
Hello World console application, Beginning programming with the Visual Studio 2013 environment
hill-climbing algorithm, Tasks, threads, and the ThreadPool
HTTP requests and responses, Creating and using a REST web service
PUT, POST, and DELETE requests, Creating and using a REST web service
REST web service, Creating and using a REST web service
HttpClient class, Creating and using a REST web service
GetAsync method, Creating and using a REST web service
HttpResponseMessage class, Creating and using a REST web service, Creating and using a REST web service
HttpResponseObject, Creating and using a REST web service
Hub App template, Summary
Hungarian notation, Naming variables, Defining an interface

I

IAsyncResult design pattern, Asynchronous methods and the Windows Runtime APIs
ICommand interface, Creating a ViewModel, Adding commands to a ViewModel
IComparable<T> interface, Querying data in Tree<TItem> objects
IComparer<T> interface, Contravariant interfaces
idempotency in REST web services, Inserting, updating, and deleting data through a REST web service
identifiers, Understanding statements
for variables, Naming variables
IDisposable interface, The using statement and the IDisposable interface
implementation (example), The using statement and the IDisposable interface
implementing, Quick reference
implementing (exercise), Implementing exception-safe disposal
IEnumerable interface
data structures implementing, Using LINQ in a C# application
GetEnumerator method, Enumerating the elements in a collection
IEnumerable<T> interface, Enumerating the elements in a collection
class implementing, Implementing an enumerator by using an iterator
data structures implementing, Using LINQ in a C# application
implementing, Manually implementing an enumerator
IEnumerator interface, Enumerating the elements in a collection
IEnumerator<T> interface, Enumerating the elements in a collection
if statements, Summarizing operator precedence and associativity, Following the switch statement rules
Boolean expressions in, Understanding if statement syntax
cascading, Using blocks to group statements
data types used on, Understanding switch statement syntax
syntax, Summarizing operator precedence and associativity
using blocks to group, Understanding if statement syntax
ImageBrush resource, Applying styles to a UI
Implement Interface Wizard, Implementing an interface
implicit and explicit keywords, Implementing user-defined conversion operators
implicit conversions, Providing built-in conversions
implicitly typed arrays, Populating and using an array
implicitly typed variables, Declaring implicitly typed local variables
increment operator. (see + (plus sign), under Symbols)
incrementing and decrementing variables, Associativity and the assignment operator
controlling ++ and -- operators with checked/unchecked keywords, Writing checked expressions
prefix and postfix, Associativity and the assignment operator
using ++ and -- operators instead of compound assignment operators, Using compound assignment operators
indexers, Using indexers
accessors, understanding, Understanding indexer accessors
comparison to arrays, Understanding indexer accessors
properties, arrays, and indexers, Comparing indexers and arrays
creating for class or structure, Quick reference
defined, Using indexers
example not using indexers, An example that doesn’t use indexers
example using indexers, The same example using indexers
important points about, The same example using indexers
in interfaces, Comparing indexers and arrays, Quick reference
using in a Windows application, Indexers in interfaces
examining the phone book application, Using indexers in a Windows application
testing the application, Using indexers in a Windows application
writing the indexers, Using indexers in a Windows application
using to simulate [ ] operator, Understanding operators
indexes
array, Creating an implicitly typed array
integer types as, Creating jagged arrays
multidimensional arrays, Copying arrays
Dictionary<TKey, TValue> class, The Stack<T> collection class
IndexOutOfRangeException, Creating an implicitly typed array, The mechanics of cooperative cancellation
inequality operator. (see ! (exclamation mark), under Symbols)
infinite values, Operators and types
inheritance, Working with inheritance
applicable to classes only, not structures, Using inheritance
assigning classes, Calling base class constructors
calling base class constructors, Using inheritance
classes implementing interfaces, Defining an interface
inheriting from another class, Implementing an interface
creating a hierarchy of classes (exercise), Understanding protected access
declaring new methods, Declaring new methods
declaring override methods, Declaring virtual methods
declaring virtual methods, Declaring new methods
defined, Working with inheritance
exception types, Using multiple catch handlers
from System.Object class, Using the stack and the heap
interface inheriting from another interface, Implementing an interface
interfaces, Interface restrictions
preventing with sealed classes, Abstract classes
protected access, Understanding protected access
System.Object class as root class, Using inheritance
understanding extension methods, Understanding extension methods
virtual methods and polymorphism, Declaring override methods
InitializeComponent method, MainWindow class, Examining the WPF application
initializers, collection, The HashSet<T> collection class
INotifyPropertyChanged interface, implementing, Modifying data by using data binding
instance methods
defined, Overloading constructors
writing and calling, Overloading constructors
int type, Declaring variables, An example that doesn’t use indexers
implementation of IComparable and IComparable<T>, Building a binary tree class by using generics
operators used to manipulate individual bits, An example that doesn’t use indexers
size, Propagating exceptions
Int32.Parse method, Using arithmetic operators
integers
integer types as indexes into an array, Creating jagged arrays
integer values associated with enumeration elements, Using an enumeration, Choosing an enumeration’s underlying type
IntelliSense in Visual Studio 2013, Writing your first program
icons for class members, Writing your first program
interface keyword, Understanding interfaces
interfaces, Creating interfaces and defining abstract classes
declaring and implementing interface properties, Understanding the property restrictions, Quick reference
defining, Understanding interfaces, Summary
defining and using (exercise), Interface restrictions
creating classes that implement the interface, Defining and using interfaces
testing implementation classes, Defining and using interfaces
explicitly implementing, Explicitly implementing an interface
generic, The generics solution
variance and, Defining a generic method to build a binary tree, Quick reference
implementing, Defining an interface, Summary
indexers in, Comparing indexers and arrays, Quick reference
inheriting from another interface, Implementing an interface
IntelliSense icon for, Writing your first program
keywords used in defining methods, Implementing and using an abstract class
naming convention, Defining an interface
referencing a class through its interface, Implementing an interface
restrictions, Explicitly implementing an interface
understanding, Creating interfaces and defining abstract classes
working with multiple interfaces, Referencing a class through its interface
IntersectWith, UnionWith, and ExceptWith methods, HashSet<T> class, The HashSet<T> collection class
InvalidCastException, Unboxing
Invoke method
Dispatcher object, Defining asynchronous methods: the problem
Parallel class, Abstracting tasks by using the Parallel class
reserving for computationally intensive operations, When not to use the Parallel class
is operator, Unboxing
determining if an object has specified type, Referencing a class through its interface
testing if cast is valid, Quick reference
iterators
defining enumerator by using, Quick reference
implementing an enumerator using, Implementing an enumerator by using an iterator
defining enumerator for Tree<TItem> class, A simple iterator
implementing enumerator without using an iterator, Quick reference

J

jagged arrays, Creating jagged arrays, Quick reference
Java
arrays of arrays, Creating jagged arrays
inheritance, Using inheritance
square brackets before array variable name, Declaring array variables
varargs facility operating similarly to params keyword in C#, Declaring a params Array
virtual methods, Declaring virtual methods
JavaScript Object Notation. (see JSON)
Join method, Ordering, grouping, and aggregating data, Quick reference
join operator, Using query operators, Quick reference
JSON (JavaScript Object Notation), Creating and using a REST web service
response returned from REST web service, Creating and using a REST web service

K

KeyValuePair<TKey, TValue> structure, The Dictionary<TKey, TValue> collection class
keywords, Understanding statements
defining methods for interfaces, classes, and structs, Implementing and using an abstract class

L

LabelStyle style, Applying styles to a UI
lambda expressions, Using collection initializers
and anonymous methods, The forms of lambda expressions
forms of, Lambda expressions and delegates
syntax, The Find methods, predicates, and lambda expressions
using in Select method, Using LINQ in a C# application
using in Where method, Filtering data
landscape orientation, Implementing a scalable user interface
language interoperability, operators and, Creating symmetric operators
Language-Integrated Query. (see LINQ)
last-in, first-out (LIFO) model, Using collections
Length property
Array class, Creating an implicitly typed array, Summary
List<T> class, The List<T> collection class
less than operator. (see < > (angle brackets), under Symbols)
less than or equal to operator. (see < > (angle brackets), under Symbols)
libraries
references to, in References folder, Beginning programming with the Visual Studio 2013 environment
lifecycle of Windows Store apps, What is a Windows Store app?
LinkedList<T> class, What are collection classes?, The List<T> collection class
LINQ (Language-Integrated Query), Querying in-memory data by using query expressions, Improving response time by performing asynchronous operations, Creating an entity model
await operator, inability to use in LINQ queries, Defining asynchronous methods: the solution
parallelizing a LINQ query, Quick reference
PLINQ (Parallel LINQ), Improving response time by performing asynchronous operations
cancellation of PLINQ query, Quick reference
using to parallelize declarative data access, Using PLINQ to parallelize declarative data access
using in a C# application, What is Language-Integrated Query?
filtering data, Selecting data
joining data, Ordering, grouping, and aggregating data
LINQ and deferred evaluation, Querying data in Tree<TItem> objects
ordering, grouping, and aggregating data, Filtering data
querying data in Tree<TItem> objects, Using query operators
selecting data, Using LINQ in a C# application
using query operators, Joining data
List<T> class, What are collection classes?, What are collection classes?
creating, manipulating, and iterating through, The List<T> collection class
determining number of elements in, The List<T> collection class
features that preclude array limitations, What are collection classes?
methods using delegates, Understanding delegates
local scope, defining
defining, Specifying the method call syntax
local variables
memory required for, How computer memory is organized
unassigned, Declaring variables
lock statement, Implementing exception-safe disposal
locking data, Synchronizing concurrent access to data
using concurrent collection and lock for safe data access, The concurrent collection classes
using ReaderWriterLockSlim object, Quick reference
logical operators, Understanding equality and relational operators
associativity and precedence, Summarizing operator precedence and associativity
in Boolean expressions, Following the switch statement rules
long type, Declaring variables

M

Main method, Beginning programming with the Visual Studio 2013 environment
array parameters and, Passing arrays as parameters and return values for a method
console application example, Writing your first program
MainPage.xaml folder, Creating a graphical application
MainPage.xaml.cs file, Creating a graphical application
examining for Windows Store app, Creating a graphical application
MainWindow.xaml file, Creating a graphical application
MainWindow.xaml.cs file, examining contents of, Examining the Windows Store app
managed code, Copying structure variables
managed execution environment, Copying structure variables
managed resources, destructors and, The life and times of an object
ManualResetEventSlim class, Locking data, Quick reference
Math class, Understanding classification, Overloading constructors
memory
allocation and reclamation for variables and objects, Using garbage collection and resource management
allocation for array instance, Creating an array instance
how computer memory is organized, Creating out parameters
stack and the heap, How computer memory is organized
using the stack and the heap, How computer memory is organized
unmanaged, for objects created in unsafe code, The as operator
use by multidimensional arrays, Copying arrays
MessageBox class, Adding code to the graphical application
MessageDialog object, Adding code to the graphical application
ShowAsync method, Defining asynchronous methods that return values
methods, Defining and using a class
abstract, Abstract classes
adapter, Lambda expressions and delegates
anonymous, The forms of lambda expressions
asynchronous. (see asynchronous operations)
calling, Returning data from a method
constructor. (see constructors)
creating a generic method, Creating a generic method
declaring, Declaring a method
declaring new methods for class in inheritance hierarchy, Declaring new methods
declaring override methods, Declaring virtual methods
declaring virtual methods, Declaring new methods
defining and invoking a generic method, Contravariant interfaces
delegates. (see delegates)
elements of, Using collection initializers
extension methods, understanding, Understanding extension methods
implementing encapsulation by using, Implementing properties to access fields
indexers versus, The same example using indexers
instance, Overloading constructors
IntelliSense icon for, Writing your first program
interface, Understanding interfaces, Interface restrictions
implementation of, Defining an interface
invoking, Decoupling application logic and handling events
keywords used in defining methods for interfaces, classes, and structs, Implementing and using an abstract class
length of, Returning data from a method
memory required for parameters and local variables, How computer memory is organized
naming conventions, Controlling accessibility
non-params, priority over params methods, Declaring a params Array
overloaded, Writing your first program
overloading, Overloading methods, Understanding parameter arrays
passing arrays as parameters and return values, Passing arrays as parameters and return values for a method
private or public, Controlling accessibility
replacing with properties (exercise), Replacing methods with properties
returned by lambda expressions, Using collection initializers
returning data from, Declaring a method
scope, Specifying the method call syntax
sealed, Abstract classes
signature, Declaring new methods
static, Overloading constructors, Quick reference
using optional parameters and named arguments, Writing methods
defining and calling method with optional parameters, Resolving ambiguities with optional parameters and named arguments
defining optional parameters, Defining optional parameters
passing named arguments, Defining optional parameters
resolving ambiguities, Passing named arguments
using ref and out parameters, Understanding the properties of nullable types
using value and reference parameters, Copying value type variables and classes
virtual methods and polymorphism, Declaring override methods
writing, Overloading methods
parameters, Writing methods
stepping through with debugger, Writing methods
testing the program, Writing methods
using Generate Method Stub Wizard, Writing methods
Methods For Fetching And Updating Data region, ViewModel, Inserting, updating, and deleting data through a REST web service
Microsoft Blend for Visual Studio 2013
defining complex styles to integrate into an app, Applying styles to a UI
Microsoft SQL Server, What is Language-Integrated Query?
Minimum Width setting, Implementing a scalable user interface
mobility as key requirement for modern apps, What is a Windows Store app?
Model-View-ViewModel pattern. (see MVVM pattern)
modifier methods., Implementing encapsulation by using methods
(see also properties)
modifiers., Understanding statements
(see also keywords and modifiers listed throughout)
applicable and inapplicable to oprators, Overloaded operators
modulus operator. (see % (percent sign), under Symbols)
Moore’s Law, The rise of the multicore processor
MoveNext method, enumerators, Enumerating the elements in a collection
multicore processors, rise of, Why perform multitasking by using parallel processing?
multidimensional arrays, Copying arrays
creating jagged arrays, Creating jagged arrays
params keyword, inability to use with, Declaring a params Array
using to implement a card game, Creating jagged arrays
multiplication operator. (see * (asterisk), under Symbols)
multitasking
implementing using .NET Framework, Implementing multitasking by using the Microsoft .NET Framework
performing using parallel processing, Improving throughput by using tasks
MVVM (Model-View-ViewModel) pattern, Displaying and searching for data in a Windows Store app
adding commands to a ViewModel, Creating a ViewModel
adding Next and Previous buttons to View, Adding commands to a ViewModel
adding NextCustomer and PreviousCustomer commands to ViewModel, Adding commands to a ViewModel
creating a ViewModel, Using data-binding with a ComboBox control
defined, Displaying data by using data binding
displaying data using data binding, Displaying data by using data binding
modifying data using data binding, Displaying data by using data binding

N

Name property for all controls, Implementing a scalable user interface
named arguments, Defining optional parameters
resolving ambiguities with, Passing named arguments
namespace keyword, Using namespaces
namespaces
and assemblies, Using namespaces
in WPF applications versus Windows Store apps, Examining the WPF application
IntelliSense icon for, Writing your first program
using, Writing your first program
naming conventions
for classes, Controlling accessibility
for fields and methods, Controlling accessibility
interfaces, Defining an interface
properties and field names, warning about, What are properties?
NaN (not a number), Operators and types
narrowing conversions, Providing built-in conversions
native code, Copying structure variables
New ASP.NET Project dialog box, Creating an entity model
new keyword, Defining and using a class, Summary
calling constructors, Quick reference
creating array instance, Declaring array variables, Summary
object creation, Using garbage collection and resource management
New Project dialog box, Beginning programming with the Visual Studio 2013 environment
newline character ( ), Writing while statements
NOT operator (!), Declaring Boolean variables
NOT operator (~), An example that doesn’t use indexers
NotImplementedException, Writing methods
null value
ascertaining if nullable variable contains, Using nullable types
assigning to reference variables, Understanding null values and nullable types
declaring a variable that can hold, Summary
inability to assign to value types, Understanding null values and nullable types
understanding, Copying value type variables and classes
nullable types, Understanding null values and nullable types
as method parameters, Understanding the properties of nullable types
creation in heap memory, How computer memory is organized
enumeration, Declaring an enumeration
structure, Declaring structure variables
understanding properties of, Using nullable types
numeric types
and infinite values, Operators and types
using remainder operator with, Operators and types

O

obj folder, Writing your first program
Object Collection Editor window, Implementing a scalable user interface
object initializers, Initializing objects by using properties, Initializing objects by using properties
object keyword, Using the stack and the heap
object references., Understanding values and references
(see also references; reference types)
stored by classes in System.Collections namespace, What are collection classes?
object type, Writing methods
problems with, Introducing generics
objects
classes versus, Defining and using a class
coverting to strings, Displaying primitive data type values
creating, Overloading constructors
creating using new keyword, Defining and using a class
initializing by using properties, Initializing objects by using properties, Quick reference
life and times of, Using garbage collection and resource management
memory allocation and recalamation for, Using garbage collection and resource management
memory required for, How computer memory is organized
parameters array of type object, Declaring a params Array
private modifier and, Overloading constructors
System.Object class, Using the stack and the heap, Using inheritance
Finalize method, Writing destructors
overriding Equals and GetHashCode methods, Defining operator pairs
verifying type with is operator, Unboxing
on clause of LINQ expressions, Using query operators
Open dialog box, Writing while statements
Open file picker, Writing while statements
Open Project dialog box, Displaying primitive data type values
operands, Using arithmetic operators
OperationCanceledException, The mechanics of cooperative cancellation, The mechanics of cooperative cancellation, Quick reference
handling, The mechanics of cooperative cancellation
operators, Using arithmetic operators
and data types, Using arithmetic operators
associativity, Using associativity to evaluate expressions
bitwise, An example that doesn’t use indexers
Boolean, using, Declaring Boolean variables
increment and decrement, Associativity and the assignment operator
overloading
and language interoperability, Creating symmetric operators
comparing operators in structures and classes, Comparing operators in structures and classes
compound assignment evaluation, Creating symmetric operators
conversion operators, Implementing operators
creating symmetric operators, Creating symmetric operators
declaring increment and decrement operators, Declaring increment and decrement operators
defining operator pairs, Comparing operators in structures and classes
implementing operators, Implementing operators
precedence and associativity, Short-circuiting
understanding, Operator overloading
operator constraints, Understanding operators
use on enumeration variables, Using an enumeration
use on your own structure types, Declaring a structure
optional parameters
comparing to parameter arrays, Using a params array
defining, Defining optional parameters
defining and calling a method with, Resolving ambiguities with optional parameters and named arguments
resolving ambiguities with, Passing named arguments
OrderBy method, Filtering data, Quick reference
orderby operator, Using query operators, Quick reference
OrderByDescending method, Ordering, grouping, and aggregating data
orientations
tablet app in landscape or portrait, Implementing a scalable user interface
testing for Windows Store app in Simulator, Implementing a tabular layout by using a Grid control
testing in Simulator, Implementing a scalable user interface
out keyword, Understanding the properties of nullable types
inability to use with params arrays, Declaring a params Array
out parameters
creating, Creating ref parameters, Quick reference
indexers versus arrays, Comparing indexers and arrays
Output window, Writing your first program
OverflowException, thrown by checked statements, Using checked and unchecked integer arithmetic
overloaded methods, Writing your first program
overloading methods, Overloading methods, Understanding parameter arrays
constructors, Overloading constructors
override keyword, Declaring virtual methods, Declaring override methods, Summary
inapplicable to operators, Overloaded operators
using with virtual keyword, Declaring override methods
overriding methods, Quick reference
declaring override methods, Declaring virtual methods

P

pages, Creating a graphical application
adapting to different screen resolutions and device orientation, Creating a graphical application
Parallel class
abstracting tasks by using, Abstracting tasks by using the Parallel class
Parallel.For method, Abstracting tasks by using the Parallel class
Parallel.ForEach<T> method, Abstracting tasks by using the Parallel class
Parallel.Invoke method, Abstracting tasks by using the Parallel class
parallelizing operations in GraphData application, Abstracting tasks by using the Parallel class
canceling Parallel.For or ForEach loop, The mechanics of cooperative cancellation
Parallel.For method, Synchronizing concurrent access to data
when not to use, When not to use the Parallel class
parallel processing, using to perform multitasking, Improving throughput by using tasks
parallelism
Parallel class determining degree of, Abstracting tasks by using the Parallel class
using Task class to implement, Creating, running, and controlling tasks
parallelization
degree of versus units of, Implementing multitasking by using the Microsoft .NET Framework
dividing method into series of parallel operations, Defining asynchronous methods: the solution
using PLINQ to parallelize declarative data access, Using PLINQ to parallelize declarative data access
ParallelLoopState object, Abstracting tasks by using the Parallel class, The mechanics of cooperative cancellation
ParallelQuery object, Using PLINQ to parallelize declarative data access
WithCancellation method, Using PLINQ to improve performance while iterating through a collection, Quick reference
parameter arrays, Understanding parameter arrays
comparing to optional parameters, Using a params array
overloading, recap of, Understanding parameter arrays
using array arguments, Overloading—a recap
declaring a params array, Using array arguments
important points about params arrays, Declaring a params Array
params object[ ], Declaring a params Array
using a params array (exercise), Using params object[ ]
parameters
generic types as, Creating a generic method
lambda expression, The Find methods, predicates, and lambda expressions
memory required for, How computer memory is organized
nullable variables as, Using nullable types
operator, Overloaded operators
optional parameters for methods, Writing methods
defining, Defining optional parameters
defining and calling method with, Resolving ambiguities with optional parameters and named arguments
resolving ambiguities with, Passing named arguments
passing arrays as parameters, Passing arrays as parameters and return values for a method
array parameters and Main method, Passing arrays as parameters and return values for a method
using ref and out parameters, Understanding the properties of nullable types, Summary
using value and reference parameters, Copying value type variables and classes
params keyword, Using array arguments
important points about params arrays, Declaring a params Array
partial classes, Overloading constructors
PascalCase naming scheme, Controlling accessibility
Peek Definition feature, Resolving ambiguities with optional parameters and named arguments
performance
impact of raising CanExecuteChanged event too frequently, Adding commands to a ViewModel
multidimensional arrays and, Copying arrays
pixels, font size measured in, Creating a graphical application
PLINQ (Parallel LINQ), Improving response time by performing asynchronous operations
cancellation of PLINQ query, Quick reference
using to parallelize declarative data access, Using PLINQ to parallelize declarative data access
canceling a PLINQ query, Using PLINQ to improve performance while iterating through a collection
improving performance while iterating through collections, Using PLINQ to parallelize declarative data access
pointers and unsafe code, The as operator
polymorphism
defined, Declaring override methods
virtual methods and, Declaring override methods
Pop method, Using collections
portrait mode, viewing app in, Creating a graphical application
portrait orientation, Implementing a scalable user interface
POST requests, Creating and using a REST web service
post-decrement operator (--), Short-circuiting
post-increment operator (++), Short-circuiting
pre-decrement operator (--), Short-circuiting
pre-increment operator (++), Short-circuiting
precedence, Operator overloading
controlling with arithmetic operators, Examining arithmetic operators
expressions containing operators with same precedence, Using associativity to evaluate expressions
operator precedence, summary of, Short-circuiting
predicates, Using collection initializers
delegates and, Understanding delegates
prefix and postfix, increment (++) and decrement (--) operators, Associativity and the assignment operator, Declaring increment and decrement operators
primitive data types, Declaring variables
as value types, Understanding values and references
displaying values, Displaying primitive data type values
fixed size, Propagating exceptions
in C# and equivalent types in .NET Framework, Working with structures
private keyword, Controlling accessibility, Summary
private modifier, Understanding protected access
class level versus object level, Overloading constructors
constructors, Working with constructors
copying reference types and data privacy, Copying value type variables and classes
identifiers, naming scheme for, Controlling accessibility
properties, Write-only properties
use with static keyword, Understanding static classes
Program class, Beginning programming with the Visual Studio 2013 environment
Program.cs file, Beginning programming with the Visual Studio 2013 environment
project files (.csproj suffix), Displaying primitive data type values
propagating exceptions, Catching multiple exceptions
properties, Implementing properties to access fields, Using indexers
accessibility, Write-only properties
arrays and indexers, Comparing indexers and arrays
declaring and implementing on an interface, Quick reference
declaring interface properties, Understanding the property restrictions
defined, Implementing encapsulation by using methods
generating automatic properties, Replacing methods with properties, Quick reference
initializing objects by using, Initializing objects by using properties, Quick reference
IntelliSense icon for, Writing your first program
names of, warning about field names and, What are properties?
read-only, Using properties, Quick reference
read/write, Using properties, Quick reference
replacing methods with (exercise), Replacing methods with properties
restrictions on, understanding, Property accessibility
using, What are properties?
using appropriately, Understanding the property restrictions
using to simulate assignment operator (=), Understanding operators
write-only, Using properties, Quick reference
Properties folder, Beginning programming with the Visual Studio 2013 environment
Properties window
Event Handlers for the Selected Element button, Adding code to the graphical application
specifying properties of form controls, Creating a graphical application
PropertyChanged event, Summary
protected keyword, Summary
protected modifier, Understanding protected access
properties, Write-only properties
public keyword, Controlling accessibility, Summary
public modifier, Understanding protected access
constructors, Working with constructors
identifiers, naming scheme for, Controlling accessibility
properties, Write-only properties
required for operators, Overloaded operators
structure fields and, Declaring a structure
Push method, Using collections
PUT requests, Creating and using a REST web service

Q

querying in-memory data, Querying in-memory data by using query expressions
LINQ (Language-Integrated Query), Querying in-memory data by using query expressions
using LINQ in a C# application, What is Language-Integrated Query?
filtering data, Selecting data
joining data, Ordering, grouping, and aggregating data
LINQ and deferred evaluation, Querying data in Tree<TItem> objects
ordering, grouping, and aggregating data, Filtering data
query operators, Joining data
retrieving data from BinaryTree using extension methods, Using query operators
retrieving data from BinaryTree using query operators, Querying data in Tree<TItem> objects
selecting data, Using LINQ in a C# application
queues
ConcurrentQueue<T> class, Cancelling synchronization
generic Queue<T> class, The generics solution, Using collections, What are collection classes?
example Queue<int> class and operations, The Queue<T> collection class
object-based Queue class, Introducing generics
Queue class versus Queue<T> class, The generics solution
Quick Find dialog box, Displaying primitive data type values

R

Random class, Creating an array instance
RanToCompletion status, tasks, The mechanics of cooperative cancellation
read-only properties, Using properties, Quick reference
read/write properties, Using properties, Quick reference
readability, What is a Windows Store app?
ReaderWriterLockSlim class, Synchronization primitives for coordinating tasks, Quick reference
readonly fields, Creating jagged arrays
rectangular arrays, Creating jagged arrays
ref keyword, Understanding the properties of nullable types
inability to use with params arrays, Declaring a params Array
ref parameters
creating, Creating ref parameters
indexers versus arrays, Comparing indexers and arrays
passing an argument to, Summary
using, Creating out parameters
refactoring code, Writing methods
reference types, Understanding values and references, The problem with the object type
arrays, Declaring array variables
classes, Understanding structure and class differences
copying a reference type variable, Summary
copying reference type variables, Declaring a structure
copying, data privacy and, Copying value type variables and classes
covariance, Covariant interfaces
GetHashCode method, Contravariant interfaces
initializing using null values, Copying value type variables and classes
memory allocation and reclamation for, Using garbage collection and resource management
ref and out modifiers on reference parameters, Creating out parameters
using for method parameters, Copying value type variables and classes, Understanding the properties of nullable types
variables of type object referring to, Using the stack and the heap
references
creating multiple references to an object, Writing destructors
reclamation by the heap, Using the stack and the heap
referencing a class through its interface, Implementing an interface
setting to null for immediate disposal, The life and times of an object
storage on the stack, How computer memory is organized
References folder, adding/removing references for assemblies, Using namespaces
Regex class, Inserting, updating, and deleting data through a REST web service
relational database management systems, What is Language-Integrated Query?
relational databases
tables in, vs. in memory collections, Joining data
relational operators, Declaring Boolean variables, Following the switch statement rules
associativity and precedence, Summarizing operator precedence and associativity
remainder (or modulus) operator (%), Operators and types
RenderTransform property, Applying styles to a UI
resource dictionary, Applying styles to a UI, Summary
adding reference for AppStyles.xaml file, Applying styles to a UI
resource management, Recommendations
calling Dispose method from a destructor, The using statement and the IDisposable interface
disposal methods, Recommendations
exception-safe disposal, Exception-safe disposal
implementing exception-safe disposal (exercise), Calling the Dispose method from a destructor
creating class that uses a destructor, Calling the Dispose method from a destructor
implementing IDisposable interface, Implementing exception-safe disposal
preventing multiple disposals of object, Implementing exception-safe disposal
thread safety and Dispose method, Implementing exception-safe disposal
verifying object disposal after an exception, Implementing exception-safe disposal
response time, issues with, Improving response time by performing asynchronous operations
REST web services, Quick reference
creating and using, Creating an entity model
idempotency in, Inserting, updating, and deleting data through a REST web service
inserting, updating, and deleting data through, Creating and using a REST web service
return statement, Declaring a method
return type for methods, Declaring a method
generic types as, Creating a generic method
return values, passing arrays as, Passing arrays as parameters and return values for a method
RoutedEventArgs object, Raising an event
RoutedEventHandler delegate type, Raising an event
Run method, Task class, Creating, running, and controlling tasks, Quick reference
Running status, tasks, The mechanics of cooperative cancellation

S

scalable user interface for Windows Store app, implementing, Using the Blank App template to build a Windows Store app, Summary
adapting layout using Visual State Manager, Implementing a tabular layout by using a Grid control
implementing tabular layout using Grid control, Implementing a scalable user interface
modifying layout for different form factors and orientations, Implementing a tabular layout by using a Grid control
laying out page for Customers app, Using the Blank App template to build a Windows Store app
testing app in Visual Stuido 2013 Simulator, Implementing a scalable user interface
scope, Specifying the method call syntax
defining class scope, Defining local scope
defining local scope, Specifying the method call syntax
in for statements, Understanding for statement scope
overloading methods, Overloading methods
starting new scope in code blocks, Using blocks to group statements
variables declared in using statement, The using statement and the IDisposable interface
screen resolutions
pages in Windows Store apps adjusting to, Creating a graphical application
Simulator in Visual Studio 2013, Implementing a scalable user interface
testing for Windows Store app in Simulator, Implementing a tabular layout by using a Grid control
sealed classes, Abstract classes, Quick reference
sealed keyword, Summary
inapplicable to operators, Overloaded operators
search
enabling Windows Store app to support searching, Summary
navigating to selected item, Implementing the Search contract
Search contract, Windows 8.1 contracts
implementing, Windows 8.1 contracts, Summary
registering Customers app with Windows Search, Implementing the Search contract
testing Search contract, Implementing the Search contract
SearchResultsPage class, Implementing the Search contract
OnItemClick method, Navigating to a selected item
Select method, Using LINQ in a C# application, Querying data in Tree<TItem> objects, Quick reference
select operator, Joining data, Querying data in Tree<TItem> objects, Quick reference
semantics, Working with variables, operators, and expressions
SemaphoreSlim class, Synchronization primitives for coordinating tasks, Quick reference
sentinel variable, Writing while statements
Setter elements (XAML), Applying styles to a UI
shallow copying, Copying value type variables and classes, Copying arrays
Share Target contract, Adding commands to a ViewModel
short-circuiting, Short-circuiting
showBoolValue method, Displaying primitive data type values
showDoubleValue method, Displaying primitive data type values
showFloatValue method, Displaying primitive data type values
showIntValue method, Displaying primitive data type values
signature, method, Declaring new methods
Simulator, using to test Windows Store apps, Implementing a scalable user interface, Implementing a tabular layout by using a Grid control
Snapped view for apps, Creating a graphical application
Solution Explorer, Beginning programming with the Visual Studio 2013 environment
project files in, Beginning programming with the Visual Studio 2013 environment
solution files (.sln suffix), Displaying primitive data type values
Solution ‘TestHello’ file, Beginning programming with the Visual Studio 2013 environment
SortedDictionary<TKey, TValue> class, The Dictionary<TKey, TValue> collection class
SortedList<TKey, TValue> class, What are collection classes?, The Dictionary<TKey, TValue> collection class
SortedSet<T> class, The HashSet<T> collection class
spinning, Using PLINQ to improve performance while iterating through a collection
Split App template, Using the Blank App template to build a Windows Store app, Summary
SQL (Structured Query Language), What is Language-Integrated Query?
Entity Framework reducing dependency on, Retrieving data from a database
entity model converting LINQ queries to SQL commands, Creating an entity model
generation of SQL commands by DBContext and DBSet, Creating an entity model
SQL Server, What is Language-Integrated Query?
stack, How computer memory is organized
automatic copying of item from stack to heap (boxing), Boxing
ConcurrentStack<T> class, The concurrent collection classes
organization by the runtime, How computer memory is organized
structure instances on, Understanding structure and class differences
using, How computer memory is organized
Stack<T> class, Using collections, What are collection classes?, The Stack<T> collection class
StackOverflowException, What are properties?
Start method, Task object, Creating, running, and controlling tasks
StartupUri property, App object, WPF application, Examining the WPF application
statements, Working with variables, operators, and expressions
syntax and semantics, Working with variables, operators, and expressions
static methods and data, Overloading constructors
creating a shared field, Understanding static methods and data
creating static field using const keyword, Creating a shared field
static classes, Creating a shared field
static method accepting value parameter, Copying value type variables and classes
writing static members and calling static methods, Understanding static classes
static modifier
properties, Using properties
required for operators, Overloaded operators
use with private keyword, Understanding static classes
Status property, Task object, The mechanics of cooperative cancellation
StopWatch object, Using the Task class to implement parallelism
StorageFile class, Asynchronous methods and the Windows Runtime APIs
asynchronous operations, Asynchronous methods and the Windows Runtime APIs
streams, writing to, Asynchronous methods and the Windows Runtime APIs
string concatenation operator (+), Using arithmetic operators
string keyword, Copying value type variables and classes
string type, Declaring variables
strings
+= operator used on, Using compound assignment operators
arrays of, Populating and using an array
as objects, Defining a generic method to build a binary tree
converting enumeration variables to, Using an enumeration
converting to integer values, Using arithmetic operators
coverting objets to, Displaying primitive data type values
implementation of IComparable and IComparable<T>, Building a binary tree class by using generics
string type as class, System.String, Copying value type variables and classes
Structured Query Language. (see SQL)
structures, Choosing an enumeration’s underlying type
arrays of, Declaring array variables
classes versus, Declaring a structure
common structure types, Choosing an enumeration’s underlying type
compatibility with runtime on Windows 8 and 8.1, Copying structure variables
copying structure variables, Understanding structure initialization
comparing copy behavior of structure and class, Copying structure variables
creating and using structure to represent a date, Understanding structure initialization
declaring, Declaring a structure, Quick reference
declaring structure variables, Understanding structure and class differences, Quick reference
implementing interface property in, Quick reference
inheritance not applicable to, Using inheritance
initialization, Declaring structure variables
IntelliSense icon for, Writing your first program
keywords used in defining methods, Implementing and using an abstract class
operators in, Comparing operators in structures and classes
used as parameters for Console.WriteLine method, Overloading—a recap
Style elements (XAML), Applying styles to a UI
styles, applying to Windows Store app UI, Adapting the layout by using the Visual State Manager, Summary
creating custom styles, Summary
defining styles for Customers form, Applying styles to a UI
subscribing to events, Declaring an event, Quick reference
subtraction operator. (see - (minus sign), under Symbols)
superset or subset methods, HashSet<T> class, The HashSet<T> collection class
suspending and resuming apps, What is a Windows Store app?
switch keyword, Using switch statements
switch statements, Cascading if statements, Quick reference
fall-through rules, Following the switch statement rules
rules for, Understanding switch statement syntax
syntax, Using switch statements
writing, Following the switch statement rules
synchronizing concurrent access to data, Synchronizing concurrent access to data, Quick reference
cancelling synchronization, Synchronization primitives for coordinating tasks
concurrent collection classes, Cancelling synchronization
locking data, Synchronizing concurrent access to data
synchronization primitives for coordinating tasks, Locking data
using concurrent collection and lock for safe data access, The concurrent collection classes
syntax, Working with variables, operators, and expressions
System namespace, Using namespaces
assemblies implementing classes in, Using namespaces
System.Array class, Creating an implicitly typed array
System.Array class., Enumerating collections
(see also Array class; arrays)
System.Collections namespace, What are collection classes?
System.Collections.Concurrent namespace, Cancelling synchronization
System.Collections.Generic namespace
collection classes, Using collections
IComparer interface, Contravariant interfaces
SortedDictionary<TKey, TValue> class, The Dictionary<TKey, TValue> collection class
SortedSet<T> class, The HashSet<T> collection class
System.Collections.Generic.Concurrent namespace, What are collection classes?
System.Collections.IEnumerable interface, Enumerating collections
System.Collections.IEnumerator interface, Enumerating the elements in a collection
System.Diagnostics.Stopwatch object, Using the Task class to implement parallelism
System.Int32 class, Choosing an enumeration’s underlying type
implementing IComparable and IComparable<T>, Building a binary tree class by using generics
System.Int64 class, Choosing an enumeration’s underlying type
System.Linq namespace, Enumerable class, Selecting data
System.Object class, Using the stack and the heap, Using inheritance, The problem with the object type
overriding Equals or GetHashCode methods, Defining operator pairs
ToString method, Declaring new methods
System.Random class, Creating an array instance
System.Single class, Choosing an enumeration’s underlying type
System.String class, Copying value type variables and classes
implementation of IComparable and IComparable<T>, Building a binary tree class by using generics
System.Text.RegularExpressions namespace, Inserting, updating, and deleting data through a REST web service
System.Threading namespace, Implementing multitasking by using the Microsoft .NET Framework
synchronization primitives, Locking data
System.Threading.CancellationTokenSource object, The mechanics of cooperative cancellation
System.Threading.Tasks namespace
Parallel class, Abstracting tasks by using the Parallel class
TaskStatus enumeration, The mechanics of cooperative cancellation
System.ValueType class, Using inheritance
overriding Equals or GetHashCode methods, Defining operator pairs
System.Windows namespaces, Examining the WPF application
System.Windows.Controls assembly, Examining the WPF application
System.Windows.MessageBox class, Adding code to the graphical application
SystemException class, Using multiple catch handlers
Systems.Collections.Generics namespace, The generics solution

T

tabular layout, implementing using Grid control, Implementing a scalable user interface
modifying layout to scale to different form factors and orientations, Implementing a tabular layout by using a Grid control
TabularHeaderStyle style, Applying styles to a UI
TabularLayout state, Adapting the layout by using the Visual State Manager
Task class, Implementing multitasking by using the Microsoft .NET Framework
Task List window, locating TODO comments, Copying value type variables and classes
Task Manager, closing Windows Store apps, Creating a graphical application
Task<TResult> class, Defining asynchronous methods that return values
TaskCanceledException, The mechanics of cooperative cancellation
TaskContinuationOptions enumeration, The mechanics of cooperative cancellation
TaskContinuationOptions type, Creating, running, and controlling tasks
TaskCreationOptions enumeration, Creating, running, and controlling tasks
tasks, Improving throughput by using tasks, Improving response time by performing asynchronous operations
canceling tasks and handling exceptions, When not to use the Parallel class, Quick reference
acknowledging cancellation and handling exception, The mechanics of cooperative cancellation
adding cancellation to GraphDemo application, The mechanics of cooperative cancellation
canceling Parallel For or ForEach loop, The mechanics of cooperative cancellation
continuations with canceled or faulted tasks, The mechanics of cooperative cancellation
displaying status of each task, The mechanics of cooperative cancellation
handling exceptions with AggregateException class, The mechanics of cooperative cancellation
implementing multitasking using .NET Framework, Implementing multitasking by using the Microsoft .NET Framework
abstracting tasks using Parallel class, Abstracting tasks by using the Parallel class
creating, running, and controlling tasks, Tasks, threads, and the ThreadPool
using Task class to implement parallelism, Creating, running, and controlling tasks
when not to use Parallel class, When not to use the Parallel class
PLINQ based on. (see PLINQ)
reasons to perform multitasking using parallel processing, Improving throughput by using tasks
synchronizing concurrent access to data, Synchronizing concurrent access to data
synchronization primitives for coordinating tasks, Locking data
TaskScheduler object, Creating, running, and controlling tasks
TaskStatus enumeration, The mechanics of cooperative cancellation
templates
choosing template for console application, Beginning programming with the Visual Studio 2013 environment
for graphical applications, Creating a graphical application
Windows Store app, Using the Blank App template to build a Windows Store app, Summary
TestHello folder, Beginning programming with the Visual Studio 2013 environment
TextBlock controls
adding to forms using Design View window, Creating a graphical application
adding to page in Windows Store app, Implementing a scalable user interface
labels for TextBoxes, Implementing a scalable user interface
labels used to identify data on page, Implementing a scalable user interface
setting properties, Implementing a scalable user interface
TextBox controls
adding to forms, Creating a graphical application
adding to Windows Store app
displaying text ID First Name, and Last Name, Implementing a scalable user interface
for email address and telephone number, Implementing a scalable user interface
TextReader class, Writing while statements
Close method, Recommendations
ThenBy or ThenByDescending method, Ordering, grouping, and aggregating data
this keyword
use with indexers, The same example using indexers
Thread class, Implementing multitasking by using the Microsoft .NET Framework
ThreadPool class, Implementing multitasking by using the Microsoft .NET Framework
threads
halting when garbage collector runs, How does the garbage collector work?
tasks, threads and the ThreadPool, Implementing multitasking by using the Microsoft .NET Framework
thread safety and Dispose method, Implementing exception-safe disposal
throwing exceptions, Throwing exceptions, Summary
catching the exception, Throwing exceptions
catching unhandled exceptions, Throwing exceptions
Title property, changing for forms, Creating a graphical application
ToArray method, LINQ and deferred evaluation
collection classes, The Find methods, predicates, and lambda expressions
TODO comments, Overloading constructors, Copying value type variables and classes
ToList method, LINQ and deferred evaluation, LINQ and deferred evaluation
Toolbox
dragging a control onto a form, Creating a graphical application
showing or hiding, Creating a graphical application
ToString method, Displaying primitive data type values
System.Object class, Declaring new methods
touch-based devices and user interfaces, Copying structure variables, What is a Windows Store app?
touch-based gestures, interacting with applications, Creating a graphical application
Transact-SQL Editor window, Retrieving data from a database
transformations, Applying styles to a UI
try/catch/finally statement blocks, Using a finally block
await operator and, Defining asynchronous methods: the solution
calling disposal method in finally block of try/finally, Exception-safe disposal
try blocks, Coping with errors
try/catch statement block, writing, Catching multiple exceptions
try/finally block, Finalize method in, Writing destructors
type parameter (<T>) for generics, The generics solution
type suffixes, Displaying primitive data type values
typeSelectionChanged method, Displaying primitive data type values

U

UI (user interface)
creating for Windows Store apps
Adventure Works Customers app (exercise), Using the Blank App template to build a Windows Store app
applying styles to a UI, Adapting the layout by using the Visual State Manager
implementing scalable user interface, Using the Blank App template to build a Windows Store app
events, Raising an event
unary operators, Understanding operators
explicit argument, Overloaded operators
unassigned local variables, Declaring variables
unboxing, Boxing
unchecked block statements, Using checked and unchecked integer arithmetic
unchecked keyword, Using checked and unchecked integer arithmetic
unhandled exceptions, Trying code and catching exceptions
catching, Throwing exceptions
Windows reporting of, Catching multiple exceptions
unmanaged applications, Copying structure variables
classes consumed by, through WinRT, Implementing and using an abstract class
unmanaged memory, The as operator
unmanaged resources, destructors and, The life and times of an object
unsafe keyword, marking code as unsafe, The as operator
unsubscribing from events, Subscribing to an event, Quick reference
user experience (UX), What is a Windows Store app?
using directives, Using namespaces
using statement versus, Exception-safe disposal
using statement, Quick reference
and IDisposable interface, Exception-safe disposal
purpose of, Implementing exception-safe disposal
Util class, Understanding extension methods

V

Value property, nullable types, Using nullable types
value types, Understanding values and references
copying value type variables, Declaring a structure
copying variables and classes, Understanding values and references, Summary
declaring variables and classes as, Copying value type variables and classes
creating with enumerations and structures, Creating value types with enumerations and structures
structures, Choosing an enumeration’s underlying type
working with enumerations, Creating value types with enumerations and structures
creation in heap memory, How computer memory is organized
creation in stack memory, How computer memory is organized
memory allocation and reclamation for, Using garbage collection and resource management
nullable types, Understanding null values and nullable types
ref and out modifiers on value parameters, Creating out parameters
structures., Declaring structure variables
(see also structures)
using nullable types, Understanding null values and nullable types
using value parameters, Copying value type variables and classes, Understanding the properties of nullable types
variables of type object referring to, Boxing
ValueType class, Using inheritance
var keyword, Understanding static classes
use in defining type of enumerable collection, Selecting data
using in place of a type, Declaring implicitly typed local variables
variables, Identifying keywords
array, Using arrays, Summary
declaring, Naming variables
declaring implicitly typed local variables, Prefix and postfix
defined in code block, life span of, How computer memory is organized
enumeration, Declaring an enumeration, Copying structure variables
holding information about a single item, Using arrays
initializing variable defined with a type parameter, Manually implementing an enumerator
memory allocation and recalamation for, Using garbage collection and resource management
multiple, referring to same object, Using the stack and the heap
naming, Identifying keywords
scope, Specifying the method call syntax
structure, Understanding structure and class differences, Quick reference
unassigned local variables, Declaring variables
value type, Understanding values and references
variance, generic interfaces and, Defining a generic method to build a binary tree, Quick reference
contravariant interfaces, Contravariant interfaces
covariant interfaces, Variance and generic interfaces
invariant interfaces, Variance and generic interfaces
ViewModel
adding commands to, Creating a ViewModel
adding error reporting to, Inserting, updating, and deleting data through a REST web service
adding NextCustomer and PreviousCustomer commands to, Adding commands to a ViewModel
creating, Using data-binding with a ComboBox control
GoTo method, Implementing the Search contract
implementing add and edit functionality in, Inserting, updating, and deleting data through a REST web service
virtual keyword, Summary
declaring property implementations as virtual, Declaring interface properties
inapplicable to operators, Overloaded operators
virtual methods, Declaring virtual methods, Quick reference
and polymorphism, Declaring override methods
important rules for, Declaring override methods
indexer accessors implemented in a class, Indexers in interfaces
IntelliSense display of available methods, Understanding protected access
Visual Basic
functions or subroutines, similarity of methods to, Writing methods and applying scope
functions, procedures, and subroutines, Declaring a method
global methods, Declaring a method
managed code, Copying structure variables
naming class members, case and, Controlling accessibility
operators and language interoperability with C#, Creating symmetric operators
square brackets in C# array declarations, Declaring array variables
Visual State Manager, adapting Windows Store app layout with, Implementing a tabular layout by using a Grid control
Visual Studio 2013
beginning programming with, Welcome to C#
creating console application, Beginning programming with the Visual Studio 2013 environment
default development settings, Beginning programming with the Visual Studio 2013 environment
project files in Solution Explorer, Beginning programming with the Visual Studio 2013 environment
Start page, Beginning programming with the Visual Studio 2013 environment
creating a graphical application, Creating a graphical application
creating console application, Summary
creating Windows Store app for Windows 8.1, Summary
creating WPF application for Windows 7 or 8, Summary
Microsoft Blend, Applying styles to a UI
returning to, after debugging Windows Store app, Creating a graphical application
Simulator, Implementing a scalable user interface, Implementing a tabular layout by using a Grid control
Technical Preview Edition, default version of Entity Framework, Creating an entity model
templates and tools for building web services, Retrieving data from a database
templates for Windows Store apps, Using the Blank App template to build a Windows Store app
writing your first program, Beginning programming with the Visual Studio 2013 environment
void keyword return type for methods, Declaring a method

W

Wait method, Task object, Creating, running, and controlling tasks, The mechanics of cooperative cancellation, Quick reference
WaitAll and WaitAny methods, Task class, Creating, running, and controlling tasks, The mechanics of cooperative cancellation
WaitAll method, Quick reference
WaitingToRun status, tasks, The mechanics of cooperative cancellation
Web API template, Creating an entity model
web applications, creating, Creating an entity model
web services, Retrieving data from a database
creating and using REST web service, Creating an entity model
creating AdventureWorks web service, Creating and using a REST web service
fetching data from AdventureWorks web service, Creating and using a REST web service
inserting, updating, and deleting data through REST web service, Creating and using a REST web service
implementing add and edit functionality in ViewModel, Inserting, updating, and deleting data through a REST web service
integrating add and edit functionality into Customers form, Reporting errors and updating the UI
reporting errors and updating the UI, Inserting, updating, and deleting data through a REST web service
testing Customers app, Reporting errors and updating the UI
Where method, Selecting data, Querying data in Tree<TItem> objects, Quick reference
where operator, Using query operators, Quick reference
while statements, Writing while statements, Quick reference
syntax, Writing while statements
writing, Writing while statements
white space in C#, Understanding statements
widening conversions, Providing built-in conversions
widths for Windows Store apps
default minimum, Implementing a scalable user interface
defining layout for narrow view, Adapting the layout by using the Visual State Manager
testing in Simulator, Implementing a tabular layout by using a Grid control
Win32 APIs, Copying structure variables
Windows 7
exercises in this book, Creating a graphical application
Open dialog box, Writing while statements
starting Visual Studio 2013, Beginning programming with the Visual Studio 2013 environment
templates for graphical applications, Creating a graphical application
Windows 8 and 8.1
asynchronicity in Windows 8.1, Improving response time by performing asynchronous operations
compatibility with Windows Runtime (WinRT) on, Implementing and using an abstract class
contracts in Windows 8.1, Adding commands to a ViewModel
creating console application in Visual Studio 2013, Welcome to C#
creating graphical application in Visual Studio 2013 (Windows 8.1), Creating a graphical application
exercises in this book, Creating a graphical application
gestures interacting with Windows 8.1, What is a Windows Store app?
icons and toolbars for Windows 8.1, displaying, Implementing a tabular layout by using a Grid control
Open file picker (Windows 8.1), Writing while statements
running Windows Store app in Debug mode in Windows 8.1, Creating a graphical application
structs and compatibility with Windows Runtime, Copying structure variables
templates for Windows Store apps (Windows 8), Creating a graphical application
Windows 8.1 running on wide range of devices, What is a Windows Store app?
Windows Store style UI (Windows 8.1), Creating a graphical application
Windows Forms Application template, Creating a graphical application
Windows Phone devices, width of, Implementing a scalable user interface
Windows Runtime (WinRT), Copying structure variables
asynchronicity, Improving response time by performing asynchronous operations
asynchronous methods and Windows Runtime APIs, Defining asynchronous methods that return values
compatibility with, Implementing and using an abstract class
Windows Store apps, Creating a graphical application, Implementing the user interface for a Windows Store app
accessing remote database from, Accessing a remote database from a Windows Store app
inserting, updating, and deleting data through REST web service, Creating and using a REST web service
retrieiving data from a database, Accessing a remote database from a Windows Store app
building using Blank App template, Using the Blank App template to build a Windows Store app
applying styles to a UI, Adapting the layout by using the Visual State Manager
creating Adventure Works Customers app (exercise), Using the Blank App template to build a Windows Store app
implementing scalable user interface, Using the Blank App template to build a Windows Store app
closing, Creating a graphical application
creating, Summary
creating for Windows 8.1 using Visual Studio 2013, Summary
defined, What is a Windows Store app?
displaying and searching for data, Displaying and searching for data in a Windows Store app
implementing MVVM pattern, Displaying and searching for data in a Windows Store app
Windows 8.1 contracts, Adding commands to a ViewModel
examining code generated by Visual Studio for, Creating a graphical application
on Windows 8 and 8.1, running using WinRT, Implementing and using an abstract class
templates for, Summary
using Simulator to test, Implementing a scalable user interface
Windows.UI namespaces, Examining the WPF application
Windows.UI.Popups namespace, Adding code to the graphical application
Windows.UI.Xaml namespace
DispatcherTimer class, Adding commands to a ViewModel
Windows.UI.Xaml.Controls assembly, Examining the WPF application
Windows.UI.Xaml.Media.Imaging namespace, Using the Task class to implement parallelism
WinRT. (see Windows Runtime)
WPF (Windows Presentation Foundation), CommandManager object, Adding commands to a ViewModel
WPF Application template, Creating a graphical application, Creating a graphical application
WPF applications
creating for Winsows 7 or 8 using Visual Studio 2013, Summary
examining code files generated by Visual Studio, Examining the Windows Store app
write-only properties, Using properties, Quick reference
WriteableBitmap object, Using the Task class to implement parallelism, Asynchronous methods and the Windows Runtime APIs

X

XAML (Extensible Application Markup Language), Creating a graphical application
App.xaml file for WPF application, examining, Examining the WPF application
defined, Creating a graphical application
TextBlock control for a form, Creating a graphical application
XML, data from REST web service, Creating and using a REST web service
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.225.234.28