Index
NUMBERS
101 LINQ Samples by Microsoft website, 203
A
Action delegate, Lambda Expressions, 104–106
Active Directory, 243
defining as data source, 248–252
helper attributes, 257–259
IQueryable provider
creating, 245–246
Smet, Bart De implementation, 245
IQueryProvider interface, implementing, 246–248
LINQ query conversions, 252–254
property assignments, 257
RFCs, 244
schema entities, defining, 259–260
search filters, creating from Where Lambda Expressions, 254–256
Active Directory Services Interfaces, 259
Add New Item template dialog, 488
Entity Framework, 383
conceptual data models, 385
downloading, 387
Entity Data Models (EDMs), 386
Go Live estimation date, 388
relational database solutions, 385
StockHistory database, 401–411
web resources, 387–388
objects, filling, 377
ADO.NET 2.0
obtaining stock quotes, updating the database, 397–401
StockHistory database
complete script, 394–397
defining, 389–390
foreign keys, adding, 393–394
quotes, adding, 390–392
ADSI (Active Directory Services Interfaces), 259
Aggregate method, 151–153
aggregate operations
aggregation, 151–153
averages, 154–157
finding minimum and maximum elements, 157–159
median values, 163–165
overview, 151
summing query results, 162–163
aggregation, 151–153
AJAX, 22
All, 124–125
Allow access dialog (Outlook), 242
annotating nodes, 433–434
anonymous methods
CancelKeyPress events, 25
delegate keyword, 25
generic, 26–27
nested recursion, 27–28
regular method comparisons, 25
anonymous types
arrays, initializing, 7–8
composite
behaviors, adding, 9
creating, 9
methods, adding, 10–12
binding statement, 20
elements, editing, 21
requesting stock quotes from Yahoo!, 19–20
defining, 7
equality, testing, 23
hierarchical data shaping support, 24
indexes in for statements, 12–14
IntelliSense support, 6
LINQ query examples, 24–25
object initialization, 34–36
overview, 6–7
returning from functions, 17–18
using statements, 14–16
var keyword, 5
Any, 124–125
API methods for raw device contexts, 201
anonymous types, initializing, 7–8
Blackjack game, shuffling a deck of cards, 196–199
initial capping words, 202–203
select indexes, shuffling/unsorting, 194–195
ToArray conversion operator, 51–53
ascending order, sorting information in, 138–139
AsEnumerable conversion operator, 55–56
AsEnumerable method, 278–280
assigning Lambda Expressions, predefined generic delegates, 101
AssociationAttribute, 301
associations, adding to databases, 402
attributes
Active Directory helper, 257–259
AssociationAttribute, 301
InheritanceMappingAttribute, 295
XElement class
adding to, 422
deleting from, 423
XML documents, querying, 420–421
auto-implemented properties, 34
automatic properties
creating custom objects with, 169
Lambda Expressions, 102–103
AutoSync property (ColumnAttribute class), 272
Average method, 154–157
averages, computing, 157
average file size, 154
average length of words, 156
simple averages, 154
B
behaviors, adding to anonymous composite types, 9
Bill Blogs in C# website, 203
BinaryTree class, yield return, 89–93
binding control events to Lambda Expressions, 109–110
Blackjack game, 195–199
Bonaparte, Napoleon, 137
broadcast-listeners, 51–53
business objects, returning, 190–193
C
C#, Active Directory queries, 243–244
calculated values, projecting new types, 200
calling user-defined functions, 363–366
CanBeNull property (ColumnAttribute class), 272
Cartesian joins, 228
CAS (code access security), 205
Cast conversion operator, 54–55
ChangeConflicts collection, 372
child elements, LINQ to XML and XPath comparison, 441
classes
closures, 117–119
ColoredPoint, 32–33
ColoredPointList, 37
ColumnAttribute, properties, 269–273
Customer, 460
DataAccess, 191
DirectoryAttributeAttribute, 258–259
DirectoryQuery, 252–254
DirectorySchemaAttribute, 257–258
EntitySet, adding as properties, 300–305
EventLog, 206
Hypergraph, 39–46
implementing, compound type initialization, 32–34
IOrderedQueryable, 248–252
LINQ to SQL Class designer, 285–286
LINQ to SQL Object Relational Designer generated, customizing, 299–300
MAPIFolder, 242
mapping to tables, 269–272
Person, 36
StackFrame, 27
StockHistoryEntities, 405
Supplier, 190
TransactionScope, 366
WebClient, 400
XDocument, loading XML documents, 416–419
XElement
adding/deleting attributes, 422–423
node annotations, 433–434
XML documents, loading, 420
XmlWriter
overview, 464–465
XML files, creating, 465–467
clauses
from, joins, 211–212
group by, 145–149
let, XML intermediate values, 432–433
Where, XML documents, 429
closures, 117–119
code, compiling Lambda Expressions as
assigned to Expression<TDelegate> instance emits IL example, 114, 116
expression tree exploration, 116–117
code access security (CAS), 205
CodeDOM, 485
collections
ChangeConflicts, 372
ColoredPoint class, 32–33
ColoredPointList class, 37
ColumnAttribute class, 269–273
columns, ignoring for conflict checks, 371
COM (Component Object Model), 239
comma-delimited text files, 453
CompareTo method, 159
compiling Lambda Expressions as code/data
assigned to Expression<TDelegate> instance emits IL example, 114, 116
expression tree exploration example, 116–117
Component Object Model (COM), 239
composite anonymous types
behaviors, adding, 9
creating, 9
methods, adding, 10–12
composite keys, defining joins, 237
composite resultsets, creating, 182–183
compound initialization
anonymous types, 34–36
named types, 31
auto-implemented properties, 34
classes, implementing, 32–34
default constructor and property assignment, 30
purpose-defined constructor, 30
Concat, extension methods, 132–133
concurrency conflicts, 368
catching
comparing member conflict states, 373–374
entities/tables associated with conflict, 372–373
ignoring columns for conflict checks, 371
retrieving conflict information, 372
handling, SubmitChanges method, 369–371
resolving, 375–376
concurrency control, 368
Configure Behavior dialog, 362
conflicts
catching
conflict information, retrieving, 372
entities/tables associated with conflict, 372–373
ignoring columns for conflict checks, 371
member conflict states, comparing, 373–374
concurrency conflicts, 368
concurrency control, 368
handling, SubmitChanges method, 369–371
optimistic concurrency, 368
pessimistic concurrency, 368
resolving, 375–376
console applications, creating LINQ to XSD Preview, 487
contacts (Outlook), adding email addresses, 240–241
control events, binding to Lambda Expressions, 109–110
conversion operators
AsEnumerable, 55–56
Cast, 54–55
OfType, 54
ToArray, 51–53
ToDictionary, 57–58
ToList, 56–57
ToLookup, 58–59
converting CSV files to XML, 454–456
Count method, 157
counting elements, 157
“Creating Project Templates in .NET” website, 487
cross joins, implementing, 228, 236
Northwind database customers and products example, 229–231
SQL as LINQ query example, 231–236
CSV files (comma-delimited text files), XML
converting to, 454–456
creating from, 457–458
currying, 119–120
Customer class, 460
customizing
joins, 214
defining, 215–218
multiple predicates, 219–220
temporary range variables, 220–223
LINQ to SQL Object Relational Designer generated classes, 299–300
objects, instantiating, 170–171
select statement predicates, 190
D
data
compiling Lambda Expressions as
assigned to Expression<TDelegate> instance emits IL example, 114–116
expression tree exploration, 116–117
LINQ to SQL
adding to, 349–352
deleting from, 352–354
updating in, 354–355
data access layers, writing, 384
DataAccess class, 191
databases
creating with LINQ to SQL, 305–307
relational model
C# programming problems, 384–385
data access layers, 384
Entity Framework solution, 385
StockHistory (ADO.NET 2.0)
complete script, 394–397
defining, 389–390
foreign keys, adding, 393–394
obtaining stock quotes, updating the database, 397–401
quotes, adding, 390–392
StockHistory (ADO.NET Entity Framework)
associations, adding, 402
creating EDMs, 401–402
LINQ to XML and LINQ to Entities, 407–411
querying EDMs with Entity SQL, 402–405
querying EDMs with LINQ to Entities, 405–406
databinding
anonymous types, 18
binding statement, 20
elements, editing, 21
requesting stock quotes from Yahoo!, 19–20
bindability, 345
IEnumerable interface, 345
listing example, 345–347
DataContext class, 305, 356–357
DataContext object, 275–277
DataContextMapping property, 372
DataSets
DataTables
querying with Where clause, 280–281
selecting data from, 278–280
sorting against, 282
joins, defining with, 282–284
LINQ to DataSets
equijoins, 310–312
left outer joins, 313–315
nonequijoins, 312–313
right joins, 315–317
overview, 277–278
partitioning methods, 282
DbType property (ColumnAttribute class), 272
de Gaulle, Charles, 151
debugging
stored procdures, 392
XSLT documents, 450
Decorator Structural pattern, 61
DefaultIfEmpty method, 127, 331
defining
Active Directory schema entities, 259–260
anonymous types, 7
exclusive sets, 177–181
generic extension methods, 69–70, 73
joins
based on composite keys, 237
cross joins, 228–236
group joins, 224–226
left outer joins, 226–228
with DataSets, 282–284
nonequijoins, 215–218
multiple predicates, 219–220
temporary range variables, 220–223
partial methods, 79–84
stored procedures, 358–360
tables, 266–269
XML as strings, 424–425
delegate keyword, anonymous methods, 25
delegates, Lambda Expressions
Action, 104–106
Predicate<T>, 108–109
deleting
attributes, XElement class, 423
data, LINQ to SQL, 352–354
descending keyword, 138–140
descending order, sorting information in, 139–141
design goals, LINQ to XSD, 486
dictionaries, list conversions, 57–58
DirectoryAttributeAttribute class, 258–259
DirectoryQuery class, 252–254
DirectorySchemaAttribute class, 257–258
distinct elements
customer objects
defining Order object, 169
instantiating, 170–171
distinct lists of cities, sorting/returning, 173–177
finding, 167
IEqualityComparer interface, implementing, 171–172
median grade, determining from list of numbers, 167–168
object dumper, implementing, 172–173
Distinct method, 167
DLLs (Dynamic Link Libraries), importing, 200
documents
XML documents
creating from Yahoo! stock quotes, 426–427
defining as strings, 424–425
element navigation based on context, 430–431
filtering, 429
functional construction, 450–451
intermediate values, 432–433
loading, 415–416
missing data, 425–426
namespaces, 427–428
nested queries, 428–429
node annotations, 433–434
querying, 416–421
sorting, 431
XSLT documents, debugging, 450
downloading
Entity Framework, 387–388
LINQ to XSD, 487
duct typing, 64
Dump, overloading extension methods, 62–63, 67–68
dynamic programming, Lambda Expressions
code/data, compiling as, 114–117
OrderBy<T> method, 113
Select<T> method, 110–112
Where<T> method, 112–113
E
EDMs (Entity Data Models), 386
creating, 401–402
querying
Entity SQL, 402–405
LINQ to Entities, 405–406
element operations, 131–132
elements
child elements, LINQ to XML and XPath comparison, 441
counting, aggregate operations, 157
distinct elements
defining Order object in customer objects, 169
determining median grade from list of numbers, 167–168
finding, 167
implementing IEqualityComparer interface, 171–172
implementing object Dumper, 172–173
instantiating customer objects, 170–171
sorting/returning distinct lists of cities, 173–177
editing, databinding, 21
filtering, LINQ to XML and XPath comparison, 442–443
maximum elements, finding, 157–159
minimum elements, finding, 157–159
navigation based on context, XML documents, 430–431
obtaining specific elements from sequences, 131–132
sibling elements, LINQ to XML and XPath comparison, 442
ElementsAfterSelf method, 430–431
email addresses, adding to Outlook contacts, 240–241
embedded LINQ queries, XML with, 458
console application, 460–461
Customer class example, 459–460
literal XML with embedded expressions and LINQ, 461–462
Empty, 127
entities
Active Directory schema, defining, 259–260
associated with conflict, 372–373
LINQ to Entities
EDMs, querying, 405–406
StockHistory database, UpdatePriceHistory method, 407–411
nullable, 290–293
Entity Data Models, 386
Entity Framework (ADO.NET), 383
conceptual data models, 385
downloading, 387
EDMs, 386
Go Live estimation date, 388
relational database solutions, 385
StockHistory database
adding associations, 402
creating EDMs, 401–402
LINQ to XML and LINQ to Entities, 407–411
querying EDMs with Entity SQL, 402–405
querying EDMs with LINQ to Entities, 405–406
web resources
Entity SQL blog, 387
samples, 388
Wikipedia, 387
Entity SQL
blog, 387
EDMs, querying, 402–405
website, 405
EntitySet classes, adding as properties, 300–305
Equals method, anonymous types, 23
equijoins, 214
LINQ to Datasets, 310–312
LINQ to SQL, 317–321
esoterrorism, 27
Euclidean algorithm example, 186–189
EventLog class, 206
Except method, 177–181
exclusive sets, defining, 177–181
Expression property (ColumnAttribute class), 272
expression trees, 116
expressions
Lambda
assigning to predefined generic delegates, 101
automatic properties, 102–103
capturing as generic actions, 104–106
capturing as generic predicates, 108–109
control events, binding, 109–110
currying, 119–120
delegate role listing, 100
reading, 103–104
string searches, 106–107
Where, 254–256
regular, adding to XML Schema files, 491–494
Extensible Stylesheet Language Transformations, 437
Concat, 132–133
defining generic extension methods, 69–70, 73
defining with return type, 64–65
implementing, 64–67
LINQ, 73–77
overloading, 67–68
SequenceEqual, 130
“talking” string extension methods, 78–79
uses for, 63–64
F
Feynman, Richard, 179
Field method, 280–281
filtering
elements, LINQ to XML and XPath comparison, 442–443
information, 122–124
OfType filters, 122–124
XML documents, 429
finding
distinct elements, 167
defining customer Order object, 169
determining median grade from list of numbers, 167–168
implementing IEqualityComparer interface, 171–172
implementing object Dumper, 172–173
instantiating custom objects, 170–171
sorting and returning distinct list of cities, 173–177
minimum and maximum elements, 157–159
for statements, anonymous type indexes, 12–14
foreign keys, adding to databases, 393–394
from clauses, joins, 211–212
function pointers, listings
anonymous delegate, 99
delegates in C#, 99
FunctionPointer definition, 98
Lambda Expression playing the delegate role, 100
functional construction, 443, 450–451
functions
anonymous types, returning, 17–18
ProductsUnderThisUnitPrice, 363–366
user-defined, calling, 363–366
G
GDI+, API methods for raw device contexts, 201
generation operations
DefaultIfEmpty, 127
Empty, 127
Range, 127
Repeat, 128–129
generic anonymous methods, 26–27
generic extension methods, defining, 69–70, 73
GetData method, 476
GetPoints method, 38
group by clause, 145–149
group joins
defining, 224–226
LINQ to SQL, 321–331
grouping information, 145–150
GroupJoin method, 321–331
H
helper attributes, Active Directory, 257–259
Hypergraph class, 39–46
broadcast-listener, 53
ColoredPoint class, 32–33
compound type initialization of objects
default constructor and property assignment, 30
Paint Event handler, 31
Pen object, 30
HypergraphController user control, 47–50
IHypergraph interface, 46–47
images, saving to files, 51–52
subject and observer interfaces, 50
I
IBindingList interface, databinding, 345
IComparable interface, 159
IDataReader interface methods, 215–218
IEnumberable{T}, 94
IEnumerable interface
AsEnumberable conversion operator, 55
databinding, 345
IEqualityComparer interface, implementing, 171–172
IHypergraph interface, 46–47
IL (Intermediate Language), 7
ILDASM (Intermediate Language Disassembler), 7
importing DLLs, 200
Inbox (Outlook), reading, 240–241
indexes
anonymous type, for statements, 12–14
select, shuffling/unsorting arrays, 194–195
SelectMany method, 207
SelectMany methods, 208
information filtering, 122–124
inheritance hierarchies, LINQ to SQL
Object Relational Designer, creating with, 298
single-table mapping, 294–298
InheritanceMappingAttribute, 295
initial capping words (arrays), 202–203
initializing
anonymous type arrays, 7–8
objects with
anonymous types, 34–36
named types, 30–34
inner joins, 213–214
InnerGetQuote method, 20
InsertCustomer methods, 362–363
InsertQuote stored procedure, 390–392
IntelliSense, anonymous types support, 6
interfaces
IBindingList, databinding, 345
IComparable, 159
IDataReader, methods, 215–218
IEnumerable
AsEnumerable conversion operator, 55
databinding, 345
IEqualityComparer, implementing, 171–172
IHypergraph, 46–47
IQueryProvider, implementing, 246–248
projecting interfaces, support for, 159–161
Intermediate Language, 7
Intermediate Language Disassembler, 7
intermediate values, XML documents, 432–433
Intersect method, 177–181
IOrderedQueryable class, 248–252
IQueryable, 73
IQueryable provider
creating, 245–246
Smet, Bart De implementation, 245
IQueryProvider interface, implementing, 246–248
IsDbGenerated property (ColumnAttribute class), 273
IsDiscriminator property (ColumnAttribute class), 273
IsPrimaryKey property (ColumnAttribute class), 273
IsVersion property (ColumnAttribute class), 273
J
joins
based on composite keys, 237
cross
Northwind database customers and products example, 229–231
SQL as LINQ query example, 231–236
DataSets, defining with, 282–284
equijoins, 214
LINQ to DataSets, 310–312
LINQ to SQL, 317–321
group
defining, 224–226
LINQ to SQL, 321–331
inner, 213–214
left, LINQ to SQL, 331–340
left outer, 224
implementing, 226–228
LINQ to DataSets, 313–315
multiple from clauses, 211–212
nonequijoins, 214
defining, 215–218
LINQ to DataSets, 312–313
multiple predicates, 219–220
temporary range variables, 220–223
right joins, LINQ to DataSets, 315–317
K–L
Kernighan, Brian, 98
keys
composite, 237
foreign, adding to databases, 393–394
keywords
delegate, anonymous, 25
descending, 138–140
orderby, 137
var, anonymous types, 5
Lambda Expressions
automatic properties, 102–103
capturing as
generic actions, 104–106
generic predicates, 108–109
closures, 117–119
control events, binding, 109–110
currying, 119–120
delegate role listing, 100
dynamic programming
compiling as code/data, 114–117
OrderBy<T> method, 113
Select<T> method, 110–112
Where<T> method, 112–113
predefined generic delegates, assigning to, 101
reading, 103–104
string searches, 106–107
Where, converting to Active Directory search filters, 254–256
LDAP (Lightweight Directory Access Protocol), 244
left joins, LINQ to SQL, 331–340
left outer joins, 224
implementing, 226–228
LINQ to Datasets, 313–315
Leonardo of Pisa, 177
let clause, XML intermediate values, 432–433
LINQ (Language INtegrated Query), 121
constructing queries, 122
equality testing, 129–130
extension methods, 73–77
LINQ to DataSets, joins
equijoins, 310–312
left outer joins, 313–315
nonequijoins, 312–313
right joins, 315–317
LINQ to Entities
EDMs, querying, 405–406
StockHistory database UpdatePriceHistory method, 407–411
data
adding, 349–352
deleting, 352–354
updating, 354–355
databases, creating, 305–307
databinding
bindability, 345
IEnumerable interface, 345
listing example, 345–347
inheritance hierarchies
creating with Object Relational Designer, 298
single-table mapping, 294–298
joins
equijoins, 317–321
group, 321–331
left, 331–340
n-tier applications, 376
client with reference to the service, 380–381
service contract for serializing Customer objects, 377–379
service contract, implementing, 379
WCF middle tier, 377
Object Relational Designer generated classes, customizing, 299–300
views, querying, 342–344
Visual Designer, mapping stored procedures, 360–363
LINQ to SQL Class designer, 285–286
LINQ to XML
node annotations, 433–434
StockHistory database UpdatePriceHistory method, 407–411
XML documents
creating from Yahoo! stock quotes, 426–427
element navigation based on context, 430–431
filtering, 429
intermediate values, 432–433
namespaces, 427–428
nested queries, 428–429
sorting, 431
XPath, compared, 438
child elements, 441
filtering elements, 442–443
namespaces, 439–441
sibling elements, 442
XSLT, compared, 443
debugging XSLT documents, 450
HTML documents, 444–449
LINQ to XSD
design goals, 486
downloading/installing, 487
object queries, 496–498
overview, 485
Preview console applications, creating, 487
regular expressions added to XML Schema files, 491–494
XML files, defining, 488–490
XML Schema files, defining, 490–491
listings
Active Directory
DirectorySchemaAttribute class, 257
LINQ query conversions to Active Directory queries, 253–254
property assignments, 257
querying, 260–262
schema entities, 259–260
search filters created with Where Lambda Expressions query, 254–256
Active Directory queries with straight C# code, 243–244
anonymous methods handling CancelKeyPress event, 25
anonymous types
adding behaviors to, 10
equality testing, 23
indexes in for statements, 12–13
returning from functions, 17
using statements, 14–15
AsEnumerable conversion operator, 55
ASP for AJAX page, 21
behaviors, adding to anonymous type, 10
Blackjack game
jack namespace, 439
shuffling a deck of cards, 196–199
statistics saved to XML file, 438
Cast conversion operator, 54
composite anonymous types, 9
concurrency conflicts
comparing member conflict states, 373
conflict information, retrieving, 372
entities/tables associated with conflict, 372
handling, 369
ignoring columns for conflict checks, 371
resolving, 375
data
adding, 350–352
deleting, 352–354
updating, 354
databinding with LINQ to SQL, 345–347
DataContext class, 356–357
DirectoryAttributeAttribute class, 258–259
EntitySet classes as properties, adding, 301–305
function pointers
anonymous delegate, 99
delegates in C#, 99
FunctionPointer definition, 98
Lambda Expression playing the delegate role, 100
functional construction, 451
GDI API methods for raw device contexts, 201
generic anonymous methods, 26
Hypergraph
broadcast-listener, 53
ColoredPoint class, 32–33
ColoredPointList class, 37
default constructor and property assignment, 30
Hypergraph class, 39–46
HypergraphController user control, 47–50
IHypergraph interface, 46–47
named types, 31
purpose-defined constructor, 30
saving images to files, 51–52
subject and observer interfaces, 50
IOrderedQueryable class, 249–252
IQueryProvider interface, 246
joins
based on composite keys, 237
cross join for Northwind database customers and products, 229–231
cross join SQL as LINQ query, 231–236
group joins, 224–226
inner, 213–214
left outer joins, 227
multiple from clauses, 211
nonequijoins with multiple predicates, 219
nonequijoins with temporary range variables, 220–223
nonequijoins, defining, 215–218
Lambda Expressions
assigned to Expression<TDelegate> instance emits IL example, 114–116
assigning to predefined generic delegates, 101
automatic properties, 102
capturing as generic actions, 104–105
capturing as generic predicates, 108
closures, 118
control events, binding, 109
currying, 119
demonstrating explicit argument types, 103
expression tree exploration, 116–117
OrderBy<T> method, 113
Select<T> method, 110–111
string searches, 106–107
Where<T> method, 112
LINQ to DataSets
equijoins, 310–311
left outer joins, 314–315
nonequijoins, 312–313
right outer joins, 316
LINQ to SQL
creating databases, 305
customizing Object Relational Designer generated classes, 299–300
equijoins, 317–321
group joins, 321–331
inheritance hierarchies, 294–298
left joins, 331–340
regular expressions added to XML Schema files, 492–494
LINQ to XML and XPath comparison
child elements, 441
filtering elements, 442
namespaces, 440
sibling elements, 442
LINQ to XML and XSLT comparison, HTML documents, 444–449
LINQ to XSD
queries, 496–497
XML files, creating, 488–490
XML Schema files, creating, 490
n-tier applications with LINQ to SQL
client with reference to the service, 380–381
service contract for serializing Customer objects, 377–379
service contract, implementing, 379
nested recursive anonymous generic methods, 27
nullable type entities, 290–293
OfType conversion operator, 54
Outlook
updating contacts, 240–241
Inbox, 240–241
PetCemetary.XML file, 417–419
query examples with anonymous types, 24
requesting stock quotes from Yahoo!, 19–20
select statements
customizing predicates, 190
function call effects, 186–189
indexes for shuffling/unsorting arrays, 194–195
initial capping words in arrays, 202–203
projecting types, 203
returning custom business objects, 191–193
SelectMany methods
comparing Windows Registry sections, 206–207
indexes, 207
projecting types, 203
SQL to XML conversions, 473–475
Northwind DataContext example, 472
Northwind object-relational map example, 471–472
TreeView output of XML document, 476
SQL updates from XML
examining inserted data, 481
inserting data, 480–481
osql.exe scripting output, 482–483
sample XML file, 478–479
StockHistory database
adding quotes, 390–392
Company table, 390
foreign keys, adding, 394
LINQ to XML and LINQ to Entities, 407–411
obtaining stock quotes to update the database, 397–401
PriceHistory table, 390
querying EDMs with Entity SQL, 404–405
querying EDMs with LINQ to Entities, 405
stored procedures
defining, 358–360
mapping with LINQ to SQL Visual Designer, 362–363
UpdateCustomer example, 357–358
ToDictionary conversion operator, 57
ToList conversion operator, 56
ToLookup conversion operator, 58
transactions, deleting parent/child rows, 366–368
user-defined functions, calling, 363–365
views
building with SQL Server, 342
querying with LINQ to SQL, 342–344
XElement class, adding/deleting attributes, 422–423
XML
creating from CSV files, 454–456
defining as strings, 424
missing data, 425–426
text files, creating, 457–458
creating from Yahoo! stock quotes, 426–427
element navigation based on context, 430–431
filtering, 429
intermediate values, 432–433
namespaces, 427–428
nested queries, 428–429
node annotations, 433–434
sorting, 431
XML with embedded LINQ queries in VB
console application, 460–461
Customer class example, 459–460
literal XML with embedded expressions and LINQ, 461–462
XmlWriter class for creating XML files, 465–467
lists, converting
dictionaries, to, 57–58
query results to, 56–57
literal XML in VB with embedded expressions and LINQ, 461–462
LongCount method, 157
lookups, IEnumerable object conversions, 58–59
luncheon menu example
luncheon days collection and regular expression incorporation, 497
possible weekdays XML document, 492–494
XML file, 488
XML Schema file, 490
M
MAPIFolder class, 242
mapping
classes to tables, 269–272
LINQ to SQL inheritance hierarchies
creating with Object Relational Designer, 298
single-table mappings, 294–298
stored procedures, LINQ to SQL Visual Designer, 360–363
Max method, 157–159
maximum elements, finding, 157–159
McCarthy, Dan, 177
Median method, 163–165
median grade, determining from list of numbers, 167–168
median values, 163–165
member conflict states, comparing, 373–374
methods
Aggregate, 151–153
anonymous composite types, adding to, 10–12
anonymous methods
CancelKeyPress events, 25
delegate keyword, 25
generic, 26–27
nested recursion, 27–28
regular method comparisons, 25
API for raw device contexts, 201
AsEnumerable, 278–280
Average, 154–157
CompareTo, 159
Count, 157
DefaultIfEmpty, 331
Distinct, 167
ElementsAfterSelf, 430–431
Equals, anonymous types, 23
Except, 177–181
Concat, 132–133
defining generic extension methods, 69–70, 73
defining with return type, 64–65
implementing, 64–67
LINQ, 73–77
overloading, 67–68
SequenceEqual, 130
“talking” string extension methods, 78–79
uses for, 63–64
Field, 280–281
GetData, 476
GetPoints, 38
GroupJoin, 321–331
IDataReader interface, 215–218
InnerGetQuote, 20
InsertCustomer, 362–363
Intersect, 177–181
LongCount, 157
Max, 157–159
Median, 163–165
Min, 157–159
ObjectChangeConflict.Resolve, 375
OrderBy<T>, Lambda Expressions, 113
OrderByDescending, 140
partial methods, 79–84
partitioning methods, 282
ReadSuppliers, 191
Reverse, 144–145
Select<T>, Lambda Expressions, 110–112
SelectMany
indexes, 207–208
types, projecting, 203–205
Windows Registry sections, comparing, 206–207
SubmitChanges, 369–371
Sum, 162–163
ThenBy, 138
ThenByDescending, 141
ToLookup, 150
Union, 182–183
Update, databinding anonymous types, 20
UpdatePriceHistory, 400
Where<T>, Lambda Expressions, 112–113
Microsoft Intermediate Language, 7
Microsoft XML Team WebLog website, 487
Min method, 157–159
minimum elements, finding, 157–159
missing data (XML), 425–426
MSIL (Microsoft Intermediate Language), 7
MyPoint property, 34
N
n-tier applications, 376
client with reference to the service, 380–381
service contracts
implementing, 379
serializing Customer objects, 377–379
WCF middle tier, 377
Name property (ColumnAttribute class), 273
named types, object initialization, 31
auto-implemented properties, 34
classes, implementing, 32–34
default constructor and property assignment, 30
purpose-defined constructor, 30
namespaces
LINQ to XML and XPath comparison, 439–441
XML documents, 427–428
nanotechnology, 179
Napoleon, 137
nested queries, XML documents, 428–429
nested recursive anonymous generic methods, 27–28
New Association dialog, 402
nodes
annotations, 433–434
XComment, SQL to XML conversions, 475
nonequijoins, 214
defining, 215–218
LINQ to Datasets, 312–313
multiple predicates, 219–220
temporary range variables, 220–223
Northwind Customers table object-relational map, 472
Northwind database
cross join of customers and products, 229–231
customers
adding, 350–352
table object-relational map, 471
Customers table object-relational map, 471
data, updating, 354
DataContext example, 472
examining inserted data, 481
InsertCustomer methods, 362–363
inserting data, 480–481
new customers XML file, 478–479
orders, deleting, 366–368
osql.exe scripting output, 482–483
ProductsUnderThisUnitPrice function, 363–366
stored procedure for CustomerIDs, 358–360
UpdateCustomer stored procedures, 357–358
views
Orders/Order Details tables, 342
querying, 342–344
nullable types, 289–293
O
Object Relational Designer, LINQ to SQL
generated classes, customizing, 299–300
inheritance hierarchies, 298
object-relational maps, XML conversions, 470–472
ObjectChangeConflict.Resolve method, 375
objects
ADO.NET, filling with, 377
compound initialization with anonymous types, 34–36
compound initialization with named types, 31
auto-implemented properties, 34
classes, implementing, 32–34
default constructor and property type, 30
purpose-defined constructor, 30
custom business, returning, 190–193
custom objects, instantiating, 170–171
DataContext, 275–277
LINQ to XML queries, 496–498
object dumper, implementing, 172–173
Order, defining, 169
tables
defining, 266–269
mapping classes to, 269–272
XNamespace, 427–428
OfType conversion operator, 54
OfType filter, 122–124
operations
element operations, 131–132
generation operations
DefaultIfEmpty, 127
Empty, 127
Range, 127
Repeat, 128–129
optimistic concurrency, 368
Order object, defining, 169
orderby keyword, 137
OrderBy<T> method, Lambda Expression, 113
OrderByDescending method, 140
osql.exe command line, examining inserted data, 482–483
Outlook
Allow access dialog, 242
contacts, adding email addresses, 240–241
Inbox/contacts, reading, 240–241
instances, creating, 242
overloading extension methods, 67–68
P
partial methods, defining, 79–84
partitioning, 282
Skip, 126–127
Take, 126–127
Person class, 36
pessimistic concurrency, 368
PetCemetary.XML file example, 417–419
phishing, 205
Predicate<T> delegate, Lambda Expressions, 108–109
predicates
nonequijoins, defining, 219–220
select statements, customizing, 190
prime number algorithm examples, 186–189
PRINT statements, debugging stored procedures, 392
ProductsUnderThisUnitPrice function, 363–366
profiling code, yield return, 93–94
programming
anonymous types
arrays, initializing, 7–8
composite, 9–12
composite, creating, 9
defining, 7
indexes in for statements, 12–14
returning from functions, 17–18
using statements, 14–16
dynamic programming, Lambda Expressions, 110
LINQ to XSD
downloading/installing, 487
object queries, 496–498
Preview console applications, creating, 487
regular expressions added to XML Schema files, 491–494
XML files, defining, 488–490
XML Schema files, defining, 490–491
“Programming for Fun and Profit—Using the Card.dll” website, 439
projecting interfaces, support for, 159–161
projecting new types, 200, 203–205
properties
Active Directory, assigning, 257
auto-implemented, 34
automatic properties
creating custom objects with, 169
Lambda Expressions, 102–103
ColumnAttribute class, 269–273
DataContextMapping, 372
EntitySet classes as, 300–305
MyPoint, 34
providers, IQueryable
creating, 245–246
Smet, Bart De implementation, 245
Q
quantifiers, 126
All, 124–125
Any, 124–125
querying
Active Directory, 243–244, 252–254, 260–262
converting
results to lists, 56–57
to Active Directory queries, 252–254
EDMs
Entity SQL, 402–405
LINQ to Entities, 405–406
embedded with XML in VB, 458
console application, 460–461
Customer class example, 459–460
literal XML with embedded expressions and LINQ, 461–462
joins
based on composite keys, 237
cross, 228–236
equijoins, 214
group, 224–226
inner, 213–214
left outer, 224–228
multiple from clauses, 211–212
nonequijoins, 214–223
LINQ queries, constructing, 122
LINQ with anonymous types, 24–25
nested, LINQ to XML, 428–429
results, summing, 162–163
text, viewing, 273–275
XML documents
attributes, 420–421
XDocument class, 416–419
XElement class, 420
R
Range, 127
range variables, defining nonequijoins, 220–223
ReaderHelper, 73
ReadSuppliers method, 191
Registry
overview, 205
two section comparison, 206–207
regular expressions, adding to XML Schema files, 491–494
relational data, connecting to, 275–277
relational database models
C# programming problems, 384–385
data access layers, 384
Entity Framework solution, 385
Repeat, 128–129
requesting stock quotes from Yahoo!, 19–20
Requests for Comments, 244
resolving conflicts, 375–376
resources (web), ADO.NET Entity Framework
downloads, 387
Entity SQL blog, 387
samples, 388
Wikipedia, 387
results of queries, summing, 162–163
resultsets, creating composite resultsets, 182–183
return type, defining extension methods, 64–65
Reverse method, 144–145
reversing item order, 144–145
RFCs (Requests for Comments), 244
right joins, LINQ to Datasets, 315–317
Ritchie, Dennis, 98
rules for yield return, 88
S
Santana, Carlos, 119
ScottGu’s Blog website, 203
secondary sorts, 141–144
security, CAS (code access security), 205
select indexes, shuffing/unsorting arrays, 194–195
select statements
custom business objects, returning, 190–193
function call effects, 186–189
initial capping words in arrays, 202–203
predicates, customizing, 190
types, projecting, 203–205
Select<T> method, Lambda Expression, 110–112
SelectMany method
indexes, 207–208
types, projecting, 203–205
Windows Registry sections comparisons, 206–207
SequenceEqual, 130
sequences, appending with Concat, 132–133
services oriented architecture, 462
set operations
composite resultsets, creating, 182–183
distinct elements, finding, 167
defining custom Order object, 169
determining median grade from list of numbers, 167–168
implementing IEqualityComparer interface, 171–172
implementing object dumper, 172–173
instantiating custom objects, 170–171
sorting and returning distinct list of cities, 173–177
exclusive sets, defining, 177–181
overview, 167
shaping, 35
shared source code, 86
shuffling a deck of cards (Blackjack game), 196–199
sibling elements, LINQ to XML and XPath comparison, 442
sieve of Atkin algorithm, 189
sieve of Eratosthenes algorithm example, 186–189
single-table mapping, LINQ to SQL inheritance hierarchies, 294–298
Skip, partitioning, 126–127
SOA (services oriented architectures), 462
sorting
against DataTables, 282
distinct list of cities, 173–177
information
in ascending order, 138–139
in descending order, 139–141
overview, 137
reversing order of items, 144–145
secondary sorts, 141–144
XML queries, 431
source code (shared), 86
Space Invaders website, 463
sprocs (stored procedures), 223
SQL (Structured Query Language)
LINQ to SQL
adding data, 349–352
customizing Object Relational Designer generated classes, 299–300
databases, creating, 305–307
databinding, 345–347
deleting data, 352–354
equijoins, 317–321
group joins, 321–331
inheritance hierarchies, 294–298
left joins, 331–340
n-tier applications, 376–381
querying views, 342–344
updating data, 354–355
LINQ to SQL Class designer, 285–286
LINQ to SQL Visual Designer, mapping stored procedures, 360–363
statements, executing in Visual Studio, 481
object-relational maps, defining, 470–472
TreeView output of XML document, 475–478
XComment node, 475
XML, updating from
examining inserted data, 481
inserting data, 480–481
osql.exe scripting output, 482–483
sample XML file, 478–479
SQL Server, building views, 340–342
SqlMetal, 285
StackFrame class, 27
statements
anonymous types, 14–16
binding statements in, 20
using, 14–16
binding statements, anonymous types, 20
for statements, anonymous type indexes, 12–14
PRINT, debugging stored procedures, 392
select
custom business objects, returning, 190–193
customizing predicates, 190
function call effects, 186–189
initial capping words in arrays, 202–203
projecting types, 203–205
SQL, executing in Visual Studio, 481
StockHistory database
ADO.NET 2.0
adding foreign keys, 393–394
adding quotes, 390–392
complete script, 394–397
defining, 389–390
Entity Framework (ADO.NET)
adding associations, 402
creating EDMs, 401–402
LINQ to XML and LINQ to Entities, 407–411
querying EDMs with Entity SQL, 402–405
querying EDMs with LINQ to Entities, 405–406
obtaining stock quotes, updating the database, 397, 399–401
StockHistoryEntities class, 405
Storage property (ColumnAttribute class), 273
stored procedures, 223
debugging, 392
defining, 358–360
InsertQuote, 390–392
mapping, LINQ to SQL Visual Designer, 360–363
overview, 355
UpdateCustomer example, 357–358
strings
searching, Lambda Expressions, 106–107
XML defined as, 424–425
SubmitChanges method, 369–371
Sum method, 162–163
summing query results, 162–163
Supplier class, 190
System.Ling namespace, 73
T
tables
associated with conflict, 372–373
DataTables
querying with Where clause, 280–281
selecting data from, 278–280
sorting against, 282
defining, 266–269
mapping classes to, 269–272
Take, partitioning, 126–127
“talking” string extension methods, implementing, 78–79
testing
anonymous types equality, 23
equality testing, 129–130
text (queries), viewing, 273–275
text files, creating from XML, 457–458
ThenBy method, 138
ThenByDescending method, 141
ToArray conversion operator, 51–53
ToDictionary conversion operator, 57–58
ToList conversion operator, 56–57
ToLookup conversion operator, 58–59
ToLookup method, 150
transactions
parent/child rows, deleting, 366–368
TransactionScope class, 366
TreeView output of XML document, 475–478
triggers, 22
types
anonymous, 203–205
named, 30
nullable, 289–293
U
Union method, 182–183
Update method, databinding anonymous types, 20
UpdateCheck property (ColumnAttribute class), 273
UpdateCustomer stored procedure, 357–358
UpdatePriceHistory methods, 400
updating
data, LINQ to SQL, 354–355
SQL from XML
examining inserted data, 481
inserting data, 480–481
osql.exe scripting output, 482–483
sample XML file, 478–479
user controls, HypergraphController, 47–50
user-defined functions, calling, 363–366
using statements, anonymous types, 14–16
V
var keyword, anonymous types, 5
variables (range), defining nonequijoins, 220–223
VB (Visual Basic)
VB Today website, 203
XML with embedded LINQ queries, 458
console application, 460–461
Customer class example, 459–460
literal XML with embedded expressions and LINQ, 461–462
views, 340
querying with LINQ to SQL, 342–344
SQL Server, building with, 340–342
Visual Designer (LINQ to SQL), mapping stored procedures, 360–363
Visual Studio
SQL statements, executing, 481
stored procedures, defining, 360
W
Wagner, Bill, 80
WCF (Windows Communication Foundation), 377
WebClient class, 400
websites, 438
101 LINQ Samples by Microsoft, 203
Bill Blogs in C#, 203
Creating Project Templates in .NET (quotes), 487
Entity Framework download, 387
Entity Framework Go Live estimation date, 388
Entity SQL blog, 387
Entity SQL reference, 405
Microsoft XML Team WebLog, 487
Programming for Fun and Profit—Using the Card.dll, 439
ScottGu’s Blog, 203
Smet, Bart De IQueryable provider implementation, 245
Space Invaders, 463
VB Today, 203
Wikipedia, 387
Yahoo! stock quotes, 426
West, David, 78
Where, extension methods, 73, 76
Where clauses, XML documents, 429
Where Lambda Expressions, converting to Active Directory search filters, 254–256
Where<T> method, Lambda Expression, 112–113
Wikipedia, 387
Wilde, Oscar, 167
Windows Communication Foundation, 377
Windows Registry
overview, 205
two section comparison, 206–207
X–Z
XComment node, SQL to XML conversions, 475
XDocument class, loading XML documents, 416–419
XElement class
attributes
adding, 422
deleting, 423
node annotations, 433–434
XML documents, loading, 420
XML
.csv files, creating from, 454–456
documents
creating from Yahoo! stock quotes, 426–427
defining as strings, 424–425
element navigation based on context, 430–431
filtering, 429
functional construction, 450–451
intermediate values, 432–433
loading, 415–416
missing data, 425–426
namespaces, 427–428
nested queries, 428–429
node annotations, 433–434
querying, 416–421
sorting, 431
embedded LINQ queries in VB, 458
console application, 460–461
Customer class example, 459–460
literal XML with embedded expressions and LINQ, 461–462
files, creating with
LINQ to XSD, 488–490
XmlWriter class, 465–467
LINQ to XML
StockHistory database UpdatePriceHistory method, 407–411
XPath, compared, 438–443
XSLT, compared, 443–450
Path Language, 437
Schema files
creating with LINQ to XSD, 490–491
regular expressions, adding, 491–494
SQL, creating from, 469, 473–474
object-relational maps, defining, 470–472
TreeView output of XML document, 475–478
XComment node, 475
examining inserted data, 481
inserting data, 480–481
osql.exe scripting output, 482–483
sample XML file, 478–479
text files, creating, 457–458
XmlWriter class
overview, 464–465
XML files, creating, 465–467
XNamespace object, 427–428
XPath (XML Path Language), LINQ to XML, 437–438
child elements, 441
filtering elements, 442–443
namespaces, 439–441
sibling elements, 442
XPath (XML Path Language), 437
XQuery, filtering elements, 442
XSLT (Extensible Stylesheet Language Transformations), LINQ to XML, 437, 443
debugging documents, 450
HTML documents, 444–449
Yahoo! stock quotes website, 426
yield return, 85–86
BinaryTree, 89–93
demonstration of, 87–88
profiling code, 93–94
rules for, 88
yield break, 95