C

C#, Exploring EDM Queries in Greater Depth, VB and C# syntax differences, Anonymous types, Implicitly typed local variables, Implicit and explicit anonymous type creation, Grouping, Naming Properties When Grouping, Chaining Aggregates, Implementing the property-level PropertyChanged and PropertyChanging methods, Implementing the class-level PropertyChanging and PropertyChanged events, Specifying or Excluding Derived Types in Queries, Forcing an ObjectContext to Use Its Own Thread, Setting Up the Project and Code File, Scalar Properties

anonymous types in version 3.0, Anonymous types

auto-implemented properties, Scalar Properties

direct type comparison, Specifying or Excluding Derived Types in Queries

example queries, Exploring EDM Queries in Greater Depth

grouping, Grouping, Naming Properties When Grouping, Chaining Aggregates

combining aggregates in C# LINQ, Chaining Aggregates

INTO clause, specifying group name, Naming Properties When Grouping

implementing PropertyChanged and PropertyChanging events, Implementing the class-level PropertyChanging and PropertyChanged events

implicitly typed local variables, Implicitly typed local variables

lock keyword, Forcing an ObjectContext to Use Its Own Thread

naming anonymous types, Implicit and explicit anonymous type creation

ObjectStateEntry visualizer, Setting Up the Project and Code File

partial method implementation, Implementing the property-level PropertyChanged and PropertyChanging methods

projections, VB and C# syntax differences

cached queries, Filtering based on group properties

caching, Query Plan Caching for Entity SQL, Application cache and session state

application cache, Application cache and session state

query plan caching for Entity SQL, Query Plan Caching for Entity SQL

canonical functions (Entity SQL), Entity SQL canonical functions

cascading deletes, How Did the Entity Data Model Wizard Create the Association?, Deletes and Cascading Deletes, Cascading deletes in the database, Cascading deletes in the EDM, Recommendation: Cascade in both the model and the database, or in neither

in the database, Cascading deletes in the database

in the EDM, Cascading deletes in the EDM

recommendation for use in both EDM and database, or neither, Recommendation: Cascade in both the model and the database, or in neither

chaining methods, Chaining methods

change tracking, Change Tracking, Challenges with Change Tracking Distributed Applications, How ObjectContext Manages Entities, Change Tracking, The insert and update web methods, The IEntityWithChangeTracker Interface

IEntityWithChangeTracker interface, The IEntityWithChangeTracker Interface

problems in distributed applications, Challenges with Change Tracking Distributed Applications

problems in multi-tiered applications, The insert and update web methods

remembering original values and tracking changes, How ObjectContext Manages Entities

Changing/Changed methods, Customizable Methods, The On[Property]Changed and On[Property]Changing Methods, Implementing the property-level PropertyChanged and PropertyChanging methods, The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events, The order of the Changing/Changed events, Event parameters, Implementing the class-level PropertyChanging and PropertyChanged events

class level, The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events, Event parameters, Implementing the class-level PropertyChanging and PropertyChanged events

event parameters, Event parameters

implementing, Implementing the class-level PropertyChanging and PropertyChanged events

order of events, The order of the Changing/Changed events

property level, The On[Property]Changed and On[Property]Changing Methods, Implementing the property-level PropertyChanged and PropertyChanging methods

implementing, Implementing the property-level PropertyChanged and PropertyChanging methods

checksum in data store, concurrency checks on, Concurrency Checking on a Checksum in the Data Store

class constructor, WCF service client application, The class constructor

classes, The Entity in “Entity Framework”, Code Generation from EDM to Classes, Where Did the Context and Classes Come from?, Entity Objects, Entity Objects, Object Services Supports Custom Classes, Partial Classes, Using Your Own Custom Classes–Summary, Mapping Classes to the Entity Data Model–Querying Using the Custom Classes, Resolving Conflicts Between Custom Classes and Designer-Generated Classes, Querying Using the Custom Classes, Implementing the IPOCO Interfaces–Working with the IPOCO-Enabled Objects, Custom Class Assemblies and Entity Data Model Files, Building a Data Transfer Object to Take the Place of an Entity Object

automatically created from the EDM, Code Generation from EDM to Classes

class diagram for entities (example), The Entity in “Entity Framework”

custom, Object Services Supports Custom Classes, Using Your Own Custom Classes–Summary, Mapping Classes to the Entity Data Model–Querying Using the Custom Classes, Resolving Conflicts Between Custom Classes and Designer-Generated Classes, Querying Using the Custom Classes, Implementing the IPOCO Interfaces–Working with the IPOCO-Enabled Objects, Custom Class Assemblies and Entity Data Model Files

assemblies and EDM files, Custom Class Assemblies and Entity Data Model Files

conflicts with Designer-generated classes, Resolving Conflicts Between Custom Classes and Designer-Generated Classes

implementing IPOCO interfaces, Implementing the IPOCO Interfaces–Working with the IPOCO-Enabled Objects

mapping to Entity Data Model, Mapping Classes to the Entity Data Model–Querying Using the Custom Classes

querying with, Querying Using the Custom Classes

support by Object Services, Object Services Supports Custom Classes

entity, Entity Objects, Entity Objects

(see also entity objects)

in LINQ to Entities queries example, Where Did the Context and Classes Come from?

marking as DataContract, Building a Data Transfer Object to Take the Place of an Entity Object

partial classes, Entity Framework and, Partial Classes

client applications, Building a Client That Is Ignorant of the Entity Framework, Building the Client Application–The client-side Customer versus the server-side Customer, Setting up the client project and the proxy to the service, Adding methods to interact with the web service, Designing the form, The client-side Customer versus the server-side Customer, Building the Client to Consume the WCF Service–Peeking under the covers, Editing the configuration for the web service client, Adding functionality to view the reservations, Finishing the form, Adding and deleting the reservations, Adding and deleting the reservations, Running the application and saving your changes, Using the Entity Framework in n-Tier Client-Side Applications, Thinking in Layers, Implementing the Client That Will Use the WCF Service–Testing It All with a Simple Console Application, Rules for the Client to Follow, Building a Business Layer Between the UI and the Services, What’s in These Business Classes?–Calling the Service Operations from the Business Layer, Calling the Service Operations from the Business Layer–Testing It All with a Simple Console Application

(see also n-tier client-side applications)

ASMX Web Service client, Building the Client Application–The client-side Customer versus the server-side Customer, Setting up the client project and the proxy to the service, Adding methods to interact with the web service, Designing the form, The client-side Customer versus the server-side Customer

designing form, Designing the form

ignorance of Entity Framework, The client-side Customer versus the server-side Customer

methods to interact with service, Adding methods to interact with the web service

reference to service and proxies, Setting up the client project and the proxy to the service

client for WCF service, Building the Client to Consume the WCF Service–Peeking under the covers, Editing the configuration for the web service client, Adding functionality to view the reservations, Finishing the form, Adding and deleting the reservations, Adding and deleting the reservations, Running the application and saving your changes, Implementing the Client That Will Use the WCF Service–Testing It All with a Simple Console Application, Rules for the Client to Follow, Building a Business Layer Between the UI and the Services, What’s in These Business Classes?–Calling the Service Operations from the Business Layer, Calling the Service Operations from the Business Layer–Testing It All with a Simple Console Application

adding and deleting reservations, Adding and deleting the reservations

adding functionality to view reservations, Adding functionality to view the reservations

business layer between UI and services, Building a Business Layer Between the UI and the Services

calling service operations from business layer, Calling the Service Operations from the Business Layer–Testing It All with a Simple Console Application

content of business classes, What’s in These Business Classes?–Calling the Service Operations from the Business Layer

editng configuration, Editing the configuration for the web service client

finishing the form, Finishing the form

no EntityKey or EntityReference in client, Adding and deleting the reservations

rules for client, Rules for the Client to Follow

running application and saving changes, Running the application and saving your changes

Entity Framework and, Building a Client That Is Ignorant of the Entity Framework

using Entity Framework, basic architecture for, Thinking in Layers

ClientWins, Forcing the User’s Data to the Server (ClientWins), Using ObjectContext.Refresh, Using ClientWins Refresh, Refreshing Collections of Entities

ObjectContext.Refresh method, Using ClientWins Refresh, Refreshing Collections of Entities

refreshing set of entities, Refreshing Collections of Entities

RefreshMode value, Using ObjectContext.Refresh

Code Gallery project, Extensions, Samples, and Solutions from Microsoft, Samples

samples provided by, Samples

code generation, Code Generation from EDM to Classes, Custom Code Generation

custom, Custom Code Generation

default, Code Generation from EDM to Classes

Collection class, IQueryable and IEnumerable versus, ObjectQuery and LINQ to Entities

CollectionChangeAction enumeration, Event arguments

CollectionChangeEventArgs, AssociationChanged event, Event arguments

collections, ObservableCollection object, A few WPF tricks for a more interactive ListBox

ComboBox controls, Binding the ComboBox controls to the ListBox and to the data, Editing Trip Entities and Their Related Data

binding to ListBox and to data in WPF, Binding the ComboBox controls to the ListBox and to the data

SelectionChanged event, Editing Trip Entities and Their Related Data

command execution exceptions, SaveChanges method, SaveChanges Command Execution Exceptions

command trees, Query Processing, From a LINQ to Entities query to a command tree, From Entity SQL and query builder methods to a command tree, How EntityClient turns command trees into store commands

conversion by entity client to store commands, How EntityClient turns command trees into store commands

conversion of Entity SQL and query builder methods to, From Entity SQL and query builder methods to a command tree

query processing from LINQ to Entities query to, From a LINQ to Entities query to a command tree

CommandExecutor class, building (example), Building the CommandExecutor Class–Building the CommandExecutor Class

compilation of queries, Reducing the Cost of Query Compilation, The EDM Generator for Precompiled Views (and More), Query Compilation Exceptions, Precompiling a frequently used query

EDM Generator for precompiled views, The EDM Generator for Precompiled Views (and More)

exceptions, Query Compilation Exceptions

precompiling frequently used query, Precompiling a frequently used query

reducing cost of, Reducing the Cost of Query Compilation

compiled queries, Filtering based on group properties

CompiledQuery class, Compile method, LINQ to Entities compiled queries

complex types, Creating Complex Types to Encapsulate Sets of Properties–Removing the Complex Types from the Model, Complex Types and the EDM Designer, Defining a Complex Type, Replacing Properties with a Complex Type, Mapping Entities with Complex Types, Complex Types Are Not EntityObjects, Using Complex Types, Complex Types in Data-Binding Scenarios, ASP.NET EntityDataSource, Data Binding Complex Types in ASP.NET Without the EntityDataSource–Windows Forms DataSource and Complex Types, Windows Forms DataSource and Complex Types, Removing the Complex Types from the Model, Getting ComplexType Properties Out of ObjectStateEntry

ComplexObjects rather than EntityObjects, Complex Types Are Not EntityObjects

data binding, Complex Types in Data-Binding Scenarios, ASP.NET EntityDataSource, Data Binding Complex Types in ASP.NET Without the EntityDataSource–Windows Forms DataSource and Complex Types

using EntityDataSource, ASP.NET EntityDataSource

without EntityDataSource, Data Binding Complex Types in ASP.NET Without the EntityDataSource–Windows Forms DataSource and Complex Types

defining, Defining a Complex Type

EDM designer and, Complex Types and the EDM Designer

mapping entities with, Mapping Entities with Complex Types

properties of complex type, getting from ObjectStateEntry, Getting ComplexType Properties Out of ObjectStateEntry

querying, creating, and saving entities with, Using Complex Types

removing from the EDM, Removing the Complex Types from the Model

replacing properties with, Replacing Properties with a Complex Type

Windows Forms DataSource and, Windows Forms DataSource and Complex Types

ComplexObject, Complex Types Are Not EntityObjects

composable queries, Specifying the control variable

composition versus inheritance, Creating New Derived Entities When the Base Entity Already Exists

Conceptual Schema Definition Language, The Three Parts of the Model (see CSDL)

concurrency, Concurrency Management, Optimistic concurrency, ConcurrencyMode, OptimisticConcurrencyException, Exceptions When Multiple Parties Edit Data Concurrently, Handling Concurrency Conflicts, Understanding Optimistic Concurrency Options in the Entity Framework, Using rowversion for Concurrency Checks, Using rowversion for Concurrency Checks, Handling Concurrency Exceptions at a Lower Level, Handling Granular Exceptions Without User Intervention, Handling Multiple Conflicts, Handling Exceptions When Transactions Are Your Own

(see also optimistic concurrency)

checking using rowversion field, Using rowversion for Concurrency Checks

ConcurrencyMode attribute, ConcurrencyMode

exceptions when multiple parties edit data concurrently, Exceptions When Multiple Parties Edit Data Concurrently

handling conflicts in, Handling Concurrency Conflicts

handling exceptions for your transactions, Handling Exceptions When Transactions Are Your Own

handling of low-level exceptions, Handling Concurrency Exceptions at a Lower Level, Handling Granular Exceptions Without User Intervention, Handling Multiple Conflicts

handling multiple conflicts, Handling Multiple Conflicts

handling without user intervention, Handling Granular Exceptions Without User Intervention

optimistic concurrency, Optimistic concurrency

optimistic concurrency options in Entity Framework, Understanding Optimistic Concurrency Options in the Entity Framework

OptimisticConcurrencyException, OptimisticConcurrencyException

ConcurrencyMode property, Determining the Scope of Changes, Flagging a Property for Concurrency Checking, How the Entity Framework Uses the ConcurrencyMode Property, Concurrency Checks and Inherited Types

derived types, Concurrency Checks and Inherited Types

how Entity Framework uses it, How the Entity Framework Uses the ConcurrencyMode Property

conditional mapping, Using Conditional Mapping to Filter Entity Mappings–Removing the conditional mapping from Activity and re-creating the Category property, Creating a Conditional Mapping for the Activity Entity, Testing the Conditional Mapping, Removing the conditional mapping from Activity and re-creating the Category property

creating for an entity, Creating a Conditional Mapping for the Activity Entity

querying, creating, and saving conditionally mapped entities, Testing the Conditional Mapping

removing, Removing the conditional mapping from Activity and re-creating the Category property

ConfigurationManager class, Using the EntityConnectionStringBuilder Class

connection pooling, What About Connection Pooling?

Connection property, ObjectContext, Connection versus Connection.StoreConnection

connection strings, EntityConnection and the Connection String, ObjectContext.Connection, EntityConnectionString Exceptions, Handling Connection String Exceptions, Accessing the Model Files When They Are Not in a Referenced Assembly

ConnectionString to find EDM files in file path, Accessing the Model Files When They Are Not in a Referenced Assembly

EntityConnection and, EntityConnection and the Connection String

EntityConnectionString exceptions, EntityConnectionString Exceptions

handling exceptions in, Handling Connection String Exceptions

specifying EntityConnection string to use for context, ObjectContext.Connection

connections, Making It Real: Connections, Transactions, Performance, and More–What About Connection Pooling?, EntityConnection and Database Connections in the Entity Framework, Manually opening and closing connections, Default behavior 1: Many calls on a single connection, Default behavior 2: Multiple connections, Forcing an explicit connection, Taking Control of How Store Connections Are Disposed, Protecting Data from Connection Piggybacks

disposal of store connections, Taking Control of How Store Connections Are Disposed

EntityConnection and database connections, EntityConnection and Database Connections in the Entity Framework

opening and closing Entity and database connections, Manually opening and closing connections, Default behavior 1: Many calls on a single connection, Default behavior 2: Multiple connections, Forcing an explicit connection

forcing explicit connection, Forcing an explicit connection

manually, Manually opening and closing connections

many calls on single connection, Default behavior 1: Many calls on a single connection

multiple connections, Default behavior 2: Multiple connections

protecting data from connection piggybacks, Protecting Data from Connection Piggybacks

constraints, ReferentialConstraint, How Did the Entity Data Model Wizard Create the Association?, Referential Integrity and Constraints, Constraints that are not checked until they hit the database, Constraints that the Entity Framework checks when SaveChanges is called, Deletes and Cascading Deletes, Model and Mapping Constraints Are Broken: UpdateException, Exceptions Thrown by Broken Constraints in the Database, Deleting from Grids When EntityCollections and Referential Constraints Are Involved–Deleting child entities in a grid when no referential constraint exists in the CSDL, Deleting children from a grid is easier when the child has a composite key

association with a constraint in CSDL, Deleting children from a grid is easier when the child has a composite key

checked by Entity Framework in calls to SaveChanges, Constraints that the Entity Framework checks when SaveChanges is called

checks deferred to database, Constraints that are not checked until they hit the database

database constraints enforcing referential integrity, cascading deletes and, Deletes and Cascading Deletes

deletions from grids with referential constraints involved, Deleting from Grids When EntityCollections and Referential Constraints Are Involved–Deleting child entities in a grid when no referential constraint exists in the CSDL

exceptions thrown by broken constraints in database, Exceptions Thrown by Broken Constraints in the Database

model and mapping constraints broken, UpdateException, Model and Mapping Constraints Are Broken: UpdateException

referential integrity and, Referential Integrity and Constraints

ReferentialConstraint element in the SSDL, ReferentialConstraint

context, Where Did the Context and Classes Come from?, Where Did the Context and Classes Come from?, Using your own context, EntityDataSource Context Events

(see also ObjectContext class)

EntityDataSource context events, EntityDataSource Context Events

using your own for EntityDataSource, Using your own context

ContextCreated event, EntityDataSource, EntityDataSource Context Events

ContextCreating event, EntityDataSource, Using your own context, EntityDataSource Context Events

ContextDisposing event, EntityDataSource, EntityDataSource Context Events

control variable, LINQ to Entities Queries, Entity SQL, ObjectQuery’s Query Builder Methods, Specifying the control variable

default alias for, ObjectQuery’s Query Builder Methods

specifying, Specifying the control variable

ControlState, ASP.NET page, EntityDataSource and ViewState

Create factory method, overloading, Overloading Context and Entity Methods

CreateInstance method, Creating a New Entity with CreateInstance

CreateQuery method, Using Include with an ObjectQuery, A Better Understanding of Query Builder Methods, Query Execution with the ToList or ToArray Method

Entity SQL expression as parameter, A Better Understanding of Query Builder Methods

ToList appended to, focing query execution, Query Execution with the ToList or ToArray Method

using Include method with, Using Include with an ObjectQuery

CreateSourceQuery method, enhancing deferred loading, Using CreateSourceQuery to Enhance Deferred Loading

CSDL (Conceptual Schema Definition Language), The Three Parts of the Model, CSDL: The Conceptual Schema–Where Are the Foreign Keys?, Schema, EntityContainer, EntitySet, EntityType, Associations, AssociationSet, NavigationProperty, Navigation Properties That Return Collections, Where Are the Foreign Keys?, The EDM Designer’s Model Browser, Defining a Complex Type, Constraints that are not checked until they hit the database

associations, Associations

AssociationSet objects, AssociationSet

complex type defined in, Defining a Complex Type

constraints in, Constraints that are not checked until they hit the database

EntityContainer class, EntityContainer

EntitySet class, EntitySet

EntityType data type, EntityType

foreign keys, missing, Where Are the Foreign Keys?

navigation properties returning collections, Navigation Properties That Return Collections

NavigationProperty, NavigationProperty

schema, Schema

viewing in Designer’s Model Browser, The EDM Designer’s Model Browser

CurrentValueRecord.DataRecordInfo, CurrentValueRecord.DataRecordInfo

CurrentValueRecord.SetBoolean, Modifying Values with ObjectStateManager

CurrentValues property, ObjectStateEntry, State Management and ObjectStateEntry, ObjectContext.Attach, CurrentValues and OriginalValues, Reading the OriginalValues and CurrentValues of an ObjectStateEntry, Modifying Values with ObjectStateManager

modifying values with ObjectStateManager, Modifying Values with ObjectStateManager

reading with visualizer tool, Reading the OriginalValues and CurrentValues of an ObjectStateEntry

CurrentValues, ObjectStateEntry, CurrentValues and OriginalValues

reading, CurrentValues and OriginalValues

customization of entities, Customizing Entities–Summary, Partial Classes, Customizable Methods–Using PropertyChanged to Calculate Database-Computed Columns Locally, Customizable Event Handlers–Other Opportunities for Customization, Custom Properties–Custom Properties That Perform Calculations on Child Collections, Overloading Context and Entity Methods, Custom Code Generation, Creating Common Methods or Properties for All Entities

creating common methods or properties for all entities, Creating Common Methods or Properties for All Entities

custom code generation, Custom Code Generation

event handlers, Customizable Event Handlers–Other Opportunities for Customization

methods, Customizable Methods–Using PropertyChanged to Calculate Database-Computed Columns Locally

overloading context and entity methods, Overloading Context and Entity Methods

partial classes, Partial Classes

properties, Custom Properties–Custom Properties That Perform Calculations on Child Collections