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 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
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.