• Although we want to perform a simple task, several steps and verbose code are required.
• Queries are expressed as quoted strings , which means they bypass all kinds of compile-time checks. What if the string does not contain a valid SQL query? What if a column has been renamed in the database?
• The same applies for the parameters and for the result sets : they are loosely defined. Are the columns of the type we expect? Also, are we sure we’re using the correct number of parameters? Are the names of the parameters in sync between the query and the parameter declarations?
• The classes we use are dedicated to SQL Server and cannot be used with another database server. Naturally, we could use DbConnection and its friends to avoid this issue, but that would solve only half of the problem. The real problem is that SQL has many vendor-specific dialects and data types. The SQL we write for a given DBMS is likely to fail on a different one.

• To be able to work with any of these technologies or languages individually
• To mix and match them to build a rich and coherent solution

• A good knowledge of the tools is required before being able to use them efficiently and avoid performance issues.
• Optimal use still requires knowledge of how to work with a relational database.
• Mapping tools are not always as efficient as handwritten data-access code.
• Not all the tools come with support for compile-time validation.

• Relational databases are based on relational algebra and are all about tables, rows, columns, and SQL.
• XML is all about documents, elements, attributes, hierarchical structures, and XPath.
• Object-oriented general-purpose programming languages and .NET live in a world of classes, methods, properties, inheritance, and loops.

• Fundamentally different technologies
• Different skill sets
• Different staff and ownership for each of the technologies
• Different modelling and design principles

• We get compile-time checking for all queries. Unlike SQL statements today, where we typically only find out at runtime if something is wrong, this means we can check during development that our code is correct. The direct benefit is a reduction of the number of problems discovered late in production. Most of the time, issues come from human factors. Strongly typed queries allow us to detect early typos and other mistakes made by the developer in charge of the keyboard.
• We get IntelliSense within Visual Studio when writing LINQ queries. This not only makes typing faster, but also makes it much easier to work against both simple and complex collection and data source object models.

• A control flow extension for asynchronous wide-area concurrency (formerly known as Polyphonic C#)
• A data type extension for XML and database manipulation (formerly known as Xen and as X#)

• Visual C# 2008 Express Edition
• Visual Basic 2008 Express Edition
• Visual Web Developer 2008 Express Edition
• Visual Studio 2008 Standard Edition or higher

• SQL Server 2005 Express Edition or SQL Server 2005 Compact Edition
(included with most versions of Visual Studio)
• SQL Server 2005
• SQL Server 2000a
• A later version of SQL Server⁹

hello
linq
world

Words of length     9
   beautiful
   wonderful
Words of length     5
   hello
   world
Words of length     4
   linq

decimal totalAmount = orders.Sum(order => order.Amount);

class Book
{
  public string Publisher;
  public string Title;
  public int Year;

  public Book(string title, string publisher, int year)
  {
    Title = title;
    Publisher = publisher;
    Year = year;
  }
}

Public Class Book
  Public Publisher As String
  Public Title As String
  Public Year As Integer

  Public Sub New( _
      ByVal title As String, _
      ByVal publisher As String, _
      ByVal year As Integer)
    Me.Title = title
    Me.Publisher = publisher
    Me.Year = year
  End Sub
End Class

Book[] books = new Book[] {
  new Book("Ajax in Action", "Manning", 2005),
  new Book("Windows Forms in Action", "Manning", 2006),
  new Book("RSS and Atom in Action", "Manning", 2006)
};

<books>
  <book title="Windows Forms in Action">
    <publisher>Manning</publisher>
  </book>
  <book title="RSS and Atom in Action">
    <publisher>Manning</publisher>
  </book>
</books>

from contact in contacts
where contact.City == "Paris"
select contact;

from contact in db.GetTable<Contact>()
where contact.City == "Paris"
select contact;

[Table(Name="Contacts")]
class Contact
{
  public int ContactID;
  public string Name;
  public string City;
}

[Table(Name="Contacts")]
class Contact
{
   [Column(IsPrimaryKey=true)]
   public int ContactID { get; set; }
   [Column(Name="ContactName"]
   public string Name { get; set; }
   [Column]
   public string City { get; set; }
}

string path = Path.GetFullPath(@"..\..\..\..\Data\northwnd.mdf");
DataContext db = new DataContext(path);

Table<Contact> contacts = db.GetTable<Contact>();

Bonjour Marie Bertrand
Bonjour Dominique Perrier
Bonjour Guylène Nodier

SELECT [t0].[ContactID], [t0].[ContactName] AS [Name], [t0].[City]
FROM [Contacts] AS [t0]
WHERE [t0].[City] = @p0

• Opening a connection to the database
• Generating the SQL query
• Executing the SQL query against the database
• Creating and filling our objects out of the tabular results

• Queries explicitly written SQL in quotes
• No compile-time checks
• Loosely bound parameters
• Loosely typed result sets
• More code required
• More knowledge required

1. "It was like you had to order your dinner in one language and drinks in another," said Jason McConnell, product manager for Visual Studio at Microsoft. "The direct benefit is programmers are more productive because they have this unified approach to querying and updating data from within their language."



2. Syntactic sugar is a term coined by Peter J. Landin for additions to the syntax of a computer language that do not affect its expressiveness but make it "sweeter" for humans to use. Syntactic sugar gives the programmer an alternative way of coding that is more practical, either by being more succinct or more like some familiar notation.



3. It is estimated that dealing with the task of storing and retrieving objects to and from data stores accounts for between 30 and 40 percent of a development team’s time.



4. We are talking only about relational databases here because this is what is used in the vast majority of business applications. Object-oriented databases offer a different approach that allows persisting objects more easily. Whether object-oriented databases are better than relational databases is another debate, which we are not going to address in this book.



5. WinFS was a project for a relational file system Microsoft had been developing for Windows. It was canceled in 2006.



6. A server-side implementation of XQuery is included with SQL Server 2005, and now that the XQuery standard has been finalized, Microsoft is once again considering whether to add support for XQuery in .NET.



7. Nevertheless, .NET 2.0 Service Pack 1 is required for LINQ to SQL.



8. Release To Manufacturing.



9. The new data types provided by SQL Server 2008 are not supported by the first release of LINQ to SQL.



10. Here we use public fields in the Book class for the sake of simplicity, but properties and private fields would be better. Another option is to use auto-implemented properties, which is a new feature of C# 3.0. You’ll see auto-implemented properties in action in chapters 2, 7, and 13.



11. See the CSharpSamples.zip and VBSamples.zip files in the Samples subfolder of your Visual Studio 2008 installation folder.



12. It should be noted that while LINQ to SQL includes a lot of functionality, its narrow focus means it doesn’t include some of the features found in other object-relational mapper products available today on the market. In 2008, Microsoft will be providing an even broader object-relational mapping solution: the ADO.NET Entity Framework. We will include a quick introduction to it after discussing LINQ to SQL later in this book.