Omer van Kloeten's .NET Zen

Extension Methods Roundup: Remove, Aggregate, At, AsIndexed and Friends

2008-06-19T19:28:00Z

Hey hey hey! It's time for another Extension Methods Roundup! Here are some of the extension methods I've written since the last one:

Dictionary's Missing Remove Methods

public static void Remove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TValue value)
{
    // Check to see that dictionary is not null
    if (dictionary == null)
        throw new ArgumentNullException("dictionary");

    foreach (var key in (from pair in dictionary
                         where EqualityComparer<TValue>.Default.Equals(value, pair.Value)
                         select pair.Key).ToArray())
    {
        dictionary.Remove(key);
    }
}

public static void RemoveRange<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, IEnumerable<TValue> values)
{
    // Check to see that dictionary is not null
    if (dictionary == null)
        throw new ArgumentNullException("dictionary");

    // Check to see that values is not null
    if (values == null)
        throw new ArgumentNullException("values");

    foreach (var value in values.ToArray())
    {
        ExtensionMethods.Remove(dictionary, value);
    }
}

public static void RemoveRange<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, IEnumerable<TKey> keys)
{
    // Check to see that dictionary is not null
    if (dictionary == null)
        throw new ArgumentNullException("dictionary");

    // Check to see that keys is not null
    if (keys == null)
        throw new ArgumentNullException("keys");

    foreach (var key in keys.ToArray())
    {
        dictionary.Remove(key);
    }
}

String Aggregation

public static string Aggregate(this IEnumerable<string> enumeration, string separator)
{
    return Aggregate(enumeration, str => str, separator);
}

public static string Aggregate<T>(this IEnumerable<T> enumeration, Func<T, string> toString, string separator)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    // Check to see that toString is not null
    if (toString == null)
        throw new ArgumentNullException("toString");

    // Check to see that separator is not null or an empty string
    if (string.IsNullOrEmpty(separator))
        throw new ArgumentNullException("separator");

    return enumeration.Aggregate(string.Empty,
        (accum, item) => string.Format("{0}{1}{2}", accum, separator, toString(item)),
        str => str.Length > separator.Length ? str.Substring(separator.Length) : str);
}

Those are very good for when you want to create strings such as "a, b, c, d".

LastOrDefault

public static T LastOrDefault<T>(this IList<T> list)
{
    // Check to see that list is not null
    if (list == null)
        throw new ArgumentNullException("list");

    if (list.Count == 0)
        return default(T);

    return list[list.Count - 1];
}

This is an optimized version of the original LastOrDefault for lists that allow random access.

At

public static T At<T>(this IEnumerable<T> enumeration, int index)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    return enumeration.Skip(index).First();
}

public static IEnumerable<T> At<T>(this IEnumerable<T> enumeration, params int[] indices)
{
    return At(enumeration, (IEnumerable<int>)indices);
}

public static IEnumerable<T> At<T>(this IEnumerable<T> enumeration, IEnumerable<int> indices)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    // Check to see that indices is not null
    if (indices == null)
        throw new ArgumentNullException("indices");

    int currentIndex = 0;

    foreach (int index in indices.OrderBy(i => i))
    {
        while (currentIndex != index)
        {
            enumeration = enumeration.Skip(1);
            currentIndex++;
        }

        yield return enumeration.First();
    }
}

At provides pseudo-random access to enumerable lists, where needed. I've found use for it in a couple of places which returned indices for non-IList<T> enumerations.

SequenceEqual<T1, T2>

public static bool SequenceEqual<T1, T2>(this IEnumerable<T1> left, IEnumerable<T2> right, Func<T1, T2, bool> comparer)
{
    using (IEnumerator<T1> leftE = left.GetEnumerator())
    {
        using (IEnumerator<T2> rightE = right.GetEnumerator())
        {
            bool leftNext = leftE.MoveNext(), rightNext = rightE.MoveNext();

            while (leftNext && rightNext)
            {
                // If one of the items isn't the same...
                if (!comparer(leftE.Current, rightE.Current))
                    return false;

                leftNext = leftE.MoveNext();
                rightNext = rightE.MoveNext();
            }

            // If left or right is longer
            if (leftNext || rightNext)
                return false;
        }
    }

    return true;
}

This differs from the original SequenceEqual in that it is able to accept two different types of sequences.

AsIndexed

public static IEnumerable<KeyValuePair<int, T>> AsIndexed<T>(this IEnumerable<T> enumeration)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    int i = 0;

    foreach (var item in enumeration)
    {
        yield return new KeyValuePair<int, T>(i++, item);
    }
}

This is when you need indices, but don't want the overhead of creating an Array<T>.

The Missing SelectMany

public static IEnumerable<T> SelectMany<T>(this IEnumerable<IEnumerable<T>> source)
{
    // Check to see that source is not null
    if (source == null)
        throw new ArgumentNullException("source");

    foreach (var enumeration in source)
    {
        foreach (var item in enumeration)
        {
            yield return item;
        }
    }
}

Oh, come on! Why wasn't there a parameterless SelectMany in the framework? Oh well, here's one.

ToDictionary of IGrouping

public static Dictionary<TKey, IEnumerable<TElement>> ToDictionary<TKey, TElement>(
    this IEnumerable<IGrouping<TKey, TElement>> enumeration)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    return enumeration.ToDictionary(item => item.Key, item => item.Cast<TElement>());
}

This is shorthand for when you want to create a dictionary from the result of GroupBy.

Breadth Recursion - a yield Solution to Post's Correspondence Problem

2008-06-06T20:07:48Z

Post's Correspondence Problem (the other PCP) is a computer science problem, in which you have (and I simplify matters) a set of tiles, each having any number of letters on them from a preset group. For instance, you may have the tiles:

The idea is to create a sequence of tiles (when you can use an infinite amount of tiles from each kind) to get the exact same combination of letters both on the top row and the bottom one. One such combination would be aaaabab, where you would use tiles 4, 4, 2 and 1 to create the sequence: [aa][aa][b][ab] at the top and [a][a][a][abab] at the bottom. If you like, a good mental exercise would be to find the next shortest sequences.

PCP is an undecidable decision problem, which means that no program can be written that could receive a finite set of tiles as its input and return true or false as to whether a combination exists, without the risk of running indefinitely. However, a program that has the risk of running indefinitely that solves the problem can be written: Simply check all sequences of length 1, 2, 3, etc. and stop at the first that is a match.

Writing such a program is a bit cumbersome, as at each sequence of length n, you will have to either save all sequences of length n-1 or recalculate them. Using a classic recursion isn't that useful, since those are used for depth-based analysis, rather than breadth based. Luckily, C# 2.0's yield statement offers us a different type of recursion - the breadth recursion:

IEnumerable<Tile> GetTileSequence(IEnumerable<Tile> tiles)
{
    foreach (Tile tile in tiles)
    {
        yield return new Tile { Top = tile.Top, Bottom = tile.Bottom };
    }

    foreach (Tile sequence in GetTileSequence(tiles))
    {
        foreach (Tile tile in tiles)
        {
            yield return new Tile { Top = sequence.Top + tile.Top, Bottom = sequence.Bottom + tile.Bottom };
        }
    }
}

The above code runs on the set of tiles to create single tile sequences and then uses itself to create sequences one tile longer than itself. It's a bit confusing, I admit, but after a couple of minutes of examining it you may start seeing the hidden beauty of it. Using it to solve the problem would look something like this:

Tile[] tiles = new Tile[] { 
    new Tile { Top = "ab", Bottom = "abab" },
    new Tile { Top = "b", Bottom = "a" },
    new Tile { Top = "aba", Bottom = "b" },
    new Tile { Top = "aa", Bottom = "a" }
};

foreach (Tile sequence in GetTileSequence(tiles))
{
    if (sequence.Top == sequence.Bottom)
    {
        Debug.WriteLine("Match: " + sequence.Top + ", " + sequence.Bottom);
        return sequence;
    }
}

This whole piece of code was written a few days after a little debate I had with @yosit about whether using yield statements to build recursions was a good idea or not. I still hold the firm belief that it usually isn't a good idea, since it's, as you can see for yourself, pretty confusing; That and the fact that most people are used to the classic recursion.

Mechsonomy: Machine Assisted Folksonomy

2008-06-06T12:13:02Z

Yesterday, in front of the staff and students at my college, I presented my final project for my C.S. B.Sc.. Once I complete it and it gets reviewed this September, I will have completed my duties for the degree.
The project is a research I'm doing for nuconomy and I'll release the code once it's complete. It uses the .NET Framework 3.5 (with C# 3.0) and SQL Server 2005 Integration Services' NLP engine.

The following is the abstract and you can also download the short presentation.

Abstract

The advent of Web 2.0, with its introduction of the concept of user generated data, has posed several problems to those developers aiming to make the navigation in such data as simple as possible.

The problem was commonly met by the coupling of meta-data (tags) to the user-generated content itself, which posed another problem, simply because the vast amounts of data were no match for the small number of website operators to cope with. Thus was introduced the concept of the Folksonomy, or social tagging, which took advantage of the content’s users, asking them to explain what the content was about in an engaging way.

Unfortunately, creating a working folksonomy requires a large and cooperative user base, something that can’t be relied upon.

Automation can be introduced into such communities in order to relieve most of the pressure classic folksonomies place on the user base. By automatically analyzing the user-generated content and meta-content and applying to it a base set of tags, such automation saves users the need to come up with those tags in the first place, leaving only the easier process of correction.

Mechsonomy consists of the following building blocks:

Plain-Text Tagging – user-generated content is taken as-is and processed by a Term Extraction engine to retrieve ‘relevant’ tags.
Markup Analysis – the placement of terms retrieved in the marked-up source is examined, altering terms’ significance.
Web Analysis – the relationship between units of content is examined, altering terms’ significance.
Machine Learning – users interact and rank tags’ relevance to the content, allowing Mechsonomy to learn the impact the site’s markup has on the content’s relevance.

Quick Blurb: Test Tools Toolbar in Visual Studio and Useless Icons

2008-06-02T15:41:54Z

Let's play a little game. To the left of this text are the five central icons from the Test Tools Toolbar in Visual Studio. Their commands are, in an unordered manner: Test List Editor, Test Runs, Test View, Code Coverage Results and Test Results. Connect the icon to the appropriate command, without checking Visual Studio.

The purpose of this game? To show that whenever you don't think about your icons enough, they're meaningless and therefore useless. There may be a certain logic behind this set of icons, but since it has eluded me for the few seconds I tried to understand it, it's as if it wasn't there in the first place.

LINQ Performance Pitfall - Deferred Execution

2008-05-27T19:37:58Z

When using LINQ, queries may bloat up to dozens of lines. My personal style is to take these queries and break them apart to smaller units of logic. To each unit of logic, I append a call to ToArray. @yosit asked me why I did it and I answered I was avoiding a possible pitfall. Here's what I meant.

Take the following code for instance:

static void Main(string[] args)
{
    int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    var filter = from n in arr
                 where VeryLongOperation(n)
                 select n;

    var cartesian = from n in filter
                    from m in filter
                    select 2 * n + 3 * m;

    var result = cartesian.ToArray();
}

Imagine VeryLongOperation only allows numbers up to 3 and prints the number of times it was called to the debug output. It looks as though the very long operation will run only once per number, so you'll only have three calls, but here's the actual output you get in the debug window once you run this code:

Operation #1
Operation #2
Operation #3
...
Operation #36

This is caused by LINQ's deferred execution, which means that every time an item is taken from any of the loops, it will go back to the first filter and call the very long operation again. This means that you have 3 calls that cause 9 inner loops (27 calls together) and 6 that don't cause inner loop calls. 3 + 27 + 6 = 36.

Let's make a slight alteration to the original filter query:

var filter = (from n in arr
              where VeryLongOperation(n)
              select n).ToArray();

This forces LINQ to execute the query now. Sure, there's a slight overhead of creating a new array, but it's a static array, so that mitigates the problem a bit. Now the debug window looks like this:

Operation #1
...
Operation #9

This is a neat trick and is one of the first things that I look for when reviewing code with multiple LINQ statements.

SQL Server 2005 Analysis Services's ADOMD.NET Connection Pooling, or Lack Thereof

2008-05-27T08:33:30Z

First of all, if you've come here looking for how to activate connection pooling when using SSAS 2005 via ADOMD.NET, you're in for a little surprise - there is none by design.

Loading a new connection can take up a long time, since with every new session to the database, all of the metadata and security context has to get loaded too. I've decided to perform some mental gymnastics and try and implement a simple connection pooling mechanism. Here is the (very) basic version of the mechanism, which I may continue to post changes to as they accumulate:

public static class AdomdConnectionPool
{
    private static Dictionary<string, Dictionary<string, ArrayList>> pool = 
        new Dictionary<string, Dictionary<string, ArrayList>>();

    /// <summary>
    /// Gets a connection from the pool or creates one if one does not exist.
    /// </summary>
    public static PooledConnection GetConnection(string connectionString)
    {
        // Pooling (See the Poll method)
        ValidateListExistance(connectionString);
        return GetConnectionFromPool(connectionString);
    }

    private static PooledConnection GetConnectionFromPool(string connectionString)
    {
        KeyValuePair<string, ArrayList> session =
            new KeyValuePair<string, ArrayList>(null, null);

        lock (pool[connectionString])
        {
            if (pool[connectionString].Count > 0)
            {
                // Available session exists. Use it.
                session = pool[connectionString].First();
                pool[connectionString].Remove(session.Key);
            }
        }

        // No available connections exist. Create a new one.
        if (session.Key == null)
            return CreateNewConnection(connectionString);

        // A session exists
        AdomdConnection pooledConnection = new AdomdConnection(connectionString);
        pooledConnection.SessionID = session.Key;

        try
        {
            pooledConnection.Open();

            // Register the session with the pool.
            PooledConnection poolItem = new PooledConnection(pooledConnection, session.Value);
            poolItem.Disposed += new Action<PooledConnection, EventArgs>(poolItem_Disposed);

            return poolItem;
        }
        catch (Exception ex)
        {
            // Connection probably expired. Try again.
            return GetConnectionFromPool(connectionString);
        }
    }

    private static void ValidateListExistance(string connectionString)
    {
        lock (pool)
        {
            if (!pool.ContainsKey(connectionString))
                pool.Add(connectionString, new Dictionary<string, ArrayList>());
        }
    }

    private static PooledConnection CreateNewConnection(string connectionString)
    {
        // Create a new connection and register it with the pool.
        PooledConnection poolItem = new PooledConnection(
            new AdomdConnection(connectionString),
            new ArrayList());
        poolItem.Disposed += new Action<PooledConnection, EventArgs>(poolItem_Disposed);

        poolItem.Connection.Open();

        return poolItem;
    }

    private static void poolItem_Disposed(PooledConnection sender, EventArgs e)
    {
        Dictionary<string, ArrayList> connections = pool[sender.Connection.ConnectionString];

        try
        {
            // Close the connection, but keep the session alive.
            sender.Connection.Close(false);

            lock (connections)
            {
                // Reclaim the connection to the pool.
                connections.Add(sender.Connection.SessionID, sender.ExtraData);
            }
        }
        catch
        {
            // Can't close connection? Don't let it back in the pool.
            // We don't really care why, though. If necessary in the future, log.
        }
    }
}

Each new connection has a SessionID property, which is unique and is given to each connection that is opened without an existing value in the SessionID property. If there is a value in the property before the connection opens, the connection connects to that session once Open is called. It may have been wiser to use the same SessionID for all connections, but since timeouts may happen on old connections (see the end of the poolItem_Disposed method), I decided to use many, fresh connections. I admit I have no idea whether it's a best practice, but I have yet to see evidence otherwise.

Each pooled connection has two properties we need to use: Connection and ExtraData:

public class PooledConnection : IDisposable
{
    /// <summary>
    /// Creates a new instance of <see cref="PooledConnection" />.
    /// </summary>
    internal PooledConnection(AdomdConnection connection, ArrayList extraData)
    {
        this.Connection = connection;
        this.ExtraData = extraData;
    }

    public AdomdConnection Connection { get; private set; }
    public ArrayList ExtraData { get; private set; }

    void IDisposable.Dispose()
    {
        if (this.Disposed != null)
            this.Disposed(this, EventArgs.Empty);
    }

    internal event Action<PooledConnection, EventArgs> Disposed;
}

The ExtraData property is there to store connection-specific data, such as a list of session-scoped members already created at runtime on this session, etc.

Using the mechanism is very simple and resembles using a simple ADO.NET connection:

using (PooledConnection pooledConnection = AdomdConnectionPool.GetConnection(connectionString))
{
    // Execute the query
    AdomdDataAdapter adapter = new AdomdDataAdapter(query, pooledConnection.Connection);
}

Please note that you can not use this sort of connection pooling when you're using the integrated role-based security, unless you save your sessions according to roles. This has not and will not be implemented in my connection pooling mechanism and if you need it, you'll have to write one for yourself.

I would love to hear comments about the whole thing. Remember that it's pretty basic, but I would love to make it more interesting and intricate and most of all - useful.

Residue

2008-05-23T18:57:06Z

This is a short, off-topic rant. Please bare with me.

In an effort to spark some life into my home laptop (which is about four years old and fighting like a champ), I've gone through the list of services running on my machine to try and stop those that are non-essential to me.
To my surprise, I found XobniService.exe on the list of running processes. Since I had previously uninstalled Xobni and hadn't restarted since, I thought a restart would clear it up. It didn't.
To me, that seemed odd: I have none of your products installed, but your update service remains installed on my machine? To what avail? Not to mention that there was no way to uninstall it except to directly use InstallUtil!

I am writing this rant because this is neither the first, nor the last application to do this. This commonplace practice of leaving behind applications that call home, after the original application has been completely uninstalled is annoying - even if you're not sending any sensitive data, your application is still using my computer's resources (CPU, hard drive, Internet connection, etc.) post-mortem.
If you're writing an application that has an updater, make sure to uninstall that too once your application is uninstalled.

Thank you.

Extension Methods Roundup: IndicesWhere, TakeEvery, Distinct

2008-05-18T13:14:21Z

As I do from time to time, here is a batch of three Extension Methods I've written recently:

IndicesWhere

/// <summary>
/// Gets the indices where the predicate is true.
/// </summary>
public static IEnumerable<int> IndicesWhere<T>(this IEnumerable<T> enumeration, Func<T, bool> predicate)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    // Check to see that predicate is not null
    if (predicate == null)
        throw new ArgumentNullException("predicate");

    int index = 0;

    foreach (T item in enumeration)
    {
        if (predicate(item))
            yield return index;

        index++;
    }
}

This is especially useful when you want to cache indices from an array, rather than the array itself. Here's an example:

var indicesWithValues = values.IndicesWhere(value => value != null);

TakeEvery

/// <summary>
/// Take items from 'startAt' every at 'hopLength' items.
/// </summary>
public static IEnumerable<T> TakeEvery<T>(this IEnumerable<T> enumeration, int startAt, int hopLength)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    int first = 0;
    int count = 0;

    foreach (T item in enumeration)
    {
        if (first < startAt)
        {
            first++;
        }
        else if (first == startAt)
        {
            yield return item;

            first++;
        }
        else
        {
            count++;

            if (count == hopLength)
            {
                yield return item;

                count = 0;
            }
        }
    }
}

This is equivalent to an unbounded series of Skip(startAt).Take(1).Skip(hopLength).Take(1).Skip(hopLength)... Useful for when you, for instance, need only every other item in a list.

Distinct

It's really been pissing me off that there's no overload to Distinct that takes a delegate, which means I have to write a new class whenever my comparison isn't the default one. When talking about Anonymous Types, Distinct becomes useless. So here's an overload I can actually use:

private class EqualityComparer<T> : IEqualityComparer<T>
{
    public Func<T, T, bool> Comparer { get; internal set; }
    public Func<T, int> Hasher { get; internal set; }

    bool IEqualityComparer<T>.Equals(T x, T y)
    {
        return this.Comparer(x, y);
    }

    int IEqualityComparer<T>.GetHashCode(T obj)
    {
        // No hashing capabilities. Default to Equals(x, y).
        if (this.Hasher == null)
            return 0;

        return this.Hasher(obj);
    }
}

/// <summary>
/// Gets distinct items by a comparer delegate.
/// </summary>
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> enumeration, Func<T, T, bool> comparer)
{
    return Distinct(enumeration, comparer, null);
}

/// <summary>
/// Gets distinct items by comparer and hasher delegates (faster than only comparer).
/// </summary>
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> enumeration, Func<T, T, bool> comparer, Func<T, int> hasher)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    // Check to see that comparer is not null
    if (comparer == null)
        throw new ArgumentNullException("comparer");

    return enumeration.Distinct(new EqualityComparer<T> { Comparer = comparer, Hasher = hasher });
}

I'll be integrating these methods into the Linq Extensions project soon enough. Good hunting. :)

A Limitation of Lambda Expressions and Overloaded Extension Methods

2008-05-07T12:07:46Z

Tamir hates lambdas. He was having a problem with one of his lambda expressions and twittered about it. Around that time I opened my twitter account (yes, Yosi finally convinced me) and offered my help.

He wanted to have a single extension method that could iterate over a collection and either change or keep the values it got. Kind of like this:

items.ForEach(item => item.SubItems.ForEach(subItem => subItem = newValue));

Where ForEach was defined as:

static void ForEach<T>(this IList<T> collection, Action<T> action)
{
    for (int i = 0; i < collection.Count; i++)
    {
        action(collection[i]);
    }
}

This did not work simply because subItem is a local variable - a copy of either the reference (when using a Reference Type) or of the value itself (when using a Value Type) - the lambda expression was (very loosely) translated to the following:

void Foo(SubItem subItem)
{
    subItem = newValue;
}

What I then tried to do was to replace Action<T> with a delegate with a ref parameter, so that the local variable will change. It turns out lambda expressions can not contain ref parameters.

On to the next solution - overloading the ForEach extension method:

static void ForEach<T>(this IList<T> collection, Action<T> action)
{
    for (int i = 0; i < collection.Count; i++)
    {
        action(collection[i]);
    }
}

static void ForEach<T>(this IList<T> collection, Func<T, T> action)
{
    for (int i = 0; i < collection.Count; i++)
    {
        collection[i] = action(collection[i]);
    }
}

This way, one can now write the following:

items.ForEach(item => item.SubItems.ForEach(subItem => newValue));

The first call (outer ForEach) will use the overload with Action<T> and the second (inner ForEach) will use the Func<T, T> overload and end up changing the current subItem. The C# compiler does a nice job finding the best overload to call.

Linq to SQL: ChangeConflictException With "WHERE 0 = 1"

2008-04-28T14:48:48Z

I just finished debugging a very annoying error, where I kept getting a ChangeConflictException with the message "Row not found or changed" while trying to update my data. I found that there were no Member Conflicts in the exception, which seemed really weird to me.

When I set the Log property on my context, I found that Linq to SQL was using UPDATE statements that looked like this:

UPDATE [dbo].[MyTable]
SET [Col1] = @p0, [Col2] = @p1
WHERE 0 = 1
-- @p0: Input ...
-- @p1: Input ...

This was apparently some optimization made by the Linq to SQL team, but it gave me a clue as to where to look.

Apparently, when you have a Linq to SQL object model that differs by even one property from your database, you're prone to get this. I found out that two of my fields that were in the SET part of the WHERE clause were defined as NOT NULL in my object model, but were marked as nullable in my database model. Quick fix and all works well.

One has to wonder why there is no "Synchronize" button in the Linq to SQL designer.

Also, here's an interesting piece of code I wrote while debugging, which serializes a ChangeConflictException to string:

public static string SerializeForLog(this ChangeConflictException e, DataContext context)
{
    StringBuilder builder = new StringBuilder();

    using (StringWriter sw = new StringWriter(builder))
    {
        sw.WriteLine("Optimistic concurrency error:");
        sw.WriteLine(e.Message);

        foreach (ObjectChangeConflict occ in context.ChangeConflicts)
        {
            Type objType = occ.Object.GetType();
            MetaTable metatable = context.Mapping.GetTable(objType);
            object entityInConflict = occ.Object;

            sw.WriteLine("Table name: {0}", metatable.TableName);

            var noConflicts =
                from property in objType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                where property.CanRead &&
                      property.CanWrite &&
                      property.GetIndexParameters().Length == 0 &&
                      !occ.MemberConflicts.Any(c => c.Member.Name != property.Name)
                orderby property.Name
                select property;

            foreach (var property in noConflicts)
            {
                sw.WriteLine("\tMember: {0}", property.Name);
                sw.WriteLine("\t\tCurrent value: {0}", 
                    property.GetGetMethod().Invoke(occ.Object, new object[0]));
            }

            sw.WriteLine("\t-- Conflicts Start Here --", metatable.TableName);

            foreach (MemberChangeConflict mcc in occ.MemberConflicts)
            {
                sw.WriteLine("\tMember: {0}", mcc.Member.Name);
                sw.WriteLine("\t\tCurrent value: {0}", mcc.CurrentValue);
                sw.WriteLine("\t\tOriginal value: {0}", mcc.OriginalValue);
                sw.WriteLine("\t\tDatabase value: {0}", mcc.DatabaseValue);
            }
        }

        sw.WriteLine();
        sw.WriteLine("Attempted SQL: ");

        TextWriter tw = context.Log;

        try
        {
            context.Log = sw;
            context.SubmitChanges();
        }
        catch (ChangeConflictException)
        {
            // This is what we wanted.
        }
        catch
        {
            sw.WriteLine("Unable to recreate SQL!");
        }
        finally
        {
            context.Log = tw;
        }

        sw.WriteLine();

        sw.WriteLine(e.SerializeForLog());
    }

    return builder.ToString();
}

Linq: FirstOrFallback

2008-04-23T10:44:53Z

Sometimes you want to use FirstOrDefault, but the default value of T is a valid value that might get returned. If you used FirstOrDefault, you wouldn't know whether the value that you got is a valid first or the default fallback. I use FirstOrFallback to explicitly specify which fallback value I want, rather than always use default(T):

public static T FirstOrFallback<T>(this IEnumerable<T> enumeration, T fallback)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    IEnumerator<T> enumerator = enumeration.GetEnumerator();

    enumerator.Reset();

    if (enumerator.MoveNext())
        return enumerator.Current;

    return fallback;
}

On a side note: I realize most of the extension methods I post here are pretty obvious, but I love sharing time-saving code. :)

Linq Extensions Release 2 Now on CodePlex

2008-04-23T07:29:49Z

I've updated my long standing Linq Extensions project on CodePlex to .NET 3.5 RTM and added the latest extension methods.

You can open bugs and feature requests using the Issue Tracker. If you want to download it, go and download the source code directly.

Linq: The Missing ToDictionary Extension Method Overload

2008-04-22T13:20:33Z

Enumerating over a Dictionary<TKey, TValue> you will get structs of type KeyValuePair<TKey, TValue>. Whenever you use the ToDictionary extension method, you are forced to specify how to get the key and value for each item, even if it's an enumeration of KeyValuePairs. Seems a bit redundant, doesn't it?

public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> enumeration)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    return enumeration.ToDictionary(item => item.Key, item => item.Value);
}

Well, that little bit of code settles that. :)

Linq: SequenceSuperset

2008-04-22T12:46:41Z

Here's another Linq method I wanted to share. This one takes two enumerations, enumeration and subset and checks to see whether subset exists in enumeration in its original order. I used the naming convention set by SequenceEqual.

Examples:

enumeration = (1, 2, 3, 4, 5); subset = (3, 4) ==> SequenceSuperset(enumeration, subset) = true
enumeration = (1, 2, 3, 4, 5); subset = (6, 5) ==> SequenceSuperset(enumeration, subset) = false (6 does not exist in enumeration)
enumeration = (1, 2, 3, 4, 5); subset = (3, 5) ==> SequenceSuperset(enumeration, subset) = false (3 is never immediately followed by 5 in enumeration)
enumeration = (1, 2, 3, 4, 5); subset = (5, 4) ==> SequenceSuperset(enumeration, subset) = false (5 is never immediately followed by 4 in enumeration)

And here's the code:

public static bool SequenceSuperset<T>(this IEnumerable<T> enumeration, IEnumerable<T> subset)
{
    return SequenceSuperset(enumeration, subset, EqualityComparer<T>.Default.Equals);
}

public static bool SequenceSuperset<T>(this IEnumerable<T> enumeration,
                                            IEnumerable<T> subset,
                                            Func<T, T, bool> equalityComparer)
{
    // Check to see that enumeration is not null
    if (enumeration == null)
        throw new ArgumentNullException("enumeration");

    // Check to see that subset is not null
    if (subset == null)
        throw new ArgumentNullException("subset");

    // Check to see that comparer is not null
    if (equalityComparer == null)
        throw new ArgumentNullException("comparer");

    using (IEnumerator<T> big = enumeration.GetEnumerator(), small = subset.GetEnumerator())
    {
        big.Reset(); small.Reset();

        while (big.MoveNext())
        {
            // End of subset, which means we've gone through it all and it's all equal.
            if (!small.MoveNext())
                return true;

            if (!equalityComparer(big.Current, small.Current))
            {
                // Comparison failed. Let's try comparing with the first item.
                small.Reset();
                
                // There's more than one item in the small enumeration. Guess why I know this.
                small.MoveNext();

                // No go with the first item? Reset the collection and brace for the next iteration of the big loop.
                if (!equalityComparer(big.Current, small.Current))
                    small.Reset();
            }
        }

        // End of both, which means that the small is the end of the big.
        if (!small.MoveNext())
            return true;
    }

    return false;
}

Help! My Web Application Throws an Insane Amount of TypeLoadExceptions!

2008-04-17T20:51:42Z

One of the first things I noticed when I started debugging our web application was that at load I got an insane amount of these:

A first chance exception of type 'System.TypeLoadException' occurred in System.Web.dll
A first chance exception of type 'System.TypeLoadException' occurred in System.Web.dll
A first chance exception of type 'System.TypeLoadException' occurred in System.Web.dll
...

After digging into the code, I found out that during the loading process of controls, ASP.NET tries to find the type that matches a certain tag. The following code piece from System.Web.UI.NamespaceTagNameToTypeMapper (line 82):

Type type = null; 

// If loading the type from the assembly depends on a referenced assembly that cannot
// be loaded, we should throw the actual exception, instead of later reporting a more
// generic error saying the type was not found (Devdiv 138674) 
try {
    type = _assembly.GetType(typeName, true /*throwOnError*/, true /*ignoreCase*/); 
} 
catch (System.IO.FileNotFoundException) {
    throw; 
}
catch (System.IO.FileLoadException) {
    throw;
} 
catch (BadImageFormatException) {
    throw; 
} 
catch {
    // For all other exceptions, such as when the type is not present in the assembly, 
    // we ignore the exception so that we can continue to check other assemblies to look
    // for the type.
}
return type;

What the hell?! This is a horrible bottleneck!

What's the solution, you ask? Well, it's simple - just tell ASP.NET ahead of time where your controls are with the @ Register directive. For instance:

<%@ Register Assembly="System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A" 
             Namespace="System.Web.UI.WebControls" TagPrefix="wc" %>

This gives ASP.NET a little hint, telling it that if it wants controls with the wc tag prefix, it should look for them in the System.Web.UI.WebControls namespace in the System.Web assembly. Then all you have to do is to mark all of the controls that come from that namespace in that assembly with that specific prefix, as such:

<wc:Literal ID="Something" runat="server"></wc:Literal>

And that's that. No more annoying exceptions.

Make sure to use the full assembly name in the @ Register directive, otherwise you'll get a System.IO.FileNotFoundException thrown when ASP.NET can't find the assembly.

One more thing that's important to note is that if you have only a few of these, set your web.config's compilation element's batch attribute to false, which means ASP.NET will load pages on demand. This way you'll know the culprit page when you hit it for the first time, rather than have the exception thrown when the whole application starts.

[Update: An application-wide solution would be to use the system.web / pages / controls element in the web.config to declare prefixes for all of your controls, rather than at the single page level:

<configuration>
  <system.web>
    <pages>
      <controls>
        <add tagPrefix="wc" namespace="System.Web.UI.WebControls"
             assembly="System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=B03F5F7F11D50A3A"/>

And thanks to Ofer Bar from my team for the tip.]