I added to an existing project which needed to keep the EF classes isolated in the data layer. This made it difficult to pass in a sort order without having a massive switch statement to deal with each of the options.

I solved this by building an OrderBy extension method that takes a string, and builds the sort expression using reflection. This means you can sort without having to know the actual type of what you’re ordering by.

Here’s the Gist:

        public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string sortExpression)
        {
            if (source == null)
                throw new ArgumentNullException("source", "source is null.");

            if (string.IsNullOrEmpty(sortExpression))
                throw new ArgumentException("sortExpression is null or empty.", "sortExpression");

            var parts = sortExpression.Split(' ');
            var isDescending = false;
            var propertyName = "";
            var tType = typeof(T);

            if (parts.Length > 0 && parts[0] != "")
            {
                propertyName = parts[0];

                if (parts.Length > 1)
                {
                    isDescending = parts[1].ToLower().Contains("esc");
                }

                PropertyInfo prop = tType.GetProperty(propertyName);

                if (prop == null)
                {
                    throw new ArgumentException(string.Format("No property '{0}' on type '{1}'", propertyName, tType.Name));
                }

                var funcType = typeof(Func<,>)
                    .MakeGenericType(tType, prop.PropertyType);

                var lambdaBuilder = typeof(Expression)
                    .GetMethods()
                    .First(x => x.Name == "Lambda" && x.ContainsGenericParameters && x.GetParameters().Length == 2)
                    .MakeGenericMethod(funcType);

                var parameter = Expression.Parameter(tType);
                var propExpress = Expression.Property(parameter, prop);

                var sortLambda = lambdaBuilder
                    .Invoke(null, new object[] { propExpress, new ParameterExpression[] { parameter } });

                var sorter = typeof(Queryable)
                    .GetMethods()
                    .FirstOrDefault(x => x.Name == (isDescending ? "OrderByDescending" : "OrderBy") && x.GetParameters().Length == 2)
                    .MakeGenericMethod(new[] { tType, prop.PropertyType });

                return (IQueryable<T>)sorter
                    .Invoke(null, new object[] { source, sortLambda });
            }

            return source;
        }

Another feature that JavaScript doesn’t explicitly support is events. Though using some of the same techniques I used for events also work very well for building events.

Most implementations of events in JavaScript use optional arguments in order to provide two overrides to an “event” function, one for adding a listener and the other for raising the event, like this:

// Add a handler
obj.click(objClicked);

function objClicked() {
}

// Raise the event
obj.click();

This provides a very straight forward to use interface (though doesn’t support unbinding.)

Below is a simple function for generating event functions that work in the way shown above.

In the returned “event” function I have no parameters, instead I check the inherent “arguments” object to see if there’s a single function parameter, and add it to “_handlers” if there is.

The for loop at the end raises the event by calling “apply” on the function and passing all the arguments from this method into it.

var createEvent = function() { 
  var _handlers = [];
  
  return function() {
    if (arguments.length === 1 && typeof arguments[0] === 'function') {
      _handlers.push(arguments[0]);
      return;
    }
    
    for (var i = 0; i < _handlers.length; ++i) {
      _handlers[i].apply(this, arguments);
    }
  }; 
};

Use like such:

var MyClass = new function() {
  this.click = createEvent();
}

var obj = new MyClass();

obj.click(function (x, y) {
  alert('x: ' + x + ', y: ' + y);
});

obj.click(12, 24);

While there’s no easy way to detect all of the possible encodings, by checking the byte order mark (BOM) there is a pretty straight forward way to detect the following encodings:

• UTF-16
• UTF-16BE
• UTF-32
• UTF-32BE
• UTF-8

public static Encoding GetFileEncoding(string path)
{
	if (path == null)
		throw new ArgumentNullException("path");

	var encodings = Encoding.GetEncodings()
		.Select(e => e.GetEncoding())
		.Select(e => new { Encoding = e, Preamble = e.GetPreamble() })
		.Where(e => e.Preamble.Any())
		.ToArray();

	var maxPrembleLength = encodings.Max(e => e.Preamble.Length);
	byte[] buffer = new byte[maxPrembleLength];

	using (var stream = File.OpenRead(path))
	{
		stream.Read(buffer, 0, (int)Math.Min(maxPrembleLength, stream.Length));
	}

	return encodings
		.Where(enc => enc.Preamble.SequenceEqual(buffer.Take(enc.Preamble.Length)))
		.Select(enc => enc.Encoding)
		.FirstOrDefault() ?? Encoding.Default;
}

There’s a common solution to this in JavaScript, that exploits the fact that JavaScript function arguments are optional. A property function will have a single argument. If the argument is undefined then the current call is a ‘get’, otherwise it’s a ‘set’. jQuery has many good examples of this, for example the val() method:

It isn’t particularly hard to define a method this way, below is an example class with a single property, ‘name’:

// A new class
var MyClass = function() {
    var _name;

    this.name = function(value) {
        if (value !== undefined)
            _name = value;

        return _name;
    };
};

// Example usage
var instance = new MyClass();
instance.name('Phil');
var name = instance.name(); // name = 'Phil'

This way of doing things is achieves the desired effect, but ends up being overly verbose if you have a lot of properties that are just wrappers around a value, like an auto-implemented property is in C#.

I came up with the solution below while I was working on findthatrobot.com. It helps in the creation of auto-implemented like properties, as well as allowing the getter and setter to be customized, or just one of the two, creating a read-only or write-only property.

With this function a property can be created as such:

var MyClass = function() {
    var customPropertyValue;

    // Auto-implemented proeprty
    this.prop1 = createProperty();

    // Custom getter and setter
    this.prop2 = createProperty({
        get: function() { return customPropertyValue; },
        set: function(value) { customPropertyValue = value; }
    });
};

And here is the ‘createProperty’ function:

var createProperty = function(getSet) { 
    var _value;
    var autoImplement = {
        get: function() { return _value; },
        set: function(value) { _value = value; return _value; }
    };

    getSet = getSet || autoImplement;

    var get = getSet.get || function() { throw new Error('No get method defined for this property.'); },
        set = getSet.set || function() { throw new Error('No set method defined for this property.'); };

    return function(value) {
        if (value !== undefined)
            return set(value);

        return get();
    }; 
};

Phil

While I couldn’t find anywhere in EF the inherently support any form of async calls, I did find that you can with the underlying SqlConnection (assuming you’re using MSSQL.)

So with a little bit of Async CTP magic mixed in, I created an extension method to read the data asynchronously.

Unfortunately I couldn’t find an obvious way to open the connection or write data asynchronously, but I think this is good step.

Phil

Comments and questions are welcome.

Phil

I’ve played around with some small Node.js projects over the last year or so, mostly following tutorials and the such, and this was my first complete project. I’m going to share with you what worked for me and what didn’t, in hopes that anyone else out there might learn something to make their lives easier, or perhaps be inspired to try Node.js for the first time.

Getting Started and Development Environment

The first thing I needed to get set up was the development environment. We’d already decided on using a free Amazon EC2 Micro instance as our hosting, and I’d played around with running Cloud9 IDE locally on a Virtual Box running Ubuntu, so setting up Cloud9 IDE on EC2 seemed like the most sensible first step forward.  For those who don’t know, Cloud9 IDE is a browser based IDE, which might seem strange at first, though it doesn’t take long to see what a powerful tool it is, and how much of a pleasure it is to use. I really can’t recommend Cloud9 IDE enough.

In the end I set up two instances listening on different ports, since the Cloud9IDE in NPM is a limit version of what’s on c9.io, and restricted it to one user at a time. I used GIT to sync the changes between the two, and to deploy to the production site and backup locally.

Frameworks and Middleware

When I started, I didn’t have much of an idea of what the final structure of the app would be. I’ve had a fair bit of experience in building MVC web apps, so I figured that’d be a good place to start.

After trying a couple of different frameworks and doing a bit of research on what was popular, I discovered Express, which takes Connect, a middleware framework, and expands it into a reasonably complete web app framework. I come from an ASP.net background, so the word “middleware” didn’t mean a lot to me a first. Simply put, a middleware component is a function that acts on request and / or response. Connect “connects” these functions in a pipeline. An example middleware component might be parsing a file in the request, or compressing a response.

It took me a while to pick the bits and pieces of middleware I needed, though most of what I wanted came built in to Express or Connect. I used a couple of components built by others, and built a few myself. I found it really easy to create my own, perhaps too easy, and got carried away re-inventing the wheel a couple of times, though it was all good learning.

Here’s the additional bits of middleware I used:

• A custom logger for errors and request logging. I loved the inbuilt formatting options in Connect.logger, but I wanted to output the data into a rolling log. I found Winston was good for the job, as well as giving me more logging capabilities elsewhere. Winston wasn’t connect ready to begin with, though it didn’t take much coaxing to make the Connect.logger use it as its output.
• I had quite a bit of trouble finding a gzip component. I started with connect-gzip but the static encoding didn’t add an expires header. I switched to gzippo which did, but didn’t have compression for dynamic files. So I ended up using both. I’m not entirely sure of how well either component performs, but they both seemed to work well enough for my purposes.
• I added connect-form to deal with uploading files in the admin screens.
• I wrote some custom tracing code that utilized Winston’s tracing capabilities and the inbuilt connect profiler. It also added custom timing logic to to each middleware component. After writing all this profiling logic, the only thing I discovered was that everything was running well.

Coding Style and Standards

There’s a couple of practices that I picked up early on, most of which I learnt from Stella Laurenzo’s post on Bulletproof Node.js Coding.

The habit of returning on the last statement is a technique I think every Node.js coder should use. The code becomes much easier to follow since callbacks often obscure the end of the function, and it stops you accidentally executing code after a call to an async function.

Using named function declarations instead of inline functions vastly improves maintainability. It makes following the flow of async callbacks much more straight forward to read, and makes the code a little more self-documenting with the callbacks given names.

Data access was something I struggled with and I think, given time, I would have rewritten much of my current solution. I used redis as my sole data store because I was more concerned with performance than data reliability. This meant that the act of reading and writing data was simply serializing and deserializing JSON strings to and from redis. I kept a set of model objects which I serialized directly into JSON, and each model object had an ‘update’ method that took the deserialized data and copied it into the instance. The goal of this was to make sure the fields on the object where always consistent, and gave the opportunity to deal with different versions of the data.

I think the approach was generally okay, but in its current state there’s a lot of duplication. If I were to rewrite it, I’d attempt to abstract much of the serializing, deserializing and object update logic. I’d also attempt to centralize the actual calls to redis, as at the moment there’s a lot of code that’d need to change if I wanted to change data providers.

The last thing I’d like to mention is using a Block to centralize error handling, as mentioned Stella Laurenzo’s blog post. This pattern fits very nicely into the Express framework and can be a lifesaver, because any exception that bubbles up to the core Node.js event loop will terminate your Node.js instance. The code in Express itself already has error handling built in, but if a callback comes from somewhere else (such as redis) the exception will cause problems. The Block pattern simplifies the error handling, reducing the amount of code you need to write. This sort of error handling is a requirement for any Node.js app.

Final Thoughts

If you’re coming from a Windows / .NET development background there’s a steep, but short, learning curve to start programming in Node.js, but it’s well worth it. JavaScript offers a very different way to thinking about application programming from C# and VB.net, it feels more free-form and dynamic and gives you more of an opportunity mould your application into a shape that you feel comfortable with.

Node.js is still a very new environment, tools are still being built, patterns and best practices are being forged, much will change in times to come and it all makes Node.js a fun tool to work with. It has great potential as a tool for building websites and so much more, and I hope that you get a chance to use it on your next project.

// Phil

Because the ItemsControl in Silverlight 4 doesn’t support alternating styles on the child items, I’ve made this set of attached properties to allow you to switch the style on any item contained within an ItemsControl or anything that inherits from it (e.g. ListBox.)

I’ve uploaded a sample project, but here’s the entirety of the code for those who don’t want to download anything.

SilverlightApplication1.zip

Here’s a sample of it’s usage:

<UserControl x:Class="SilverlightApplication1.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:SilverlightApplication1"
    mc:Ignorable="d" Loaded="UserControl_Loaded"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">
        <ListBox x:Name="ListItems">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Border>
                        <Border.Style>
                            <Style TargetType="Border">
                                <Setter Property="Background" Value="White" />
                            </Style>
                        </Border.Style>
                        <local:ItemsControlAlternation.AlternateStyle>
                            <Style TargetType="Border">
                                <Setter Property="Background" Value="LightBlue" />
                            </Style>
                        </local:ItemsControlAlternation.AlternateStyle>
                        <ContentPresenter Content="{Binding}" />
                    </Border>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>

</UserControl>

And here’s the main part of the code, separated into two classes. One for the attached properties, and one that’s the new behavior. Also I’ve included two extension methods in this example, that aren’t specific to this code, but do make it cleaner.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace SilverlightApplication1
{
    public static class ItemsControlAlternation
    {
        public static readonly DependencyProperty AlternateStyleProperty =
            DependencyProperty.RegisterAttached("AlternateStyle", typeof(Style), typeof(ItemsControlAlternation), new PropertyMetadata(AlternateStylePropertySet));

        public static readonly DependencyProperty AlternationIndexProperty =
            DependencyProperty.RegisterAttached("AlternationIndex", typeof(int), typeof(ItemsControlAlternation), new PropertyMetadata(2, AlternationIndexPropertySet));

        private static readonly DependencyProperty AlternationHelperProperty =
            DependencyProperty.RegisterAttached("AlternationHelper", typeof(ItemsControlAlternationHelper), typeof(ItemsControlAlternation), new PropertyMetadata(null));

        public static Style GetAlternateStyle(DependencyObject obj)
        {
            return (Style)obj.GetValue(AlternateStyleProperty);
        }

        public static void SetAlternateStyle(DependencyObject obj, Style value)
        {
            obj.SetValue(AlternateStyleProperty, value);
        }

        public static int GetAlternationIndex(DependencyObject obj)
        {
            return (int)obj.GetValue(AlternationIndexProperty);
        }

        public static void SetAlternationIndex(DependencyObject obj, int value)
        {
            obj.SetValue(AlternationIndexProperty, value);
        }

        private static ItemsControlAlternationHelper GetAlternationHelper(DependencyObject obj)
        {
            return (ItemsControlAlternationHelper)obj.GetValue(AlternationHelperProperty);
        }

        private static void SetAlternationHelper(DependencyObject obj, ItemsControlAlternationHelper value)
        {
            obj.SetValue(AlternationHelperProperty, value);
        }

        private static void AlternateStylePropertySet(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ItemsControlAlternationHelper helper = GetOrCreateAlternationHelper(sender);

            helper.AlternateStyle = (Style)e.NewValue;
        }

        private static void AlternationIndexPropertySet(DependencyObject sender, DependencyPropertyChangedEventArgs e)
        {
            ItemsControlAlternationHelper helper = GetOrCreateAlternationHelper(sender);

            helper.AlternationIndex = (int)e.NewValue;
        }

        private static ItemsControlAlternationHelper GetOrCreateAlternationHelper(DependencyObject target)
        {
            ItemsControlAlternationHelper helper = GetAlternationHelper(target);

            if (helper == null)
            {
                helper = new ItemsControlAlternationHelper(target as FrameworkElement);
                SetAlternationHelper(target, helper);
            }

            return helper;
        }
    }

    internal class ItemsControlAlternationHelper
    {
        private FrameworkElement targetItem;
        private Style originalStyle;
        private Style alternateStyle;
        private int alternationIndex;

        private ItemsControl parentCollection;
        private INotifyCollectionChanged parentCollectionItems;
        private FrameworkElement[] parentPath;

        public ItemsControlAlternationHelper(FrameworkElement targetItem)
        {
            if (targetItem == null)
            {
                throw new ArgumentNullException("targetItem", "targetItem is null.");
            }

            this.targetItem = targetItem;
            this.originalStyle = targetItem.Style;
            this.alternationIndex = 2;

            // Check for loaded in case the element hasn't been added to the visual tree yet.
            targetItem.Loaded += TargetItemLoaded;

            LocateParents();
        }

        /// <summary>
        /// The style to apply to the alternate items.
        /// </summary>
        public Style AlternateStyle
        {
            get { return alternateStyle; }
            set
            {
                alternateStyle = value;
                UpdateAlernationStyle();
            }
        }

        /// <summary>
        /// At what frequency to apply the alternate style. Defaults to 2, which applies the style to every second item.
        /// </summary>
        public int AlternationIndex
        {
            get { return alternationIndex; }
            set
            {
                if (value == 0)
                {
                    throw new ArgumentOutOfRangeException("value", "value must be non-zero.");
                }

                alternationIndex = value;
                UpdateAlernationStyle();
            }
        }

        /// <summary>
        /// Parses the visual tree of the target element to find the ItemsControl
        /// </summary>
        private void LocateParents()
        {
            if (parentCollectionItems != null)
            {
                parentCollectionItems.CollectionChanged -= ParentCollectionChanged;
            }

            DependencyObject[] parents = targetItem.GetVisualParents().ToArray();

            parentCollection = parents.OfType<ItemsControl>().FirstOrDefault();

            if (parentCollection == null)
            {
                return;
            }

            parentPath = parents.TakeWhile(x => x != parentCollection).Skip(1).OfType<FrameworkElement>().ToArray();
            parentCollectionItems = parentCollection.Items as INotifyCollectionChanged;

            if (parentCollectionItems != null)
            {
                parentCollectionItems.CollectionChanged += ParentCollectionChanged;
            }
        }

        private void TargetItemLoaded(object sender, RoutedEventArgs e)
        {
            LocateParents();
            UpdateAlernationStyle();
        }

        private void ParentCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            UpdateAlernationStyle();
        }

        /// <summary>
        /// Update the Style of the target element.
        /// </summary>
        private void UpdateAlernationStyle()
        {
            if (IsAlternate())
            {
                targetItem.Style = AlternateStyle;
            }
            else
            {
                targetItem.Style = originalStyle;
            }
        }

        /// <summary>
        /// Checks to see if the item is at the alternate index
        /// </summary>
        private bool IsAlternate()
        {
            if (parentCollection == null)
            {
                return false;
            }

            Panel panel = parentCollection.GetVisualChildrenRecursive().OfType<Panel>().FirstOrDefault();

            if (panel == null)
                return false;

            int itemIndex = panel.Children.IndexOf(i => i.GetVisualChildrenRecursive().Contains(targetItem));

            return (itemIndex + 1) % AlternationIndex == 0;
        }

    }

    public static class Extensions
    {
        /// <summary>
        /// Walks the visual tree to find all of an items parents.
        /// </summary>
        public static IEnumerable<DependencyObject> GetVisualParents(this DependencyObject source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source", "source is null.");
            }

            DependencyObject parent = VisualTreeHelper.GetParent(source);

            while (parent != null)
            {
                yield return parent;

                parent = VisualTreeHelper.GetParent(parent);
            }
        }

        /// <summary>
        /// Returns the first index of an item in the collection that matches the given predicate.
        /// </summary>
        public static int IndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate)
        {
            return source
                .Select((item, index) => new { item, index })
                .Where(i => predicate(i.item))
                .Select(i => i.index + 1)
                .FirstOrDefault() - 1;
        }

        /// <summary>
        /// Returns all the direct visual children of an object
        /// </summary>
        public static IEnumerable<DependencyObject> GetVisualChildren(this DependencyObject source)
        {
            return Enumerable.Range(0, VisualTreeHelper.GetChildrenCount(source))
                .Select(i => VisualTreeHelper.GetChild(source, i));
        }

        /// <summary>
        /// Returns the children of a dependancy object using a breadth first algorithm
        /// </summary>
        public static IEnumerable<DependencyObject> GetVisualChildrenRecursive(this DependencyObject source)
        {
            DependencyObject[] children = source.GetVisualChildren()
                .ToArray();

            while (children.Any())
            {
                foreach (var item in children)
                {
                    yield return item;
                }

                children = children.SelectMany(c => c.GetVisualChildren())
                    .ToArray();
            }
        }
    }
}

I’m not particularly happy with how it uses DataContext to determine if it’s a sub-item, so any suggestions on how to improve it would be appreciated

Phil

Here’s an example, in .NET 4.0, to show you what I mean. In this example I have a simple logging setup, with a list of IListeners which handle messages that a logged with the LogMessage function. It’ll get into a infinite recursive loop becuase the LogToDiskListener attempts to log a message, and the ThreadStaticAttribute doesn’t help because each listener is executed in it’s own thread.

        [ThreadStatic]
        private static bool _isLoggingMessage;

        private static List<IListener> _listeners = new List<IListener>();

        public static void Main()
        {
            _listeners.Add(new LogToDiskListener());
            LogMessage("Starting main function");
        }

        private static void LogMessage(string message)
        {
            if (_isLoggingMessage)
                return;

            _isLoggingMessage = true;

            _listeners.AsParallel()
                .ForAll(listener => listener.HandleMessage(message));

            _isLoggingMessage = false;
        }

        public class LogToDiskListener : IListener
        {
            public void HandleMessage(string message)
            {
                LogMessage("Writing message to disk");

                // Write the message to disk
            }
        }

        public interface IListener
        {
            void HandleMessage(string message);
        }

The code above won’t throw a StackOverFlowException, but will continue to use CPU and increase memory usage until it starves itself of threads.

Fortunately there is a particular solution to this scenario, using the CallContext.LogicalSetData method. Any data set with this method will continue to flow down through child threads, offering a solution to the recursion. Below is a example that wont loop indefinitely:

        private const string IsLoggingMessageKey = "LoggingExample_IsLoggingMessage";

        private static bool IsLoggingMessage
        {
            get
            {
                return ((bool?)CallContext.LogicalGetData(IsLoggingMessageKey))
                    .GetValueOrDefault();
            }
            set
            {
                CallContext.LogicalSetData(IsLoggingMessageKey, value);
            }
        }

        private static List<IListener> _listeners = new List<IListener>();

        public static void Main()
        {
            _listeners.Add(new LogToDiskListener());
            LogMessage("Starting main function");
        }

        private static void LogMessage(string message)
        {
            if (IsLoggingMessage)
                return;

            _listeners.AsParallel()
                .ForAll(listener =>
                {
                    IsLoggingMessage = true;
                    listener.HandleMessage(message);
                });
        }

        public class LogToDiskListener : IListener
        {
            public void HandleMessage(string message)
            {
                LogMessage("Writing message to disk");

                // Write the message to disk
            }
        }

        public interface IListener
        {
            void HandleMessage(string message);
        }

In the new version of the I’ve replaced the field with a ThreadStaticAttribue with a property that wraps around some calls to the CallContext. I’ve also removed the call to set it to false, since it’s value is lost as soon as all the threads that are using are finished. I’ve also move the place where the new property is set to within the child threads.

Phil