SquaredRoot

Return of the PagedList

// June 15th, 2009 // 7 Comments » // C#, LINQ, MVC

It has been nearly a year since I posted an updated version of the PagedList<T> functionality originally created by Scott Guthrie and posted by Rob Conery. Since then I have used the class in a number of projects and find it indispensable.

A few days ago, Craig Stuntz reported an interesting observation: when the first page is returned, the class performs a Skip(0). Suprisingly, this is not free. With that in mind, I set out to correct that issue as well as incorporate a few changes I’ve made over the past year. The result is nearly identical to the last posted version, just a bit more readable. Additionally…
(more…)

Storing LINQ Objects in SQL-Based Session State

// January 30th, 2008 // 3 Comments » // LINQ

Scott Hanselman recently posted about various options you have for session storage while using ASP.Net. In the comments of his post I brough up an issue I recently encountered at work (where we use SQL Server session state):

LINQ-To-Sql generated objects are not marked [Serializable] and cannot be stored in out-of-process session storage.

To get around this I have whipped up the following helper class which will serialize LINQ-To-Sql objects if you set the DataContext's Serializable property to "Unidirectional".

Note: The following class does not current work for storing List<X> where X is a LINQ-To-Sql object. I'll be working to resolve that sometime later this week.

   1: using System;

   2: using System.IO;

   3: using System.Runtime.Serialization;

   4: using System.Text;

   5: using System.Xml;

   6: using System.Web;

   7: 

   8: namespace SquaredRoot.Helper

   9: {

  10:   public class SessionHelper

  11:   {

  12: 

  13:     private SessionHelper(){}

  14: 

  15:         public static T Get<T>( string key ) where T : class

  16:         {

  17: 

  18:             object o = HttpContext.Current.Session[key];

  19:             if( o == null )

  20:                 return default( T );

  21: 

  22:             if( o.GetType() == typeof( string ) && typeof( T ) != typeof( string ) )

  23:             {

  24:                 string s = o as string;

  25:                 Stream stream = new MemoryStream( Encoding.Unicode.GetBytes(s) );

  26:                 XmlDictionaryReader xml = XmlDictionaryReader.CreateTextReader( stream, new XmlDictionaryReaderQuotas() );

  27:                 DataContractSerializer dcs = new DataContractSerializer( typeof( T ) );

  28:                 T t = (T)dcs.ReadObject( xml, true );

  29:                 xml.Close();

  30:                 return t;

  31:             }

  32:             else

  33:                 return o as T;

  34: 

  35:         }

  36: 

  37:         private static bool HasClassAttribute( object o, Type attribute, bool inherit )

  38:         {

  39:             return ( o.GetType().GetCustomAttributes( attribute, inherit ).Length > 0 );

  40:         }

  41: 

  42:         public static void Set( string key, object item )

  43:         {

  44: 

  45:             object value = item;

  46:             if( HasClassAttribute( item, typeof(DataContractAttribute), false )

  47:         && !HasClassAttribute( item, typeof(SerializableAttribute), false ) )

  48:             {

  49:                 DataContractSerializer dcs = new DataContractSerializer(item.GetType());

  50:                 StringBuilder sb = new StringBuilder();

  51:                 XmlWriter writer = XmlWriter.Create(sb);

  52:                 dcs.WriteObject( writer, item );

  53:                 writer.Close();

  54:                 value = sb.ToString();

  55:             }

  56: 

  57:             if( HttpContext.Current.Session[key] == null )

  58:         HttpContext.Current.Session.Add( key, value );

  59:             else

  60:         HttpContext.Current.Session[key] = value;

  61: 

  62:         }

  63: 

  64:     }

  65: }

Add/Update/Delete with LINQPad

// December 5th, 2007 // 6 Comments » // LINQ

Danny Douglass recently posted about LINQPad, a query tool that understands LINQ. I spent some time today using it and am very impressed. It did take a while, however, to look through the numerous sample scripts and figure out exactly how to insert/update/delete data, so I thought I would share what I've found. The biggest changes between working in LINQ-To-SQL in a Visual Studio 2008 project and writing a LINQ query in LINQPad are the lack of a DataContext, the difference between C# Expressions and C# Statements, and the addition of a Dump command.

No Data Context: When you need to interact with a database via LINQ in a Visual Studio 2008 project, you do so by creating a LINQ-To-SQL DBML file that generates a data context for you. This data context is in charge of maintaining your database connection and is what you use to submit changes to the database. Because there is no data context readily available to you (and no .dbml file) in LINQPad, the way you go about this is slightly different. There is a globally-scoped subroutine, "SubmitChanges()," that should be called whenever you wish to commit an action to the database.

C# Expressions vs. C# Statements: By default LINQPad opens in "C# Expression" mode. In this mode you can type a simple query like "from r in Regions select r" and run it to see the results. As far as I can tell there is no way to insert/update/delete data in this mode. By switching to "C# Statement(s)" mode you are able to declare variables, control flow statements, and reference objects; this is the mode you need to be in to insert/update/delete data. To enter "C# Statement(s)" mode, select it from the "Type" drop-down box at the top of the window as show below:

object.Dump(): When you write a query in "C# Expression" mode the result of that query is automatically rendered to the Results frame (shown below). Because "C# Statement(s)" mode gives you the capability to run many queries in one execute, displaying the results of those queries must be manually invoked. To do so simply call the ".Dump()" method on the resultset of the query you want to display. ".Dump()" is implemented as an extension method available on all objects, so whether you are retrieving a single object, a list of objects, or an anonymous type the Dump method will be available to display your data.

Below I have included examples of several ways to query data, as well as an example each for inserting, updating, and deleting data.