The Azure website has documentation to setup a node app with automated deployment through Git. The sample uses the node http server but hapi works just as well with a few modifications.

The sample doesn’t make it clear but Azure handles the host and port environment variables a bit differently than expected. Rather than the port being an integer, as expected, it’s a string containing a named pipe. Hapi can manage Windows named pipes just fine but requires a different setup than the normal host, port parameters.

The key in the below sample is to use the port as the host if it’s a named pipe.

var hapi = require('hapi');

var host = process.env.HOST || '0.0.0.0';
var port = process.env.PORT || 8081;

var server;
if (port.toString().indexOf('pipe') >= 0) {
    // Azure uses named pipes defined in the port env variable
    server = hapi.createServer(port);
}
else {
    // running locally
    server = hapi.createServer(host, port);
}

This github issue describes the problem and resolution.

[DataContract]
public class MyClass
{
    [DataMember]
    public IEnumerable<IAnimal> Animals { get; set; }
}

public interface IAnimal
{
    string Name { get; set; }
}

[DataContract]
public class Dog : IAnimal
{
    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public bool IsMansBestFriend { get; set; }
}

[DataContract]
public class Cat : IAnimal
{
    [DataMember]
    public string Name { get; set; }
    
    [DataMember]
    public string FavoriteCatFood { get; set; }
}

In fact, WCF won’t even return the DataContract MyClass. WCF can’t figure out how to deserialize the list of dogs and cats. The solution is to use the KnownTypes attribute on the DataContract making use of these subclassed objects. With the KnownType attribute, WCF knows which concrete objects to use when deserializing.

[DataContract]
[KnownType(typeof(Dog))]
[KnownType(typeof(Cat))]
public class MyClass
{
    [DataMember]
    public IEnumerable<IAnimal> Animals { get; set; }
}

It appears WCF handles this situation a bit differently depending on whether you’re using Add Service Reference to go after the WSDL or if you’re using the contracts directly and opening a ChannelFactory. Using the WSDL it appears you’ll get back a list of objects, not strongly typed. If you’re using the ChannelFactory and using the contract definitions then you’ll get strongly typed results.

The concept of a developer getting “in the zone” is well documented. It seems that most programmers with a blog have at least one post discussing how they best get “in the zone.” This is the idea that the highest quality code is written when a developer can fully immerse themselves in the code or problem at hand and completely lose awareness of their surroundings. Joel Spolsky has noted this occurs most frequently when a developer has quiet surroundings, possibly aided by headphones, see number 8 and 9 in his list of ways to improve your development process. Keeping a dev “in the zone” is key to keeping them as productive as they possibly can be.

One of the easiest ways to get a developer out of the zone is to keep them from waiting for their computer to catch up. Most processes that a developer waits on such as opening new applications, compiling, and running unit tests can be shortened by better hardware. Though expensive, the hardware is much less expensive than the developer themselves. As such it easy to show how the smallest time savers can improve productivity and save money.

Take a developer making $50,000, an amount not uncommon for entry level developers. Assuming 2 weeks of vacation, they’re working 2,000 hours per year (250 days) works out to $25/hour. Let’s also assume a cost of $2,000 for a new computer that will have a useful life of 2 years. If this developer waits 9.6 minutes per day on their computer, the cost to his/her company is $4/day ($25*(9.6/60)). Take $4 per day for 250 days per year works out to $1,000/year. Over a 2 year period the organization will break even, financially. The chart below shows the break-even point for developers at different salary levels and the amount of time saved per day that would justify a $2,000 computer.

The above chart shows only the break-even point. Consider a developer making $60,000 working on a slow machine that he/she waits on for 20 minutes each day. That 20 minutes in which the developer waits costs their organization $2,500 per year! Spending $2,000 results in a return on investment in less than 10 months. Over the 2 year life of the computer that results in an internal rate of return (IRR) of 91%. Let’s assume for a minute that a company expects a 15% return for any investment to be accepted. Over the 2 year span an investment of $2,000 to save 1 developer 20 minutes each day results in a net present value (NPV>) of $2,064.

Providing high performance machines for developers not only increases productivity but can also provide incentive for new hires as well as perks for existing ones. Developers enjoy working on the latest and greatest and providing that equipment can result in better employees.

This is one such case in which I want to specify a custom attribute on a constructor parameter that specifies the name the container should use to resolve the dependency. Unity, the underlying container, already provides this through the DependencyAttribute class. The problem is that using this attribute requires a reference to the Unity assembly. In order to utilize this feature but not take another dependency on Unity I’m going to add an extension to allow me to specify my own attribute from which to pull the name used to resolve the dependency.

Step 1: Inherit from the DefaultUnityConstructorSelectorPolicy

This policy is used when resolving dependencies from the ctor. Override the CreateResolver method which takes a ParameterInfo object as a parameter. This method is called on each parameter to the ctor and with it we’ll look for the custom attribute and pull the name of the dependency being resolved. First is the custom attribute itself, it contains a single string field for the name of the dependency.

[AttributeUsage(AttributeTargets.Parameter)]
public class NamedAttribute : Attribute
{
    private readonly string name;

    public NamedAttribute(string name)
    {
        this.name = name;
    }

    public string Name { get { return name; } }
}

public class NamedAttributeConstructorSelectorPolicy
    : DefaultUnityConstructorSelectorPolicy
{
    protected override IDependencyResolverPolicy
        CreateResolver(ParameterInfo parameter)
    {
        List<NamedAttribute> attributes = 
            parameter.GetCustomAttributes(false)
                .OfType<NamedAttribute>()
                .ToList();
        if (attributes.Count > 0)
        {
            string name = attributes[0].Name;
            return new NamedTypeDependencyResolverPolicy(
                parameter.ParameterType, name);
        }

        return base.CreateResolver(parameter);
    }
}

Step 2: Add the custom policy to the context.

This is a simple class that simply adds the custom policy created in the first step to the collection of policies that default with Unity in the current context.

public class CustomUnityExtension : UnityContainerExtension
{
    protected override void Initialize()
    {
        Context.Policies
            .SetDefault<IConstructorSelectorPolicy>(
                new NamedAttributeConstructorSelectorPolicy());
    }
}

Step 3: Add the extension to the container.

Another simple snippet that adds the custom extension to the container. This taken from the ctor of the wrapper class around Unity.

public UnityApplicationBlockContainer(IUnityContainer container)
{
    this.container = container;

    container.AddNewExtension<CustomUnityExtension>();
}

With these 3 steps in place you can start marking up the parameters within the ctors of services.

public class Service
{
    private readonly IDatabase sqlDatabase;
    private readonly IDatabase couchDatabase;

    public Service([Named("SqlDb")]IDatabase sqlDatabase, 
        [Named("CouchDb")]IDatabase couchDatabase)
    {
        this.sqlDatabase = sqlDatabase;
        this.couchDatabase = couchDatabase;
    }
}

A better approach I’ve found for interacting with the queue is to abstract away the specific queue that is being used as well as the type of the object being pulled from it. This is done by using the fully qualified type of the object being pushed to the queue as the queue name. This means you no longer need to specify which specific queue a message should be sent to because it’s based on the type of the object being serialized into a message. This has the side effect of no longer needing to worry about the type of the object that is getting deserialized from the queue either since the queue is dependent on the type of object.

Lets start off with a definition of the object we’ll serialize and push to the queue.

namespace Organization.SubNamespace
{
    public class User
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public DateTime Birthday { get; set; }
    }
}

Now that we have an object to serialize, lets look at the base definition of the queue service and some helper methods we’ll use.

public class GenericQueueService<T>
    : IQueuePublisher<T>, IQueueConsumer<T>, IAsyncQueueConsumer<T> where T : class
{
    private readonly IQueue queue;
    private readonly Serializer serializer;
    private ISession session;
    private IMessageConsumer messageConsumer;
    private IMessageProducer messageProducer;

    public event EventHandler<ConsumeQueueItemEventArgs<T>> ConsumeQueueItem;

    public GenericQueueService()
    {
        queue = new ActiveMQQueue(typeof(T).FullName);
        serializer = new Serializer();
    }

    private void EnsureConsumerExists()
    {
        if (messageConsumer != null)
        {
            return;
        }

        if (session == null)
        {
            session = CreateSession();
        }

        messageConsumer = session.CreateConsumer(queue);
    }

    private static ISession CreateSession()
    {
        IConnectionFactory connectionFactory = 
            new ConnectionFactory(Settings.Default.MQServer);
        IConnection connection = connectionFactory.CreateConnection();
        connection.Start();
        return connection.CreateSession(AcknowledgementMode.ClientAcknowledge);
    }

    private void EnsureProducerExists()
    {
        if (messageProducer != null)
        {
            return;
        }

        if (session == null)
        {
            session = CreateSession();
        }

        messageProducer = session.CreateProducer(queue);
    }
}

On the class definition I’ve identified a number of interfaces that can be used to get at specific parts of this service depending on whether there’s a need to push or pull messages from the queue. Also included is an async specific listener so that messages can be pulled asynchronously. This implementation requires that a separate service be instantiated for each type of object that will be pushed/pulled from the queue.

Notice in the constructor when a the new ActiveMQQueue object is created the fully qualified type name is used as the queue in which to communicate with. A feature I like about ActiveMQ is that if a queue doesn’t exist yet pushing a message will create it on the fly.

public void Publish(T publishObject)
{
    EnsureProducerExists();

    ITextMessage textMessage = session.CreateTextMessage(serializer.Serialize(publishObject));
    messageProducer.Send(textMessage);
}

The above method first ensures a producer exists which can push messages to the queue. Next the object is serialized and the result passed to a TextMessage which is used host the serialized object. Finally the message is sent to the server.

public T Consume()
{
    EnsureConsumerExists();

    IMessage message = messageConsumer.Receive();
    ITextMessage textMessage = message as ITextMessage;
    if (textMessage == null)
    {
        throw new MQException("Message pulled from queue must be of type ITextMessage.");
    }

    return ProcessTextMessage(textMessage);
}

private T ProcessTextMessage(ITextMessage textMessage)
{
    if (textMessage == null)
    {
        throw new MQException("Message from queue must be of type ITextMessage.");
    }

    return serializer.Deserialize<T>(textMessage.Text);
}

Here we see how to consume messages synchronously. The message is retrieved from the queue, casted to an ITextMessage and its contents are then deserialized back into an object.

public void StartAsyncConsumer()
{
    EnsureConsumerExists();

    messageConsumer.Listener += messageConsumer_Listener;
}

private void messageConsumer_Listener(IMessage message)
{
    T item = ProcessTextMessage(message as ITextMessage);
    if (ConsumeQueueItem != null)
    {
        ConsumeQueueItem(this, new ConsumeQueueItemEventArgs<T>(item));
    }
}

This implementation requires that an instance of the queue service be created for each object type that is pushed to the message queue. An enhancement could be made to allow a single service that takes in multiple types and manages itself which queues the messages are passed to and which queues messages should be retrieved from.

It should be mentioned that generally I’m not providing the interface definitions. Unless otherwise noted, assume all public members are exposed via the interface. I’ve also removed comments from all of the members for sake of brevity but comments should always be included!

The implementation below of the CommandExecutor is to execute the provided database command and return either an IDataReader or the number of records affected by the query depending on the method executed.

public class CommandExecutor : ICommandExecutor
{
    private readonly ILogger logger;

    public CommandExecutor(ILogger logger)
    {
        this.logger = logger;
    }

    public IDataReader ExecuteReader(IDbCommand command)
    {
        IDataReader reader;
        try
        {
            reader = command.ExecuteReader();
        }
        catch(SqlException e)
        {
            logger.Log(e);
            throw;
        }
        catch(InvalidOperationException e)
        {
            logger.Log(e);
            throw;
        }

        return reader;
    }

    public int ExecuteNonQueury(IDbCommand command)
    {
        try
        {
            return command.ExecuteNonQuery();
        }
        catch(SqlException e)
        {
            logger.Log(e);
            throw;
        }
        catch(InvalidOperationException e)
        {
            logger.Log(e);
            throw;
        }
    }
}

The purpose of the ObjectMapper class is to utilize the utility automapper which I’ve discussed in 2 parts here and here. This class will map the results contained in an IDataReader to a List of strongly typed objects that make sense in the domain in which they are used. We’ll see in a bit the configuration required in order to make this work (it’s pretty simple, only a single line of code if everything lines up right).

public class ObjectMapper : IMapper
{
    public TDestination Map<TSource, TDestination>(TSource source)
    {
        return Mapper.Map<TSource, TDestination>(source);
    }

    public TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
    {
        return Mapper.Map(source, destination);
    }
}

Below is an implementation of a SQL Server specific connection. The connection string is pulled from the application configuration file of the project in which this class is contained. This class does not protect itself against some possible null reference exceptions and attempts to log critical errors regarding failure to connect to the database. Remember all public members are exposed through the interface and note the judicious use of non-SQL Server specified interfaces as the return types of the methods and properties in order to support the possibility of utilizing a different database platform. As a side effect, the use of these interfaces also eases the unit testability of this abstraction.

public class SqlConnection : IDatabaseConnection
{
    private readonly ILogger logger;

    public SqlConnection(ILogger logger)
    {
        this.logger = logger;

        ChangeConnection(Settings.Default.MADatabase);
    }

    public IDbConnection DbConnection { get; set; }

    public void Open()
    {
        DbConnection.Open();
    }

    public IDbTransaction GetSqlTransaction()
    {
        return DbConnection.BeginTransaction();
    }

    public void EstablishNewConnection()
    {
        ChangeConnection(Settings.Default.MADatabase);
    }

    public void ChangeConnection(string connectionString)
    {
        // Nice to register connection string in the container, then resolve named parameters (Unity addon would be needed).
        if (string.IsNullOrEmpty(connectionString))
        {
            logger.Log("Could not retrieve db connection string from Settings file.", LogSeverity.Error);
            return;
        }

        try
        {
            DbConnection = new System.Data.SqlClient.SqlConnection(connectionString);
            DbConnection.Open();
        }
        catch(InvalidOperationException e)
        {
            logger.Log("Could not open database connection!", e, LogSeverity.Critical);
        }
        catch(SqlException e)
        {
            logger.Log("Could not open database connection!", e, LogSeverity.Critical);   
        }
    }

    public IDbCommand CreateCommand()
    {
        return DbConnection.CreateCommand();
    }
}

The below class, DatabaseExecutor, is used as a utility by the abstract class that our domain specific services will implement. This class allows for the creation of transactions as well as executing commands and returning strongly typed results. The dependencies have all been defined above and are represented as interfaces of which the implementations will be injected. There are a number of overloads of the Execute method to return the results of the command, return whether the command executed successfully and passing the results as an out parameter and finally executing a command that doesn’t return results.

public class DatabaseExecutor : IDatabase
{
    private readonly ILogger logger;
    private readonly IDatabaseConnection dbConnection;
    private readonly IMapper mapper;
    private readonly ICommandExecutor commandExecutor;
    private IDbTransaction currentTransaction;

    public DatabaseExecutor(ILogger logger, IDatabaseConnection dbConnection,
        IMapper mapper, ICommandExecutor commandExecutor)
    {
        this.logger = logger;
        this.dbConnection = dbConnection;
        this.mapper = mapper;
        this.commandExecutor = commandExecutor;

        currentTransaction = null;
    }

    public void BeginTransaction()
    {
        currentTransaction = dbConnection.GetSqlTransaction();
    }

    public void CommitTransaction()
    {
        currentTransaction.Commit();

        currentTransaction = null;
    }

    public void RollbackTransaction()
    {
        currentTransaction.Rollback();

        currentTransaction = null;
    }

    public T Execute<T>(IDbCommand command) where T : class, new()
    {
        if (command == null)
        {
            return null;
        }

        command.Connection = dbConnection.DbConnection;
        command.Transaction = currentTransaction;

        IDataReader reader;
        try
        {
            reader = commandExecutor.ExecuteReader(command);
        }
        catch(SqlException)
        {
            StringBuilder builder = new StringBuilder("Database command failure details");
            builder.AppendLine();
            builder.AppendLine(command.CommandText);
            foreach (IDataParameter parameter in command.Parameters)
            {
                builder.AppendLine(string.Format("{0}:{1}",
                    parameter.ParameterName, parameter.Value));
            }

            logger.Log(builder.ToString(), LogSeverity.Error);

            throw;
        }

        if (reader == null)
        {
            return null;
        }

        try
        {
            return typeof(IEnumerable).IsAssignableFrom(typeof(T))
                       ? mapper.Map<IDataReader, T>(reader)
                       : mapper.Map<IDataReader, List<T>>(reader).FirstOrDefault();
        }
        catch(Exception e)
        {
            logger.Log(e);
            throw;
        }
        finally
        {
            reader.Close();
        }
    }

    public bool Execute<T>(IDbCommand command, out T result)
        where T : class, new()
    {
        result = Execute<T>(command);

        return result != null
            ? true
            : false;
    }

    public void Execute(IDbCommand command)
    {
        if (command == null)
        {
            return;
        }

        command.Connection = dbConnection.DbConnection;
        command.Transaction = currentTransaction;

        try
        {
            commandExecutor.ExecuteNonQueury(command);
        }
        catch(SqlException)
        {
            StringBuilder builder = new StringBuilder("Database command failure details");
            builder.AppendLine(command.CommandText);
            foreach (IDataParameter parameter in command.Parameters)
            {
                builder.AppendLine(string.Format("{0}:{1}",
                    parameter.ParameterName, parameter.Value));
            }

            logger.Log(builder.ToString(), LogSeverity.Error);
            throw;
        }
    }
}

The abstract class that should be used as the base for any data access services is provided below. From this class transaction may be started. Also is a helper function, GetValueCatchNull, which is used when using Automapper to map between fields that don’t match by convention (example shown further below).

My original implementation of this abstract class included properties and methods that would dynamically inspect the properties of an object and create parameter and value lists that could be passed to sql insert/select/update/delete commands but was only half-baked and thus not included here so if this looks a bit sparse and you’re wondering why you couldn’t just request the IDatabase class as a direct dependency within your data access service, you could. Hopefully in the future I’ll find a better implementation of a way to do this but as of yet hasn’t worked very well.

public abstract class DatabaseServiceBase
{
    protected readonly IDatabase database;

    protected DatabaseServiceBase(IDatabase database)
    {
        this.database = database;
    }

    public void BeginTransaction()
    {
        database.BeginTransaction();
    }

    public void CommitTransaction()
    {
        database.CommitTransaction();
    }

    public void RollbackTransaction()
    {
        database.RollbackTransaction();
    }

    protected static T GetValueCatchNull<T>(Func<T> func)
    {
        try
        {
            return func();
        }
        catch(SqlNullValueException)
        {
            return default(T);
        }
    }
}

Finally, an implementation of the data service layer utilizing the above defined classes. Notice here how we’re implementing the abstract class DatabaseServiceBase and calling the base constructor and passing to it the requested dependency IDatabase. Also of importance is the static constructor which creates the mapping between the results from the database (IDataReader) and mapping that to the User object. See the previous automapper post for info on why we’re mapping a single object to a data type that may return multiple results. Notice the use of the GetValueCatchNull in order to manage if a null value is returned from the IDataReader and cannot be applied to value types. Last but not least notice that in the GetUsers method we’re actually returning a list of results and this is possible due to the previous implementation of the IDatabase interface defined as DatabaseExecutor which allows us to pass in a single object or List of objects and it will map both.

public class UserService : DatabaseServiceBase, IUserService
{
    private readonly ILogger logger;

    public UserService(ILogger logger, IDatabase database)
        : base(database)
    {
        this.logger = logger;
    }

    static UserService()
    {
        Automapper.Mapper.CreateMap<IDataReader, User>()
            .ForMember(m => m.FirstName, opt => opt.MapFrom(p => GetValueCatchNull(() => p.GetString(p.GetOrdinal("First")))));
    }

    public User GetUserById(int userId)
    {
        SqlCommand command = new SqlCommand("select * from Users where UserId = @UserId");
        command.Parameters.AddWithValue("@UserId", userId);

        return database.Execute<User>(command);
    }

    public List<Users> GetUsers()
    {
        SqlCommand command = new SqlCommand("select * from Users");
        
        return database.Execute<List<Users>>(command);
    }
}

There you have it, an abstraction of a data layer that will ease transition from a SQL Server database to Oracle or even an unsupported system like DB2 or MySql.

public class User
{
    public int UserId { get; set; }

    public string FirstName { get; set; }

    public string LastName { get; set; }
}

public List<User> GetUsers()
{
    Automapper.Mapper.CreateMap<IDataReader, User>();

    SqlCommand command = new SqlCommand("select * from Users");
    command.Connection = new SqlConnection("connection string goes here");

    IDataReader dataReader = command.ExecuteReader();
    List<User> users = Automapper.Mapper.Map<List<User>>(dataReader);
    return users;
}

Establishing the mapping relationship and actually mapping the objects gets a little tricky. Notice the line Automapper.Mapper.CreateMap() maps the data reader to a single object. The problem is that likely multiple records will be returned from the query resulting in multiple objects. As such when the IDataReader is actually mapped to a list of objects, the destination is specified as an IEnumberable. I prefer to directly use the List class because it is not uncommon to use the FirstOrDefault() Linq extenstion method when I know there is only 1 record being returned by the query if I’m retrieving a record by PK for example.

It would probably be a good idea to throw a try-catch around the Map method call in order to catch exceptions thrown when the results of an IDataReader cannot be mapped to an object. Also a good idea to close the IDataReader but the example shown is to demonstrate the object mapping capabilities.

The example above expects that the database column names identically match the data model properties (including case, ie ‘UserId’ does not map to ‘UserID’). In these cases when you create the mapping relationship you can specify which properties should be mapped where. Mapping the data reader is a bit annoying but looks like the below code.

public List<User> GetUsers()
{
    Automapper.Mapper.CreateMap<IDataReader, User>()
        .ForMember(m => m.UserId, opt => opt.MapFrom(r => r.GetInt32(r.GetOrdinal("UserID"))))
        .ForMember(m => m.FirstName, opt => opt.MapFrom(r => r.GetString(r.GetOrdinal("FirstNameColumnName"))));

    // Rest of code...
}

Part 2 is about using Automapper as an object-relational mapper (ORM).

This tool has a number of useful and time saving functions. It’s normal function proves helpful when implementing best practices around XML serialization/deserialization as well as WCF data contracts in which you want to utilize objects in your application that aren’t necessarily marked up with XML attributes, are able to be versioned in the case of WCF or in which you want to change the structure of the data model to better fit your needs for use within your application. In these scenarios you typically have two identical data model objects with properties of the same name and type, except one of the objects is marked up with XML attributes or WCF data contract attributes. Rather than create a helper method to map between these objects Automapper will figure out which properties line up based on convention (same name and type). Automapper requires a single line of code to tell it, statically, which objects should map to each other and then you simply give Automapper your source object and it returns to you a new instance of your mapped object. Simple example is provided below.

[DataContract]
public class SourceObject
{
    [DataMember]
    public int MyIntegerProperty { get; set; }

    [DataMember]
    public string MyStringProperty { get; set }
}

public class DestinationObject
{
    public int MyIntegerProperty { get; set; }

    public string MyStringProperty { get; set; }
}

public class Test
{
    public static void Main(string[] args)
    {
        Automapper.Mapper.CreateMap<SourceObject, DestinationObject>();

        SourceObject source = new SourceObject
            {
                MyIntegerProperty = 123, 
                MyStringProperty = "asdf"
            };

        // destination object contains int property with value 123 
        // and string property with value "adsf".
        DestinationObject destination =
            Automapper.Mapper.Map<DestinationObject>(source);
    }
}

For situations in which you have properties that do not match by convention, as in they are spelled differently or in the case where you wish to change the data structure, Automapper provides a way to specify which properties should be matched to other properties.

public class NewDestinationObject
{
    public int SomeIntegerProperty { get; set; }

    public string AStringProperty { get; set; }
}

public static void Main(string[] args)
{
    Automapper.Mapper.CreateMap<SourceObject, NewDestinationObject>()
        .ForMember(m => m.SomeIntegerProperty, opt => opt.MapFrom(p => p.MyIntegerProperty))
        .ForMember(m => m.AStringProperty, opt => opt.MapFrom(p => p.MyStringProperty));

        SourceObject source = new SourceObject
            {
                MyIntegerProperty = 123, 
                MyStringProperty = "asdf"
            };

        DestinationObject destination =
            Automapper.Mapper.Map<DestinationObject>(source);
}

In the above example, Automapper allows you to use Lambda expressions to specify the properties to map to and the properties they should be mapped from. Given the use of Lambda’s, you can create any number of complicated mapping schemas.

I find it convenient also to reference web services used by the Silverlight client relative the base url of the rest service (the url of the browser).

[ServiceContract]
public interface IFrameworkRestService
{
    [OperationContract]
    [WebGet(UriTemplate="clientaccesspolicy.xml")] 
    Stream ClientAccessPolicy();

    [OperationContract]
    [WebGet(UriTemplate = "{fileName}")]
    Stream GetFile(string fileName);

    [OperationContract]
    [WebGet(UriTemplate = "")]
    Stream RootHtmlPage();
}

As with all WCF services, attributes are used to indicate a particular class is a web service. Additionally each method is marked with the OperationContract attribute. The WebGet attribute indicates a particular method should be accessed in a restful way. The UriTemplate parameter defines how the operation can be accessed relative the base URL used to expose the service. For example if the service is exposed on the URL, “http://localhost/MyService”, the ClientAccessPolicy can be executed by calling the URL, “http://localhost/MyService/clientaccesspolicy.xml”. The RootHmtlPage can be accessed through the URL, “http://localhost/MyService” as an empty string is passed to the UrlTemplate attribute. The GetFile method has a special parameter, with brackets around the name, that maps to any URL after the ‘MyService’ part of the URL. This method will serve up the Xap Silverlight files. Some examples would be “http://localhost/MyService/Test1.xap” and ‘http://localhost/MyService/Test2.xap’. The name of the file is passed into the GetFile method in the fileName parameter.

[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single, AddressFilterMode=AddressFilterMode.Any)]
public class FrameworkRestService : IFrameworkRestService
{
    private readonly ILogger logger;

    public FrameworkRestService(ILogger logger)
    {
        this.logger = logger;
    }

    public Stream ClientAccessPolicy()
    {
        const string result = @"<?xml version=""1.0"" encoding=""utf-8""?>
                    <access-policy>
                        <cross-domain-access>
                            <policy>
                                <allow-from http-request-headers=""*"">
                                    <domain uri=""*""/>
                                </allow-from>
                                <grant-to>
                                    <resource path=""/"" include-subpaths=""true""/>
                                </grant-to>
                            </policy>
                        </cross-domain-access>
                    </access-policy>";

        if (WebOperationContext.Current != null)
        {
            WebOperationContext.Current.OutgoingResponse.ContentType = "application/xml";
        }

        return new MemoryStream(Encoding.UTF8.GetBytes(result));
    }

    public Stream GetFile(string fileName)
    {
        string path = AppDomain.CurrentDomain.BaseDirectory;
        string absolutePath = string.Format(@"{0}\{1}", path, fileName);

        logger.Log(string.Format("Serving up {0}.", absolutePath));

        try
        {
            return new FileStream(absolutePath, FileMode.Open);
        }
        catch(Exception e)
        {
            logger.Log("Exception getting file.", e);
        }

        return null;
    }

    public Stream RootHtmlPage()
    {
        if (WebOperationContext.Current != null)
        {
            WebOperationContext.Current.OutgoingResponse.ContentType = "text/html";
        }

        string path = AppDomain.CurrentDomain.BaseDirectory;

        logger.Log("Serving up root MAClient html page.");

        try
        {
            return new FileStream(string.Concat(path, @"ClientTestPage.html"), FileMode.Open);
        }
        catch(Exception e)
        {
            logger.Log("Exception retrieving root html page.", e);
        }

        return null;
    }
}

Couple things to note in the implementation of the REST service. Don’t forget to set the MIME type when serving up the root html page and the clientaccesspolicy. Not sure why but the browser has trouble figuring out what it’s getting if this isn’t set. It is assumed that the Silverlight HTML files and Xap files are located in the directory that the application is running from but this could be set to anywhere in the GetFile method.

The test html page created by Visual Studio usually references the base Silverlight xap file within the ClientBin directory. Edit the html file and remove the ClientBin from before the xap file reference. Otherwise the GetFile method won’t be called because it won’t match the UriTemplate of the GetFile interface method.

public class RestServiceHost
{
    private readonly IFrameworkRestService;
    private readonly WebServiceHost restServiceHost;

    public RestServiceHost()
    {
        IFrameworkRestService restService = new FrameworkRestService(new Logger());
        restServiceHost = new WebServiceHost(restService, new Uri("http://localhost/MyService", UriKind.Absolute));

        restServiceHost.Open();
    }

}

Use the WebServiceHost rather than ServiceHost as it is better suited for hosting Rest services (less configuration required). Once these services are running navigate your browser to http://localhost/MyService and the Silverlight app should appear.

There are a number of popular logging utilities and for the most part each is about as good as any other. They are all very similar. I am partial to the Enterprise Library Logging Application Block which can be downloaded here.

The Enterprise Library Logging Application Block, like other logging frameworks, allow you to create log messages and send those messages to different targets of output. Multiple output targets may be configured. The most typical output targets include a console window, file, database, web services and email though any conceivable target could be configured. Use of the logging infrastructure includes 3 components. 1) configuring each logging component 2) calling the logging infrastructure and 3) listening for log messages and sending them to the output targets.

The implementation below starts off with a wrapper around the actual EntLib logger. The wrapper is intended to limit references to the EntLib assemblies to one project. Going this route would allow for the EntLib logger to be swapped out for another with minimal impact on the application.

I should note that access to most loggers is static. The wrapper implementation below uses the static calls but the object itself is intended to be registered in an IoC container and used as an instance. This way I can add an interface and have better control over the object lifetime and better manage multiple loggers. The application in which this logger is used manages long running background threads. Each thread could be thought of as a sub-application and thus gets its own logger to differentiate the log messages. Though when I say “own logger” it’s really separate instances of the wrapper making static calls to the underlying EntLib logger. This approach also makes testing easier as I can mock out the logger interface and just ignore all logging calls in the unit tests.

public class EntLibLogger : ILogger
{
    public string Name { get; set; }
        
    public void Log(string message)
    {
        Log(message, LogSeverity.Information);
    }

    public void Log(string message, LogSeverity logSeverity)
    {
        LogEntry log = new LogEntry
                           {
                               Message = message,
                               Priority = GetLogSeverity(logSeverity),
                               Title = Name
                           };
        log.Categories.Add(Name);
            
        Logger.Write(log);
    }

    public void Log(Exception exception)
    {
        Log(exception, LogSeverity.Error);
    }

    public void Log(Exception exception, LogSeverity logSeverity)
    {
        Log(string.Empty, exception, logSeverity);
    }

    public void Log(string message, Exception exception)
    {
        Log(message, exception, LogSeverity.Information);
    }

    public void Log(string message, Exception exception, LogSeverity logSeverity)
    {
        const string subjectFormat = "{0}\r\n\r\n{1}";
        LogEntry logEntry = new LogEntry
                                {
                                    Message = string.IsNullOrEmpty(message) ? FormatException(exception) : string.Format(subjectFormat, message, FormatException(exception)),
                                    Priority = GetLogSeverity(logSeverity),
                                    Title = Name
                                };

        logEntry.Categories.Add(Name);
            
        // Set the category to the name of this logger, hopefully we can use this to distinguish log messages.
        // Setting the category causes the message to not be picked up by the console or email listeners, not sure whats up.
        //logEntry.Categories.Add(Name);
        Logger.Write(logEntry);
    }

    private static int GetLogSeverity(LogSeverity severity)
    {
        switch(severity)
        {
            case LogSeverity.Information:
                return 10;
            case LogSeverity.Highlight:
                return 20;
            case LogSeverity.Warning:
                return 30;
            case LogSeverity.Error:
                return 40;
            case LogSeverity.Critical:
                return 50;
            default:
                return 10;
        }
    }

    private static string FormatException(Exception exception)
    {
        StringBuilder formattedException = new StringBuilder();
        formattedException.AppendLine(exception.Source);
        formattedException.AppendLine(exception.Message);
        formattedException.AppendLine(exception.StackTrace);
        formattedException.AppendLine();

        if (exception.InnerException != null)
        {
            formattedException.AppendLine(FormatException(exception.InnerException));
        }

        return formattedException.ToString();
    }
}

There are a number of utility/helper overrides of the Log method to ease logging the desired information at the certain levels. The Name property exists to track in the log output where log messages come from. The Name property is set when the log instance is created and each message that gets log has this Name included in it. The GetLogSeverity method maps EntLib logging priority levels, indicated as integers, and translates those numbers to an enum containing more descriptive levels of logging priority. The FormatException method translates the important information contained in an exception into something readable. The ILogger interface contains all of the public methods in this class.

[ConfigurationElementType(typeof(CustomTraceListenerData))]
public class ConsoleTraceListener : CustomTraceListener
{
    public ConsoleTraceListener()
    {
        Console.BufferHeight = 9999;
    }

    public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
    {
        LogEntry log = data as LogEntry;
        if (log != null && Formatter != null)
        {
            ConsoleColor color = Console.ForegroundColor;
            SetConsoleColor(log);
            WriteLine(Formatter.Format(data as LogEntry));
            Console.ForegroundColor = color;
        }
        else if (data != null)
        {
            WriteLine(data.ToString());
        }
    }

    public override void Write(string message)
    {
        Console.Write(message);
    }

    public override void WriteLine(string message)
    {
        Console.WriteLine(message);
    }

    private static void SetConsoleColor(LogEntry entry)
    {
        if (entry.Priority <= 10)
        {
            Console.ForegroundColor = Settings.Default.InformationLogColor;
        }
        else if (entry.Priority <= 20)
        {
            Console.ForegroundColor = Settings.Default.HighlightLogColor;
        }
        else if (entry.Priority <= 30)
        {
            Console.ForegroundColor = Settings.Default.WarningLogColor;
        }
        else if (entry.Priority <= 40)
        {
            Console.ForegroundColor = Settings.Default.ErrorLogColor;
        }
        else if (entry.Priority <= 50)
        {
            Console.ForegroundColor = Settings.Default.CriticalLogColor;
        }
    }
}

The above class inherits from the CustomTraceListener and has an attribute ConfigurationElementType. The TraceData method is where the log messages get outputed. It is a good idea to make use of the Write and WriteLine overrides in case the underlying class calls them as well. The constructor sets the buffer of the Console window to be big in order to maintain a longer history of log messages. This is important when you start to see large numbers of log messages.

The final step to logging with EntLib is to configure each of the previous components to work together.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="loggingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.LoggingSettings, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
    <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
  </configSections>
  <loggingConfiguration name="Logging Application Block" tracingEnabled="true"
    defaultCategory="General" logWarningsWhenNoCategoriesMatch="true">
    <listeners>
      <add formatter="ConsoleFormatter" initializeData="" delimiter="------------------------------------"
        listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.CustomTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
        traceOutputOptions="None" filter="All" type="MyNamespace.ConsoleTraceListener, MyAssembly.Name, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
        name="ConsoleTraceListener" />
      <add source="Enterprise Library Logging" formatter="Text Formatter"
        log="Application" machineName="" listenerDataType="Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.FormattedEventLogTraceListenerData, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
        traceOutputOptions="None" filter="All" type="Microsoft.Practices.EnterpriseLibrary.Logging.TraceListeners.FormattedEventLogTraceListener, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
        name="Formatted EventLog TraceListener" />
    </listeners>
    <formatters>
      <add template="Timestamp: {timestamp}
Message: {message}
Category: {category}
Priority: {priority}
EventId: {eventid}
Severity: {severity}
Title:{title}
Machine: {machine}
Application Domain: {appDomain}
Process Id: {processId}
Process Name: {processName}
Win32 Thread Id: {win32ThreadId}
Thread Name: {threadName}
Extended Properties: {dictionary({key} - {value}
)}"
        type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
        name="Text Formatter" />
      <add type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
           name="ConsoleFormatter"
           template="{category} {timestamp}:  {message}" />
    </formatters>
    <categorySources>
      <add switchValue="All" name="General">
        <listeners>
          <add name="ConsoleTraceListener" />
        </listeners>
      </add>
    </categorySources>
    <specialSources>
      <allEvents switchValue="All" name="All Events" />
      <notProcessed switchValue="All" name="Unprocessed Category" />
      <errors switchValue="All" name="Logging Errors &amp; Warnings">
        <listeners>
          <add name="Formatted EventLog TraceListener" />
        </listeners>
      </errors>
    </specialSources>
  </loggingConfiguration>
</configuration>

Configuring the logger is a tedious process but does provide a lot of flexibility in terms of formatting output and determining which loggers get which log messages. First, you need to setup the configuration sections of which there is one required for the EntLib logging application block called loggingConfiguration. In the loggingConfiguration section add a listener to point to the ConsoleTraceListener class created ealier. Also in the loggingConfiguration section create a formatter to determine how the output of the log messages in text will appear. After the formatters, create categorySources which determines which targets will receive log messages from each logger.

Once the configuration is completed you’re ready to start logging messages. There are a number of other log targets, mentioned earlier, that can be created to solve unique logging requirements. I’ll include a couple other log listeners below that can be used. The comments are removed for sake of brevity.

[ConfigurationElementType(typeof(CustomTraceListenerData))]
public class EmailTraceListener : CustomTraceListener
{
    private readonly EmailLogService emailService;

    public EmailTraceListener()
    {
        emailService = new EmailLogService();
    }
    public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
    {
        LogEntry logEntry = data as LogEntry;
        if (logEntry != null && logEntry.Priority >= 50)
        {
            emailService.SendExceptionEmail(logEntry.Title, logEntry.Message);
        }
    }

    public override void Write(string message)
    {
    }

    public override void WriteLine(string message)
    {
    }
}

public class EmailLogService
{
    private readonly SmtpClient mailClient;

    public EmailLogService()
    {
        mailClient = new SmtpClient(Constants.EmailHost, 25);
    }
   
    public void SendExceptionEmail(string subject, string body)
    {
        MailMessage email = new MailMessage
                                {
                                    From = new MailAddress(Constants.DefaultDebugEmailAddress),
                                    Subject = string.IsNullOrEmpty(subject) ? "MAFramework Critical Error" : subject,
                                    Body = body
                                };

        email.To.Add(Settings.Default.DefaultDebugEmailAddresses);

        mailClient.Send(email);
    }
}

The EmailTraceListener sends an email for log messages of the highest priority which are reserved for serious system errors, usually in which the application is crashing or is being prevented from running normally. Note in the TraceData method the send email service is used only when log priority is greater than or equal to 50. Also note the Write and WriteLine methods do nothing.

[ConfigurationElementType(typeof(CustomTraceListenerData))]
public class PublishLogTraceListener : CustomTraceListener
{
    private readonly ILogNotifier logNotifier;

    public PublishLogTraceListener()
    {
        logNotifier = LogNotifierFactory.GetLogNotifier();
    }

    static PublishLogTraceListener()
    {
        Mapper.CreateMap<LogEntry, LogMessage>();
    }

    public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
    {
        LogEntry logEntry = data as LogEntry;
        if (logEntry == null)
        {
            return;
        }

        logNotifier.FireMessageLogged(Mapper.Map<LogEntry, LogMessage>(logEntry));
    }

    public override void Write(string message)
    {
    }

    public override void WriteLine(string message)
    {
    }
}

The PublishLogTraceListener is used to broadcast log messages using WCF’s duplex services. I have created a Silverlight web app that listens for and displays these log messages essentially creating a Console window in the browser that allows for viewing application log messages without being logged onto the server to see the actual console window. Also since the Silverlight client is dealing with log message objects I can create a UI around sorting and filtering different messages to view only the most significant errors for the application function I’m interested in. A sample implementation of the of the PollingDuplexBinding can be found in an older post here. Note too that I’m using Automapper to map from the EntLib log object to a log object of my own. This is so the client can have access to the log object without needing a reference to EntLib.