Stefan Sedich's Blog

Paging with NHibernate using a custom Extension method to make it 'easier' :)...

stefan.sedich — Fri, 03 Oct 2008 11:28:00 GMT

Evening All,

What better thing to do on a friday night than code and blog :P. Thought it was about time I shared my custom paging helper methods for NHibernate. I quite liked this solution as it worked nicely and was easy to use. I will go into as much detail as I can here without putting you to sleep.

The Idea

Basically my idea was to replicate something like in Linq to SQL, where you can basically define a query and call Skip(x).Take(x), in the end I came up with the idea of calling an ToPagedResult(index, pageSize); extension method, this would then return a PagedResult<T> object, the PageResult object would basically just be a container which would hold the total results and the total item count. Simple really, reason for this is just to make paging results a little easier and reduce code waste by wrapping my common functionality in my extension method.

The Solution

The solution will need 2 things, first it will need my PagedResult<T> class, and then the ToPagedResult Extension method. Firstly the PagedResult class:

/// <summary>
    /// The paged result container class, holds the page of data and the
    /// total item count for the query.
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class PagedResult<TEntity> {

        #region Properties

        /// <summary>
        /// Gets the total number of items.
        /// </summary>
        public long TotalItems { get; protected set; }

        /// <summary>
        /// Gets the items for the current page.
        /// </summary>
        public IList<TEntity> Items { get; protected set; }

        #endregion

        #region Constructor

        /// <summary>
        /// Inititialize an instance of the paged result object, setting the
        /// items and total items.
        /// </summary>
        public PagedResult(IList<TEntity> items, long totalItems) {
            TotalItems = totalItems;
            Items = items;
        }

        #endregion

    }

This is a simple class really just holds the page of items and the total item count, only reason for this is just a neat way to return the results. In another version of this class I have added properties for the page index, total pages properties too but in this example I kept it simple and just added what is needed.

Next up is the extension method, basically I have in my project an NHibernateExtensions class which holds all my common extension methods, but for the example I am only including the ToPagedResult extension, the code for this is below:

public static class NHibernateExtensions {

        /// <summary>
        /// Based on the ICriteria will return a paged result set, will create two copies
        /// of the query 1 will be used to select the total count of items, the other
        /// used to select the page of data.
        ///
        /// The results will be wraped in a PagedResult object which will contain
        /// the items and total item count.
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="criteria"></param>
        /// <param name="startIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public static PagedResult<TEntity> ToPagedResult<TEntity>(this ICriteria criteria, int startIndex, int pageSize) {

            // Clone a copy of the criteria, setting a projection
            // to get the row count, this will get the total number of
            // items in the query using a select count(*)
            ICriteria countCriteria = CriteriaTransformer.Clone(criteria)
                    .SetProjection(Projections.RowCount());

            // Clone a copy fo the criteria to get the page of data,
            // setting max and first result, this will get the page of data.s
            ICriteria pageCriteria = CriteriaTransformer.Clone(criteria)
                .SetMaxResults(pageSize)
                .SetFirstResult(startIndex);

            // Create a new pagedresult object and populate it, use the paged query
            // to get the items, and the count query to get the total item count.
            var pagedResult = new PagedResult<TEntity>(pageCriteria.List<TEntity>(),
                                                       (int)countCriteria.UniqueResult());

            // Return the result.
            return pagedResult;

        }

    }

The extension method works as follows, it is an extension on the ICriteria, could be made to work with DetachedCriteria too but in my case I only need it for ICriteria, based on the query it will make 2 copies using the CriteriaTransformer.Clone method, one query will be used to get the total item count, so we set a count projection on it.

The second copy is used to get the actual page of data, it uses NHibernates SetMaxResults and SetFirstResult methods to do this, then finally we create a new instance of our PagedResult container setting the items and item count using the two queries. Finally returning the paged result.

Usage Example

To use this extension method we first define an ICriteria query and then call the extension method to get the data, and example on out People table would be something like so, the search is just getting a list of people with age > 20. The page to get will be 0, i.e. the first page and there will be 10 items per page.

// Create the criteria to get people with age > 20
ICriteria criteria = this.session.CreateCriteria(typeof (Person))
.Add(Restrictions.Gt("Age", 20));

// Get the paged result using the above criteria and our new extension method.
PagedResult<Person> pagedResult = criteria.ToPagedResult<Person>(0, 10);

Finish

Hope you might find this useful in some of your projects, although it it something very simple it has saved me a great deal of time with paging in my project and means writing less code which is always a bonus. Send me any comments/suggestions you wish I am always open to criticism :).

Cheers
Stefan

Set the value of a version column in NHibernate manually

stefan.sedich — Wed, 01 Oct 2008 14:28:00 GMT

My first post in a long time :), look forward to more from me as I am back baby.

I am currently working on a project and for the first time am using NHibernate, I must say compared to LINQ to Sql I am in love, NHibernate ROCKS! An issue I was having was that I have a version column in my database defined as an integer and then in my NHibernate mapping files have defined a <version> element to map to this column. Now one issue is that in my service methods I do something like this:

public void Update(MyDTO dto) {

// Select the item.
var item = this.repository.SelectById(dto.Id);

// Map values from DTO to model.
item.Name = dto.Name;
item.Version = dto.Version;

// Call update
this.repository.Update(item);

}

Because I am passing in a DTO object from my UI layer I need to first load the entity from the repository by Id. Then I map across my properties including the version, which in this case was populated from a hidden field on the UI into the DTO. Next I call update, now my initial assumption was that this would work as I excepted for optimistic locking. I thought that for example say the current version in the DB was 2, and the item we are updating is version 1, so it would load the item with a version = 2.

Then we override the version to 1 and upon update I would expect it to use this version 1 for the optimistic check. WRONG it from what I understand uses the version value which is cached from a copy of the item upon loading it. If you look at the documentation there are 3 types approaches to optimistic concurrency.

10.4.1. Long session with automatic versioning

A single ISession instance and its persistent instances are used for the whole application transaction.

The ISession uses optimistic locking with versioning to ensure that many database transactions appear to the application as a single logical application transaction. The ISession is disconnected from any underlying ADO.NET connection when waiting for user interaction. This approach is the most efficient in terms of database access. The application need not concern itself with version checking or with reattaching detached instances.

// foo is an instance loaded earlier by the Session
session.Reconnect();
transaction = session.BeginTransaction();
foo.Property = "bar";
session.Flush();
transaction.Commit();
session.Disconnect();
The foo object still knows which ISession it was loaded it. As soon as the ISession has an ADO.NET connection, we commit the changes to the object.

This pattern is problematic if our ISession is too big to be stored during user think time, e.g. an HttpSession should be kept as small as possible. As the ISession is also the (mandatory) first-level cache and contains all loaded objects, we can propably use this strategy only for a few request/response cycles. This is indeed recommended, as the ISession will soon also have stale data.

10.4.2. Many sessions with automatic versioning

Each interaction with the persistent store occurs in a new ISession. However, the same persistent instances are reused for each interaction with the database. The application manipulates the state of detached instances originally loaded in another ISession and then "reassociates" them using ISession.Update() or ISession.SaveOrUpdate().

// foo is an instance loaded by a previous Session
foo.Property = "bar";
session = factory.OpenSession();
transaction = session.BeginTransaction();
session.SaveOrUpdate(foo);
session.Flush();
transaction.Commit();
session.Close();
You may also call Lock() instead of Update() and use LockMode.Read (performing a version check, bypassing all caches) if you are sure that the object has not been modified.

10.4.3. Application version checking

Each interaction with the database occurs in a new ISession that reloads all persistent instances from the database before manipulating them. This approach forces the application to carry out its own version checking to ensure application transaction isolation. (Of course, NHibernate will still update version numbers for you.) This approach is the least efficient in terms of database access.

// foo is an instance loaded by a previous Session
session = factory.OpenSession();
transaction = session.BeginTransaction();
int oldVersion = foo.Version;
session.Load( foo, foo.Key );
if ( oldVersion != foo.Version ) throw new StaleObjectStateException();
foo.Property = "bar";
session.Flush();
transaction.Commit();
session.close();
Of course, if you are operating in a low-data-concurrency environment and don't require version checking, you may use this approach and just skip the version check.

-------------------

Now if you look at the above it is clear that I am using the third scenario hence why I as having the issues, if I kept the session around for the life of the transaction i.e store in cache when you display the page and then use this session again for the save, the version would have been handled automagically same being if you had the full object and call an Update with it on a new Session.

But in my case I do not have the full object and am only mapping over a sub set of parameters from my DTO, so I need to first load the item by ID from the session and then map across my parameters, finally calling an update, this is where the issue is. To fix this the solution which I found on the Java forums and adopted was to create an interceptor which would handle the OnFlushDirty method. In here I will compare the Version of the entity being flushed to the Version of the item in the database, this will do what I would like and allows me to set the Version manually.

The main issue is that there is 1 extra DB call to get the version, but in my case this is minimal. The code for the interceptor is below, it doesn't seem to have any issues as yet but will undergo more testing as time goes by. The solution/ideas came from here: http://forum.hibernate.org/viewtopic.php?t=977889, and was changed to work.

public class NHInterceptor : EmptyInterceptor {
private ISession _session;

public override void SetSession(ISession session) {
this._session = session;

base.SetSession(session);
}

public override bool OnFlushDirty(object entity, object id, object[] currentState, object[] previousState, string[] propertyNames, NHibernate.Type.IType[] types) {
ISessionImplementor sessimpl = _session.GetSessionImplementation();
IEntityPersister persister = sessimpl.GetEntityPersister(entity);
EntityMode mode = _session.GetSessionImplementation().EntityMode;

if(persister.IsVersioned) {
object version = persister.GetVersion(entity, mode);
object currentVersion = persister.GetCurrentVersion(id, sessimpl);

if (!persister.VersionType.IsEqual(currentVersion, version))
throw new StaleObjectStateException(persister.EntityName, id);
}

return base.OnFlushDirty(entity, id, currentState, previousState, propertyNames, types);
}

}

Maybe you find this useful.

Thanks
Stefan

Enhanced XMLSiteMapProvider with support for dynamic nodes.

stefan.sedich — Thu, 14 Aug 2008 11:43:00 GMT

Hello All,

This might be a long one so bear with me here this might bore you :).

I have have had the need to be able to add dynamic nodes to my sitemap, I am using a sitemap xml file. My first solution, was to create a custom sitemap provider, which would parse the XML and if it detected the node I had to insert my dynamic nodes into, it would do this and then continue.

Fine I thought but not good enough. I wanted a generic solution that could be reused and that would be easy to use. I came up with the idea of extending the sitemap XML file to contain some new nodes. Then create a custom parser that would make use of this. The idea in the end was to add two new elements to the sitemap, the elements being <dynamicNode> and <dynamicNodes>, the idea was that they would call a static method on a class that would either return 1 node or a collection. These would then be injected into the sitemap when it is created.

The beauty here was that you could add dynamic nodes to our sitemap, one other side effect was that you could now nest dynamic nodes in static nodes, and also nest static nodes in either a dynamic node, or a dynamic nodes collection. If you look at the sample project supplied you will see this works quite well. One thing to note is that any static nodes added to either a dynamic node or dynamic nodes collection. It will be added at the end. Which I think is expected behaviour, well for me anyway.

- The new sitemap file -

Here is an example of what the sitemap file will now look like. Say we have 3 static nodes, and within the static products node, we need to get products from our database, and add them as children. You could create an easy site map file like so:

Here you can see that we have added some static nodes, and within our products node, we have added a dynamicnodes, node. You can see that this calls the static method GetProducts on the MenuHelper class. This method will return a collection of nodes which will be inserted into our static nodes children. And dynamic insertion of child nodes is now possible :)... You are also able to have a dynamic node, which is a single root node, plus you can nest until your heart is content, which you will see in the sample.

-- MenuHelper --

In this class we would have a static GetProducts method, this would return a list of XX objects. These objects are helpers, they allow us to create a collection of sitemap nodes, so that they can be used in the provider to build up the sitemap. The node has the default properties (key,url,title,description) and you can add custom attributes too. The method would look like so, you could imagine this would use the database to get products and build up the list.

public static List<EnhancedXMLSiteMapProvider.EnhancedSiteMapNode> GetProducts() {
            return new List<EnhancedXMLSiteMapProvider.EnhancedSiteMapNode>() {
                  new EnhancedXMLSiteMapProvider.EnhancedSiteMapNode() {
                       Key="Product1.aspx",
                       Url="Product1.aspx",
                       Title="Product 1"
                   }
             };
}

-- Web.Config Configuration --

You need to configure the provider in the web.config. In the sample project this is done as so:

<siteMap defaultProvider="EnhancedXMLSiteMapProvider">
            <providers>
                <add name="EnhancedXMLSiteMapProvider" type="EnhancedXMLSiteMapProviderSample.EnhancedXMLSiteMapProvider, EnhancedXMLSiteMapProviderSample"
                siteMapFile="~/Web.sitemap"
cacheDuration="15"/>
            </providers>
</siteMap>

I am basically setting it as the default provider, I am pointing it to the xml sitemap file, and setting the cache duration (this defaults to 5 if not set). Once this is done you are ready to run. One thing to note is that the provider also puts a dependancy on the xml file, so that once changed it invalidates the sitemap. And also after the time duration.

One issue is that any dynamic data does not invalidate the cache, you are able to set a cacheKey on the provider which is used for caching. Then you can use code to remove the item. So you backend could remove the cache item when it needs the menu to change.

-- The Provider --

I am not going to go into full detail on the provider and show all the code, it is all included in the sample project so just have a look. Basically the main workings, just parses the XML file, depending on the node type will do different things. If it encounters a dynamicNode or dynamicNodes element it will grab the type and method attributes, and use reflection to call these methods and continue parsing the data.

I have tested this with many levels/combinations of nodes and I have not had any issues yet, mind you I know this needs neatening up and it is only the efforts of a days work. I will post updates as I go and any bug fixes to this. But at the moment I am happy with where it is.

-- Final Word --

The sample project is supplied below, have a play and let me know what you think. Also this is the first time I have ever used the site map provider, so if I have just reinvented the wheel please give me a gentle slap and let me know :).

Sample Project Files
------------------------------------------------------------
EnhancedXMLSiteMapProviderSample.zip

Cheers
Stefan

Nullable ConvertTo Extension Method

stefan.sedich — Tue, 12 Aug 2008 06:21:00 GMT

Hello,

I have the need to easily convert a string to another type i.e. int. And would like to return null if the string is empty. I created a quick extension method, thought id post it up incase anyone finds it helpful.

        /// <summary>
        /// Converts a string value to the given type, if the string is empty,
        /// will return null.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="input"></param>
        /// <returns></returns>
        public static T? ConvertTo<T>(this string input) where T : struct {
            T? ret = null;

            if (!string.IsNullOrEmpty(input)) {
                ret = (T)Convert.ChangeType(input, typeof(T));
            }

            return ret;
        }

Basically to use this, just call the extension method on a string:

"12".ConvertTo<int>(); // Returns 12
"".ConvertTo<int>(); // Returns null
"1ddsfs".ConvertTo<int>(); // Exception thrown (behaviour I wanted)

Just a quick one today, will be posting some more useful things in the weeks to come.

Cheers
Stefan

Long time no post :(

stefan.sedich — Sun, 13 Jul 2008 10:21:00 GMT

Hello All,

I must say I have been slack, I have not had a post in a long time. I am still alive just have not had the time/motivation to keep this upto date like I had planned.

I am going to hit the road hard again and I hope to be blogging again in the next few weeks. Look forward to sharing my findings with everyone once again.

Cheers
Stefan

Urchin ELF2 Ecommecre Log File Helper

stefan.sedich — Fri, 04 Apr 2008 12:25:00 GMT

Hello,

I am currently needing to implement ecommerce tracking with our Urchin stats server. To do this it reads your transaction logs that you write to when users buy from your site. This file needs to be in a special format ELF2 click here for more info.

I though I would write some helper classes to make writing my ELF2 logs easier and something that would be reusable and could even have functionality added in the future to parse the logs (most likely never needed but you never know). So I created a set of classes to do this for me. I will not post the source code right now but if there is interest will tidy it up and release it for all too use.

Adding a new order to a transaction record to your log is as easy as pie:

ELF2TransactionLog log = new ELF2TransactionLog();

log.TransactionLines.Add(new ELF2LogTransactionLine() {
                OrderID = "100",
                RemoteHost = "GETIPHERE",
                UserAgent = Request.ServerVariables["HTTP_USER_AGENT"].ToString(),
                Store = "My Store",
                SessionID = "000-111",
                Total = 895,
                Tax = 10,
                Shipping = 10,
                BillCity = "Perth",
                BillState = "WA",
                BillZip = "6025",
                BillCountry = "Australia",
                Cookies = "GETCOOKIESHERE :)",
                LineItems = {
                    new ELF2LogTransactionItemLine() {
                        OrderID = "100",
                        ProductCode = "test1",
                        ProductName = "Test Product 1",
                        Variation = "",
                        Price = 100M,
                        Quantity = 1,
                        UpSold = false,
                        UserAgent = Request.ServerVariables["HTTP_USER_AGENT"].ToString(),
                        Cookies = "GETCOOKIESHERE",
                        RemoteHost = "GETIPHERE"
                    }
                }
            });

log.Save(Server.MapPath("~/biglog.log"), true);

Thanks
Stefan

Our First ASP.NET 3.5 Site Goes Live!!

stefan.sedich — Thu, 03 Apr 2008 04:45:00 GMT

Hello All,

UPDATE 20080409:

Another site has launced, check out www.betts.com.au!!!

Thanks
Stefan

----------------------------------------------------------------------

Finally our first ASP.NET 3.5 website went live today, there are 2 more to come but this one is the only one live atm:

http://www.zushoe.com.au/

This has been challenging and fun as we have used all the latest tools and technologies in this project, some include:

- Visual Studio 2008
- ASP.NET 3.5
- LINQ to SQL
- ASP.NET AJAX

There are really cool features in this site too, for example the paging in the catalogue is done with ajax but using custom link controls I have allowed SEO to still work. It has full AJAX history support too. There are custom developed ASP.NET AJAX controls and extensive caching, plus much more.

All in all this project was great to work on, being able to use .NET 3.5 and Visual Studio 2008 saved us a lot of time, and using LINQ to SQL cut down creating the DAL quite a bit. Of course with all new techs we have had challenges along the way, but still developed it alot quicker using VS 2008 and .NET 3.5.

That is all for now, might try post on our challenges sometime soon.

Thanks
Stefan

Simplified ASP.NET AJAX Custom Control Development With VS Item Template

stefan.sedich — Tue, 01 Apr 2008 14:05:00 GMT

Hello,

At work today I had a friend (Blair) have issues with trying to get a browser alert to popup on the page during an ASYNC post back. I told him I would make a custom control in 30 secounds or less that would do this and make life much easier. Overkill I know for such a simple task but it was more of a demo to show the ease/speed of creating a control using my custom item template.

The VS Item Template:

I have created a template in Visual Studio that lets me add a new ASP.NET AJAX server control to any project, this adds the Control class and the debug and release JS files. So basically all I need to do is right click (add new item) ASP.NET AJAX Server Control. The files are now in my solution. The benefit of this is that the default java script file that is added when you create a new control library will not be able to be packed as it is missing a few ; and { }. My template has fixed these issues and it makes life a heck of a lot easier. I then just make the two JS files embedded resources and I am good to go (I need to do this as I could not see a way to get the item template to do this). I will not go into how to create the template here, but have included it for download if you would like to see/use it.

Creating the control:

This was the easy part, once I have added my control called MessageBoxControl to my project, which gives me a shell control, I just added a private variable to hold the message and a ShowMessage method. The ShowMessage method does nothing but set this private message variable. It just looks nice to use MessageBox1.ShowMessage("error!"). The code for the control is below:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml.Linq;

[assembly: WebResource("MessageBox.MessageBoxControl.js", "text/javascript")]
[assembly: WebResource("MessageBox.MessageBoxControl.debug.js", "text/javascript")]
namespace MessageBox {

    /// <summary>
    /// Summary description for ServerControl1
    /// </summary>
    public class MessageBoxControl : ScriptControl {

private string _message = string.Empty;

#region Script Descriptiors

        protected override IEnumerable<ScriptDescriptor>
                GetScriptDescriptors() {
            ScriptControlDescriptor descriptor = new ScriptControlDescriptor("MessageBox.MessageBoxControl", this.ClientID);

descriptor.AddProperty("Message", this._message);

yield return descriptor;
}

        // Generate the script reference
        protected override IEnumerable<ScriptReference>
                GetScriptReferences() {
            yield return new ScriptReference("MessageBox.MessageBoxControl.js", this.GetType().Assembly.FullName);
        }

#endregion

#region Message Showing

        /// <summary>
        /// Just sets my message text.
        /// </summary>
        /// <param name="message"></param>
        public void ShowMessage(string message) {
            this._message = message;
        }

#endregion

}

As you can see the control is ultra simple. The private var is set and in my GetScriptDescriptors this is where I pass this value to my client script library. The client script library is also very simple. I need to add the Message Property and show the message using an alert().

/// <reference name="MicrosoftAjax.js"/>

Type.registerNamespace("MessageBox");

MessageBox.MessageBoxControl = function(element) {
MessageBox.MessageBoxControl.initializeBase(this, [element]);
this._message = "";
};

MessageBox.MessageBoxControl.prototype = {
initialize: function() {
MessageBox.MessageBoxControl.callBaseMethod(this, 'initialize');

        if(this._message != "") {
            alert(this._message);
        }
    },
    dispose: function() {
        //Add custom dispose actions here
        MessageBox.MessageBoxControl.callBaseMethod(this, 'dispose');
    },
    get_Message: function() {
        return this._message;
    },
    set_Message: function(value) {
        this._message = value;
    }
};

MessageBox.MessageBoxControl.registerClass('MessageBox.MessageBoxControl', Sys.UI.Control);
if (typeof(Sys) !== 'undefined') { Sys.Application.notifyScriptLoaded(); }

Here we can see that we have the Message property and then in our initialise function we simply use this value to show a message to the user using a java script alert. Now that is my control done, I add it to my page and I can then use Control.ShowMessage("tesing") to show an alert message on the page.

With the java script here a 2 files a .debug.js and a .js file. The .debug.js file will be used when your script manager is in debug mode and the .js when in release mode. Use Dean Edwards Packer to compress your debug script into a tight release mode script. If you have script errors when compressing your script make sure you use JSLint to verify your script, fixing any errors and pack again.

Final:

While this control was not really an example of how to build a rich control (or the most efficient way to show a message to the user), it was more of a demo on how creating your own VS Templates can make your day to day life much easier. And also demonstrating how quick and easy it is to develop a custom client control built on top of the ASP.NET AJAX Framework. I have included a copy of my VS Template below if you would like to use it. And also a copy of the sample project that this was built in. To use the template simply add the zip file to your visual studio template folder. I.E. C:\Users\USER\Documents\Visual Studio 2008\Templates\ItemTemplates\Visual C# on my vista machine.

- VS Template File
- Sample Project

Thanks
Stefan

Update to my LINQ to SQL performance in VB.NET saga

stefan.sedich — Sat, 29 Mar 2008 07:05:00 GMT

Hello,

If you have read my posts before where I was complaining about VB generated sub optimal SQL when using nullable columns in your where clauses, I came to the conclusion I was being silly and not using .Value on those nullable fields in my queries.

I stumbled across this post today:

http://blogs.msdn.com/vbteam/archive/2008/03/28/linq-to-sql-and-linq-to-entities-performance-improvements-tim-ng.aspx

Looks like it was an issue in the end and not me being totally stupid :).

Thanks
Stefan

Book Review: Linq Quickly by N Satheesh Kumar

stefan.sedich — Wed, 26 Mar 2008 13:23:00 GMT

This books title does not lie, it is LINQ and it is quickly. This book is an excellent introduction into the world of LINQ and also a great reference once you get your feet wet.

The start of the book gives you a brief introduction into what LINQ is and also an introduction into the new features in C# 3.0. It covers things like anonyms types, object initializers, collection initializers, partial methods, implicitly typed local variables, extension methods, lambda expressions, query expressions and also a small intro to expression trees.

Then it covers LINQ to Objects, which gives you a good idea on how to use LINQ over your in memory objects, including arrays, collections, string and even text files. It shows you just how easy it is to do things that in the past would have been a lot harder to complete.

Next up is LINQ to XML, this is a great introduction to this subject, it covers a great deal of information in regards to all the new LINQ to XML classes, how to create/update/delete XML documents using these new classes and methods. You are also shown the power you now have when you are querying XML and how easy it just is.

The LINQ to SQL chapter is also an excellent reference if you would like to get your feet wet but would not like to be overwhelmed with information. There are plenty of good examples on how to begin using LINQ to SQL and the code samples provided make this very easy. It covers everything from Data Context, Attributes, Relationships, querying, data manipulation, using stored procedures and also all the other common query operators that you would use. There is also a chapter on LINQ to Datasets but as I never use datasets this was something I briefly skimmed over and did not digest.

Finally the book provides a good chapter on Standard Query Operators, this is an excellent post reference once you are already in the world of LINQ, it is good to able to flick to be back, find what you need and see the function prototypes and even a code sample on how to use it. I still sometimes will flick to this part of the book to quickly reference things when I forget :P.

All in all this was an excellent book and I would highly recommend it to anyone who would like to start out with LINQ but would like to get a quick introduction and be on their way to actually using it. This book provides just that and more

Book Information:

Title:           LINQ Quickly
Author:      N Satheesh Kumar
Publisher: PACKT Publishing (http://www.packtpub.com/)
Link:           http://www.packtpub.com/linq-quick-starter/book

And finally a big thanks to Duane at PACKT Publishing for giving me the opportunity to review this book.

Thanks
Stefan