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
- != not equal to operator, if Statements
- & address-of operator, Pointers
- && Boolean combination operator (if both true), if Statements
- * dereference operator, Pointers
- * multiplication operator, Expressions and Statements
- + addition operator, Expressions and Statements
- ++ increment operator, Increment and Decrement Operators
- += adding value operator, Assignment Statements, Race conditions
- - subtraction operator, Expressions and Statements
- -- decrement operator, Increment and Decrement Operators
- -> member access operator, Pointers
- . delineation operator, Namespaces and Types
- / division operator, Expressions and Statements
- /* */ multi-line comment, Comments, Regions, and Readability
- // single-line comment, Comments, Regions, and Readability
- /// XML Documentation Comments, XML Documentation Comments
- 32-bit processes, Managed Code, Integers, Array Size, 64-bit Versus 32-bit–64-bit Versus 32-bit
- 3D graphics, 3D graphics
- 64-bit processes, Managed Code, Integers, Array Size, 64-bit Versus 32-bit–64-bit Versus 32-bit
- : calling one constructor from another, Value Types and Reference Types
- : part of ternary operator, if...else
- ; end statement, Projects and Solutions
- < less than operator, if Statements
- <= less than or equal to operator, if Statements
- = field initializer operator, Fields: A Place to Put Data
- == equal to operator, if Statements
- => lambda expression, Creating Delegates with Lambda Expressions
- > greater than operator, if Statements
- >= greater than or equal to operator, if Statements
- ? part of ternary operator, if...else
- @” " string literal, Escaping Special Characters
- [ ] array index, Arrays
- (backslash) escape character, Escaping Special Characters–Escaping Special Characters
- line feed, Composing Strings
- carriage return, Composing Strings
- {} braces, C# containment, Namespaces and Types, Projects and Solutions
- || Boolean combination operator (if either true), if Statements
A
- ∀ universal quantifier, Testing the Whole Collection
- abstract base classes, Requiring Overrides with abstract–Requiring Overrides with abstract, Explicit Interface Implementation
- abstracting ideas, Abstracting Ideas with Classes and Structs–Object-oriented analysis
- accepting incoming connections, Implementing Services with the Socket Class
- accessibility modifiers, Protection Levels, Inheritance and Protection–Inheritance and Protection
- ACL (access control list), WCF configuration
- Action<T>, Generic Actions with Action<T>–Generic Actions with Action<T>
- ActiveX Controls, Importing ActiveX Controls–Importing a Control in .NET
- Add method, List<T>, Collections and Polymorphism, IDictionary<TKey, TValue>, Creating, Updating, and Deleting
- Add Reference menu item, Projects and Solutions
- AddAnything method, The dynamic Type, Ordinary .NET objects
- AddBefore/AddAfter methods, Linked Lists
- adding value (+=) operator, Assignment Statements, Race conditions
- addition (+) operator, Expressions and Statements
- AddNew method, Data Binding
- AddNumbers method, Finding and Sorting, Creating Your Own IEnumerable<T>, Creating Your Own IEnumerable<T>
- AddProcess method, Generic Actions with Action<T>
- AddRange method, List<T>, Concatenation
- AddTo methods, Creating, Updating, and Deleting
- administrative privileges, WCF configuration
- ADO.NET, Classic ADO.NET–ADO.NET data sets, The EntityClient ADO.NET Provider
- Adobe PDF Reader control, Importing a Control in .NET–Importing a Control in .NET
- affine transformations, Transforms
- aggregation, Association Through Composition and Aggregation, Testing the Whole Collection
- air traffic control example, Object-oriented analysis, Defining Classes–Representing State with Properties, Protection Levels–Protection Levels, Initializing with a Constructor–Initializing with a Constructor, Fields: A Place to Put Data–Read-only Fields and Properties, Related Constants with enum–Related Constants with enum, Value Types and Reference Types–Value Types and Reference Types, Overloading–Overloaded Methods and Default Named Parameters, Object Initializers–Object Initializers, Defining Methods–Defining Methods, Static Fields and Properties–Static Constructors
- constructors, overloading, Overloading–Overloaded Methods and Default Named Parameters
- declaring an enum, Related Constants with enum–Related Constants with enum
- defining classes, Defining Classes–Representing State with Properties
- defining methods, Defining Methods–Defining Methods
- defining variables/types, Value Types and Reference Types–Value Types and Reference Types
- initializing with a constructor, Initializing with a Constructor–Initializing with a Constructor
- object initializers, Object Initializers–Object Initializers
- setting protection levels, Protection Levels–Protection Levels
- setting up fields and properties, Fields: A Place to Put Data–Read-only Fields and Properties
- specs for, Object-oriented analysis
- static fields and properties, Static Fields and Properties–Static Constructors
- aliases, Integers
- All operator, Testing the Whole Collection
- ampersand (&), address-of operator, Pointers
- anchoring, Docking and Anchoring
- animation, Animation
- anonymous methods, Using Anonymous Methods
- anonymous type, Projections
- Any operator, Testing the Whole Collection
- APM (Asynchronous Programming Model), The Asynchronous Programming Model–The Asynchronous Programming Model, Tasks and the Asynchronous Programming Model
- appdomains, Unloading
- AppendLine method, Mutable Strings with StringBuilder
- application isolation, Isolation by user and application
- args variable, Flow Control with Selection Statements
- argument exceptions, Deciding What to Catch
- arrays, Flow Control with Selection Statements, Construction and Initialization–Array arguments and the params keyword, Array arguments and the params keyword, Custom Types in Arrays–Custom Types in Arrays, Array Members–Moving or copying elements, Array Size–Rectangular arrays, Arrays of arrays (or jagged arrays)–Arrays of arrays (or jagged arrays), Rectangular arrays–Rectangular arrays, Rectangular arrays, Rectangular arrays, List<T>–Finding and Sorting, Custom Indexers–Immutability and List<T>
- construction and initialization of, Construction and Initialization–Array arguments and the params keyword
- custom indexers in, Custom Indexers–Immutability and List<T>
- custom types in, Custom Types in Arrays–Custom Types in Arrays
- jagged, Arrays of arrays (or jagged arrays)–Arrays of arrays (or jagged arrays), Rectangular arrays
- List<T> as resizable, List<T>–Finding and Sorting
- members/elements of, Array Members–Moving or copying elements
- multidimensional, Rectangular arrays
- params keyword, Array arguments and the params keyword
- rectangular, Rectangular arrays–Rectangular arrays
- size of, Array Size–Rectangular arrays
- as keyword, The Last Resort: Checking Types at Runtime
- ASCII, Encoding Characters
- ASP.NET, Web Forms Fundamentals (see Web Forms and ASP.NET)
- .aspx extension, Web Forms Fundamentals
- assemblies, .NET Components: Assemblies, References–References, Writing Libraries–Writing Libraries, Protection–Internal protection, Naming–Signing and Strong Names, Loading–Unloading
- loading, Loading–Unloading
- naming, Naming–Signing and Strong Names
- overview, .NET Components: Assemblies
- protecting, Protection–Internal protection
- referencing, References–References
- writing libraries, Writing Libraries–Writing Libraries
- AssemblyInfo.cs, Projects and Solutions
- assignment statements, Assignment Statements
- associations, Association Through Composition and Aggregation, Inheritance and Polymorphism, Relationships–Navigation properties
- asterisk (*) dereference operator, Pointers
- asynchronous file operations, Asynchronous File Operations–Asynchronous File Operations, WebRequest and WebResponse
- asynchronous programming, Asynchronous Programming–Ad Hoc Asynchrony, Tasks and the Asynchronous Programming Model
- Atom, Stream-based uploads and downloads
- attached properties, Layout Panels
- attributes, XML Attributes–XML Attributes, Attributes–Using an attribute
- authentication, Authentication
- Authenticode signature, Isolation by user and application
- auto properties, Fields: A Place to Put Data
B
- backlog, Implementing Services with the Socket Class
- backslash (), escape character, Escaping Special Characters–Escaping Special Characters
- base classes, Inheritance and Polymorphism, Calling Base Class Methods–Calling Base Class Methods, Requiring Overrides with abstract
- Base64 encoding, Representing Binary As Text with Base64 Encoding–Representing Binary As Text with Base64 Encoding
- basic authentication, Authentication
- basic profile, Web Application with Client-Side Code
- Begin methods, The Asynchronous Programming Model, Tasks and the Asynchronous Programming Model
- BeginTransaction/EnlistTransaction methods, Transactions
- behaviors, Animation
- Berners-Lee, Tim, Downloading resources
- BigInteger, Integers
- binary, Projects and Solutions, Floating point, Representing Binary As Text with Base64 Encoding–Representing Binary As Text with Base64 Encoding, Assemblies
- bindings, Server configuration for duplex and sessions, Control Templates, Data Binding–Data Binding, Data Binding–Data Binding, Data Binding–Data Binding
- bit fields, Related Constants with enum
- bitmaps, Images
- bitness, 64-bit Versus 32-bit
- blocking APIs, Asynchronous Programming
- BlockingCollection, BlockingCollection
- BOM (Byte Order Mark), Why Encodings Matter
- bool type, if Statements
- boxing, Boxing and Unboxing Value Types
- braces {}, C# containment, Namespaces and Types, Projects and Solutions
- brackets [ ], array index, Arrays
- break keyword, switch and case Statements, Breaking Out of a Loop
- breakpoints, foreach Statements, Debugging with Return Values, Managing Isolated Storage
- buffering, Stream Buffers
- bugs, defined, Dealing with Errors
- Bustamante, Michele Leroux, WCF Test Client and Host
- button element, Xaml and Code Behind–Xaml and Code Behind, Layout Panels–Transforms, Controls–Styles, Postback versus nonpostback events, Data Binding–Adding Controls and Events
- Byte Order Mark, Why Encodings Matter
C
- C#, Introducing C#–C# 4.0, .NET 4, and Visual Studio 2010, Language Style–Continuity and the Windows Ecosystem, Managed Code, Managed Code, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010, Summary, Getting Started, Object Initializers, Creating Your Own IEnumerable<T>, Query Expressions, Anonymous types, C# 4.0 Interop Syntax Enhancements–Optional ref
- compared to Java, Managed Code
- creating a new program in, Getting Started
- improvements in version 2.0, Creating Your Own IEnumerable<T>
- improvements in version 3.0, Object Initializers, Query Expressions, Anonymous types
- improvements in version 4.0, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010, C# 4.0 Interop Syntax Enhancements–Optional ref
- Internet resources for, Summary
- language style, Language Style–Continuity and the Windows Ecosystem
- and managed code, Managed Code
- overview, Introducing C#–C# 4.0, .NET 4, and Visual Studio 2010
- C++, Language Style, Managed Code
- memory management issues in, Managed Code
- and .NET Framework, Language Style
- caching, Caching–Caching, Controlling cache behavior
- calculated properties, Initializing with a Constructor
- call stack, Methods, Debugging with Return Values
- callback interface, Bidirectional Communication with Duplex Contracts
- calling base class methods, Calling Base Class Methods–Calling Base Class Methods
- calling client from server, Calling the client from the server–Calling the client from the server
- camel casing, Representing State with Properties, Functional Composition with delegate
- CancelAsync method, The Event-Based Asynchronous Pattern
- cancellation, Cancellation
- cancelling events, Notifying Clients with Events–Notifying Clients with Events
- Canvas panel, Layout Panels
- carriage return ( ), Composing Strings
- cascading deletes, Creating, Updating, and Deleting
- cast operator, Floating point
- catch blocks, Handling Exceptions–When Do finally Blocks Run?
- chaining enumerations, Lazy collections
- char types, The String and Char Types, Checking Character Types
- characters, Accessing Characters by Index, Getting a Range of Characters–Getting a Range of Characters
- charmap, Encoding and Decoding
- child elements, Elements
- Church, Alonzo, Creating Delegates with Lambda Expressions
- cipher text, Streams That Aren’t Files
- classes, Language Style, Namespaces and Types, Abstracting Ideas with Objects and Classes, Object-oriented analysis, Defining Classes, Thus Far and No Farther: sealed, Generic Actions with Action<T>
- defined, Abstracting Ideas with Objects and Classes
- how to decide on, Object-oriented analysis
- how to define, Namespaces and Types, Defining Classes
- in .NET, Language Style
- nested, Generic Actions with Action<T>
- sealing, Thus Far and No Farther: sealed
- CleanupTestDirectories method, Creating and Securing Directory Hierarchies
- CLI (Common Language Infrastructure), Value Types and Reference Types
- ClickOnce Publication Wizard, Isolation by user and application
- Close method, C# 4.0, .NET 4, and Visual Studio 2010
- closures, Generic Delegates for Functions
- CLR (Common Language Runtime), Language Style
- code pages, Encoding Characters
- code points, Encoding Characters
- code separation, Web Forms Fundamentals
- code-behind files, Xaml and Code Behind, Web Forms Fundamentals, Code-Behind Files, Adding Controls and Events
- codespace, Encoding Characters
- collection classes, Language Style, Methods, Collections and Polymorphism–Collections and Polymorphism, Lazy collections–Lazy collections, Dictionaries–Sparse arrays, IDictionary<TKey, TValue>–Dictionaries and LINQ, HashSet and SortedSet, Queues, Linked Lists, Stacks
- defined, Methods
- dictionaries, Dictionaries–Sparse arrays
- HashSet and SortedSet, HashSet and SortedSet
- IDictionary<TKey>, <TValue>, IDictionary<TKey, TValue>–Dictionaries and LINQ
- lazy, Lazy collections–Lazy collections
- linked lists, Linked Lists
- and polymorphisms, Collections and Polymorphism–Collections and Polymorphism
- queues, Queues
- stacks, Stacks
- when working in C++, Language Style
- colon (:), calling one constructor from another, Value Types and Reference Types
- COM automation, Continuity and the Windows Ecosystem, The Dynamic Style and COM Automation, COM objects
- Combine methods, Well-Known Folders
- command-line inputs, Flow Control with Selection Statements
- comments, use of, Comments, Regions, and Readability–XML Documentation Comments
- Common Language Infrastructure (CLI), Value Types and Reference Types
- Common Language Runtime (CLR), Language Style
- comparable types, Ordering elements
- CompareBytes method, Streams
- CompareFiles method, Reading Files into Memory
- CompareTo method, Ordering elements
- comparison operators, if Statements, All Sorts of “Empty” Strings
- Comparison<T>, Ordering elements
- compilation, Projects and Solutions, Overloaded Methods and Default Named Parameters, Custom Indexers, let Clauses, Anonymous types
- Compile method, LINQ to Entities
- composability with delegates, Composability and Extensibility with Delegates (see extensibility with delegates)
- composing strings, Composing Strings–Upper- and Lowercase
- composite formatting, Composite Formatting with String.Format
- composition, Association Through Composition and Aggregation, Functional Style and Composition
- Concat method, Composing Strings, The dynamic Type
- concatenation, Concatenation, Composing Strings, Concatenating Path Elements Safely
- conceptual models, The Entity Data Model
- Concurrent Programming on Windows (Joe Duffy), Deadlocks and livelocks
- Configure method, Functional Composition with delegate
- Connect method, Session-based communication, Connecting to Services with the Socket Class
- connection handling, database, Connection Handling–Connection Handling
- Console Application template, Getting Started
- const modifier, Fields Can Be Fickle, but const Is Forever
- constrained layout, General-purpose layout properties
- constructors, Initializing with a Constructor, Value Types and Reference Types–Too Many Constructors, Mr. Mozart, FileStream Constructors–Setting Advanced Options
- Contains method, HashSet and SortedSet
- contended resource, defined, Dealing with Errors
- content controls, Content controls–User Controls
- contention, Threads
- context switches, The Stack
- contextual keywords, Initializing with a Constructor
- continuations, Continuations
- ContinueWith method, Continuations, Error Handling
- control characters, Encoding Characters, Encoding Characters
- controls, Importing ActiveX Controls–Importing a Control in .NET, Importing a Control in .NET–Importing a Control in .NET, Controls–User Controls, Items controls, Server Controls, Adding Controls and Events–Adding Controls and Events, Controls–Controls
- ActiveX, Importing ActiveX Controls–Importing a Control in .NET
- Adobe PDF Reader, Importing a Control in .NET–Importing a Control in .NET
- Silverlight/WPF, Controls–User Controls
- web form, Server Controls, Adding Controls and Events–Adding Controls and Events
- Windows Forms, Controls–Controls
- Xaml libraries, Items controls
- conversions, Expressions and Statements, Conversions
- cookies, Using cookies
- copying array elements, Moving or copying elements
- CopyTo method, Moving or copying elements, Writing Data with Streams
- Count method/property, List<T>, Aggregation
- countdown, Countdown
- coupling, Composability and Extensibility with Delegates
- CreateDirectory methods, Well-Known Folders
- CreateEncryptor method, An Adapting Stream: CryptoStream
- CreateFile method, Writing Text with a StreamWriter, Pointers
- CreateInstance/CreateComInstanceFrom/CreateComInstanceFrom methods, Late Binding
- CreateNewItem method, Data Binding
- CreateText method, Writing Text with a StreamWriter
- CRUD (Create, Read, Update, and Delete) operations, Creating, Updating, and Deleting–Creating, Updating, and Deleting
- CryptoStream, An Adapting Stream: CryptoStream
- .cs extension, Getting Started
- culture sensitivity, Culture Sensitivity–Culture Sensitivity
- currency values, Currency
- current working directory, Path and the Current Working Directory
- Curry, Haskell, Creating Delegates with Lambda Expressions
- custom attributes, Custom Attributes–Using an attribute
- custom dynamic objects, Custom dynamic objects
- custom event storage, Exposing Large Numbers of Events–Exposing Large Numbers of Events
- custom exceptions, Custom Exceptions–Custom Exceptions
- custom indexers, Custom Indexers–Immutability and List<T>
- custom interfaces (COM), COM objects
- custom numeric format strings, Custom Numeric Format Strings–Custom Numeric Format Strings
D
- Dahl, Ole-Johan, Abstracting Ideas with Objects and Classes
- data access with LINQ, Composability
- data binding, Data Binding–Data Binding, Data Binding–Data Binding, Data Binding–Data Binding
- data parallelism, Data Parallelism–PLINQ: Parallel LINQ
- database LINQ providers, LINQ and Databases
- databases, WCF Data Services, Databases, The Entity Data Model–The Entity Data Model, Generated Code–Generated Code, Changing the Mapping, Relationships–Multiplicity, Queries–The EntityClient ADO.NET Provider, LINQ to Entities, Entity SQL–The EntityClient ADO.NET Provider, Object Context–Connection Handling, Connection Handling–Connection Handling, Creating, Updating, and Deleting–Creating, Updating, and Deleting, Transactions–Transactions, Optimistic Concurrency–Optimistic Concurrency, Context and Entity Lifetime, Context and Entity Lifetime, WCF Data Services–WCF Data Services
- changing the mapping of, Changing the Mapping
- connection handling, Connection Handling–Connection Handling
- context and entity lifetime, Context and Entity Lifetime
- creating, updating, deleting data, Creating, Updating, and Deleting–Creating, Updating, and Deleting
- Entity data model, The Entity Data Model–The Entity Data Model
- and ESQL, Entity SQL–The EntityClient ADO.NET Provider
- functions delegates versus expressions, LINQ to Entities
- generated code from .edmx, Generated Code–Generated Code
- and object context, Object Context–Connection Handling, Context and Entity Lifetime
- optimistic concurrency, Optimistic Concurrency–Optimistic Concurrency
- queries, Queries–The EntityClient ADO.NET Provider
- relationships between tables, Relationships–Multiplicity
- and SQL Server 2008 Express, Databases
- transactions, Transactions–Transactions
- WCF Data Services, WCF Data Services, WCF Data Services–WCF Data Services
- DataSet class, ADO.NET data sets
- date and time strings, Dates and Times–Dates and Times
- daytime service, IP, IPv6, and TCP, Implementing Services with the Socket Class
- deadlocks, Deadlocks and livelocks
- deadly embraces, Deadlocks and livelocks
- debugger (Visual Studio), foreach Statements, Exceptions, Examining File Information, Managing Isolated Storage
- decimal floating point, Decimal floating point
- decimal format, Decimal
- declarative pinning, Pointers
- decoding, Encoding and Decoding, Encoding and Decoding
- decrement (--) operator, Increment and Decrement Operators
- decryption, Representing Binary As Text with Base64 Encoding
- default constructors, Value Types and Reference Types
- default named parameters, Overloaded Methods and Default Named Parameters–Overloaded Methods and Default Named Parameters
- deferred execution, Lazy collections, Deferred Execution, LINQ and Databases, LINQ to Entities
- degenerate query, Projections
- degrees, in relationships, Multiplicity
- delegates, Functional Composition with delegate–Functional Composition with delegate, Delegates in Properties–Delegates in Properties, Delegates and Lambdas
- Delete method, Deleting Files, Writing Text with a StreamWriter
- DeleteObject method, Creating, Updating, and Deleting
- deleting files, Deleting Files
- Dequeue method, Queues
- derived classes, Inheritance and Polymorphism–Replacing Methods in Derived Classes
- Descendants method, Search Axes
- Deserialize method, XML Serialization
- design by contract philosophy, Exceptions
- dictionaries, Dictionaries–Sparse arrays
- digest authentication, Authentication
- digital signing, Signing and Strong Names
- Dijkstra, Edsger, Breaking Out of a Loop
- directories, Inspecting Directories and Files–Examining Directories, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies, Deleting a Directory–Deleting a Directory
- creating and securing, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies
- deleting, Deleting a Directory–Deleting a Directory
- inspecting, Inspecting Directories and Files–Examining Directories
- disambiguation, Namespaces and Types
- Disconnect method, Session-based communication, Calling the client from the server
- disconnected operation, ADO.NET data sets
- DisplayMatches function, Reading Files into Memory
- DisplayResults method, Reading Files into Memory
- Distinct operator, Set Operations
- divide-by-zero problems, Dealing with Errors
- division (/) operator, Expressions and Statements
- division, integer versus floating-point, Expressions and Statements
- DLL, Projects and Solutions, .NET Components: Assemblies, Loading from the Application Folder, P/Invoke, Items controls
- .dll extension, Projects and Solutions, .NET Components: Assemblies
- do while Statements, while and do Statements
- docking, Docking and Anchoring
- DockPanel, Layout Panels
- document processing example, Composability and Extensibility with Delegates (see extensibility with delegates)
- Domain Name Service (DNS), IP, IPv6, and TCP
- Don’t Make Me Think (Krug), Adding Controls and Events
- dot (.) delineation operator, Namespaces and Types
- double keyword, Variable Types
- double type, Floating point–Floating point, Dealing with Errors
- Download methods, Downloading resources, Downloading resources, Asynchronous Programming, The Event-Based Asynchronous Pattern
- downloading from URL, Downloading resources
- dry (don’t repeat yourself) principle, Initializing with a Constructor
- dual-mode sockets, Implementing Services with the Socket Class
- Duffy, Joe, Deadlocks and livelocks
- duplex clients, Duplex client–Duplex client
- duplex contracts, Bidirectional Communication with Duplex Contracts
- dynamic keyword, C# 4.0, .NET 4, and Visual Studio 2010, Object Types and dynamic, Ordinary .NET objects, Ordinary .NET objects, dynamic in Noninterop Scenarios?
- dynamic object types, Object Types and dynamic–Custom dynamic objects
- dynamic programming, C# 4.0, .NET 4, and Visual Studio 2010, Static Versus Dynamic–The dynamic Type
- dynamic properties, Dynamic properties
- dynamic type, The dynamic Type
- DynamicWhere method, dynamic in Noninterop Scenarios?
E
- ∃ existential quantifier, Testing the Whole Collection
- EDM (Entity Data Model), The Entity Data Model
- .edmx extension, Generated Code
- EF (Entity Framework), LINQ and Databases, LINQ and Databases, WCF Data Services, The Entity Data Model–The Entity Data Model, The Entity Data Model–The Entity Data Model, Changing the Mapping, Navigation properties–Navigation properties, Multiplicity, Inheritance, Queries, LINQ to Entities–The EntityClient ADO.NET Provider, LINQ to Entities, Entity SQL–The EntityClient ADO.NET Provider, The EntityClient ADO.NET Provider, Connection Handling–Connection Handling, Creating, Updating, and Deleting–Creating, Updating, and Deleting, WCF Data Services
- and ADO.NET, The EntityClient ADO.NET Provider
- connection handling in, Connection Handling–Connection Handling
- and CRUD operations, Creating, Updating, and Deleting–Creating, Updating, and Deleting
- and EDM, The Entity Data Model–The Entity Data Model
- and ESQL, Entity SQL–The EntityClient ADO.NET Provider
- first release, LINQ and Databases
- inheritance, Inheritance
- and Link to Entities, LINQ to Entities–The EntityClient ADO.NET Provider
- and mapping, Changing the Mapping
- multiplicity, Multiplicity
- and navigation properties, Navigation properties–Navigation properties
- queries in, Queries, LINQ to Entities
- versus LINQ to SQL, LINQ and Databases
- and WCF, WCF Data Services, WCF Data Services
- elements, Array Members–Ordering elements, Elements, XML Elements, Searching for a Single Node, Elements and Controls–Transforms, Graphical Elements–3D graphics
- array, Array Members–Ordering elements
- graphical, Graphical Elements–3D graphics
- method, Searching for a Single Node
- UI, Elements and Controls–Transforms
- XML, Elements, XML Elements
- embarrassingly parallel tasks, Myth: Multiple logical processors will necessarily make things faster
- empty strings, All Sorts of “Empty” Strings–All Sorts of “Empty” Strings
- encapsulation, Abstracting Ideas with Methods, Initializing with a Constructor, Composability and Extensibility with Delegates
- encoding characters, Encoding Characters–Why Represent Strings As Byte Sequences?
- encryption, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding
- EncryptString method, Streams That Aren’t Files
- End methods, The Asynchronous Programming Model, The Asynchronous Programming Model, Tasks and the Asynchronous Programming Model
- EndGetHostEntry method, The Asynchronous Programming Model
- endpoints, WCF configuration
- English, cultural variants in, Culture Sensitivity
- Enqueue method, Queues
- Entity Data Model (EDM), The Entity Data Model
- Entity Framework (EF), LINQ and Databases (see EF (Entity Framework))
- entity lifetime, Context and Entity Lifetime
- Entity SQL (ESQL), Entity SQL–The EntityClient ADO.NET Provider
- entry point, .NET Components: Assemblies
- enum keyword, Related Constants with enum–Related Constants with enum, Returning Error Values
- EnumerateFiles method, Query Expressions
- enumerations, Collections and Polymorphism, Lazy collections–Lazy collections, Query Expressions, Reading, Writing, and Locking Files
- FileMode, FileAccess, FileShare, Reading, Writing, and Locking Files
- filenames, Query Expressions
- lazy, Lazy collections–Lazy collections
- and variance, Collections and Polymorphism
- equals (=), field initializer operator, Fields: A Place to Put Data
- Equals methods, Dictionaries
- errors, Dealing with Errors–Dealing with Errors, When and How to Fail–When and How to Fail, Returning Error Values–Debugging with Return Values, Debugging with Return Values, Exceptions–Handling Exceptions, Handling Exceptions–When Do finally Blocks Run?, Deciding What to Catch–Deciding What to Catch, Custom Exceptions–Custom Exceptions, Creating Your Own IEnumerable<T>, Error Handling
- custom exceptions, Custom Exceptions–Custom Exceptions
- debugging with return values, Debugging with Return Values
- deciding what to catch, Deciding What to Catch–Deciding What to Catch
- exceptions, Exceptions–Handling Exceptions
- overview, Dealing with Errors–Dealing with Errors
- setting return values, Returning Error Values–Debugging with Return Values
- task handling, Error Handling
- try, catch, finally blocks, Handling Exceptions–When Do finally Blocks Run?, Creating Your Own IEnumerable<T>
- when and how to fail, When and How to Fail–When and How to Fail
- escape characters, Escaping Special Characters–Escaping Special Characters
- ESQL (Entity SQL), Entity SQL–The EntityClient ADO.NET Provider
- evaluation order, Expressions and Statements
- event keyword, Notifying Clients with Events
- event overlaps, Testing the Whole Collection
- event storage management, Exposing Large Numbers of Events–Exposing Large Numbers of Events
- EventHandler<T>, Notifying Clients with Events
- events handling, Notifying Clients with Events–Exposing Large Numbers of Events, Events, Web Forms Events, Adding Controls and Events–Adding Controls and Events, Event Handling
- exception types, Deciding What to Catch
- exceptions, Exceptions–Handling Exceptions, Custom Exceptions–Custom Exceptions, Creating Your Own IEnumerable<T>, When Files Go Bad: Dealing with Exceptions–Finding and Modifying Permissions
- .exe extension, Projects and Solutions, .NET Components: Assemblies
- existential quantifier, Testing the Whole Collection
- ExpandoObject class, ExpandoObject
- explicit, Defining Methods, Explicit Interface Implementation–Explicit Interface Implementation, Construction and Initialization, Explicit Loading, Items controls
- element types, Construction and Initialization
- interface implementation, Explicit Interface Implementation–Explicit Interface Implementation
- loading, Explicit Loading
- member access, Defining Methods
- TreeViewItem containers, Items controls
- exponential form, Exponential form
- Expression Blend, Microsoft, Xaml and Objects
- expression trees, Creating Delegates with Lambda Expressions
- Expression<T> type, LINQ to Entities
- expressions, Expressions and Statements–Expressions and Statements
- extensibility and polymorphism, Association Through Composition and Aggregation, Inheritance and Polymorphism–Inheritance and Polymorphism, Replacing Methods in Derived Classes–Replacing Methods with virtual and override, Inheritance and Protection–Inheritance and Protection, Calling Base Class Methods–Calling Base Class Methods, Thus Far and No Farther: sealed–Thus Far and No Farther: sealed, Requiring Overrides with abstract–Requiring Overrides with abstract, All Types Are Derived from Object–Boxing and Unboxing Value Types, C# Does Not Support Multiple Inheritance of Implementation–C# Supports Multiple Inheritance of Interface, Deriving Interfaces from Other Interfaces–Explicit Interface Implementation, The Last Resort: Checking Types at Runtime, X Stands for eXtensible
- all types derived from Object, All Types Are Derived from Object–Boxing and Unboxing Value Types
- association through composition and aggregation, Association Through Composition and Aggregation
- calling base class methods, Calling Base Class Methods–Calling Base Class Methods
- checking types at runtime, The Last Resort: Checking Types at Runtime
- deriving interfaces from other interfaces, Deriving Interfaces from Other Interfaces–Explicit Interface Implementation
- inheritance and polymorphism, Inheritance and Polymorphism–Inheritance and Polymorphism
- inheritance and protection, Inheritance and Protection–Inheritance and Protection
- marking a class sealed, Thus Far and No Farther: sealed–Thus Far and No Farther: sealed
- multiple inheritance, C# Does Not Support Multiple Inheritance of Implementation–C# Supports Multiple Inheritance of Interface
- replacing methods in derived classes, Replacing Methods in Derived Classes–Replacing Methods with virtual and override
- requiring overrides with abstract, Requiring Overrides with abstract–Requiring Overrides with abstract
- XML, X Stands for eXtensible
- extensibility with delegates, Composability and Extensibility with Delegates–Composability and Extensibility with Delegates, Functional Composition with delegate–Functional Composition with delegate, Generic Actions with Action<T>–Generic Actions with Action<T>, Generic Predicates with Predicate<T>–Generic Predicates with Predicate<T>, Using Anonymous Methods, Creating Delegates with Lambda Expressions–Creating Delegates with Lambda Expressions, Delegates in Properties–Delegates in Properties, Generic Delegates for Functions–Generic Delegates for Functions, Notifying Clients with Events–Exposing Large Numbers of Events
- creating delegates with lambda expressions, Creating Delegates with Lambda Expressions–Creating Delegates with Lambda Expressions
- delegates in properties, Delegates in Properties–Delegates in Properties
- functional composition with delegate, Functional Composition with delegate–Functional Composition with delegate
- generic action with Action<T>, Generic Actions with Action<T>–Generic Actions with Action<T>
- generic delegates for functions, Generic Delegates for Functions–Generic Delegates for Functions
- generic predicates with Predicate<T>, Generic Predicates with Predicate<T>–Generic Predicates with Predicate<T>
- notifying clients with events, Notifying Clients with Events–Exposing Large Numbers of Events
- setup, Composability and Extensibility with Delegates–Composability and Extensibility with Delegates
- using anonymous methods, Using Anonymous Methods
- extension methods, Extension Methods and LINQ–Extension Methods and LINQ, Getting a Range of Characters, Ordinary .NET objects
- external client, External Client and .NET Web Service
- external party web service, .NET Client and External Party Web Service
F
- F#, Language Style
- factory methods, Object Initializers
- fall-through in case statements, switch and case Statements
- fetching, Downloading resources
- fibers, Threads and the OS Scheduler
- field initializer, Fields: A Place to Put Data
- fields, Fields: A Place to Put Data–Read-only Fields and Properties
- File.Exists method, When Files Go Bad: Dealing with Exceptions
- FileInfo object, Path and the Current Working Directory, Finding and Modifying Permissions
- FileOptions enumeration, Setting Advanced Options
- files and streams, Inspecting Directories and Files–Examining Directories, Examining Directories, Manipulating File Paths–Path and the Current Working Directory, Creating Temporary Files, Deleting Files, Well-Known Folders–Well-Known Folders, Concatenating Path Elements Safely, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies, Deleting a Directory–Deleting a Directory, Writing Text Files–Writing Text with a StreamWriter, When Files Go Bad: Dealing with Exceptions–Finding and Modifying Permissions, Finding and Modifying Permissions–Finding and Modifying Permissions, Reading Files into Memory–Reading Files into Memory, Streams–Writing Data with Streams, Reading, Writing, and Locking Files–Reading, Writing, and Locking Files, FileStream Constructors–Setting Advanced Options, Asynchronous File Operations–Asynchronous File Operations, Isolated Storage–Managing Isolated Storage, Managing User Storage with Quotas–Managing Isolated Storage, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding, An Adapting Stream: CryptoStream, In Memory Alone: The MemoryStream
- asynchronous file operations, Asynchronous File Operations–Asynchronous File Operations
- concatenating path elements safely, Concatenating Path Elements Safely
- creating and securing directory hierarchies, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies
- creating temporary files, Creating Temporary Files
- CryptoStream, An Adapting Stream: CryptoStream
- dealing with exceptions, When Files Go Bad: Dealing with Exceptions–Finding and Modifying Permissions
- deleting a directory, Deleting a Directory–Deleting a Directory
- deleting files, Deleting Files
- examining directories, Examining Directories
- FileStream constructors, FileStream Constructors–Setting Advanced Options
- finding and modifying permissions, Finding and Modifying Permissions–Finding and Modifying Permissions
- inspecting directories and files, Inspecting Directories and Files–Examining Directories
- isolated storage, Isolated Storage–Managing Isolated Storage
- managing user storage with quotas, Managing User Storage with Quotas–Managing Isolated Storage
- manipulating file paths, Manipulating File Paths–Path and the Current Working Directory
- MemoryStream, In Memory Alone: The MemoryStream
- reading files into memory, Reading Files into Memory–Reading Files into Memory
- reading, writing, and locking files, Reading, Writing, and Locking Files–Reading, Writing, and Locking Files
- streams, Streams–Writing Data with Streams
- streams that aren’t files, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding
- well-known folders, Well-Known Folders–Well-Known Folders
- writing text files, Writing Text Files–Writing Text with a StreamWriter
- filtering, Filtering
- finalization, Error Handling
- finally blocks, Handling Exceptions
- FindAll method, Finding elements, Arrays of arrays (or jagged arrays), Finding and Sorting
- finding and replacing content, Finding and Replacing Content
- fine-grained concurrency, Fine-grained concurrency
- firefighter training and simulation example, Extensibility and Polymorphism (see extensibility and polymorphism)
- firewalls, Bidirectional Communication with Duplex Contracts, Implementing Services with the Socket Class
- fixed keyword, Pointers, Pointers
- Fixed-point format, Fixed point
- [Flags] enum, Related Constants with enum
- flags-style enumeration, Setting Advanced Options
- floating point types, Floating point–Floating point
- flow control, Flow Control with Selection Statements–Breaking Out of a Loop
- flushing data, Stream Buffers
- fonts, What Is a String?
- for statements, for Statements
- ForEach methods, Myth: Maxing the CPU must mean we’re going really fast, Parallel For and ForEach–PLINQ: Parallel LINQ
- foreach statements, foreach Statements, Collections and Polymorphism, Collections and Polymorphism–Creating Your Own IEnumerable<T>
- format characters, Encoding Characters
- format items, Composite Formatting with String.Format
- formatting data for output, Formatting Data for Output–Round trip
- friendly feed rendering, WCF Data Services
- FromAsync method, Tasks and the Asynchronous Programming Model
- Func<> types, Generic Delegates for Functions
- functional coding/style, Namespaces and Types, Composability and Extensibility with Delegates, Functional Style and Composition, Concatenation
- functional decomposition, Abstracting Ideas with Methods
- functions, Abstracting Ideas with Methods, Generic Delegates for Functions–Generic Delegates for Functions
- futures, Tasks with results
G
- GAC (global assembly cache), Loading from the GAC
- garbage collection, Managed Code
- general format, General
- GenerateIV/GenerateKey methods, Streams That Aren’t Files
- generic classes, List<T>–Finding and Sorting
- List<T>, List<T>–Finding and Sorting
- generic delegates, Generic Actions with Action<T>–Generic Actions with Action<T>, Generic Predicates with Predicate<T>–Generic Predicates with Predicate<T>, Notifying Clients with Events
- Action<T>, Generic Actions with Action<T>–Generic Actions with Action<T>
- EventHandler<T>, Notifying Clients with Events
- Predicate<T>, Generic Predicates with Predicate<T>–Generic Predicates with Predicate<T>
- generic types, List<T>
- get accessor, Representing State with Properties–Initializing with a Constructor, Boxing and Unboxing Value Types
- GetAccessControl method, Finding and Modifying Permissions
- GetAllFilesInDirectory method, Query Expressions
- GetCipherText method, Representing Binary As Text with Base64 Encoding
- GetEnumerator method, Collections and Polymorphism
- GetFiles method, Examining Directories
- GetFolderPath method, Well-Known Folders, Well-Known Folders
- GetHashCode method, Dictionaries
- GetLength method, Rectangular arrays
- GetMachineStoreForApplication/Domain/Assembly methods, Machine isolation
- GetMembers method, Finding all type members, Finding type methods
- GetMethods, Finding type methods
- GetRandomFileName method, Deleting Files
- GetResourceStream method, Explicit Loading
- GetStream method, WebRequest and WebResponse
- GetString method, Encoding and Decoding, Pointers
- GetTempFileName method, Creating Temporary Files
- GetType method, XML Serialization, Type Discovery
- GetUserStoreForAssembly/GetUserStoreForDomain methods, Isolation by user and assembly
- GetWeb methods, Stream-based uploads and downloads
- global assembly cache (GAC), Loading from the GAC
- global namespace, Namespaces and Types
- Go method, The Stack, The Thread Pool, Race conditions
- GoNow method, Notification
- governing type, Related Constants with enum
- graphic characters, Encoding Characters
- Grid panel, Layout Panels–Layout Panels
- groupby clause, Using multiple sources
- grouping, Grouping–Grouping
- guard clauses, Exceptions
H
- hardware threads, Threads and the OS Scheduler
- hashes, Dictionaries
- HashSet, HashSet and SortedSet
- heap, on the, Value Types and Reference Types
- heap-allocated objects, Managed Code
- Hejlsberg, Anders, Representing State with Properties
- “Hello, world”, The .NET Framework Class Library, Getting Started, Namespaces and Types, Projects and Solutions, Projects and Solutions
- hexadecimal format, Hexadecimal
- hiding methods, Hiding Base Members with new–Hiding Base Members with new
- hierarchies, directory, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies
- high surrogates, Encoding Characters
- HighlightTrademarks method, Functional Composition with delegate
- HorizontalAlignment, General-purpose layout properties
- Hurwitz, Dan, Programming ASP.NET Applications
- hyperthreading, Threads and the OS Scheduler
I
- IANA (Internet Assigned Numbers Authority), IP, IPv6, and TCP
- ICollection<T>, Aggregation
- IDataReader, IDataReader and friends–ADO.NET data sets
- IDictionary<TKey>, <TValue>, IDictionary<TKey, TValue>–Dictionaries and LINQ
- IEnumerable<T> and IEnumerator<T>, Collections and Polymorphism, Extension Methods and LINQ, Functional Style and Composition
- if statements, if Statements–if...else
- if...else statements, if...else–if...else
- IL (Intermediate Language), Managed Code, Projects and Solutions
- images, Images
- immutability, Value Types and Reference Types, Immutability and List<T>, Functional Style and Composition, Strings Are Immutable
- of sources, Functional Style and Composition
- of strings, Strings Are Immutable
- of value types, Value Types and Reference Types, Immutability and List<T>
- implementation, switching of, Initializing with a Constructor
- implicit transactions, Transactions
- Implicit type conversions, Expressions and Statements
- in keyword, Collections and Polymorphism
- Include method, Navigation properties
- IncreaseQuotaTo method, Managing User Storage with Quotas
- increment operator (++), Increment and Decrement Operators
- indexed properties, Indexed Properties
- indexers, Custom Indexers–Immutability and List<T>
- indexes, array, Arrays
- IndexOf method, Finding and Replacing Content
- infinite series, Lazy collections
- inheritance, Inheritance and Polymorphism–Inheritance and Polymorphism, Inheritance
- initialization vector, Streams That Aren’t Files
- initialization, field, Fields: A Place to Put Data
- initializer list, Construction and Initialization
- InitializeService method, WCF Data Services
- inline array initializer, Construction and Initialization
- inlined methods, Using Anonymous Methods
- inner exceptions, Handling Exceptions
- inscrutable identifiers, Looking up values
- InspectDirectories method, Inspecting Directories and Files, Finding and Modifying Permissions
- integers (int), Integers–Integers, Related Constants with enum
- IntelliSense, Creating Delegates with Lambda Expressions, Culture Sensitivity, Ordinary .NET objects, Xaml and Code Behind
- interface keyword, C# Supports Multiple Inheritance of Interface
- interfaces, C# Supports Multiple Inheritance of Interface–Explicit Interface Implementation, Collections and Polymorphism
- Intermediate Language, Managed Code, Projects and Solutions
- internal protection level, Protection Levels, Internal protection–Internal protection
- Internet Assigned Numbers Authority (IANA), IP, IPv6, and TCP
- Internet Protocol, IP, IPv6, and TCP–IP, IPv6, and TCP
- interop assemblies, Interop Assemblies–No PIA
- interop scenarios, FileStream Constructors
- interop syntax enhancements, C# 4.0 Interop Syntax Enhancements–Optional ref
- interoperability, C# 4.0, .NET 4, and Visual Studio 2010, Interop with COM and Win32
- into keyword, Grouping
- intrinsic ordering, Ordering elements
- Invoke function, Functional Composition with delegate, Late Binding
- IP/IPv6, IP, IPv6, and TCP–IP, IPv6, and TCP
- is keyword, The Last Resort: Checking Types at Runtime
- is-a association, Association Through Composition and Aggregation
- IsAssignableFrom method, Reflecting on a Specific Type
- ISet<T>, HashSet and SortedSet
- IsHighSurrogate/IsLowSurrogate methods, Encoding Characters
- IsNumber/IsLetter methods, Encoding Characters
- isolated storage, Files and Streams, Isolated Storage–Managing Isolated Storage
- IsWhitespace method, Trimming Whitespace
- iteration statements, Iteration Statements–Breaking Out of a Loop
- iteration variables, for Statements
J
- jagged arrays, Arrays of arrays (or jagged arrays)–Arrays of arrays (or jagged arrays), Rectangular arrays
- Java, compared to C#, Managed Code
- JavaScript, Silverlight script objects, Xaml and Objects
- Join method, The Stack, Notification
- joining of sources, Joining
- JSON (JavaScript Object Notation), Web Application with Client-Side Code
K
- key pairs, Signing and Strong Names
- key type, Dictionaries
- keys, Strings Are Immutable, WCF Data Services
- Kleene, S. C., Creating Delegates with Lambda Expressions
- Krug, Steve, Adding Controls and Events
L
- lambda expressions, Creating Delegates with Lambda Expressions–Creating Delegates with Lambda Expressions, Delegates and Lambdas, Ordinary .NET objects
- late binding, Late Binding–Late Binding
- layout panels, Layout Panels–Transforms
- layout properties, General-purpose layout properties–Transforms
- layout slot, Layout Panels
- lazy enumeration, Lazy collections–Lazy collections, Deferred Execution
- lazy loading, Navigation properties
- Learning ASP.NET 3.5 (Liberty, Hurwitz, MacDonald), Programming ASP.NET Applications
- Learning WCF (Bustamante), WCF Test Client and Host
- least-significant byte (LSB), Encoding and Decoding
- let clauses, let Clauses
- Liberty, Jesse, Programming ASP.NET Applications
- libraries, Projects and Solutions, Writing Libraries–Writing Libraries
- life cycle, Web Forms Life Cycle
- LIFO (last in, first out) queues, Fine-grained concurrency
- ligatures, Encoding Characters
- lightweight value types, Value Types and Reference Types
- line feed, Composing Strings
- linked lists, Linked Lists
- LINQ (Language Integrated Query), Composability, Namespaces and Types, Query Expressions–Query Expressions Versus Method Calls, LINQ Concepts and Techniques–Deferred Execution, Filtering, Ordering–Ordering, Concatenation, Grouping–Grouping, Projections–Numbering items, Zipping, Testing the Whole Collection, Set Operations, Joining, Conversions, Searching in XML with LINQ–Searching in XML with LINQ, LINQ and Databases
- aggregation, Testing the Whole Collection
- concatenation, Concatenation
- concepts and techniques, LINQ Concepts and Techniques–Deferred Execution
- conversions, Conversions
- data access with, Composability
- and databases, LINQ and Databases
- filtering, Filtering
- grouping, Grouping–Grouping
- joining, Joining
- namespace, Namespaces and Types
- ordering, Ordering–Ordering
- projections, Projections–Numbering items
- query expressions, Query Expressions–Query Expressions Versus Method Calls
- searching in XML with, Searching in XML with LINQ–Searching in XML with LINQ
- set operations, Set Operations
- zipping, Zipping
- LINQ to Entities, LINQ to Entities–The EntityClient ADO.NET Provider
- LINQ to SQL, LINQ and Databases
- LINQ to XML, Creating XML Documents–Creating XML Documents
- Linux, Continuity and the Windows Ecosystem, WPF and Silverlight
- Liskov Substitution Principle (LSP), Inheritance and Polymorphism
- Liskov, Barbara, Inheritance and Polymorphism
- List<T> class, Boxing and Unboxing Value Types, Composability and Extensibility with Delegates, List<T>–Finding and Sorting
- listening, Implementing Services with the Socket Class–Implementing Services with the Socket Class
- literal expressions, Expressions and Statements
- literal strings/chars, The String and Char Types
- little-endian form, Encoding and Decoding
- livelocks, Deadlocks and livelocks
- Load method, Creating XML Documents, Navigation properties, Explicit Loading, Type Discovery
- LoadFile method, Streams, Explicit Loading
- LoadFiles function, Reading Files into Memory
- loading assemblies, Loading–Unloading
- localhost, IP, IPv6, and TCP, Implementing Services with the Socket Class
- lock keyword, Notification
- locking, Monitor–Mutexes
- logical processors, Threads and the OS Scheduler
- loops, breaking out of, Breaking Out of a Loop
- low surrogates, Encoding Characters
- lowercase letters, Upper- and Lowercase
- Lowy, Juval, WCF Test Client and Host
- LSP (Liskov Substitution Principle), Inheritance and Polymorphism
M
- Mac OS X, Continuity and the Windows Ecosystem
- MacDonald, Brian, Programming ASP.NET Applications
- machine isolation, Machine isolation
- machine language, Projects and Solutions
- machine translation, Composability and Extensibility with Delegates (see extensibility with delegates)
- Maharry, Dan, Programming ASP.NET Applications
- Main method, Namespaces and Types, Flow Control with Selection Statements, Defining Methods
- MakeTestDirectories method, Well-Known Folders, When Files Go Bad: Dealing with Exceptions
- Managed Extensibility Framework (MEF), Explicit Loading
- many-to-many relationships, Multiplicity
- mapping, database, The Entity Data Model, Changing the Mapping
- media, Media
- MEF (Managed Extensibility Framework), Explicit Loading
- member access (->) operator, Pointers
- members of a type, Finding all type members
- memory, reading files into, Reading Files into Memory–Reading Files into Memory
- MemoryStream, In Memory Alone: The MemoryStream
- Message property, Exceptions
- metadata, Sharing contracts, .NET Components: Assemblies, Reflection
- methods, Namespaces and Types, Methods–Methods, Abstracting Ideas with Classes and Structs–Object-oriented analysis, Abstracting Ideas with Methods, Abstracting Ideas with Methods, Overloaded Methods and Default Named Parameters–Overloaded Methods and Default Named Parameters, Defining Methods–Declaring Static Methods, Declaring Static Methods, Hiding Base Members with new–Hiding Base Members with new, Replacing Methods with virtual and override–Replacing Methods with virtual and override, Replacing Methods with virtual and override–Replacing Methods with virtual and override, Calling Base Class Methods–Calling Base Class Methods, Thus Far and No Farther: sealed, Using Anonymous Methods, Query Expressions Versus Method Calls
- abstracting ideas with, Abstracting Ideas with Classes and Structs–Object-oriented analysis
- anonymous, Using Anonymous Methods
- calling base class, Calling Base Class Methods–Calling Base Class Methods
- declaring, Defining Methods–Declaring Static Methods
- defined, Namespaces and Types
- hiding, Hiding Base Members with new–Hiding Base Members with new
- and LINQ queries, Query Expressions Versus Method Calls
- needs of users and developers, Abstracting Ideas with Methods
- overloaded, Overloaded Methods and Default Named Parameters–Overloaded Methods and Default Named Parameters
- overview, Methods–Methods
- replacing, Replacing Methods with virtual and override–Replacing Methods with virtual and override
- static, Declaring Static Methods
- versus functions, Abstracting Ideas with Methods
- virtual, Replacing Methods with virtual and override–Replacing Methods with virtual and override, Thus Far and No Farther: sealed
- MIME features, Other Networking Features
- ML programming language, Language Style
- monitors, Monitor–Monitor, Monitor–Mutexes, Notification–Notification, Events, BlockingCollection
- BlockingCollection, BlockingCollection
- events, Events
- locking, Monitor–Mutexes
- notification, Notification–Notification
- overview, Monitor–Monitor
- Moonlight project, Continuity and the Windows Ecosystem
- MoveFile method, P/Invoke
- moving/copying array elements, Moving or copying elements
- MSB (most-significant byte), Encoding and Decoding
- multidimensional arrays, Rectangular arrays
- multiple inheritance, C# Does Not Support Multiple Inheritance of Implementation–C# Supports Multiple Inheritance of Interface
- multiple sort criteria, Ordering
- multiple sources, Using multiple sources
- multiplexing, Threads and Asynchronous Code
- multiplication (*) operator, Expressions and Statements
- multiplicity, relationship, Multiplicity
- multithreaded coding, Multithreaded Coding Is Hard–Synchronization
- mutable strings, Mutable Strings with StringBuilder–Mutable Strings with StringBuilder
- mutexes, Mutexes
N
- namespaces (.NET), Namespaces and Types–Namespaces and Types, Projects and Solutions
- NaN (not a number), Dealing with Errors
- navigation properties, EF, Navigation properties, Creating, Updating, and Deleting
- nested classes, Generic Actions with Action<T>
- .NET client/server, .NET Client and .NET Server–.NET Client and External Party Web Service
- .NET Framework, The .NET Framework Class Library–Language Style, The .NET Framework Class Library, Language Style, Language Style, Continuity and the Windows Ecosystem, Continuity and the Windows Ecosystem, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010, Value Types and Reference Types, Overloaded Methods and Default Named Parameters, Static Constructors, All Types Are Derived from Object, C# Does Not Support Multiple Inheritance of Implementation–C# Supports Multiple Inheritance of Interface, Array Size, Collections and Polymorphism, Using cookies, The .NET Data Access Landscape–ADO.NET data sets, .NET Components: Assemblies
- and array size, Array Size
- and assemblies, .NET Components: Assemblies
- and C#, The .NET Framework Class Library–Language Style
- and C++, Language Style
- class library, The .NET Framework Class Library
- and collections, Collections and Polymorphism
- continuity with Windows ecosystem, Continuity and the Windows Ecosystem
- and cookies, Using cookies
- and data access, The .NET Data Access Landscape–ADO.NET data sets
- and default constructors, Overloaded Methods and Default Named Parameters
- memory management in, Value Types and Reference Types
- and multiple inheritance, C# Does Not Support Multiple Inheritance of Implementation–C# Supports Multiple Inheritance of Interface
- multiple language support in, Language Style
- order of static initialization, Static Constructors
- security model of, Continuity and the Windows Ecosystem
- types derived from Object, All Types Are Derived from Object
- version 4, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010
- networking, Choosing a Networking Technology, Choosing a Networking Technology, Web Application with Client-Side Code–Web Application with Client-Side Code, .NET Client and .NET Server–.NET Client and External Party Web Service, .NET Client and External Party Web Service, Bidirectional Communication with Duplex Contracts–Duplex client, HTTP–Authentication, Sockets, IP, IPv6, and TCP–IP, IPv6, and TCP, Connecting to Services with the Socket Class–Implementing Services with the Socket Class
- (see also WCF (Windows Communication Foundation))
- bidirectional communication with duplex contracts, Bidirectional Communication with Duplex Contracts–Duplex client
- choosing technology, Choosing a Networking Technology
- client-side code, Web Application with Client-Side Code–Web Application with Client-Side Code
- external party web service, .NET Client and External Party Web Service
- HTTP, HTTP–Authentication
- Internet Protocol, IP, IPv6, and TCP–IP, IPv6, and TCP
- .NET client/server, .NET Client and .NET Server–.NET Client and External Party Web Service
- sockets, Sockets, Connecting to Services with the Socket Class–Implementing Services with the Socket Class
- new keyword, Replacing Methods in Derived Classes, Custom Types in Arrays, Projections
- NHibernate, Non-Microsoft Data Access Technologies
- NIST (National Institute of Standards and Technology), IP, IPv6, and TCP
- no-PIA, C# 4.0, .NET 4, and Visual Studio 2010, No PIA
- nodes, Searching for a Single Node
- noninterop scenarios (dynamic), dynamic in Noninterop Scenarios?–dynamic in Noninterop Scenarios?
- nonpostback events, Postback versus nonpostback events
- not equal to (!=) operator, if Statements
- NotePosted method, Calling the client from the server
- null character, Escaping Special Characters, All Sorts of “Empty” Strings
- null keyword, Value Types and Reference Types
- numbering from zero, Flow Control with Selection Statements
- numbering items, Numbering items
- numeric format, Numeric
- Nygaard, Kristen, Abstracting Ideas with Objects and Classes
O
- object context, Generated Code, Object Context, Context and Entity Lifetime
- object-oriented programming, Abstracting Ideas with Objects and Classes
- objects, Abstracting Ideas with Objects and Classes, Object Initializers–Object Initializers, Xaml and Objects–Xaml and Objects
- defined, Abstracting Ideas with Objects and Classes
- initializers, Object Initializers–Object Initializers
- and Xaml, Xaml and Objects–Xaml and Objects
- Office, Microsoft, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010, Dynamic, The Dynamic Style and COM Automation, Interop Assemblies
- one-to-many relationships, Multiplicity
- one-to-one relationships, Multiplicity
- OnGetHostEntryComplete method, The Asynchronous Programming Model
- OnProcessing/OnProcessed methods, Notifying Clients with Events
- Open method, C# 4.0, .NET 4, and Visual Studio 2010, COM objects
- OpenRead/OpenWrite methods, Reading, Writing, and Locking Files, Stream-based uploads and downloads
- optimistic concurrency, Optimistic Concurrency–Optimistic Concurrency
- order of evaluation, Expressions and Statements
- OrderBy method, Ordering
- ordering, Ordering–Ordering
- Organize Usings item, Namespaces and Types
- orthotopes, Rectangular arrays
- out keyword, Collections and Polymorphism
- output, The .NET Framework Class Library, Formatting Data for Output–Round trip
- formatting, Formatting Data for Output–Round trip
- to console, The .NET Framework Class Library
- overexpression of concurrency, Fine-grained concurrency
- overloading, Overloading–Overloaded Methods and Default Named Parameters, The Last Resort: Checking Types at Runtime
- overriding, Replacing Methods with virtual and override, Requiring Overrides with abstract–Requiring Overrides with abstract
P
- P/Invoke, P/Invoke–P/Invoke
- Page_Load method, Adding Controls and Events
- Parallel class, Parallel For and ForEach–PLINQ: Parallel LINQ
- parallel execution, Threads and Asynchronous Code
- Parallel LINQ, PLINQ: Parallel LINQ
- parameter list, Namespaces and Types
- parameters, avoiding SQL attacks with, IDataReader and friends
- params keyword, Array arguments and the params keyword
- parent-child relationships, Parent-child relationships
- parental element, Elements
- partial keyword, Generated Code
- partial-trust scenarios, Pointers
- Pascal casing, Representing State with Properties, Functional Composition with delegate
- Path class/methods, Manipulating File Paths, Concatenating Path Elements Safely
- patterns, Object Initializers
- peer-to-peer networking, Other Networking Features
- percent format, Percent
- permissions, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies, Creating and Securing Directory Hierarchies–Finding and Modifying Permissions, Setting Permissions During Construction
- PIAs (primary interop assemblies), C# 4.0, .NET 4, and Visual Studio 2010, Interop Assemblies
- pinging, Other Networking Features
- pinning, Pointers
- “pit of success,” designing for the, Fields Can Be Fickle, but const Is Forever
- Platt, David, Adding Controls and Events
- PLINQ (Parallel LINQ), PLINQ: Parallel LINQ
- POCO (Plain Old CLR Object), Generated Code
- pointers, Pointers–Pointers
- polymorphism, Inheritance and Polymorphism, Collections and Polymorphism–Collections and Polymorphism
- (see also extensibility and polymorphism)
- popping, Methods
- port numbers, IP, IPv6, and TCP
- post conditions, Exceptions
- Post method, Thread Affinity and Context
- postback events, Postback versus nonpostback events
- PostNote method, Proxy
- precedence, Expressions and Statements
- preconditions, Exceptions
- predicate, defined, Generic Actions with Action<T>
- Predicate<T>, Generic Predicates with Predicate<T>–Generic Predicates with Predicate<T>
- primary interop assemblies (PIAs), C# 4.0, .NET 4, and Visual Studio 2010, Interop Assemblies
- printable characters, Encoding Characters
- private protection level, Protection Levels–Initializing with a Constructor
- procedural coding, Namespaces and Types
- Process method, Notifying Clients with Events
- Program.cs, Getting Started
- Programming ASP.NET 3.5 (Liberty, Maharry, and Hurwitz), Programming ASP.NET Applications
- Programming WCF Services (Lowy), WCF Test Client and Host
- programming, basic techniques, Getting Started–Getting Started, Namespaces and Types–Namespaces and Types, Projects and Solutions–Projects and Solutions, Comments, Regions, and Readability–XML Documentation Comments, Variables–Decimal floating point, Expressions and Statements–Increment and Decrement Operators, Flow Control with Selection Statements–Breaking Out of a Loop, Methods–Methods
- comments, regions, and readability, Comments, Regions, and Readability–XML Documentation Comments
- expressions and statements, Expressions and Statements–Increment and Decrement Operators
- flow control with selection statements, Flow Control with Selection Statements–Breaking Out of a Loop
- getting started, Getting Started–Getting Started
- methods, Methods–Methods
- namespaces and types, Namespaces and Types–Namespaces and Types
- projects and solutions, Projects and Solutions–Projects and Solutions
- variables, Variables–Decimal floating point
- project, Getting Started, Projects and Solutions, XML Documentation Comments
- creating in Visual Studio, XML Documentation Comments
- defined, Getting Started, Projects and Solutions
- projections, Projections–Numbering items
- properties, Representing State with Properties–Initializing with a Constructor, Delegates in Properties–Delegates in Properties
- Properties panel (Solution Explorer), Iteration Statements
- property elements, Layout Panels
- protected internal modifier, Inheritance and Protection–Inheritance and Protection
- protected modifier, Inheritance and Protection–Inheritance and Protection
- protection levels, Protection Levels–Protection Levels, Protection–Internal protection
- Proust, Marcel, Pointers
- proxies, Proxy–Proxy, Working with proxies
- public protection level, Protection Levels
- Pulse/PulseAll methods, Notification
- pushing, Methods
Q
- quantifiers, Testing the Whole Collection
- quantum, Threads and the OS Scheduler
- query expressions, Query Expressions–Query Expressions Versus Method Calls
- queues, Queues
- QueueUserWorkItem method, The Thread Pool
- quotas, Managing User Storage with Quotas
R
- race conditions, Race conditions–Race conditions
- RAD (Rapid Application Development), Web Forms Fundamentals
- radio buttons, Adding Controls, Data Binding–Adding Controls and Events
- RaisePostDataChangedEvent method, Web Forms Life Cycle
- raising events, Notifying Clients with Events
- random numbers, Deleting Files, Streams That Aren’t Files
- range checking, When and How to Fail
- range variables, Query Expressions
- Rapid Application Development, Web Forms Fundamentals
- Read method, Streams, Writing Data with Streams, Pointers
- read-only fields and properties, Read-only Fields and Properties–Read-only Fields and Properties, Static Constructors
- ReadAll methods, Iteration Statements, Reading Files into Memory, Myth: Threads are necessary to get work done
- reader/writer locks, Reader/writer locks
- ReadLines method, Reading Files into Memory, Static Versus Dynamic
- ReadNumbersFromFile method, Methods
- ReadToEnd method, Connecting to Services with the Socket Class
- rectangular arrays, Rectangular arrays–Rectangular arrays
- ref object, Optional ref
- refactoring, Methods
- reference types, Value Types and Reference Types, Custom Types in Arrays, Custom Types in Arrays
- reference versus value, Value Types and Reference Types
- References item, Projects and Solutions
- references, assembly, References–References
- reflection, Reflection–Late Binding
- Refresh method, Optimistic Concurrency
- regions and readability, Comments, Regions, and Readability–XML Documentation Comments
- Register method, Cancellation
- Remove Unused Usings item, Namespaces and Types
- Remove/RemoveAt method, List<T>
- RemoveAt method, Monitor
- repaginating, Composability and Extensibility with Delegates (see extensibility with delegates)
- Replace methods, Finding and Replacing Content, Static Versus Dynamic
- replacing methods, Replacing Methods with virtual and override–Replacing Methods with virtual and override
- responsiveness, Threads and Asynchronous Code
- REST (Representational State Transfer), Web Application with Client-Side Code
- RESTful Web Services (Ruby and Richardson), Web Application with Client-Side Code
- rethrowing an exception, Handling Exceptions
- return keyword, Methods
- return values, Returning Error Values–Debugging with Return Values
- Richardson, Leonard, Web Application with Client-Side Code
- Right method, Getting a Range of Characters
- root element, Elements
- round-trip format, Round trip
- Ruby, Sam, Web Application with Client-Side Code
- runnable threads, Threads and the OS Scheduler
- runtime, The Last Resort: Checking Types at Runtime
S
- Sandcastle, Microsoft, XML Documentation Comments
- SaveChanges method, Creating, Updating, and Deleting
- schedulers, Threads and the OS Scheduler, Schedulers
- Schneier, Bruce, Streams That Aren’t Files
- sealing classes, Thus Far and No Farther: sealed
- search axes, Search Axes
- Secrets and Lies: Digital Security in a Networked World (Schneier), Streams That Aren’t Files
- security issues, Managed Code, Protection Levels, Fields: A Place to Put Data, Inheritance and Protection, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies, When Files Go Bad: Dealing with Exceptions–Finding and Modifying Permissions, Isolated Storage, Managing Isolated Storage, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding, WCF Contracts, WCF configuration, WCF configuration, Bidirectional Communication with Duplex Contracts, Authentication, WCF Data Services, Entity SQL, WCF Data Services, Pointers, Examining the Code
- access control lists, WCF configuration
- accessibility modifiers, Protection Levels, Inheritance and Protection
- authentication, Authentication
- directory hierarchies, Creating and Securing Directory Hierarchies–Creating and Securing Directory Hierarchies
- dynamic queries, Entity SQL
- encryption, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding
- exceptions, When Files Go Bad: Dealing with Exceptions–Finding and Modifying Permissions
- fields initialization, Fields: A Place to Put Data
- firewalls, Bidirectional Communication with Duplex Contracts
- .NET security model, Managed Code, Isolated Storage, Managing Isolated Storage, Examining the Code
- Silverlight, Pointers
- stack traces, WCF configuration
- WCF contracts, WCF Contracts
- WCF data services, WCF Data Services, WCF Data Services
- Seek method, Moving Around in a Stream
- select clause, Query Expressions
- Select method, Query Expressions Versus Method Calls, Projections
- selection statements, flow control with, Flow Control with Selection Statements–Breaking Out of a Loop
- SelectKeyAndIV method, Streams That Aren’t Files
- SelectMany method, Using multiple sources
- semicolon (;) end statement, Projects and Solutions
- separated presentation, Data Templates
- serialization, Custom Exceptions, XML Serialization–Customizing XML Serialization Using Attributes
- server configuration, Server configuration for duplex and sessions
- server-side controls, Web Forms Life Cycle, Adding Controls, Server Controls
- service contract, WCF Contracts
- session-based communication, Session-based communication
- set accessor, Representing State with Properties, Boxing and Unboxing Value Types
- set-based operations, Set Operations
- SetAccessControl method, Finding and Modifying Permissions
- shapes, Shapes–Shapes
- sharing contracts, Sharing contracts
- side effects, Creating Delegates with Lambda Expressions
- signed assemblies, Isolation by user and assembly
- signed integer types, Integers
- Silverlight, Microsoft, Web Application with Client-Side Code–Web Application with Client-Side Code, WCF configuration, Downloading resources, Using cookies, Silverlight and Data Access, WCF Data Services, References, Loading from a Silverlight .xap File, Silverlight script objects, Pointers, WPF and Silverlight, Xaml and Code Behind–Xaml and Objects, Graphical Elements–3D graphics
- (see also WPF (Windows Presentation Foundation) and Silverlight)
- and assembly references, References
- and cookies, Using cookies
- and Data Access, Silverlight and Data Access
- and graphical elements, Graphical Elements–3D graphics
- loading from, Loading from a Silverlight .xap File
- and partial trust, Pointers
- script objects, Silverlight script objects
- and WCF, Web Application with Client-Side Code–Web Application with Client-Side Code, WCF configuration, Downloading resources, WCF Data Services, Xaml and Code Behind–Xaml and Objects
- Simula 67, Abstracting Ideas with Objects and Classes
- Skip operator, Getting Selective
- SMT (simultaneous multithreading), Threads and the OS Scheduler
- SMTP relays, Other Networking Features
- sockets, Sockets, Connecting to Services with the Socket Class–Implementing Services with the Socket Class
- Solution Explorer, Projects and Solutions
- solutions, Projects and Solutions
- SortedSet<T>, HashSet and SortedSet
- sorting arrays, Ordering elements, Finding and Sorting
- source code, Projects and Solutions
- sparse arrays, Sparse arrays
- special folders, Well-Known Folders–Well-Known Folders
- special permissions, Creating and Securing Directory Hierarchies
- speculation, Threads and Asynchronous Code
- spellchecking, Composability and Extensibility with Delegates (see extensibility with delegates)
- SpinLock, SpinLock
- Split method, Splitting It Up Again
- splitting strings, Splitting It Up Again
- SQL injection attacks, IDataReader and friends, Entity SQL
- SQL Profiler, LINQ to Entities
- SQL Server 2008 Express, Databases
- stacks, Methods, Value Types and Reference Types, Debugging with Return Values, Stacks, The Stack–The Stack
- standard numeric format strings, Standard Numeric Format Strings–Round trip
- Start method, The Stack, Notification
- StartNew method, Tasks, Tasks with results
- state sharing, The Stack–The Stack
- state, view, View state
- statement-form lambda, Creating Delegates with Lambda Expressions, Generic Delegates for Functions
- statements, Expressions and Statements
- static fields/properties, Namespaces and Types, Declaring Static Methods–Static Constructors, Internal protection, Static Versus Dynamic
- static keyword, Defining Methods
- static versus dynamic, Static Versus Dynamic–The dynamic Type
- Step Into item, foreach Statements
- storage management for events, Exposing Large Numbers of Events–Exposing Large Numbers of Events
- store schemas, The Entity Data Model
- stores, Stores
- Stream buffering, Stream Buffers
- streams, Streams–Writing Data with Streams, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding, Stream-based uploads and downloads
- StreamWriter/Reader, Writing Text with a StreamWriter–Writing Text with a StreamWriter, Reading and Writing Text
- StringBuilder, Mutable Strings with StringBuilder–Mutable Strings with StringBuilder
- strings, if Statements, Strings–What Is a String?, The String and Char Types, Literal Strings and Chars–Escaping Special Characters, Formatting Data for Output, Standard Numeric Format Strings–Round trip, Custom Numeric Format Strings–Custom Numeric Format Strings, Dates and Times–Dates and Times, Going the Other Way: Converting Strings to Other Types, Composite Formatting with String.Format, Culture Sensitivity–Culture Sensitivity, Exploring Formatting Rules, Accessing Characters by Index, Strings Are Immutable, Getting a Range of Characters–Getting a Range of Characters, Composing Strings–Upper- and Lowercase, Manipulating Text–Mutable Strings with StringBuilder, Finding and Replacing Content, All Sorts of “Empty” Strings–All Sorts of “Empty” Strings, All Sorts of “Empty” Strings, Trimming Whitespace–Trimming Whitespace, Checking Character Types, Encoding Characters–Why Represent Strings As Byte Sequences?
- accessing characters by index, Accessing Characters by Index
- checking character types, Checking Character Types
- comparing, if Statements, All Sorts of “Empty” Strings
- composing, Composing Strings–Upper- and Lowercase
- composite formatting with String.Format, Composite Formatting with String.Format
- converting to other types, Going the Other Way: Converting Strings to Other Types
- culture sensitivity, Culture Sensitivity–Culture Sensitivity
- custom numeric format, Custom Numeric Format Strings–Custom Numeric Format Strings
- dates and times, Dates and Times–Dates and Times
- empty, All Sorts of “Empty” Strings–All Sorts of “Empty” Strings
- encoding, Encoding Characters–Why Represent Strings As Byte Sequences?
- exploring formatting rules, Exploring Formatting Rules
- finding and replacing content, Finding and Replacing Content
- formatting data for output, Formatting Data for Output
- getting a range of characters, Getting a Range of Characters–Getting a Range of Characters
- immutability of, Strings Are Immutable
- literal strings and chars, Literal Strings and Chars–Escaping Special Characters
- manipulating text with, Manipulating Text–Mutable Strings with StringBuilder
- overview, Strings–What Is a String?
- standard numeric format, Standard Numeric Format Strings–Round trip
- string and char types, The String and Char Types
- trimming whitespace, Trimming Whitespace–Trimming Whitespace
- strongly named assemblies, Signing and Strong Names
- strongly typed DataSet, ADO.NET data sets
- struct keyword, Value Types and Reference Types
- styles, Styles–Styles
- subscribing to events, Notifying Clients with Events, Notifying Clients with Events
- Substring method, Getting a Range of Characters
- subtraction (-) operator, Expressions and Statements
- Sum method, Ordinary .NET objects
- surface area, minimizing, Protection Levels
- Swann’s Way (Proust), Pointers
- switch and case statements, switch and case Statements
- symmetric algorithm, Streams That Aren’t Files
- synchronization primitives, Synchronization Primitives–Monitor, Synchronization Primitives–Monitor, Notification–Notification
- monitors, Synchronization Primitives–Monitor
- notification, Notification–Notification
- overview, Synchronization Primitives–Monitor
- System namespace types, Namespaces and Types
- System.Double type, Dealing with Errors
T
- Take method, BlockingCollection
- Take operator, Getting Selective
- target, attribute, Attributes
- Task Parallel Library, The Task Parallel Library–Tasks and the Asynchronous Programming Model
- tasks, The Task Parallel Library–Tasks and the Asynchronous Programming Model
- TCP (Transmission Control Protocol), IP, IPv6, and TCP–Implementing Services with the Socket Class
- templates, Control Templates–Data Templates
- temporary files, Creating Temporary Files
- ternary operator, if...else
- ternary relationships, Multiplicity
- test command-line switch, Examining File Information
- test directories, Well-Known Folders
- Test method, dynamic in Noninterop Scenarios?
- text, What Is a String?, What Is a String?, Culture Sensitivity–Culture Sensitivity, Manipulating Text, All Sorts of “Empty” Strings–Trimming Whitespace, Encoding Characters–Why Represent Strings As Byte Sequences?, Writing Text Files–Writing Text with a StreamWriter, Reading and Writing Text, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding, Thread Affinity and Context, Xaml and Code Behind, Data Binding, Controls, Data Binding–Event Handling
- and culture sensitivity, Culture Sensitivity–Culture Sensitivity
- encoding/decoding, Encoding Characters–Why Represent Strings As Byte Sequences?
- encryption, Streams That Aren’t Files–Representing Binary As Text with Base64 Encoding
- fonts, What Is a String?
- manipulating, Manipulating Text
- reading and writing, Reading and Writing Text
- strings, What Is a String?
- and text boxes, Thread Affinity and Context, Data Binding, Controls, Data Binding–Event Handling
- and TextBlock, Xaml and Code Behind
- whitespace in, All Sorts of “Empty” Strings–Trimming Whitespace
- writing files, Writing Text Files–Writing Text with a StreamWriter
- TextWriter, Writing Text with a StreamWriter
- this keyword, Value Types and Reference Types, Defining Methods, Custom Indexers, Extension Methods and LINQ
- thread pools, The Thread Pool
- threads, Threads–Threads, Threads and the OS Scheduler–Threads and the OS Scheduler, The Stack–The Stack, Thread Affinity and Context, Common Thread Misconceptions–Myth: Maxing the CPU must mean we’re going really fast, Multithreaded Coding Is Hard–Synchronization, Synchronization Primitives, Monitor, Asynchronous Programming
- (see also asynchronous programming)
- (see also synchronization primitives)
- affinity and context, Thread Affinity and Context
- multithreaded coding, Multithreaded Coding Is Hard–Synchronization
- myths regarding, Common Thread Misconceptions–Myth: Maxing the CPU must mean we’re going really fast
- and OS Scheduler, Threads and the OS Scheduler–Threads and the OS Scheduler
- overview, Threads–Threads
- safety and, Monitor
- and stack, The Stack–The Stack
- throw keyword, Handling Exceptions
- Thumbnail property, Data Templates
- tightly controlled deployment, Tightly controlled deployment
- ToArray method, Methods, Finding and Sorting, Representing Binary As Text with Base64 Encoding
- ToBuffer method, Representing Binary As Text with Base64 Encoding
- ToLowerInvariant/ToUpperInvariant, Upper- and Lowercase
- ToString method, Formatting Data for Output, Dates and Times
- TPL (Task Parallel Library), The Task Parallel Library–Tasks and the Asynchronous Programming Model
- transactions, database, Transactions–Transactions
- transforms, Transforms
- Transmission Control Protocol, IP, IPv6, and TCP–Implementing Services with the Socket Class
- triggers, Animation
- trimming whitespace, Trimming Whitespace–Trimming Whitespace
- try blocks, Handling Exceptions–When Do finally Blocks Run?
- TryGetValue method, Caching, IDictionary<TKey, TValue>
- TryParse methods, Going the Other Way: Converting Strings to Other Types
- turtle robotics example, Dealing with Errors–Dealing with Errors, When and How to Fail–When and How to Fail, Returning Error Values–Debugging with Return Values, Debugging with Return Values, Exceptions–Handling Exceptions, Handling Exceptions–When Do finally Blocks Run?, Deciding What to Catch–Deciding What to Catch, Custom Exceptions–Custom Exceptions
- custom exceptions, Custom Exceptions–Custom Exceptions
- debugging with return values, Debugging with Return Values
- deciding what errors to catch, Deciding What to Catch–Deciding What to Catch
- exceptions, Exceptions–Handling Exceptions
- setting return values, Returning Error Values–Debugging with Return Values
- setup, Dealing with Errors–Dealing with Errors
- try, catch, finally blocks, Handling Exceptions–When Do finally Blocks Run?
- when and how to fail, When and How to Fail–When and How to Fail
- types, Namespaces and Types–Namespaces and Types, Variable Types–Methods, Variable Types, Expressions and Statements, if Statements, List<T>, Type Discovery–Type Discovery, No PIA
- bool, if Statements
- and discovery, Type Discovery–Type Discovery
- and equivalence, No PIA
- implicit conversion of, Expressions and Statements
- namespace, Namespaces and Types–Namespaces and Types
- numeric, Variable Types
- and parameters, List<T>
- variable, Variable Types–Methods
U
- UI (user interface), Web Forms Fundamentals, Adding Controls and Events
- UML 2.0, Association Through Composition and Aggregation
- unboxing, Boxing and Unboxing Value Types
- “unexpected” errors, Dealing with Errors
- unhandled exceptions, Exceptions
- Unicode, Encoding Characters, Encoding and Decoding
- Unified Modeling Language (UML) 2.0, Association Through Composition and Aggregation
- Uniform Resource Identifiers (URIs), Downloading resources
- Uniform Resource Locators, Downloading resources (see URLs)
- universal quantifier, Testing the Whole Collection
- universal sortable form, Dates and Times
- unsafe keyword, Pointers, Pointers
- unsigned integer types, Integers
- UpdatePosition method, Defining Methods
- UpdateUi method, Schedulers
- uploading methods, Uploading resources
- uppercase letters, Upper- and Lowercase
- Uri class, Downloading resources
- URIs (Uniform Resource Identifiers), Downloading resources
- URLs (Uniform Resource Locators), Getting Started, Namespaces and Types, XML Documentation Comments, Expressions and Statements, Breaking Out of a Loop, Representing State with Properties, Value Types and Reference Types, Exceptions, Exceptions, Upper- and Lowercase, When Files Go Bad: Dealing with Exceptions, WCF Test Client and Host, WCF configuration, Downloading resources, IP, IPv6, and TCP, Non-Microsoft Data Access Technologies, Signing and Strong Names, Explicit Loading, Unloading, Pointers, Layout Panels, Examining the Code
- appdomains, Unloading
- Daytime Protocol, IP, IPv6, and TCP
- defined, Downloading resources
- Dijkstra letter on go-to statements, Breaking Out of a Loop
- Exception class, Exceptions
- MEF, Explicit Loading
- misleading MSDN documentation on structs, Value Types and Reference Types
- MSDN on culture-sensitive string operations, Upper- and Lowercase
- MSDN on long paths, When Files Go Bad: Dealing with Exceptions
- naming/capitalization conventions, Representing State with Properties
- .NET Framework class library namespaces, Namespaces and Types
- NHibernate, Non-Microsoft Data Access Technologies
- precedence in expression evaluation, Expressions and Statements
- Project Gutenberg, Pointers
- Sandcastle documentation tool, XML Documentation Comments
- secure coding in .NET, Examining the Code
- Silverlight Toolkit, Layout Panels
- Spec#, Exceptions
- strong names, Signing and Strong Names
- Visual Studio Express (free edition), Getting Started
- Visual Studio logging privileges, WCF configuration
- Wireshark, WCF Test Client and Host
- UseItem method, Monitor, Notification
- user controls, User Controls
- user interface (UI), Web Forms Fundamentals
- user state, Asynchronous File Operations
- user storage, Managing User Storage with Quotas
- UseStream method, Reading and Writing Text
- using directives, Getting Started
- UTF-8, UTF-16, Encoding Characters–Encoding and Decoding, Writing Text with a StreamWriter, Representing Binary As Text with Base64 Encoding
- utility features, .NET Framework, The .NET Framework Class Library
V
- VALUE keyword, Entity SQL
- value types, Value Types and Reference Types, Boxing and Unboxing Value Types, Custom Types in Arrays
- value versus reference, Value Types and Reference Types
- var keyword, Query Expressions, Anonymous types, Dictionaries, The dynamic Type
- variables, Variables–Decimal floating point
- variance, Collections and Polymorphism
- VB.NET, Language Style
- VBA (Visual Basic for Applications), The Dynamic Style and COM Automation
- Vertical Stack panel, Layout Panels–Layout Panels
- view models, Data Templates
- virtual methods, Replacing Methods with virtual and override–Replacing Methods with virtual and override, Thus Far and No Farther: sealed
- visibility and accessibility modifiers, Protection Levels
- visual state manager, The Visual State Manager
- Visual Studio, Microsoft, Language Style, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010, Getting Started, Getting Started, Projects and Solutions, Implementing Services with the Socket Class, Generated Code, References, Writing Libraries–Writing Libraries, Xaml and Code Behind
- 2010, Language Style, C# 4.0, .NET 4, and Visual Studio 2010–C# 4.0, .NET 4, and Visual Studio 2010
- free Express version, Getting Started
- generated code in, Generated Code
- handling of libraries, Projects and Solutions, Writing Libraries–Writing Libraries
- New Project dialog box, Getting Started
- and references, References
- running client and server copies, Implementing Services with the Socket Class
- and Xaml, Xaml and Code Behind
- void keyword, Namespaces and Types
W
- Wait method, Notification, Tasks
- WaitAll method, Tasks
- WaitUntilReady method, Notification
- WCF (Windows Communication Foundation), The .NET Framework Class Library, Dynamic properties, WCF, Creating a WCF Project, WCF Contracts–WCF Contracts, WCF Test Client and Host–WCF Test Client and Host, Hosting a WCF Service–WCF configuration, Writing a WCF Client–Proxy, WCF Data Services, WCF Data Services, WCF Data Services–WCF Data Services
- contracts, WCF Contracts–WCF Contracts
- creating a project, Creating a WCF Project
- Data Services, WCF Data Services, WCF Data Services–WCF Data Services
- and Entity Framework, WCF Data Services
- hosting a service, Hosting a WCF Service–WCF configuration
- Test Client and Host, WCF Test Client and Host–WCF Test Client and Host
- writing a client program, Writing a WCF Client–Proxy
- and XML, WCF
- weakly controlled deployment, Weakly controlled deployment
- web application projects, Creating a Web Application
- Web Forms and ASP.NET, Web Forms Fundamentals, Web Forms Events, Web Forms Life Cycle, Creating a Web Application, Code-Behind Files, Adding Controls–Server Controls, Data Binding–Data Binding, Examining the Code–Examining the Code, Adding Controls and Events–Adding Controls and Events
- adding controls and events, Adding Controls and Events–Adding Controls and Events
- adding controls to, Adding Controls–Server Controls
- code-behind files, Code-Behind Files
- creating a web application, Creating a Web Application
- data binding, Data Binding–Data Binding
- events, Web Forms Events
- examining the code, Examining the Code–Examining the Code
- life cycle, Web Forms Life Cycle
- overview, Web Forms Fundamentals
- WebClient, WebClient–Stream-based uploads and downloads
- WebRequest and WebResponse, WebRequest and WebResponse–Using cookies
- website projects, Creating a Web Application
- well-known folders, Well-Known Folders–Well-Known Folders
- where clauses, Delegates and Lambdas, Where Clauses
- Where method, Query Expressions Versus Method Calls, dynamic in Noninterop Scenarios?
- while and do statements, while and do Statements–while and do Statements
- whitespace, Projects and Solutions, Representing State with Properties, All Sorts of “Empty” Strings–Trimming Whitespace
- in C# code, Projects and Solutions, Representing State with Properties
- in text output, All Sorts of “Empty” Strings–Trimming Whitespace
- Why Software Sucks (Platt), Adding Controls and Events
- Windows Communication Foundation, WCF (see WCF)
- Windows Forms, Importing a Control in .NET–Importing a Control in .NET, Windows Forms, Creating the Application, Adding a Binding Source–Adding a Binding Source, Controls–Controls, Docking and Anchoring–Docking and Anchoring, Data Binding–Event Handling, Event Handling
- and ActiveX, Importing a Control in .NET–Importing a Control in .NET
- adding a binding source, Adding a Binding Source–Adding a Binding Source
- controls, Controls–Controls
- creating the application, Creating the Application
- data binding, Data Binding–Event Handling
- docking and anchoring, Docking and Anchoring–Docking and Anchoring
- event handling, Event Handling
- versus WPF, Windows Forms
- Windows, .NET and, Continuity and the Windows Ecosystem
- word wrapping, Layout Panels
- WPF (Windows Presentation Foundation) and Silverlight, The .NET Framework Class Library, WPF and Silverlight–WPF and Silverlight, Xaml and Code Behind–Xaml and Objects, Elements and Controls, Elements and Controls, Layout Panels–Transforms, Transforms, Controls–User Controls, Control Templates–Styles, The Visual State Manager, Data Binding–Data Binding, Data Templates–Data Templates, Windows Forms
- control templates, Control Templates–Styles
- controls, Elements and Controls, Controls–User Controls
- data binding, Data Binding–Data Binding
- data templates, Data Templates–Data Templates
- elements, Elements and Controls
- layout panels, Layout Panels–Transforms
- overview, WPF and Silverlight–WPF and Silverlight
- transforms, Transforms
- versus Windows Forms, Windows Forms
- visual state manager, The Visual State Manager
- and Xaml, Xaml and Code Behind–Xaml and Objects
- WrapPanel, Layout Panels
- wrappers, .NET Framework, The .NET Framework Class Library
- Write method, Writing Data with Streams, Pointers
- “write-only code”, Comments, Regions, and Readability
- WriteAllText methods, Writing Text with a StreamWriter, Writing Text with a StreamWriter
- WriteLine method, Namespaces and Types, Expressions and Statements, Reading and Writing Text, Implementing Services with the Socket Class
- writing data with streams, Writing Data with Streams
X
- Xaml, Xaml and Code Behind–Xaml and Objects
- Xaml Browser Application (XBAP), Web Application with Client-Side Code
- .xap extension, References, Loading from a Silverlight .xap File
- XBAP (Xaml Browser Application), Web Application with Client-Side Code
- XHTML, XHTML
- XML 1.0, XML, Elements, XHTML, X Stands for eXtensible, Creating XML Documents–Creating XML Documents, XML Elements, XML Attributes–XML Attributes, Putting the LINQ in LINQ to XML–Searching in XML with LINQ, Searching for a Single Node, Search Axes, Where Clauses, XML Serialization–Customizing XML Serialization Using Attributes, Attributes
- attributes, XML Attributes–XML Attributes
- creating documents, Creating XML Documents–Creating XML Documents
- elements, Elements, XML Elements
- extensibility, X Stands for eXtensible
- and LINQ, Putting the LINQ in LINQ to XML–Searching in XML with LINQ
- overview, XML
- search axes, Search Axes
- serialization, XML Serialization–Customizing XML Serialization Using Attributes, Attributes
- single node search, Searching for a Single Node
- and where clauses, Where Clauses
- XHTML, XHTML
- XML Documentation Comments, XML Documentation Comments
- XML documents, Why Encodings Matter
- XML literals, Composability
Y
- yield return, Creating Your Own IEnumerable<T>–Lazy collections
- yielding, SpinLock
Z
- zero, dividing by, Dealing with Errors
- zero, numbering from, Flow Control with Selection Statements
- zero-day attack, Bidirectional Communication with Duplex Contracts
- zipping, Zipping
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.