Matt Manela's Blog : C#

Useful Moq Extension Method

MattManela — Wed, 25 Nov 2009 00:03:24 GMT

I have been working with ASP .NET MVC and I use the Moq mocking library to help test the code I write. Often in ASP MVC anonymous objects are passed around as function arguments. This is especially common in calls to RouteUrl. Since I want to be able to test this and verify that it is called correctly I wrote a handy extension method to make it easier called AsMatch.

Given a call to generate a Url like this:

var url = Url.RouteUrl("Show", new { projectName="matt" });

You can write a setup on your Mock of the Url helper using a similar syntax:

UrlHelperMock
.Setup(x => x.RouteUrl("Show",new{ projectName="matt"}.AsMatch()))
.Return("someUrlToTest");

Here is the code that defines the AsMatch extension method:

    public static class ObjectMoqExtensions
    {
        public static object AsMatch(this object @object)
        {
            return Match<object>.Create(testObject => DoObjectsMatch(@object, testObject));
        }
        private static bool DoObjectsMatch(object object1, object object2)
        {
            var props1 = ToDictionary(object1);
            var props2 = ToDictionary(object2);
            var query = from prop1 in props1
                        join prop2 in props2 on prop1.Key equals prop2.Key
                        select prop1.Value.Equals(prop2.Value);
            return query.Count(x => x) == Math.Max(props1.Count(), props2.Count());
        }
        public static Dictionary<string, object> ToDictionary(object @object)
        {
            var dictionary = new Dictionary<string, object>();
            var properties = TypeDescriptor.GetProperties(@object);
            foreach (PropertyDescriptor property in properties)
                dictionary.Add(property.Name, property.GetValue(@object));
            return dictionary;
        }
    }

Converting RTF to HTML

MattManela — Mon, 28 Sep 2009 21:28:00 GMT

Have you ever had the desire to convert some RTF text into HTML? Probably not. But if you do, then you are in luck! I recently had the need to do this conversion and after some searching found out a way to do it by enhancing a sample distributed in the MSDN library. The sample is called: XAML to HTML Conversion Demo.

The sample has code which converts HTML to and from a XAML Flow Document. But this doesn’t make things easier until you realize that there is a way to convert RTF to XAML easily. The key is to use System.Windows.Controls.RichTextBox which can load RTF from a stream and save it as XAML. This conversion is shown below:

        private static string ConvertRtfToXaml(string rtfText)
        {
            var richTextBox = new RichTextBox();
            if (string.IsNullOrEmpty(rtfText)) return "";
            var textRange = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);
            using (var rtfMemoryStream = new MemoryStream())
            {
                using (var rtfStreamWriter = new StreamWriter(rtfMemoryStream))
                {
                    rtfStreamWriter.Write(rtfText);
                    rtfStreamWriter.Flush();
                    rtfMemoryStream.Seek(0, SeekOrigin.Begin);
                    textRange.Load(rtfMemoryStream, DataFormats.Rtf);
                }
            }
            using (var rtfMemoryStream = new MemoryStream())
            {
                textRange = new TextRange(richTextBox.Document.ContentStart, richTextBox.Document.ContentEnd);
                textRange.Save(rtfMemoryStream, DataFormats.Xaml);
                rtfMemoryStream.Seek(0, SeekOrigin.Begin);
                using (var rtfStreamReader = new StreamReader(rtfMemoryStream))
                {
                    return rtfStreamReader.ReadToEnd();
                }
            }
        }

With this code we have all we need to convert RTF to HTML. I modified the sample to add this RTF To XAML conversation and then I run that XAML through HTML converter which results in the HTML text. I added an interface to these conversion utilities and converted the sample into a library so that I would be able to use it from other projects. Here is the interface:

 public interface IMarkupConverter
    {
        string ConvertXamlToHtml(string xamlText);
        string ConvertHtmlToXaml(string htmlText);
        string ConvertRtfToHtml(string rtfText);
    }
    public class MarkupConverter : IMarkupConverter
    {
        public string ConvertXamlToHtml(string xamlText)
        {
            return HtmlFromXamlConverter.ConvertXamlToHtml(xamlText, false);
        }
        public string ConvertHtmlToXaml(string htmlText)
        {
            return HtmlToXamlConverter.ConvertHtmlToXaml(htmlText, true);
        }
        public string ConvertRtfToHtml(string rtfText)
        {
            return RtfToHtmlConverter.ConvertRtfToHtml(rtfText);
        }
    }

With this I am now able to convert from RTF to HTML. However, there is one catch - the conversion uses the RichTextBox WPF control which requires a single threaded apartment (STA). Therefore in order to run your code that calls the ConvertRtfToHtml function, it must also be running in a STA. If you can’t have your program run in a STA then you must create a new STA thread to run the conversion. Like this:

MarkupConverter markupConverter = new MarkupConverter();
private string ConvertRtfToHtml(string rtfText)
{
   var thread = new Thread(ConvertRtfInSTAThread);
   var threadData = new ConvertRtfThreadData { RtfText = rtfText };
   thread.SetApartmentState(ApartmentState.STA);
   thread.Start(threadData);
   thread.Join();
   return threadData.HtmlText;
}
private void ConvertRtfInSTAThread(object rtf)
{
   var threadData = rtf as ConvertRtfThreadData;
   threadData.HtmlText = markupConverter.ConvertRtfToHtml(threadData.RtfText);
}
        
private class ConvertRtfThreadData
{
   public string RtfText { get; set; }
   public string HtmlText { get; set; }
}

Here is the zip contain the code for the Markup converter: MarkupConverter.zip

I finally got fed up with Enum.Parse

MattManela — Fri, 24 Jul 2009 19:02:04 GMT

I don’t know why I didn’t do this long ago, but I am done writing this:

var val = (SomeEnum)Enum.Parse(typeof(SomeEnum),”someString”);

I have typed this too many times and it annoys me.

I wrote a small extension method on the string type to make this better:

public static class StringExtensions
{
    public static T ToEnum<T>(this string @string)
    {
        return (T)Enum.Parse(typeof (T), @string);
    }
}

With this I can now write the previous line as:

var val = "someString".ToEnum<SomeEnum>()

It is a bit shorter and I think much more readable.

My xUnit.net Visual Studio Code Snippets

MattManela — Tue, 03 Mar 2009 02:58:00 GMT

The xUnit .Net codeplex page lists one useful Visual Studio code snippet for creating a Fact. As you can tell I am fairly fond of code snippets so I created a few more which I use when writing xUnit.net facts. These are one line snippets that I find very convenient when writing my assertions.

Below is a table which shows the shortcut you use to access the snippet and the code the snippet generates

Shortcut	Snippet
ae	Assert.Equal($expected$,$actual$)
ane	Assert.NotEqual($expected$,$actual$)
an	Assert.Null($actual$)
ann	Assert.NotNull($actual$)
at	Assert.True($actual$)
af	Assert.False($actual$)

I have included a zip containing these snippets. Enjoy!

Inline Regular Expression Options

MattManela — Thu, 01 Jan 2009 23:10:15 GMT

I was using attributes from the System.ComponentModel.DataAnnotations namespace for model validation. This namespace includes a few very useful validation attributes such as

Required Attribute – Validates the field has a value
Range Attribute – Validates the field is within a given range
RegularExpression Attribute – Validates the field matches a given regular expression.

The regular expression attribute is very useful since you can describe exactly what format you want a string property to be in. While using this though I ran into a problem. The attribute doesn’t let you specify RegexOptions. This was an issue for me since I wanted to use the regex to validate that the users input was between 5 and 200 characters long , so I had attribute that property as such:

        1: [RegularExpression(@".{5,200}")]

       2: public string Text{get;set;}

However this doesn’t work since by default the wildcard . does not match new lines (which I am allowing in the input). The way to fix this is to specify the RegexOptions.SingleLine option to either the Regex constructor or Match function. The problem is I have no way of doing that here, and there is no argument on the attribute constructor to specify those options. I was considering overriding the attribute to create one that allows specifying the attribute but then I stumbled upon this:

Regular Expression Options

You are able to specify the regex option inside of the regular expression text! (which I thought was a huge discovery until my co-worker said he knew this all along but never let me know!).

So I just changed the expression to look like this:

       1: [RegularExpression(@"(?s).{5,200}")]

       2: public string Text{get; set;}

The (?s) is the inline regex option definition so say I want this in SingleLine mode! And now the validation works the way I wanted!

Model Binder

MattManela — Tue, 16 Dec 2008 09:45:27 GMT

When working with a multi-tier application I often find myself converting from one of the tiers object models to my own similar (but often different) model. I often write code that would set one by one each property from a web tier object to my object. In order to make this easier I wrote this object binder. It is a fake deep copy in a way. You tell it what destination type you want to build and give it a source object and it will go through each property (matching by names) and checks if it can copy from that property from the source to the destination. If it can’t it will call itself again on that object to try to copy its properties.

Here is the code:

        1: using System;

       2: using System.Reflection;

       3: using System.Collections;

       4:  

       5: namespace Binder

       6: {

       7:     public class ObjectBinder

       8:     {

       9:         /// <summary>

        /// Copies one object to an instance of a different type.

        /// 

        /// Assumptions:

        /// Object which implements IList'1 also implements IList 

        /// Object which implements IDictionary'2 also implements IDictionary 

        /// </summary>

        /// <typeparam name="T"></typeparam>

        /// <param name="source">The source.</param>

        /// <returns></returns>

        public static T Copy<T>(object source) where T : new()

        {

            return (T)Copy(source, typeof(T));

        }

  

  

        private static object Copy(object source, Type destinationType)

        {

            if (source == null) throw new ArgumentNullException("source", "source must not be null");

  

            var destination = Activator.CreateInstance(destinationType);

  

            var sourceProperties = source.GetType().GetProperties();

            foreach (var sourceProp in sourceProperties)

            {

                var sourcePropType = sourceProp.PropertyType;

                var destinationProp = destination.GetType().GetProperty(sourceProp.Name);

  

                if (sourceProp.CanRead && destinationProp != null && destinationProp.CanWrite)

                {

                    var destinationPropType = destinationProp.PropertyType;

                    Type sourcePropInterfaceType = null;

                    Type destinationPropInterfaceType = null;

  

                    // Skip indexer properties

                    if (sourceProp.GetIndexParameters().Length > 0) continue;

                    

                    var sourceValue = sourceProp.GetValue(source, null);

                    if (sourceValue == null) continue;

  

                    object destinationValue = null;

                    if (destinationPropType.IsAssignableFrom(sourcePropType))

                    {

                        destinationValue = sourceValue;

                    }

                    else if (

                        (sourcePropInterfaceType = sourcePropType.GetInterface("IList`1", true)) != null &&

                        (destinationPropInterfaceType = destinationPropType.GetInterface("IList`1", true)) != null)

                    {

  

                        var sourceArgType = sourcePropInterfaceType.GetGenericArguments()[0];

                        var destArgType = destinationPropInterfaceType.GetGenericArguments()[0];

                        bool isAssignable = destArgType.IsAssignableFrom(sourceArgType);

  

                        IList listCopy = null;

  

                        if (destinationPropType.IsArray)

                        {

                            // If array there must be a one argument constructor

                            listCopy = (IList)Activator.CreateInstance(destinationPropType, ((IList)sourceValue).Count);

                        }

                        else

                        {

                            // If not an array require a parameterless constructor

                            if (destinationPropType.GetConstructor(Type.EmptyTypes) == null) continue;

                            listCopy = (IList)Activator.CreateInstance(destinationPropType);

                        }

  

                        int index = 0;

                        foreach (var item in ((IList)sourceValue))

                        {

                            var itemCopy = item;

                            if (!isAssignable)

                                itemCopy = Copy(item, destArgType);

  

                            if (destinationPropType.IsArray)

                                listCopy[index] = itemCopy;

                            else

                                listCopy.Add(itemCopy);

  

                            index++;

                        }

  

                        destinationValue = listCopy;

                    }

                    else if (

                        (sourcePropInterfaceType = sourcePropType.GetInterface("IDictionary`2", true)) != null &&

                        (destinationPropInterfaceType = destinationPropType.GetInterface("IDictionary`2", true)) != null)

                    {

  

                        var sourceArgTypes = sourcePropInterfaceType.GetGenericArguments();

                        var destArgTypes = destinationPropInterfaceType.GetGenericArguments();

                        bool isKeyAssignable = destArgTypes[0].IsAssignableFrom(sourceArgTypes[0]);

                        bool isValueAssignable = destArgTypes[1].IsAssignableFrom(sourceArgTypes[1]);

  

                        var defaultConstructor = destinationPropType.GetConstructor(Type.EmptyTypes);

                        if (defaultConstructor == null) continue;

                        var dictionaryCopy = Activator.CreateInstance(destinationPropType) as IDictionary;

  

                        foreach (DictionaryEntry pair in ((IDictionary)sourceValue))

                        {

                            var keyCopy = pair.Key;

                            var valueCopy = pair.Value;

                            if (!isKeyAssignable)

                                keyCopy = Copy(keyCopy, destArgTypes[0]);

                            if (!isValueAssignable)

                                valueCopy = Copy(valueCopy, destArgTypes[1]);

  

                            dictionaryCopy.Add(keyCopy, valueCopy);

                        }

  

                        destinationValue = dictionaryCopy;

                    }

                    else

                    {

                        destinationValue = Copy(sourceValue, destinationPropType);

                    }

  

  

                    destinationProp.SetValue(destination, destinationValue, null);

  

                }

            }

  

  

            return destination;

        }

    }

}

And the tests using XUnit.Net:

       1: using System;

       2: using System.Collections.Generic;

       3: using System.Linq;

       4: using System.Text;

       5: using Xunit;

       6: using System.Collections.ObjectModel;

       7:  

       8: namespace Binder

       9: {

    public class ObjectBinderFacts

    {

        public class The_Copy_Method

        {

  

            [Fact]

            public void throws_if_source_is_null()

            {

  

                Exception ex = Record.Exception(() => ObjectBinder.Copy<Destination>(null));

  

                Assert.IsType<ArgumentNullException>(ex);

                Assert.Equal("source", ((ArgumentNullException)ex).ParamName);

            }

  

            [Fact]

            public void will_copy_assignable_scalar_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.A, res.A);

                Assert.Equal(source.B, res.B);

                Assert.Equal(source.C, res.C);

                Assert.Equal(source.D, res.D);

                Assert.Equal(source.E, res.E);

  

            }

  

            [Fact]

            public void will_copy_assignable_generic_list_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.F.Count, res.F.Count);

                Assert.Equal(source.F[0], res.F[0]);

                Assert.Equal(source.F[1], res.F[1]);

  

            }

  

            [Fact]

            public void will_copy_assignable_array_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.N.Length, res.N.Length);

                Assert.Equal(source.N[0], res.N[0]);

                Assert.Equal(source.N[1], res.N[1]);

  

            }

  

            [Fact]

            public void will_copy_unassignable_array_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.O.Length, res.O.Length);

                Assert.Equal(source.O[0].Value, res.O[0].Value);

                Assert.Equal(source.O[1].Value, res.O[1].Value);

  

            }

  

            [Fact]

            public void will_copy_assignable_generic_dictionary_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.J.Count, res.J.Count);

                Assert.Equal(source.J["a"], res.J["a"]);

                Assert.Equal(source.J["b"], res.J["b"]);

  

            }

  

            [Fact]

            public void will_copy_unassignable_generic_dictionary_with_assignable_keys_and_values()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.K.Count, res.K.Count);

                Assert.Equal(source.K["a"], res.K["a"]);

                Assert.Equal(source.K["b"], res.K["b"]);

  

            }

  

            [Fact]

            public void will_copy_unassignable_generic_dictionary_with_assignable_keys_and_unassignable_values()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.L.Count, res.L.Count);

                Assert.Equal(source.L["a"].Value, res.L["a"].Value);

                Assert.Equal(source.L["b"].Value, res.L["b"].Value);

  

            }

  

            [Fact]

            public void will_copy_unassignable_generic_dictionary_with_unassignable_keys_and_unassignable_values()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.M.Count, res.M.Count);

                Assert.Equal(source.M[new SomeObject { Value = 1 }].Value, res.M[new OtherObject { Value = 1 }].Value);

                Assert.Equal(source.M[new SomeObject { Value = 2 }].Value, res.M[new OtherObject { Value = 2 }].Value);

  

            }

  

            [Fact]

            public void will_copy_unassignable_generic_list_with_assignable_values()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.G.Count, res.G.Count);

                Assert.Equal(source.G[0], res.G[0]);

                Assert.Equal(source.G[1], res.G[1]);

  

            }

  

            [Fact]

            public void will_copy_unassignable_object_property()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.H.Value, res.H.Value);

  

            }

  

            [Fact]

            public void will_copy_unassignable_generic_list_properties()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<Destination>(source);

  

                Assert.Equal(source.I.Count, res.I.Count);

                Assert.Equal(source.I[0].Value, res.I[0].Value);

                Assert.Equal(source.I[1].Value, res.I[1].Value);

  

            }

  

            [Fact]

            public void will_return_object_with_default_values_if_no_properties_match()

            {

                var source = new Source();

  

                var res = ObjectBinder.Copy<SomeObject>(source);

  

                Assert.Equal(0, res.Value);

            }

  

            class SomeObject

            {

                public int Value { get; set; }

  

                public override int GetHashCode()

                {

                    return Value;

                }

  

                public override bool Equals(object obj)

                {

                    var some = obj as SomeObject;

                    if (obj == null) return false;

                    return some.Value == Value;

                }

            }

  

            class OtherObject

            {

                public int Value { get; set; }

  

                public override int GetHashCode()

                {

                    return Value;

                }

  

                public override bool Equals(object obj)

                {

                    var some = obj as OtherObject;

                    if (obj == null) return false;

                    return some.Value == Value;

                }

            }

  

            class OtherDictionary<TKey, TValue> : Dictionary<TKey, TValue>

            {

  

            }

  

            class Source

            {

                public Source()

                {

                    A = "String";

                    B = 5;

                    C = Guid.NewGuid();

                    D = 5.5;

                    E = 'a';

                    F = new List<int> { 1, 2 };

                    G = new List<string> { "a", "b" };

                    H = new SomeObject();

                    I = new List<SomeObject> { new SomeObject { Value = 1 }, new SomeObject { Value = 2 } };

                    J = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };

                    K = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };

                    L = new Dictionary<string, SomeObject> { { "a", new SomeObject { Value = 1 } }, { "b", new SomeObject { Value = 2 } } };

                    M = new Dictionary<SomeObject, SomeObject> {

                        { new SomeObject { Value = 1 }, new SomeObject { Value = 10 } }, 

                        { new SomeObject { Value = 2 }, new SomeObject { Value = 20 } } 

                    };

                    N = new[] { 1, 2 };

                    O = new[] { new SomeObject { Value = 1 }, new SomeObject { Value = 2 } };

                }

  

                // Assignable

                public string A { get; set; }

                public int B { get; set; }

                public Guid C { get; set; }

                public double D { get; set; }

                public char E { get; set; }

                public List<int> F { get; set; }

                public Dictionary<string, int> J { get; set; }

                public int[] N { get; set; }

  

                // Not assignable

                public List<string> G { get; set; }

                public SomeObject H { get; set; }

                public List<SomeObject> I { get; set; }

                public Dictionary<string, int> K { get; set; }

                public Dictionary<string, SomeObject> L { get; set; }

                public Dictionary<SomeObject, SomeObject> M { get; set; }

                public SomeObject[] O { get; set; }

            }

  

  

            class Destination

            {

                public string A { get; set; }

                public int B { get; set; }

                public Guid C { get; set; }

                public double D { get; set; }

                public char E { get; set; }

                public List<int> F { get; set; }

                public Dictionary<string, int> J { get; set; }

                public int[] N { get; set; }

  

                public Collection<string> G { get; set; }

                public OtherObject H { get; set; }

                public List<OtherObject> I { get; set; }

                public OtherDictionary<string, int> K { get; set; }

                public Dictionary<string, OtherObject> L { get; set; }

                public Dictionary<OtherObject, OtherObject> M { get; set; }

                public OtherObject[] O { get; set; }

            }

        }

    }

}

One possible enhancement I thought about was to add a attribute to indicate on the destination model that is maps to a property of a different name. I haven’t had a need for it yet but I will surely add it when I do.

SQL CE 3.5 with LINQ to SQL Revisited

MattManela — Fri, 26 Sep 2008 18:26:08 GMT

A few days ago I made a post about using SQL CE 3.5 with LINQ to SQL. I described a way to use connection pooling with SQL CE. A gracious blog reader (Mike Brown) pointed out a way I could make my solution much simpler by using the [ThreadStatic] attribute. I never heard of this attribute but it is really nifty. You mark a field with it and then each thread that accesses that field will be accessing a unique instance of it!

Using this attribute my code for connection pooling went from this:

/// <summary>
/// Manages open connections on a per-thread basis
/// </summary>
public class ConnectionPool
{
    private Dictionary<int, IDbConnection> threadConnectionMap;
 
    /// <summary>
    /// Gets the connection string.
    /// </summary>
    /// <value>The connection string.</value>
    public string ConnectionString
    {
        get;
        private set;
    }
 
    /// <summary>
    /// Gets a connection.
    /// </summary>
    /// <returns>An open connection</returns>
    public IDbConnection Connection
    {
        get
        {
            lock (threadConnectionMap)
            {
                int threadId = Threading.Thread.CurrentThread.ManagedThreadId;
 
                IDbConnection connection = null;
                if (threadConnectionMap.ContainsKey(threadId))
                {
                    connection = threadConnectionMap[threadId];
                }
                else
                {
                    connection = new SqlCeConnection(ConnectionString);
                    connection.Open();
                    threadConnectionMap.Add(threadId, connection);
                }
 
                return connection;
            }
        }
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="ConnectionPool"/> class.
    /// </summary>
    /// <param name="connectionString">The connection string.</param>
    public ConnectionPool(string connectionString)
    {
        threadConnectionMap = new Dictionary<int, IDbConnection>();
        ConnectionString = connectionString;
    }

to this:

/// <summary>
    /// Manages open connections on a per-thread basis
    /// </summary>
    public class ConnectionPool
    {
        [ThreadStatic]
        private IDbConnection threadConnection;

        /// <summary>
        /// Gets the connection string.
        /// </summary>
        /// <value>The connection string.</value>
        public string ConnectionString
        {
            get;
            private set;
        }

        /// <summary>
        /// Gets a connection.
        /// </summary>
        /// <returns>An open connection</returns>
        public IDbConnection Connection
        {
            get
            {
                if (threadConnection == null)
                {
                    threadConnection = new SqlCeConnection(ConnectionString);
                    threadConnection.Open();
                }

                return threadConnection;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ConnectionPool"/> class.
        /// </summary>
        /// <param name="connectionString">The connection string.</param>
        public ConnectionPool(string connectionString)
        {
            ConnectionString = connectionString;
        }
    }

Very nice and clean.

Thanks Mike!

SQL CE 3.5 with LINQ to SQL

MattManela — Wed, 10 Sep 2008 00:04:35 GMT

Using LINQ to SQL with SQL CE 3.5 can be a bit of a challenge. First off, the LINQ to SQL Visual Studio designer doesn't support SQL CE so you need to run sqlmetal from the command line to create the object model (or write it by hand). Once you get past this point then you can use LINQ to SQL the same way you would for SQL Sever BUT there is a catch.

The way LINQ to SQL is built makes it work well with SQL Server and its connection pooling ability. If you look at this FAQ under the "Database Connection: Open How Long?" section it says:

A connection typically remains open until you consume the query results.

Therefore given the following code:

   1: using(Northwind db = new Northwind(MyConnectionString))

   2: {

   3:     (from p in db.Products).ToList();

   4:     (from p in db.Customers).ToList();

   5: }

On line 3 and 4 in the above code will open a database connection (which will be pulled from the open connections in connection pool), execute the query, and then close the connection after the operation is completed (which will return the connection to the pool).

This works great with connection pooling but when you move to SQL CE you don't have that luxury. What happens now is that for each query a new SQL CE connection will be opened, the query will be executed and then the connection is closed. Each query is incurring the cost of opening a new connection. To make matters even worse, in SQL CE the first open connection brings the database engine into memory, and once you have no open connections anymore it removes the engine from memory. What this means is that each time we close the only open connection and then re-open we are incurring a HUGE cost.

One way to get around this is to pass into the DataContext an open SQLCeConnection object. LINQ to SQL will only automatically close a connection if it opens it. Therefore, if you pass it an open connection then you won't incur this cost over and over again. This will work fine in a single threaded application but once you move to a mutlithreaded app where you are performing database operations from different threads you encounter a problem: The SQLCeConnection object is not thread safe. You need to have a different connection object per thread in order to make this work. What you want is to be able to request a connection from any thread and get an already opened one for that thread. This sounds a lot like a simple connection pooler, which could look something like this:

/// <summary>
/// Manages open connections on a per-thread basis
/// </summary>
public class ConnectionPool
{
    private Dictionary<int, IDbConnection> threadConnectionMap;
 
    /// <summary>
    /// Gets the connection string.
    /// </summary>
    /// <value>The connection string.</value>
    public string ConnectionString
    {
        get;
        private set;
    }
 
    /// <summary>
    /// Gets a connection.
    /// </summary>
    /// <returns>An open connection</returns>
    public IDbConnection Connection
    {
        get
        {
            lock (threadConnectionMap)
            {
                int threadId = Threading.Thread.CurrentThread.ManagedThreadId;
 
                IDbConnection connection = null;
                if (threadConnectionMap.ContainsKey(threadId))
                {
                    connection = threadConnectionMap[threadId];
                }
                else
                {
                    connection = new SqlCeConnection(ConnectionString);
                    connection.Open();
                    threadConnectionMap.Add(threadId, connection);
                }
 
                return connection;
            }
        }
    }
 
    /// <summary>
    /// Initializes a new instance of the <see cref="ConnectionPool"/> class.
    /// </summary>
    /// <param name="connectionString">The connection string.</param>
    public ConnectionPool(string connectionString)
    {
        threadConnectionMap = new Dictionary<int, IDbConnection>();
        ConnectionString = connectionString;
    }

With this you create a DataContext like this:

   1: // Defined somewhere

   2: ConnectionPool connectionPool = new ConnectionPool(MyConnectionString);

3:

   4: // ...

   5: // ...

6:

   7: using(Northwind db = new Northwind(connectionPool.Connection))

   8: {

   9:     (from p in db.Products).ToList();

  10:     (from p in db.Customers).ToList();

  11: }

Now each thread will have its own open connection which will minimize the cost of opening connections.

CollectionView.DeferRefresh() : My new best friend

MattManela — Fri, 29 Aug 2008 00:23:20 GMT

Well, maybe not best friend but its a nice function. When working with bound collections in WPF you often end up dealing with a CollectionView. This is the MSDN documentation description of a CollectionView :

You can think of a collection view as a layer on top of a binding source collection that allows you to navigate and display the collection based on sort, filter, and group queries, all without having to manipulate the underlying source collection itself.

As stated above the main use of the CollectionView is to enable modifying the visible collection without actually changing the underlying data. In the application I am working on I let the user change what a ListBox is sorted by. This is the code I originally had:

        1: ICollectionView dataView = CollectionViewSource.GetDefaultView(listBox.ItemsSource);

       2: dataView.SortDescriptions.Clear();

       3: SortDescription sd = new SortDescription(newField, ListSortDirection.Ascending);

       4: dataView.SortDescriptions.Add(sd);

The problem with this code is that it causes the view to refresh twice! The Clear and Add function both trigger a SortDescriptionsChanged event which leads to a Refresh of the view. This problem becomes worse when you are also adding or changing filter in addition to sort descriptions and your collection is very large. This could visibly slow you application.

This is where my friend DeferRefresh comes in. If you change the code above to this:

       1: ICollectionView dataView = CollectionViewSource.GetDefaultView(listBox.ItemsSource);

       2: using (dataView.DeferRefresh())

       3: {

       4:     dataView.SortDescriptions.Clear();

       5:     SortDescription sd = new SortDescription(newField, ListSortDirection.Ascending);

       6:     dataView.SortDescriptions.Add(sd);

       7: }

Now the CollectionView will only be refreshed once! All the methods inside the using block will no longer cause a refresh, they will just indicate that a refresh is needed. Then when the code leaves the using block the method EndDefer() is called which just refreshes the CollectionView if needed.

Generic Insert and Update for LINQ To SQL

MattManela — Wed, 13 Aug 2008 00:46:04 GMT

Quick code snippet time!

The following are generic methods for inserting and updating a detached entity into a database using LINQ to SQL.

        1: /// <summary>

       2: /// Updates the database with item.

       3: /// </summary>

       4: /// <typeparam name="T">Type of the item</typeparam>

       5: /// <param name="item">The item.</param>

       6: public static void UpdateDatabaseWithItem<T>(T item) where T : class

       7: {

       8:     var store = GetNewDataContext();

       9:     var table = store.GetTable<T>();

      10:     table.Attach(item);

      11:     store.Refresh(RefreshMode.KeepCurrentValues, item);

      12:     store.SubmitChanges();

      13: }

      14:  

      15:  

      16: /// <summary>

      17: /// Inserts the item into database.

      18: /// </summary>

      19: /// <typeparam name="T">Type of the item</typeparam>

      20: /// <param name="item">The item.</param>

      21: public static void InsertItemIntoDatabase<T>(T item) where T : class

      22: {

      23:     var store = GetNewDataContext();

      24:     var table = store.GetTable<T>();

      25:     table.InsertOnSubmit(item);

      26:     store.SubmitChanges();

      27: }

GetNewDataContext() is a method (not shown) which does what its name says, returns a data context.

The only part that is not really obvious is on line 11. That line is a "hack" to allow you to attach an entity as modified without using a timestamp or turning off optimistic concurrency or attaching a previous version of the entity. What this means is that this update will throw a fit if there is a concurrency error! However, for my use of this code ( mainly for unit test preparation ) it works great.

Foreach is Duck Typed!

MattManela — Tue, 22 Jul 2008 20:04:00 GMT

I thought I know how the foreach construct worked under the covers. I figured the compiler would check if the type being iterated over implement IEnumerable or IEnumerator. And if so it will call MoveNext and Current to loop over the elements. But then I read this:

http://blogs.msdn.com/kcwalina/archive/2007/07/18/DuckNotation.aspx

In that post Krzysztof reveals that in reality implementation of those interfaces are NOT checked. In fact, it uses duck typing to determine if iteration can occur. The compiler will just look for a method that matches a certain signature and use that.

Very interesting!

ArgumentNullException vs ArgumentException

MattManela — Thu, 29 May 2008 07:17:59 GMT

Both ArgumentNullException and ArgumentException have a constructor which takes two strings. One is the name of the parameter (or argument) in question and the other is a string describing the exception.

The funny/odd/interesting thing about them is that one has the opposite order of arguments.

For ArgumentException the constructor is:

   1: public ArgumentException(   2:     string message,   3:     string paramName   4: )

While for ArgumentNullException is it:

   1: public ArgumentNullException(   2:     string paramName,   3:     string message   4: )

And my point is....

Well, I don't have one I just thought it was an interesting thing to point out :)

Intro to LINQ to SQL Optimistic Concurrency

MattManela — Fri, 23 May 2008 06:40:00 GMT

After some investigation I feel I have a decent understanding on how LINQ to SQL concurrency works.

LINQ to SQL uses optimistic concurrency which means that it never takes an exclusive lock on a table. It caches the information you are working with and then (by default) when you submit changes verifies that the table is in the same state as when you started. If it isn’t an exception is thrown allowing you to merge values if needed.

Now for more details :)

Let’s say I have two tables:

Albums

- ID (primary key)

- Name

- Year

Songs

- ID (primary key)

- AlbumID (foreign key)

- Name

- Lyrics

LINQ to SQL will turn these tables into two classes that looks vaguely similar but much more complex than this:

   1: class Albums {   2:     [Column(UpdateCheck=UpdateCheck.Always)]   3:     public int ID { get; set; }   4:        5:     [Column(UpdateCheck=UpdateCheck.Always)]   6:     public string Name  { get; set; }   7:        8:     [Column(UpdateCheck=UpdateCheck.Always)]   9:     public int Year { get; set; }  10: }  11:    12: class Songs {  13:     [Column(UpdateCheck=UpdateCheck.Always)]  14:     public int ID { get; set; }  15:       16:     [Column(UpdateCheck=UpdateCheck.Always)]  17:     public string Name  { get; set; }  18:    19:     [Column(UpdateCheck=UpdateCheck.Always)]  20:     public string Lyrics { get; set; }  21:       22:     [Column(UpdateCheck=UpdateCheck.Always)]  23:     public int AlbumID { get; set; }  24: }

I oversimplified many of the details and changed some to help describe how the concurrency works.

You may notice that each property in the class maps to a column in the table. In addition, each property has an attribute on it which gives extra details about it.

The Column attribute means the property maps to a column and inside that attribute there is a UpdateCheck property. This determines what role this column plays in the optimistic concurrency checking. The UpdateCheck enum has three possible values:

UpdateCheck.Always - This column is always checked for concurrency

UpdateCheck.Never – This column is never checked for concurrency

UpdateCheck.WhenChanged – This column is only checked for concurrency when you change the corresponding property's value in your local copy.

When I first read this it meant little to me so I dug deeper to see exactly what SQL queries LINQ to SQL would create.

Assume that (as shown above) I have all columns set with UpdateCheck.Always (which is the default behavior) . Let’s say in the Albums table I have a row with the values: ID = 1, Name = “DanceMix”, Year = 2007. And we want to update the name of this album using LINQ to SQL :

   1: // connect to db using linqtosql datacontext   2: DataContext db = new DataContext(CONNECTION_STRING);    3:     4: // select the album with an ID of 1, this will cache this album   5: var someAlbum = db.Albums.Single(album => album.ID == 1);    6:     7: // make the new name “BestDance”   8: someAlbum.Name = “BestDance”;    9:    10: db.SubmitChanges();

The update SQL call generated behind the scenes will look something like this:

   1: UPDATE Albums    2: SET Name = “BestDance”   3: WHERE    4: ID = ‘1’ AND Name = ‘DanceMix’ AND Year=2007

As you can see, the SQL query is checking to make sure ALL fields in the Album table are the same as they were when we queried for it. All the fields are included since we set the UpdateCheck property for each field to UpdateCheck.Always. If we had set all of them to UpdateCheck.Never the same query would become:

   1: UPDATE Albums    2: SET Name = “BestDance”   3: WHERE    4: ID = ‘1’

Notice now that Name and Year columns are excluding from the where clause since we are telling LINQ to SQL to not check them for concurrency.

If we had UpdateCheck on each column set to UpdateCheck.WhenChanged the generated query would be:

   1: UPDATE Albums    2: SET Name = “BestDance”   3: WHERE    4: ID = ‘1’ AND Name = ‘DanceMix’

Since we modified Name locally it is included in the concurrency check because that is what UpdateCheck. WhenChanged means.

When we do have a conflict the update will fail and then an exception is thrown. We can catch that exception and LINQ to SQL will give us a list of all items in conflict. From here we can tell LINQ what do to. Such as overwrite database values, overwrite local values or merge values.

For some more info on the concurrency please visit: http://msdn.microsoft.com/en-us/library/bb399373.aspx it isn’t very long.

For more information on how to merge if we have a concurrency exception go here: http://msdn.microsoft.com/en-us/library/bb298529.aspx

For a very long but more detailed look at LINQ to SQL in general go here: http://msdn.microsoft.com/en-us/library/bb425822.aspx

Closures and Pass by Reference

MattManela — Thu, 01 May 2008 05:15:24 GMT

What do you think the following code will do?

Compile time error
Run time error
Work fine

   1: static void Main(string[] args)   2: {   3:     int x = 10;   4:     int y = 5;   5:     Swap(ref x, ref y);   6: }   7:     8:     9: static void Swap(ref int x, ref int y)  10: {  11:     int temp = x;  12:     x = y;  13:     y = temp;  14:     Func<int> closure = () => x;  15: }

If you said 1. Compile time error then you would be correct. The resulting error message is:

Cannot use ref or out parameter 'x' inside an anonymous method, lambda expression, or query expression

The reason for this is that although C# provides the ability to pass parameters by reference (as opposed to by value), it offers no way to assign to a variable by reference.

This ability exists in C++ :

   1: int x = 5;   2: int & y = x;

Now y refers to the same variable location as x.

So, what does this all have to do with the original code? As I described in my previous post Understanding Variable Capturing in C#, since we are using the variable x in a lambda expression (a.k.a. a closure) the C# compiler will rewrite the method so that it looks something like this:

   1: class Capture   2: {   3:     public int x;   4:     public int Lambda()   5:     {   6:         return this.x;   7:     }   8: }   9:    10: static void Swap(ref int x, ref int y)  11: {  12:     Capture capture = new Capture();  13:     capture.x = x;  14:     int temp = capture.x;  15:     capture.x = y;  16:     y = temp;  17:     Func<int> closure = () => capture.x;  18: }

Do you see the problem now? On line 13 the ref parameter x is being assigned to the member variable x of the Capture class. But since you can't assign by reference this would change the semantics of the method. The C# compiler is smart enough to know this, so it throws the error. It won't generate code that has different meaning than what the user intended.

Covariance and Contravariance

MattManela — Mon, 31 Mar 2008 02:21:25 GMT

I just finished reading the series of ten blog posts by Eric Lippert about covariance and contravariance. These topics were new to me but after reading this blog series it all made sense. It finally explained to me why some things which I thought I should be able to do does not work in C#.

One example of this is assigning collection to each other. For example look at this code:

IEnumerable<String> strings = new List<String> { "sttt" };
IEnumerable<Object> objects = strings;

This code will cause the compile time error:

"Cannot implicitly convert type 'System.Collections.Generic.IEnumerable' to 'System.Collections.Generic.IEnumerable'. An explicit conversion exists (are you missing a cast?) at line 2 column 31 "

Although the code makes logical sense it wont work. After reading Lippert's blog series I can now explain way. Interfaces in C# are NOT covariant on their generic type parameters. This means that even though you can assign a String to an Object, you cannot assign Interface<String> into Interface<Object>. In order to do so you would need to allow the programmer to specify when he wanted variance since many times this behavior is not desired.

For example if the type argument is used as a both a function parameter and a return value in the interface then you want it to be invariant.

This is just a taste of what is described in the blog series so I encourage you to go read and enjoy!.