Introducing LINQ!

Throughout this week and beyond, we’re going to be doing a lot of talking about Project LINQ, so I wanted to start with a relatively brief overview of what the project is, what its goals are, and how they apply to VB.

To start with, LINQ stands for “Language Integrated QUery.” LINQ fundamentally is about integrating query operations into the .NET platform in a comprehensive and open manner. It’s also about providing a unified way for you to query across any kind of data that you have in your program, whether it’s relational, objects or XML. This, we believe, will represent a tectonic shift in the way that VB programmers will work with data. The possibilities that having query capabilities always available right at your fingertips, regardless of the type of data you’re working with, are immense and will fundamentally alter the way people program.

The core of LINQ is a set of API patterns. I say “patterns” instead of “interfaces” or “classes” because we want to maintain maximum flexibility in our ability to provide querying for any kind of data, regardless of whether it has a particular object model or interface implemented. These API patterns specify how an object model can become “queryable,” and they cover all the basic query operations that we know and love: projection (select), filter (where), grouping (group by), ordering (order by), joining (join), etc. By implementing this API pattern, any data provider on .NET can become queryable. There is also a lot of flexibility as to how a data provider can become flexible — i.e., whether it wants to delegate most of the work on querying or whether it wants to do all the work itself.

(It’s also important to note that these patterns are fully compatible with .NET 2.0 and require no additional platform features. They’re totally implementable in VS 2005, so you won’t need a new CLR to use them.)

We will also be providing three implementations of the LINQ API patterns that cover 95% of the types of data that people need to query: relational, object and XML. First, we will provide a set of “standard query operators” that will make the interface IEnumerable(Of T), the fundamental collection interface on the .NET platforms, queryable. Second, we will provide a component called “DLinq” that implements a query-enabled object/relational mapping service which allows querying over remote relational data. And third, we will provide a component called “XLinq” that implements a very lightweight, query-enabled XML DOM. By hitting each element of the ROX equation, we believe we will provide a query solution for most situations right out of the box.

Now we get to the languages, which is where the fun really starts. Any .NET-enabled language is free to build extra language support on top of the LINQ API patterns, and VB and C# have already begun to do so. Although you are welcome to call the lower-level APIs directly if you like, VB will provide a set of “query comprehensions” that provide a very natural, SQL-like syntax on top of the LINQ APIs. For example, if you have an array of Customer objects, you can write a query that looks like this:

Dim custs() As Customer = ...
Dim waCusts = Select c.Name, c.City From c In custs Where c.State = “WA”

This high-level syntax then compiles down to calls to the standard LINQ APIs. This means that you can learn a very simple, natural query language that then applies across any component that is query-enabled, including the standard query operators, DLinq, and XLinq. (C# will also be providing a high level syntax that is similar, but not the same. We’ll be talking about some of the differences as we dig more into the syntax.)

So far we’ve been discussing things that are general to the platform or apply to both VB and C# (modulo the differences in approaches). However, there are a several things that are specific to VB that play a role in the LINQ project.

The first is that we’ve been working on several features that we believe will make working with dynamic data easier. By “dynamic data,” I mean data whose schema is flexible, malleable or likely to change. The best example of this is XML data — although there is plenty of highly schematized XML out there, there is a vast sea of XML data for which no schema information exists or for which there is no 100% solid schema (RSS is a perfect example). For languages that understand only static type information, this means that when you deal with dynamic data, you frequently have to do a lot of extra work to access information, for example you end up writing:

XElement ord = ...;
int amount = (int)ord.Element(“amount”);

instead of something much more natural like:

Dim ord As Order
Dim amount As Integer = ord.amount

So, what we’ve been doing is taking VB’s historical embrace of dynamic binding (aka “late binding”) and extending it further to make working with dynamic data such as XML and relational much easier.

The other major thing we’ve been working on is making it much more natural to read and produce XML data. XML has become the lingua franca of the Internet and XML should be as easy as possible to work with. We’ve been exploring ways to take the XLinq API and add syntax that looks and feels very natural, but still compiles down to regular API calls:

Dim orderAmount As Integer = 10
Dim order As XElement = _

<% orderAmount %>

Dim orderDate As Date = CDate(order.@date)

As you can see, the LINQ project is extremely ambitious and this blog entry has just scratched the surface. In conjunction with the PDC, we are releasing a bunch of preliminary information about LINQ and about VB LINQ support specifically. There are documents describing in more detail a lot of what I discussed here today, as well as pointers to preliminary bits. (I would emphasize that word “preliminary” as in “lots of things don’t work yet.” We expect to roll out new bits regularly as functionality comes online.) I encourage everyone who’s interested to check them out and then check back here regularly. I’ll be talking in more detail about a lot of this stuff as time goes on and we’re looking forward to your feedback!

Tag:

25 thoughts on “Introducing LINQ!

  1. Pingback: Sam Gentile's Blog

  2. Pingback: PaulY's Weblog

  3. Pingback: RedoBlog - The .NET Gentleman !!

  4. Pingback: Ken Schaefer

  5. Pingback: AprilR's WebLog

  6. Pingback: C# Nuggets

  7. Pingback: Brad McCabe's WebLog

  8. Pingback: David Hayden - Sarasota Web Desi

  9. Pingback: guidmaster´s .NET blog

  10. Pingback: VS Data Team's WebLog

  11. Pingback: Bill Evjen's Blog

  12. Pingback: Daniel Moth

  13. Unilynx

    Sounds like what we’ve been doing for five years already 🙂

    HareScript is a scripting language we developed for a CMS – it removes the database layer and allows using SQL in web statements. It can select from many different sources: databases, file systems, self-generated arrays, and even perform joins between these different types.

    Reply
  14. Pingback: Panopticon Central

  15. Pingback: guidmaster´s .NET blog

  16. andrew

    i have created a dataset using the .net ide. and am trying to populate the dataset and display it in the crystal report. i encounter the logon error. The code for poppulating dataset is given below. any sugesstions would be deeply apriciated

    // this code is written inside formload

    String conString="Provider=Microsoft.Jet.OLEDB.4.0;User ID=admin;Data Source=E:/asdf/report/receipt.mdb";

    String SQLString="Select * from receiptclient";

    SqlDataAdapter oDAdap=new SqlDataAdapter(SQLString,conString);

    DataSet odataset =new DataSet("mydataset");

    oDAdap.Fill(odataset);

    Reply
  17. Fernando

    I still don´t understand what are the benefits of LINQ. Instead of programming DataBase stored procedures as .NET programs we are trying to embed SQL Code inside your code.

    It sounds like the old Power Builder where you can do similar things.

    I think there is also a very dangerous (an also kind of very dirty) thing embed SQL Code into your bussiness or web tiers

    I just what I think for now.

    Fer

    Reply
  18. Pingback: Anonymous

Leave a Reply