Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

[LINQ via C# series]

So far LINQ to SQL data CRUD (Creating / Retrieving / Updating / Deleting) has been explained. This post takes a deeper look at the internal implementation of LINQ to SQL query.

The provider model

Unlike IEnumerable / IEnumerable<T>,  the IQueryable / IQueryable<T> need a query provider:

namespace System.Linq
{
    public interface IQueryable : IEnumerable
    {
        Type ElementType { get; }

        Expression Expression { get; }

        IQueryProvider Provider { get; }
    }

    public interface IQueryable<out T> : IEnumerable<T>, IQueryable, IEnumerable
    {
    }
}

And this is the definition of IQueryProvider:

namespace System.Linq
{
    public interface IQueryProvider
    {
        IQueryable CreateQuery(Expression expression);

        IQueryable<TElement> CreateQuery<TElement>(Expression expression);

        object Execute(Expression expression);

        TResult Execute<TResult>(Expression expression);
    }
}

Yes, IQueryable / IQueryable<T> are much more complex than IEnumerable / IEnumerable<T>, because they are supposed to work against non-.NET data source, like SQL Server database, etc.

Please also notice IOrderedQueryable and IOrderedQueryable<T>:

namespace System.Linq
{
    // The same as IQueryable.
    public interface IOrderedQueryable : IQueryable, IEnumerable
    {
    }
    
    // The same as IQueryable<T>.
    public interface IOrderedQueryable<out T> : IOrderedQueryable,
                                                IQueryable<T>, IQueryable,
                                                IEnumerable<T>, IEnumerable
    {
    }
}

They are the same as IQueryable and IQueryable<T>, and just used to represent an ordering query, like OrderBy(), etc.

Implement IQueryable<T> and IOrderedQueryable<T>

The best way to understand these interfaces is just creating IQueryable / IQueryable<T> objects, and examining how they work and query data from SQL Server.

This is one simple implementation:

public class Queryable<TSource> : IOrderedQueryable<TSource>
{
    public Queryable(IQueryProvider provider, IQueryable<TSource> innerSource)
    {
        this.Provider = provider;
        this.Expression = Expression.Constant(innerSource);
    }

    public Queryable(IQueryProvider provider, Expression expression)
    {
        this.Provider = provider;
        this.Expression = expression;
    }

    #region IEnumerable<TSource> Members

    public IEnumerator<TSource> GetEnumerator()
    {
        return this.Provider.Execute<IEnumerable<TSource>>(this.Expression).GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    #endregion

    #region IQueryable Members

    public Type ElementType
    {
        get
        {
            return typeof(TSource);
        }
    }

    public Expression Expression
    {
        get;
        private set;
    }

    public IQueryProvider Provider
    {
        get;
        private set;
    }

    #endregion
}

Since Queryable<TSource> implements IOrderedQueryable<T>, it also implements IQeryable<TSource>, IQeryable and IOrderedQueryable.

There is not too much things. The most important method is GetEnumerator(). When a Queryable<TSource> object is iterated to traverse the data items, it simply asks its query provider to execute its expression to retrieve an IEnumerable<TSource> object, and return that object’s iterator.

Implement IQueryProvider

So the actual SQL query implantation is in the query provider:

public class QueryProvider : IQueryProvider
{
    // Translates LINQ query to SQL.
    private readonly Func<IQueryable, DbCommand> _translator;

    // Executes the translated SQL and retrieves results.
    private readonly Func<Type, string, object[], IEnumerable> _executor;

    public QueryProvider(
        Func<IQueryable, DbCommand> translator,
        Func<Type, string, object[], IEnumerable> executor)
    {
        this._translator = translator;
        this._executor = executor;
    }

    #region IQueryProvider Members

    public IQueryable<TElement> CreateQuery<TElement>(Expression expression)
    {
        return new Queryable<TElement>(this, expression);
    }

    public IQueryable CreateQuery(Expression expression)
    {
        throw new NotImplementedException();
    }

    public TResult Execute<TResult>(Expression expression)
    {
        bool isCollection = typeof(TResult).IsGenericType &&
            typeof(TResult).GetGenericTypeDefinition() == typeof(IEnumerable<>);
        Type itemType = isCollection
            // TResult is an IEnumerable`1 collection.
            ? typeof(TResult).GetGenericArguments().Single()
            // TResult is not an IEnumerable`1 collection, but a single item.
            : typeof(TResult);
        IQueryable queryable = Activator.CreateInstance(
            typeof(Queryable<>).MakeGenericType(itemType), this, expression) as IQueryable;

        IEnumerable queryResult;

        // Translates LINQ query to SQL.
        using (DbCommand command = this._translator(queryable))
        {
            // Executes the transalted SQL.
            queryResult = this._executor(
                itemType,
                command.CommandText,
                command.Parameters.OfType<DbParameter>()
                                  .Select(parameter => parameter.Value)
                                  .ToArray());
        }

        return isCollection
            ? (TResult)queryResult // Returns an IEnumerable`1 collection.
            : queryResult.OfType<TResult>()
                         .SingleOrDefault(); // Returns a single item.
    }

    public object Execute(Expression expression)
    {
        throw new NotImplementedException();
    }

    #endregion
}

QueryProvider must be initialized with a translator and executor, so that it is able to translate LINQ query to SQL, and execute the translated SQL.

And here the most important is the generic Execute() method, which is called by the above Queryable<TSource>.GetEnumerator(). It does the following work:

  • Checks whether it should return a collection of items (for the Where() scenarios, etc.), or should return a sinlge item (for the Single() query scenarios, etc.)
  • Invokes the translator to translate LINQ query to SQL.
  • Invokes the executor to execute the translated SQL and retrieves the result.
  • Returns result of a proper type (either a collection, or a single item).

Query method internals

Before running the query, take a look at the IQueryable<T> query methods.

Deferred execution methods

Take Where() as an example:

public static class Queryable
{
    public static IQueryable<TSource> Where<TSource>(
        this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
    {
        // Checks arguments.
        return source.Provider.CreateQuery<TSource>(
            Expression.Call(
                null,
                ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[]
                    { 
                        typeof(TSource) 
                    }),
                new Expression[] 
                    { 
                        source.Expression, 
                        Expression.Quote(predicate) 
                    }));
    }
}

It is very very different from IEnumerable<T>’s Where() query method. It is not executing any thing, it just:

  • Constructs a new expression tree, which contains the following information:
    • The original expression tree from the source IQueryable<T> object
    • The predicate expression tree
    • This Where() query method is invoked
  • Then invokes the query provider’s generic CreateQuery() method to construct a new IQueryable<TSource> object.

Obviously, the above constructed expression tree is used to contain the information which is prepared to be translated.

The ordering query method, like OrderBy(), is a little different, which converts the constructed IQueryable<TSource> object to an IOrderedQueryable<TSource> object:

public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(
    this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
{
    // Checks arguments.
    return (IOrderedQueryable<TSource>)source.Provider.CreateQuery<TSource>(
        Expression.Call(
            null, 
            ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] 
                { 
                    typeof(TSource), 
                    typeof(TKey) 
                }), 
            new Expression[] 
                { 
                    source.Expression, 
                    Expression.Quote(keySelector) 
                }));
}

And so is ThenBy():

public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(
    this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector)
{
    // Checks arguments.
    return (IOrderedQueryable<TSource>)source.Provider.CreateQuery<TSource>(
        Expression.Call(
            null, 
            ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] 
                { 
                    typeof(TSource), 
                    typeof(TKey) 
                }), 
            new Expression[] { 
                    source.Expression, 
                    Expression.Quote(keySelector) 
            }));
}

ThenBy() / ThenByDescending() are extension methods of IOrderedQueryable<TSource> instead of IQueryable<TSource>, which means, It must be invoked after invoking OrderBy() / OrderByDescending().

Eager execution methods

Single() is different:

public static TSource Single<TSource>(this IQueryable<TSource> source)
{
    // Checks arguments.
    return source.Provider.Execute<TSource>(
        Expression.Call(
            null, 
            ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] 
                { 
                    typeof(TSource) 
                }), 
            new Expression[] 
                { 
                    source.Expression 
                }));
}

Logically, Single() cannot be deferred. So after construction the expression tree, it invokes query provider’s generic Execute() method, and returns a TSource object instead of a IQueryable<TSource>.

Of course, the aggregate methods looks similar, invoking Execute() instead of CreateQuery():

public static decimal Average<TSource>(
    this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector)
{
    // Checks arguments.
    return source.Provider.Execute<decimal>(
        Expression.Call(
            null, 
            ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(new Type[] 
                { 
                    typeof(TSource) 
                }), 
            new Expression[] 
                { 
                    source.Expression, 
                    Expression.Quote(selector) 
                }));
}

It cannot be deferred either.

Work together

Now it is ready to run all the stuff above.

Query a collection of items (deferred execution)

The following query expects a collection of Product objects:

using (NorthwindDataContext database = new NorthwindDataContext())
{
    IQueryProvider provider = new QueryProvider(database.GetCommand, database.ExecuteQuery);
    IQueryable<Product> source = new Queryable<Product>(provider, database.GetTable<Product>());
    IQueryable<string> results = source.Where(product => product.CategoryID == 2)
                                       .OrderBy(product => product.ProductName)
                                       .Select(product => product.ProductName)
                                       .Skip(5)
                                       .Take(10);

    using (IEnumerator<string> iterator = results.GetEnumerator())
    {
        while (iterator.MoveNext())
        {
            string item = iterator.Current;
            Console.WriteLine(item);
        }
    }
}

To initialize the provider, DataContext.GetCommand() and DataContext.ExecuteQuery() are passed as translator and executor.

When results.GetEnumerator() is invoked, provider.Execute() is invoked. The query is translated to:

exec sp_executesql N'SELECT [t1].[ProductName]
FROM (
    SELECT ROW_NUMBER() OVER (ORDER BY [t0].[ProductName]) AS [ROW_NUMBER], [t0].[ProductName]
    FROM [dbo].[Products] AS [t0]
    WHERE [t0].[CategoryID] > @p0
    ) AS [t1]
WHERE [t1].[ROW_NUMBER] BETWEEN @p1 + 1 AND @p1 + @p2
ORDER BY [t1].[ROW_NUMBER]',N'@p0 int,@p1 int,@p2 int',@p0=2,@p1=5,@p2=10

by the provider’s translator, then provider’s executor executes the above SQL in SQL Server, and return a collection of items.

This is the printed output:

Escargots de Bourgogne
Filo Mix
Flotemysost
Geitost
Gnocchi di nonna Alice
Gorgonzola Telino
Gravad lax
Gudbrandsdalsost
Gumbär Gummibärchen
Gustaf's Knäckebröd

Query a single item (eager execution)

The following sample is different:

IQueryProvider provider = new QueryProvider(database.GetCommand, database.ExecuteQuery);
IQueryable<Product> source = new Queryable<Product>(provider, database.GetTable<Product>());
string productName = source.Where(product => product.CategoryID > 2)
                           .Select(product => product.ProductName)
                           .First();

Without deferred execution and iterating, the First() invokes provider.Execute() directly.

This is the translated SQL:

exec sp_executesql N'SELECT TOP (1) [t0].[ProductName]
FROM [dbo].[Products] AS [t0]
WHERE [t0].[CategoryID] > @p0',N'@p0 int',@p0=2

Aggregate (eager execution)

Aggregate query is also eager:

IQueryProvider provider = new QueryProvider(database.GetCommand, database.ExecuteQuery);
IQueryable<Product> source = new Queryable<Product>(provider, database.GetTable<Product>());
decimal averagePrice = source.Where(product => product.CategoryID == 2)
                             .Average(product => product.UnitPrice.GetValueOrDefault());

This is the translated SQL:

exec sp_executesql N'SELECT AVG([t1].[value]) AS [value]
FROM (
    SELECT COALESCE([t0].[UnitPrice],0) AS [value], [t0].[CategoryID]
    FROM [dbo].[Products] AS [t0]
    ) AS [t1]
WHERE [t1].[CategoryID] = @p0',N'@p0 int',@p0=2

SQL translating and executing

The above samples explained the implementation of LINQ to SQL query and query provider. Inside the QueryProvider class, it does not provide the detailed implementation of SQL translating and executing, but pass the work to DataContext.GetCommand() and DataContext.ExecuteQuery().

This post has demonstrated the simplest SQL translating and executing. But the realistic work is very very complex. Since this is not a SQL series but a LINQ / functional programming series, to develop a full featured SQL “compiler” is far beyond this series’ scope. For SQL executing, it is also complex to convert the retrieved data back to strong-typed objects in LINQ to SQL. To understand the entire translating and executing process, please follow the source code of Table<T>, which implements IQueryProvider.

Internally, Table<T> uses several internal classes, like SqlProvider, QueryConverter, etc., to accomplish the translating. For example, one of the core APIs is the QueryConverter.VisitSequenceOperatorCall():

internal class QueryConverter
{
    private SqlNode VisitSequenceOperatorCall(MethodCallExpression mc)
    {
        Type declaringType = mc.Method.DeclaringType;
        if (!(declaringType == typeof(Enumerable)) && !(declaringType == typeof(Queryable)))
        {
            throw new InvalidOperationException(string.Format(
                CultureInfo.InvariantCulture,
                "Sequence operator call is only valid for Sequence, Queryable, or DataQueryExtensions not for '{0}'",
                declaringType));
        }

        bool isNotSupported = false;
        switch (mc.Method.Name)
        {
            case "Where":
                isNotSupported = true;

                // The overload:
                // IQueryable<TSource> Where<TSource>(
                // this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate)
                // is not supported.

                // The MethodCallExpression object mc should have 2 arguments.
                // The first argument should be null.
                // The second argument should be Expression.Quote(predicate).
                if (mc.Arguments.Count != 2 ||
                    // IsLambda() removes the quote to get the predicate object,
                    // and checks predicate.NodeType ==  ExpressionType.Lambda.
                    !this.IsLambda(mc.Arguments[1]) ||
                    // precicate should have 1 TSource argument.
                    this.GetLambda(mc.Arguments[1]).Parameters.Count != 1)
                {
                    break; // The overload is not supported.
                }

                // The overload:
                // IQueryable<TSource> Where<TSource>(
                // this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate)
                // is supported.
                return this.VisitWhere(mc.Arguments[0], this.GetLambda(mc.Arguments[1]));

            case "OrderBy":
                isNotSupported = true;

                if (mc.Arguments.Count != 2 || !this.IsLambda(mc.Arguments[1]) ||
                    this.GetLambda(mc.Arguments[1]).Parameters.Count != 1)
                {
                    break; // The overload is not supported.
                }

                return this.VisitOrderBy(
                    mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlOrderType.Ascending);

            case "ThenBy":
                isNotSupported = true;

                if (mc.Arguments.Count != 2 || !this.IsLambda(mc.Arguments[1]) ||
                    this.GetLambda(mc.Arguments[1]).Parameters.Count != 1)
                {
                    break; // The overload is not supported.
                }

                return this.VisitThenBy(
                    mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlOrderType.Ascending);

            case "Single":
            case "SingleOrDefault":
                isNotSupported = true;

                if (mc.Arguments.Count != 1)
                {
                    if (mc.Arguments.Count != 2 || !this.IsLambda(mc.Arguments[1]) ||
                        this.GetLambda(mc.Arguments[1]).Parameters.Count != 1)
                    {
                        break; // The overload is not supported.
                    }

                    return this.VisitFirst(
                        mc.Arguments[0], this.GetLambda(mc.Arguments[1]), false);
                }

                return this.VisitFirst(mc.Arguments[0], null, false);

            case "Average":
                isNotSupported = true;

                if (mc.Arguments.Count != 1)
                {
                    if (mc.Arguments.Count != 2 || !this.IsLambda(mc.Arguments[1]) ||
                        this.GetLambda(mc.Arguments[1]).Parameters.Count != 1)
                    {
                        break; // The overload is not supported.
                    }

                    return this.VisitAggregate(
                        mc.Arguments[0], this.GetLambda(mc.Arguments[1]), SqlNodeType.Avg, mc.Type);
                }

                return this.VisitAggregate(mc.Arguments[0], null, SqlNodeType.Avg, mc.Type);

            // Other cases, like "Take", "Skip", "Distinct", etc.                
        }

        if (isNotSupported)
        {
            throw new NotSupportedException(string.Format(
                CultureInfo.InvariantCulture,
                "Unsupported overload used for query operator '{0}'.",
                mc.Method.Name));
        }

        throw new NotSupportedException(string.Format(
            CultureInfo.InvariantCulture,
            "The query operator '{0}' is not supported.",
            mc.Method.Name));
    }
}

Please compare this with the fore mentioned IQueryable<T> query methods, Where(), OrderBy(), Single(), Average(), etc.

There is also an excellent tutorial from MSDN.

LINQ Providers

There are several kinds of built-in LINQ in .NET 4.0:

built-in-linq 

Built-in IQueryable LINQ Providers

LINQ to Objects and LINQ to XML are IEnumerable based, and the 3 kinds of LINQ to ADO.NET are IQueryable-based, which have their specific IQueryProvider.

For example, in LINQ to SQL, the IQueryable, IQueryable<T> and IQueryProvider are implemented by Table<T> class and an internal DataQuery<T> class. DataQuery<T> also implements IOrderedQueryable and IOrderedQueryable<T>. These classes and all the other related classes (like SqlProvider, ) can be considered the provider of LINQ to SQL.

LINQ to Everything

To implement any other LINQ query against a specific data source, the specific LINQ provider should be provided. That is, classes which implements the above IQueryable, IQueryable<T>, IQueryProvider, IOrderedQueryable and IOrderedQueryable<T> interfaces. The LINQ to Wikipedia provider at the beginning of the series is one example. This post lists a lot of custom LINQ providers, like:

etc.

This tutorial teaches how to create a IQueryable LINQ provider against the TerraServer-USA Web service.

LINQ to Objects provider

LINQ to Objects is IEnumerable based, but the interesting thing is, IEnumerble<T> has an AsQueryable() extension method, which turns IEnumerble-based query into IQueryable-based query:

public static class Queryable
{
    public static IQueryable<TElement> AsQueryable<TElement>(
        this IEnumerable<TElement> source)
    {
        // Checks arguments.
        if (source is IQueryable<TElement>)
        {
            return (IQueryable<TElement>)source;
        }

        return new EnumerableQuery<TElement>(source);
    }
}

Here the EnumerableQuery<T> class implements IQueryable<T>, as well as the IQueryProvider:

namespace System.Linq
{
    public abstract class EnumerableQuery
    {
        // ...
    }

    public class EnumerableQuery<T> : EnumerableQuery, IQueryProvider,
                                      IQueryable<T>, IQueryable,
                                      IOrderedQueryable<T>, IOrderedQueryable,
                                      IEnumerable<T>, IEnumerable
    {
        // ...
    }
}

Internally, EnumerableQuery<T>.Execute() invokes Expression<TDelegate>.Compile() to execute the expression representing the query.

Published Wednesday, May 12, 2010 3:43 AM by Dixin

Comments

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Wednesday, June 23, 2010 7:20 AM by Yang

Great article!

Thanks!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, September 30, 2012 8:58 AM by Flint

Normally I do not learn post on blogs, but I wish to say that this write-up very forced

me to take a look at and do so! Your writing taste has been surprised me.

Thank you, very great article.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 5, 2013 9:35 AM by Dooley

Link exchange is nothing else however it is simply placing the other person's website link on your page at proper place and other person will also do similar in support of you.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 6, 2013 10:09 AM by Romo

Hi there, of course this post is really nice and I have learned lot of

things from it concerning blogging. thanks.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 6, 2013 10:30 AM by Mcmanus

I believe this is one of the so much significant information for me.

And i am happy studying your article. But should commentary on few

general issues, The web site taste is wonderful, the articles is actually great

: D. Just right job, cheers

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 6, 2013 2:20 PM by Grissom

What's up i am kavin, its my first time to commenting anywhere, when i read this article i thought i could also create comment due to this good article.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 6, 2013 5:26 PM by Downing

I've been surfing online more than 2 hours today, yet I never found any interesting article like yours. It's pretty worth enough

for me. Personally, if all webmasters and bloggers made good content as you did, the

net will be a lot more useful than ever before.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 6, 2013 10:19 PM by Goolsby

whoah this blog is great i love reading your posts.

Stay up the good work! You recognize, many persons are searching round for this information, you could help them

greatly.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, April 7, 2013 12:20 AM by Nicholson

I love your blog.. very nice colors & theme. Did you make this website yourself

or did you hire someone to do it for you? Plz respond as I'm looking to create my own blog and would like to find out where u got this from. thanks

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, April 7, 2013 3:45 AM by Pyle

Excellent beat ! I wish to apprentice whilst you

amend your site, how can i subscribe for a weblog website?

The account helped me a appropriate deal.

I had been tiny bit familiar of this your broadcast offered bright clear idea

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, April 7, 2013 6:05 AM by Hollenbeck

I know this if off topic but I'm looking into starting my own blog and was wondering what all is needed to get setup? I'm assuming having a blog

like yours would cost a pretty penny? I'm not very internet smart so I'm not 100% certain. Any recommendations or advice would be greatly appreciated. Cheers

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, April 7, 2013 2:21 PM by Laplante

Wow, incredible weblog structure! How long have you been blogging for?

you made running a blog glance easy. The full glance of

your web site is wonderful, let alone the content material!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, April 7, 2013 5:40 PM by Mcallister

Simply desire to say your article is as amazing. The clearness in your post is just nice and i can assume you are

an expert on this subject. Well with your permission allow me

to grab your RSS feed to keep up to date with forthcoming

post. Thanks a million and please carry on the enjoyable work.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 8, 2013 10:24 AM by Cason

I don't leave a bunch of remarks, but i did a few searching and wound up here Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider - Dixin's Blog.

And I do have 2 questions for you if it's allright. Is it only me or does it look like some of the responses appear as if they are written by brain dead folks? :-P And, if you are posting on additional social sites, I'd like to

follow anything fresh you have to post. Would you list of every one

of your community pages like your linkedin profile, Facebook page or twitter feed?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 8, 2013 10:38 AM by Gage

Hello everyone, it's my first pay a visit at this site, and paragraph is really fruitful in support of me, keep up posting such articles or reviews.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 8, 2013 11:16 AM by Joy

Hi there, I desire to subscribe for this weblog to take latest updates, therefore where can

i do it please assist.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 8, 2013 1:11 PM by Perales

Hey there, I think your site might be having browser compatibility issues.

When I look at your website in Safari, it looks fine but when opening in Internet Explorer, it has some overlapping.

I just wanted to give you a quick heads up! Other then that, awesome

blog!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 8, 2013 6:44 PM by Krueger

This text is priceless. When can I find out more?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 9, 2013 1:37 AM by Ennis

Hi, I think your blog might be having browser compatibility issues.

When I look at your website in Ie, it looks fine but when opening in Internet Explorer, it has some overlapping.

I just wanted to give you a quick heads up!

Other then that, excellent blog!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 9, 2013 12:39 PM by Rockwell

Currently it looks like BlogEngine is the best blogging platform out there right

now. (from what I've read) Is that what you're using on your blog?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 9, 2013 1:05 PM by Houle

Hi, i read your blog from time to time and i own

a similar one and i was just curious if you get a lot of spam feedback?

If so how do you stop it, any plugin or anything you can recommend?

I get so much lately it's driving me insane so any support is very much appreciated.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 9, 2013 2:13 PM by Woodley

I am extremely inspired along with your writing skills as neatly as

with the structure to your blog. Is that this a paid subject matter or did you modify it

yourself? Anyway stay up the excellent quality writing, it

is rare to look a great blog like this one these days..

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 9, 2013 4:16 PM by Olive

My family all the time say that I am wasting my time here at

web, however I know I am getting knowledge everyday by reading such nice articles or reviews.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 11, 2013 8:56 AM by Mccormick

Does your site have a contact page? I'm having trouble locating it but, I'd like to shoot you

an email. I've got some ideas for your blog you might be interested in hearing. Either way, great website and I look forward to seeing it expand over time.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 11, 2013 12:42 PM by Christensen

It's going to be end of mine day, but before finish I am reading this fantastic piece of writing to increase my know-how.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 11, 2013 4:28 PM by Herbert

Thanks , I've recently been searching for information approximately this subject for a long time and yours is the best I have came upon so far. However, what about the conclusion? Are you certain about the source?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 11, 2013 5:18 PM by Matthews

Excellent blog post. I absolutely appreciate this site.

Continue the good work!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 11, 2013 7:49 PM by Stoker

Howdy! Do you know if they make any plugins to help with Search Engine Optimization?

I'm trying to get my blog to rank for some targeted keywords but I'm not seeing

very good gains. If you know of any please share.

Thanks!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 12, 2013 8:11 AM by Beaulieu

Fantastic goods from you, man. I have be aware your stuff prior to

and you're just extremely fantastic. I actually like what you have bought right here, certainly like what you're stating and the way

through which you assert it. You make it enjoyable and you continue to take

care of to stay it sensible. I cant wait to read far

more from you. That is actually a wonderful site.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 12, 2013 10:03 AM by Alcala

Excellent post. I am dealing with some of these issues as well.

.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 12, 2013 10:57 AM by Spivey

When I initially left a comment I seem to have clicked the -Notify me

when new comments are added- checkbox and from now on whenever a comment is

added I recieve four emails with the same comment. There has to be an easy method

you can remove me from that service? Thanks!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 12, 2013 12:59 PM by Koenig

Hi friends, its impressive paragraph regarding cultureand fully explained, keep it up all the time.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 7:32 AM by Renfro

Hello, i think that i saw you visited my blog thus i came to

“return the favor”.I'm attempting to find things to enhance my website!I suppose its ok to use a few of your ideas!!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 8:47 AM by Tucker

This website certainly has all the information

I wanted concerning this subject and didn't know who to ask.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 10:40 AM by Jansen

Link exchange is nothing else except it is simply

placing the other person's blog link on your page at proper place and other person will also do same in favor of you.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 11:52 AM by Thorne

I am actually grateful to the owner of this website

who has shared this wonderful article at at this time.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 3:14 PM by Rodrigue

I seriously love your site.. Excellent colors & theme.

Did you create this amazing site yourself? Please reply back as I'm looking to create my very own website and would love to know where you got this from or exactly what the theme is named. Kudos!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Saturday, April 13, 2013 6:19 PM by Prescott

I feel that is among the most significant info for me.

And i am glad reading your article. But wanna commentary

on few general things, The web site style is great, the articles is truly nice :

D. Good task, cheers

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, April 15, 2013 4:12 AM by Conti

I am not sure where you are getting your information, but great topic.

I needs to spend some time learning much more or understanding more.

Thanks for magnificent information I was looking for this information

for my mission.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 16, 2013 1:06 PM by Mesa

Amazing! This blog looks just like my old one!

It's on a entirely different topic but it has pretty much the same layout and design. Outstanding choice of colors!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, April 16, 2013 6:53 PM by Galarza

Very rapidly this web page will be famous amid all blogging and site-building visitors, due to it's pleasant content

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, April 18, 2013 12:48 PM by Moll

I have read so many content concerning the blogger lovers

except this post is genuinely a pleasant article,

keep it up.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, April 19, 2013 10:11 PM by Soliz

Hi, the whole thing is going perfectly here and ofcourse every one is

sharing information, that's in fact fine, keep up writing.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, May 3, 2013 1:20 AM by Leroy

Currently it seems like Movable Type is the best blogging platform out there right now.

(from what I've read) Is that what you're

using on your blog?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Thursday, August 15, 2013 7:04 PM by Love

In exploring for internet websites associated to web

hosting and especially comparison hosting Linux program net, your web site came up.

:)

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Wednesday, August 28, 2013 1:12 PM by Sweeney

Fine write up ... usually never ever reply to this affair, but now I want to give thanks

to the essential info.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Wednesday, September 4, 2013 10:13 AM by Blanchette

Awesome stuff thanx:)

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Monday, September 9, 2013 3:55 AM by Walls

Hi. important operate. I didn't anticipate this. That is

an critical story. Offers Thanks!

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Sunday, September 29, 2013 1:03 AM by Mawson

Wow! What an thought! What a concept! Good .. wonderful ...

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, October 4, 2013 5:20 AM by Johnson

Wow! Thank you! I constantly desired to write in my

web page a thing like that. Can I take a part of

your post to my internet log?

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, November 1, 2013 12:17 AM by jkWqlcBJhbHYHaUuJ

KZdi1S I think this is a real great blog article.Really thank you! Cool.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, November 19, 2013 2:00 AM by ATdQkSbGQYjqjPOFBp

yeGuak I cannot thank you enough for the blog post.Thanks Again. Awesome.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Tuesday, November 19, 2013 2:26 AM by EdPiootehTRqhNCb

RDkQC8 I think this is a real great blog article.Really thank you! Fantastic.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, January 17, 2014 7:40 AM by uBDilboDxfdrWDtDwd

n7107i Great article.Much thanks again. Much obliged.

# re: Understanding LINQ to SQL (10) Implementing LINQ to SQL Provider

Friday, January 31, 2014 12:29 AM by UPFZzFBTuJVXEtpT

FZjTH2 Thanks for sharing, this is a fantastic post.Really thank you! Want more.

Leave a Comment

(required) 
(required) 
(optional)
(required)