LINQ in Action - THE LINQ book

LINQ or Lync?

Fabrice Marguerie — Fri, 01 Oct 2010 22:11:00 GMT

There's a new "link" from Redmond. It's not LINQ this time, but Lync.
Isn't it great to have two names colliding in the Microsoft world?

Is someone working on LINQ to Lync?

Object databases for .NET with LINQ support

Fabrice Marguerie — Wed, 29 Sep 2010 21:52:00 GMT

More and more database management systems offer built-in support for LINQ.

I've just tested some lightweight object database engines for .NET. See this post on my blog.

LINQ in Action now in Chinese

jwooley — Sat, 10 Jul 2010 19:24:00 GMT

Today, I received an unexpected surprise in the mail. A copy of LINQ in Action translated into Chinese. We were aware that someone was making a Chinese translation, but only expected it to be a couple chapters. It turns out the entire book, including the bonus chapter 14 (LINQ to Datasets) which didn't make the printed English version of the book. Hopefully nothing got lost in translation for this version. If you read Chinese, check the book out and let us know what you Thinq.

Hex Dump using LINQ (in 7 lines of code)

Fabrice Marguerie — Fri, 12 Mar 2010 19:34:00 GMT

Eric White has posted an interesting LINQ query on his blog that shows how to create a Hex Dump in something like 7 lines of code.

Of course, this is not production grade code, but it's another good example that demonstrates the expressiveness of LINQ.

Here is the code:

byte[] ba = File.ReadAllBytes("test.xml");
int bytesPerLine = 16;
string hexDump = ba.Select((c, i) => new { Char = c, Chunk = i / bytesPerLine })
    .GroupBy(c => c.Chunk)
    .Select(g => g.Select(c => String.Format("{0:X2} ", c.Char))
        .Aggregate((s, i) => s + i))
    .Select((s, i) => String.Format("{0:d6}: {1}", i * bytesPerLine, s))
    .Aggregate("", (s, i) => s + i + Environment.NewLine);
Console.WriteLine(hexDump);

Here is a sample output:

000000: FF FE 3C 00 3F 00 78 00 6D 00 6C 00 20 00 76 00
000016: 65 00 72 00 73 00 69 00 6F 00 6E 00 3D 00 22 00
000032: 31 00 2E 00 30 00 22 00 20 00 65 00 6E 00 63 00
000048: 6F 00 64 00 69 00 6E 00 67 00 3D 00 22 00 75 00
000064: 3E 00

Eric White reports that he typically notices that declarative code is only 20% as long as imperative code.

LINQ to CSV using DynamicObject

jwooley — Sun, 22 Nov 2009 17:31:00 GMT

When we wrote LINQ in Action we included a sample of how to simply query against a CSV file using the following LINQ query:


From line In File.ReadAllLines(“books.csv”) 
Where Not Line.StartsWith(“#”) 
Let parts = line.Split(“,”c) 
Select Isbn = parts(0), Title = parts(1), Publisher = parts(3)

While this code does make dealing with CSV easier, it would be nicer if we could refer to our columns as if they were properties where the property name came from the header row in the CSV file, perhaps using syntax like the following:


From line In MyCsvFile
Select line.Isbn, line.Title, line.Publisher

With strongly typed (compile time) structures, it is challenging to do this when dealing with variable data structures like CSV files. One of the big enhancements that is coming with .Net 4.0 is the inclusion of Dynamic language features, including the new DynamicObject data type. In the past, working with dynamic runtime structures, we were limited to using reflection tricks to access properties that didn't actually exist. The addition of dynamic language constructs offers better ways of dispatching the call request over dynamic types. Let's see what we need to do to expose a CSV row using the new dynamic features in Visual Studio 2010.

First, let's create an object that will represent each row that we are reading. This class will inherit from the new System.Dynamic.DynamicObject base class. This will set up the base functionality to handle the dynamic dispatching for us. All we need to do is add implementation to tell the object how to fetch values based on a supplied field name. We'll implement this by taking a string representing the current row. We'll split that based on the separator (a comma). We also supply a dictionary containing the field names and their index. Given these two pieces of information, we can override the TryGetMember and TrySetMember to Get and Set the property based on the field name:


Imports System.Dynamic

Public Class DynamicCsv
    Inherits DynamicObject

    Private _fieldIndex As Dictionary(Of String, Integer)
    Private _RowValues() As String

    Friend Sub New(ByVal currentRow As String,
                   ByVal fieldIndex As Dictionary(Of String, Integer))
        _RowValues = currentRow.Split(","c)
        _fieldIndex = fieldIndex
    End Sub

    Public Overrides Function TryGetMember(ByVal binder As GetMemberBinder,
                                           ByRef result As Object) As Boolean
        If _fieldIndex.ContainsKey(binder.Name) Then
            result = _RowValues(_fieldIndex(binder.Name))
            Return True
        End If
        Return False
    End Function

    Public Overrides Function TrySetMember(ByVal binder As SetMemberBinder,
                                           ByVal value As Object) As Boolean
        If _fieldIndex.ContainsKey(binder.Name) Then
            _RowValues(_fieldIndex(binder.Name)) = value.ToString
            Return True
        End If
        Return False
    End Function
End Class

With this in place, now we just need to add a class to handle iterating over the individual rows in our CSV file. As we pointed out in our book, using File.ReadAllLines can be a significant performance bottleneck for large files. Instead we will implement a custom Enumerator. In our customer enumerable, we initialize the process with the GetEnumerator method. This method opens the stream based on the supplied filename. It also sets up our dictionary of field names based on the values in the first row. Because we keep the stream open through the lifetime of this class, we implement IDisposable to clean up the stream.

As we iterate over the results calling MoveNext, we will read each subsequent row and create a DynamicCsv instance object. We return this row as an Object (Dynamic in C#) so that we will be able to consume it as a dynamic type in .Net 4.0. Here's the implementation:


Imports System.Collections

Public Class DynamicCsvEnumerator
    Implements IEnumerator(Of Object)
    Implements IEnumerable(Of Object)

    Private _FileStream As IO.TextReader
    Private _FieldNames As Dictionary(Of String, Integer)
    Private _CurrentRow As DynamicCsv
    Private _filename As String

    Public Sub New(ByVal fileName As String)
        _filename = fileName
    End Sub

    Public Function GetEnumerator() As IEnumerator(Of Object) _
        Implements IEnumerable(Of Object).GetEnumerator

        _FileStream = New IO.StreamReader(_filename)
        Dim headerRow = _FileStream.ReadLine
        Dim fields = headerRow.Split(","c)
        _FieldNames = New Dictionary(Of String, Integer)
        For i = 0 To fields.Length - 1
            _FieldNames.Add(GetSafeFieldName(fields(i)), i)
        Next
        _CurrentRow = New DynamicCsv(_FileStream.ReadLine, _FieldNames)

        Return Me
    End Function

    Function GetSafeFieldName(ByVal input As String) As String
        Return input.Replace(" ", "_")
    End Function

    Public Function GetEnumerator1() As IEnumerator Implements IEnumerable.GetEnumerator
        Return GetEnumerator()
    End Function

    Public ReadOnly Property Current As Object Implements IEnumerator(Of Object).Current
        Get
            Return _CurrentRow
        End Get
    End Property

    Public ReadOnly Property Current1 As Object Implements IEnumerator.Current
        Get
            Return Current
        End Get
    End Property

    Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext
        Dim line = _FileStream.ReadLine
        If line IsNot Nothing AndAlso line.Length > 0 Then
            _CurrentRow = New DynamicCsv(line, _FieldNames)
            Return True
        Else
            Return False
        End If
    End Function

    Public Sub Reset() Implements IEnumerator.Reset
        _FileStream.Close()
        GetEnumerator()
    End Sub

#Region "IDisposable Support"
    Private disposedValue As Boolean ' To detect redundant calls

    ' IDisposable
    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                _FileStream.Dispose()
            End If
            _CurrentRow = Nothing
        End If
        Me.disposedValue = True
    End Sub

    ' This code added by Visual Basic to correctly implement the disposable pattern.
    Public Sub Dispose() Implements IDisposable.Dispose
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub
#End Region

End Class

Now that we have our custom enumerable, we can consume it using standard dot notation by turning Option Strict Off in Visual Basic or referencing it as a Dynamic type in C#:

VB:



Public Sub OpenCsv()
    Dim data = New DynamicCsvEnumerator("C:\temp\Customers.csv")
    For Each item In data
        TestContext.WriteLine(item.CompanyName & ": " & item.Contact_Name)
    Next

End Sub

C#:


[TestMethod]
public void OpenCsvSharp()
{
    var data = new DynamicCsvEnumerator(@"C:\temp\customers.csv");
    foreach (dynamic item in data)
    {
        TestContext.WriteLine(item.CompanyName + ": " + item.Contact_Name);
    }
}

In addition, since we are exposing this as an IEnumerable, we can use all of the same LINQ operators over our custom class:

VB:


Dim query = From c In data
            Where c.City = "London"
            Order By c.CompanyName
            Select c.Contact_Name, c.CompanyName

For Each item In query
    TestContext.WriteLine(item.CompanyName & ": " & item.Contact_Name)
Next

C#:


[TestMethod]
public void LinqCsvSharp()
{
    var data = new DynamicCsvEnumerator(@"C:\temp\customers.csv");
    var query = from dynamic c in data 
                where c.City == "London"
                orderby c.CompanyName
                select new { c.Contact_Name, c.CompanyName };

    foreach (var item in query)
    {
        TestContext.WriteLine(item.CompanyName + ": " + item.Contact_Name);
    }
}

Note: This sample makes a couple assumptions about the underlying data and implementation. First, we take an extra step to translate header strings that contain spaces to replace the space with an underscore. While including spaces is legal in the csv header, it isn't legal in VB to say: " MyObject.Some Property With Spaces". Thus we'll manage this by requiring the code to access this property as follows: "MyObject.Some_Property_With_Spaces".

Second, this implementation doesn't handle strings that contain commas. Typically fields in CSV files that contain commas are wrapped by quotes (subsequently quotes are likewise escaped by double quotes). This implementation does not account for either situation. I purposely did not incorporate those details in order to focus on the use of DynamicObject in this sample. I welcome enhancement suggestions to make this more robust.

Crossposted from ThinqLinq.com

New LINQ tools category on SharpToolbox.com

Fabrice Marguerie — Sat, 03 Oct 2009 12:55:00 GMT

I've just moved the LINQ tools referenced on SharpToolbox.com to a new dedicated LINQ category.
20 tools and providers are listed for the moment. I'll add more shortly.

See Jim's blog for more resources.

LINQ in Action is now available in Chinese (LINQ实战) and in English in India

Fabrice Marguerie — Wed, 22 Jul 2009 18:54:00 GMT

After English, German, Spanish, and Portuguese, LINQ in Action is now available in Chinese (中文).

The title is LINQ实战. The publisher is 人民邮电出版社 (Posts & Telecom Press). The book is also available on Amazon.cn/joyo and several other bookstores.

In addition to all the translations, LINQ in Action has been republished in English in India by DreamTech Press.

LINQ in Action XML samples now in LINQPad too

Fabrice Marguerie — Sun, 28 Jun 2009 18:58:00 GMT

After we published the code samples for LINQ in Action's first chapters in LINQPad a few weeks ago, the samples of three more chapters have just been added. These chapters cover LINQ to XML. Thanks Jim for doing the additional conversion.

The code samples for chapters 1 to 11 are now available. Read the original announcement to learn how to download and use these samples. A new download is enough to get the update.

LINQ in Action samples in LINQPad

Fabrice Marguerie — Sat, 06 Jun 2009 11:12:00 GMT

Do you know LINQPad? It's a really simple but great tool for testing LINQ queries. Not only that, but it can be used to test all kinds of C# and VB code snippets.

Another great thing about LINQPad is that it comes with code samples. Until now the integrated code samples came from the C# 3.0 in a Nutshell book. Joe Albahari, author of LINQPad and C# 3.0 in a Nutshell, has opened LINQPad so that code samples from other books can be integrated into LINQPad. Thanks Joe for this opportunity!

We worked with Joe to integrate LINQ in Action's code samples into LINQPad. The result is that in addition to being available as Visual Studio solutions and projects, you can now run our code samples directly from LINQPad. This makes it very easy to explore LINQ's features with instant "code and play".

To install LINQ in Action's code samples in LINQPad, all you have to do is click on the "Download more samples..." link:

You'll see LINQ in Action proposed as one of the LINQPad-enabled books (the only one at the moment, in fact):

Once you've clicked on "Download full code listings into LINQPad", you should see the C# and VB samples grouped by chapter:

Currently, chapters 1 to 8 are available. We'll integrate the remaining code samples soon.

Have fun with LINQ!

ForEach debate continued

Fabrice Marguerie — Thu, 21 May 2009 08:04:00 GMT

Eric Lippert, whose blog you shouldn't miss, adds his own arguments to the debate about whether using a ForEach extension method instead of foreach is a good idea or a bad one.

I don't see a definitive answer to the question. All the arguments given here and elsewhere are good, but in the end, it's up to you to decide what you prefer to do.
Read the posts and the comments to make up your own mind.

LINQ em Ação, LINQ in Action in Portuguese

Fabrice Marguerie — Wed, 20 May 2009 12:03:00 GMT

After English, German and Spanish, LINQ in Action is now available em Português.

The title is LINQ em Ação. The publisher is Editora Ciência Moderna.

LINQ in Action in Spanish

Fabrice Marguerie — Thu, 16 Apr 2009 21:44:00 GMT

Today I had the pleasure to receive a copy of LINQ in Action translated in Spanish. This came a bit unexpected, but it's great!

LINQ in Action already existed in German (LINQ im Einsatz), and I know that other translations should be published soon. The Chinese version is the next one expected, I believe.

The Spanish version of the book is published by Anaya Multimedia. The title of the book is simply... "LINQ"!

¡Espero que disfruten la lectura de este libro!

LINQ Deep Dive: great LINQ tips

Fabrice Marguerie — Fri, 03 Apr 2009 07:50:00 GMT

Zeeshan Hirani who already offered us a 500-page Entity Framework learning guide, now publishes great LINQ tips in the first part of his LINQ Deep Dive articles. These tips are not the usual introductions to LINQ features you can find elsewhere. You can tell that they come from someone who lives in the trenches. I learnt very interesting features and best practices I didn't know about.

Apply filters before a join to improve query performance
Filter LINQ queries using object reference comparison
Apply aggregates to empty collections in LINQ to SQL queries
Delay loading a property in LINQ to SQL
Use table-valued functions with eager loading turned on
Put joins in the correct order in a LINQ to Objects query
Compose a LINQ query inside a loop

LINQ Deep Dive: Part I, Tips for Delving in to LINQ

ForEach or not ForEach, that is the question

Fabrice Marguerie — Wed, 25 Feb 2009 16:19:00 GMT

In LINQ in Action, we discuss about the missing ForEach query operator. This is in Chapter 5 "Beyond basic in-memory queries", more precisely in section 5.2.2. There, we indicate that Eric White suggested this operator in his functional programming tutorial, although I'm not able to find the exact reference at the moment in this tutorial.

Since then, a lot of people have been asking for ForEach. This can be seen on Kirill Osenkov's blog, where you'll find links to discussions about whether ForEach is good or bad.
I don't know if we're going to see ForEach appear in .NET. Anyway, it's not very difficult to write your own:

public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
if (source == null)
    throw new ArgumentNullException("source");
if (action == null)
    throw new ArgumentNullException("action");

foreach (var item in source)
    action(item);
}

Converting LINQ queries from query syntax to method/operator syntax

Fabrice Marguerie — Fri, 06 Feb 2009 15:05:00 GMT

Yesterday a reader of the LINQ in Action book posted an interesting challenge on the book's forum. It's interesting enough to be reposted it here.

The request was to convert a LINQ query expression (query syntax) to a query operator call chain (method syntax or dot notation). The original query was the following one:

from publisher in SampleData.Publishers
join book in SampleData.Books on publisher equals book.Publisher into publisherBooks
from book in publisherBooks.DefaultIfEmpty()
select new
{
Publisher = publisher.Name,
Book = book == default(Book) ? "(no books)" : book.Title
};

This query comes from LINQ in Action. In chapter 4 more precisely, where we cover grouping and joins.

Converting LINQ queries is an interesting exercise because it's not always easy to find the solution but you learn a lot in the process. Often, you'll have to use "tricks". Here the tricks are based on the use of anonymous types. Side note: this is also what you'd use to translate the let keyword.

Here is the solution I gave:

SampleData.Publishers
.GroupJoin(SampleData.Books,
    publisher => publisher, book => book.Publisher,
    (publisher, publisherBooks) => new { Publisher = publisher, PublisherBooks = publisherBooks })
.SelectMany(
    group => group.PublisherBooks.DefaultIfEmpty<Book>(),
    (group, book) => new {
      Publisher = group.Publisher.Name,
      Book = (book == null) ? "(no books)" : book.Title
    });

Not as easy to read as your original query, don't you think? See my previous post about Query syntax vs. Method syntax to decide which syntax is best for you.

"How did he manage to convert the query," you may be wondering... Well, even if I know the tricks, the easiest is to use .NET Reflector to decompile the IL.
If you specify ".NET 3.5" for the Optimization option, you'll see the query expression. But if you specify ".NET 2.0", you'll see something that looks close to the above query. You'll have to replace the anonymous methods with lambda expressions and change the name of the anonymous parameters to make the code somewhat more readable, though.

As usual, Reflector is your best friend. It reveals a lot of secrets ;-)

Update: Joe Albahari, of LINQPad fame, suggested other solutions:

1) Calling .ToString() on the query's expression will work just fine if you add AsQueryable() to the first sequence: from publisher in SampleData.Publishers.AsQueryable() join book...
2) If you use LINQPad to run the query, you'll notice it shows lambda translations for all IQueryable-based queries. LINQPad uses its own expression visitor so the result is much more readable than simply calling ToString on the expression.

LINQ to SQL supported data types and functions

jwooley — Wed, 21 Jan 2009 09:02:00 GMT

When we were writing LINQ in Action, we weren't able to specify all of the possible methods and functions that have supported LINQ to SQL query translations for a couple reasons.

There were too many to be included in the scope of the book.
The book was being written at the same time that LINQ was evolving and more comprehensions were being supported, thus giving us a moving target that we couldn't ensure the accuracy of when the product shipped.
We realized that over time, translations for more functions may be added and enumerating the list in the book might not reflect the current methods supported with a given framework version.

As I was searching for an answer to a recent question, I happened upon a listing on MSDN showing the functions and methods which are and are not supported. The full list of LINQ to SQL supported and unsupported members is available online at http://msdn.microsoft.com/en-us/library/bb386970.aspx.

As an example the following methods are shown as having translations for DateTime values: Add, Equals, CompareTo, Date, Day, Month, Year. In contrast methods like ToShortDateString, IsLeapYear, ToUniversalTime are not supported.

If you need to use one of the unsupported methods, you need to force the results to the client and evaulate them using LINQ to Objects at that point. You can do that using the .AsEnumerable extension method at any point in the query comprehension. Any portion of the query that follows AsEnumerable will be evaluated on the client side.

Crossposted from http://www.thinqlinq.com/Default/LINQ-supported-data-types-and-functions.aspx

IQToolkit, building your own LINQ IQueryable provider

Fabrice Marguerie — Sat, 22 Nov 2008 21:59:00 GMT

Matt Warren, who provides the most detailed HOWTO for creating your own LINQ IQueryable provider, has now published a dedicated toolkit on CodePlex:

IQToolkit is essential if you are building your own LINQ IQueryable provider. It contains common tools and source code you can apply to your own project.
In the toolkit you will find useful techniques for manipulating LINQ expression trees, implementing IQueryable providers, and a host of extensible components for building providers that target translation of LINQ expressions into SQL like languages.

http://www.codeplex.com/IQToolkit

Creating a LINQ provider is not a walk in the park, but at least if you have to, you have everything you need at hand.

Using the Select LINQ query operator with indexes

Fabrice Marguerie — Mon, 10 Nov 2008 17:59:00 GMT

Yesterday, Fred asked me if I could help him to convert C# code to LINQ. The solution may not obvious to find unless you know LINQ well. I will reproduce here the solution I gave Fred. Whether the LINQ version of the code is easier to read than the original one is arguable. The purpose here is more to show LINQ's Select query operator in action.

Here is the original code:

int CountCorrectChars(string proposedValue, string correctValue)
{
  int correctCount = 0;
  for (int i = 0; i < proposedValue.Length && i < correctValue.Length; i++)
    if (proposedValue[i] == correctValue[i])
      correctCount++;
  return correctCount;
}

Here is the LINQ version that I suggested:

int CountCorrectChars(string proposedValue, string correctValue)
{  
  return correctValue
    .Select((testChar, index) => new { Character = testChar, Index = index })
    .Count(testChar => (testChar.Index < proposedValue.Length)
        && (testChar.Character  == proposedValue[testChar.Index]));
}

As you can see, the LINQ version is not so easy to understand and is verbose. Of course, we could use shorter names, but that wouldn't change the complexity of the query. The LINQ version is not as good in terms of performance either... So, should we use LINQ or not? My point here is that LINQ is not a "one size fits all" solution. You should use it wisely and avoid complexifying code by choosing always to use LINQ.

What's interesting in this example, is also simply the use of Select with a two-parameter lambda expression. You may know the version of Select that takes a single-parameter lambda well, but its counterpart is less known (and used).

This is something that we cover in LINQ in Action in section 4.4.2. Here is what we write there, which gives another example of Select in action:

The Select and SelectMany operators can be used to retrieve the index of each element in a sequence. Let’s say we want to display the index of each book in our collection before we sort them in alphabetical order:

index=3         Title=All your base are belong to us
index=4         Title=Bonjour mon Amour
index=2         Title=C# on Rails
index=0         Title=Funny Stories
index=1         Title=LINQ rules

Here is how to use Select to achieve that:

Listing 4.15    Code-behind for the first ASP.NET page    (SelectIndex.csproj)
var books =
SampleData.Books
    .Select((book, index) => new { index, book.Title })
    .OrderBy(book => book.Title);
ObjectDumper.Write(books);

This time we can’t use the query expression syntax because the variant of the Select operator that provides the index has no equivalent in this syntax. Notice that this version of the Select method provides an index variable that we can use in our lambda expression (precision not in the book: its not the name "index" that is important. You can use another name if you want. What makes the difference is that the lambda expression takes two parameters). The compiler automatically determines which version of the Select operator we want to use just by looking at the presence or absence of the index parameter. Notice also that we call Select before OrderBy. This is important to get the indices before the books are sorted, not after.

...One more tool in your toolbox. Now, use it wisely.

Update: Mark Sowul suggests a simpler solution:

return correctValue.Where((testChar, index) => index < proposedValue.Length && testChar == proposedValue[index]).Count();

Somehow I missed that Where overload.

See you at TechEd EMEA in Barcelona next week

Fabrice Marguerie — Mon, 03 Nov 2008 21:42:00 GMT

I'll be at TechEd in Barcelona next week. I'll be at the Ask The Experts booths a few hours during the week. Feel free to come and say hello. I'll be available if you want to discuss about LINQ, the LINQ in Action book, WPF and Silverlight, my projects, or .NET in general :-)

Please ping me if you'll be there too and would like to meet.

Speaking at DevTeach Montreal in December

Fabrice Marguerie — Thu, 25 Sep 2008 16:11:00 GMT

DevTeach Montréal will take place this year between December 1 and 5. I have the pleasure to take part to this event and speak in no less than five sessions!

Here are my sessions, all in French:

Tout d'abord une série de quatre sessions que j'ai le plaisir de présenter avec Frédéric Schäfer. Il s'agit d'une reprise enrichie de notre session de l'Université du SI.
Ces sessions vous permettrons de découvrir LINQ, Entity Framework, WPF, Silverlight et WCF en action.
Il n'est pas nécessaire d'assister à l'ensemble des quatre sessions. Vous pouvez très bien n'assister qu'à certaines sessions. Nous fournirons un bref récapitulatif des épisodes précédents au début de chaque session.

Application Order Tracking - 1/4 - Créer un modèle métier testé avec Entity Framework et manipuler des données avec LINQ
Application Order Tracking - 2/4 - Développer une interface utilisateur riche et testable avec WPF en utilisant des design patterns
Application Order Tracking - 3/4 - Persister ses objets avec Entity Framework et adapter l'interface utilisateur en conséquence
Application Order Tracking - 4/4 - Développer une application Silverlight distribuée avec WCF

Je présente également une session en solo : Nouveautés des langages C# 3.0 et VB 9.0 (LINQ)
Il s'agit d'une reprise de la session d'Introduction à LINQ, C# 3.0 et VB 9.0 que j'ai jouée avec Philippe Mougin durant les Microsoft TechDays France.

Frédéric présente une session en solo : Développement piloté par les tests.

Toutes les sessions sont détaillées sur le site de DevTeach.

Rendez-vous donc début décembre pour retrouver avec nous la fraîcheur de Montréal à cette époque et la chaleur de nos amis québécois !

Visual Studio Talk Show podcast about LINQ

Fabrice Marguerie — Mon, 15 Sep 2008 09:22:00 GMT

In July, I was invited by Mario Cardinal and Guy Barrette to register a session for their Visual Studio Talk Show podcast. This session is now online. During one hour, Guy, Mario and I discuss about LINQ in French.

You can find the podcast here. I hope that you'll enjoy it and that it'll help you to learn more about LINQ's whats, whys and hows.

I'd like to thank Mario and Guy for giving me this opportunity. It was a very good experience!

LINQ im Einsatz, LINQ in Action in German

Fabrice Marguerie — Wed, 27 Aug 2008 20:59:00 GMT

Today, I received a copy of LINQ im Einsatz. This is the German translation of LINQ in Action. It's now available from Amazon.de and from Hanser.

Bonus: The German version is bigger than the English one. It contains chapter 14, which covers LINQ to DataSet and is provided in English only as a PDF download from Manning's website.

Maybe we'll see translations in other languages next. French would be a good idea, for example ;-)

Viel Spaß beim Lesen!

Enabling the Expression Tree Visualizer in Visual Studio 2008

jwooley — Sun, 24 Aug 2008 23:43:00 GMT

In LINQ in Action, we discuss how to add the LINQ to SQL Query visualizer into the Visual Studio 2008 environment. This tool allows you to open a window during debug time to view the TSQL that is generated from the LINQ expression tree. It also allows you to run the query and view the results. If you're not familiar with it, check out this post by Scott Guthrie.

In addition to the query visualizer, you can also build and install the Expression Tree visualizer, not only as a separate application, but also as an integrated visualizer within Visual Studio 2008. To do this, download the Linq Samples from MSDN Code gallery. Inside of that, you can find a project for the ExpressionTreeVisualizer. To use it as a stand alone utility, build and run the ExpressionTreeVisualizersApplication. This is the method most people are familiar with.

Building the solution will also build the ExpressionTreeVisualizer library. This is the one you need to use to enable it in Visual Studio natively, copy the generated ExpressionTreeVisualizer.dll library and paste it into your ..\Program Files\Microsoft Visual Studio 9.0\Common7\Packages\Debugger\Visualizers directory.

Once you have placed the library in the visualizers directory, let's see what you can do to use the new visualizer . First, let's build a LINQ to SQL query:

   Dim query = From cust In dc.Customers _

                    Where cust.City = "London" _

                    Order By cust.CompanyName _

                    Select cust

Given this query, we need to access the expression object exposed by the IQueryable query object as follows:

        Dim queryExpression = query.Expression

Now, that we have our code set-up, set a breakpoint in your code after you have instantiated this queryExpression variable and debug your project. Now, if you hover over the query.Expression method, you'll see a new magnifying glass as shown below:

Clicking on the visualizer icon, will launch the visualizer tool revealing the following screen:

Sure, there's lots of information in there. The expression trees are quite complex. This tool helps you decipher them in cases where you need to either parse or dynamically create expression trees in your applications.

Object Identity tracking changes with LINQ to SQL SP1

jwooley — Thu, 21 Aug 2008 11:24:00 GMT

When we wrote LINQ in Action, we took a bit of time to explain how the identity tracking system worked with LINQ to SQL to make sure that changed objects were retained when subsequent queries are requested from a data context. In a nutshell, when you issue a query, the data context translates the LINQ query into TSQL and sends that to the database. The database returns the rowsets to LINQ to SQL. The provider checks the returned rows against those that it is already tracking from previous fetches and, rather than instantiating the object again, returns the object in its internal store. This is done primarily to ensure that changes a user has made in the course of his context's lifetime are retained rather than being overwritten.

We also discussed (p. 258 if you're following along) how there is a special optimization wherein if you are querying for a single result, the pipeline would check the internal cache first before looking at the database, thus reducing the overhead of repeated hits to the database. An astute reader checked out our claim, and sure enough that optimization did not make it into the RTM bits of VS 2008. We considered fixing this in the second printing, but consulted with the product teams first. It turns out that the intended behavior was indeed to include this optimization, but due to a last minute bug, it didn't make it in.

As Dinesh points out, this oversight has been fixed in SP1. Now, if you try to fetch a single object (using Single, SingleOrDefault, First, or FirstOrDefault), the in memory object cache will be checked based on the identity columns declared in the entity's structure. If a matching object is found, it will be returned, otherwise the record will be requested from the database.

.NET 3.5 SP1 LINQ improvements

Fabrice Marguerie — Tue, 12 Aug 2008 09:24:00 GMT

In May, I announced the changes related to LINQ that were included in .NET 3.5 Service Pack 1 Beta. Now that the SP1 is officially available, more changes have been announced.

The originally announced changes were:

The support for SQL Server 2008
The release of a new flavor of LINQ: LINQ to Entities, which comes with the ADO.NET Entity Framework

Dinesh Kulkarni announces new changes:

Performance improvements for LINQ to Objects queries
Cast<T> breaking change
Performance improvements for LINQ to SQL