Note: I’ve provided a download link to my code at the end of this article.

I started out by creating an empty ASP.NET project and added a basic web form which creates a GridView to display some results from the database (which I’ve included in the App_Data folder).  Next using NuGet (one of the best tools ever!) I installed the Fluent NHibernate package and all of its dependencies in my web application.

I created the following class to represent a single record from tUser in my application:

public class User
{
    public virtual int ID { get; set; }
    public virtual string EmailAddress { get; set; }
    public virtual string Password { get; set; }
}

Note the use of the virtual keyword here.  Without it we would get an NHibernate.InvalidProxyTypeException with an error message similar to:

The following types may not be used as proxies:
WebApplication1.Entities.User: method get_Password should be ‘public/protected virtual’ or ‘protected internal virtual’
WebApplication1.Entities.User: method set_Password should be ‘public/protected virtual’ or ‘protected internal virtual’

The next step was to set up and configure NHibernate for my application.  For database access using NHibernate we need two objects; ISessionFactory and ISession.  The ISessionFactory interface is created during the fluent configuration of NHibernate and allows us to “open” a session by calling mySessionFactory.OpenSession().  This method call returns an instance of ISession which can then be used to create queries, handle transactions and add/remove/update items in the database.

I wanted to only create a single session factory for the entire application and a open a single session per request so I added a Global.asax file to my project in order to take advantage of the Application_Start and Application_BeginRequest events.  This is where I configured my application using the code below:

public class Global : System.Web.HttpApplication
{
    protected void Application_Start(object sender, EventArgs e)
    {
        Application["NHSessionFactory"] = CreateSessionFactory();
    }
 
    private static ISessionFactory CreateSessionFactory()
    {
        return Fluently.Configure()
            .Database(MsSqlConfiguration.MsSql2008
                .ConnectionString(ConfigurationManager.AppSettings["ConnectionString"]))
            .Mappings(m => m.AutoMappings.Add(CreateAutomappings))
            .BuildSessionFactory();
    }
 
    private static AutoPersistenceModel CreateAutomappings()
    {
        return AutoMap
            .AssemblyOf<AutomappingConfiguration>(new AutomappingConfiguration())
            .Override<User>(u => u.Table("tUser"));
    }
 
    protected void Application_BeginRequest(object sender, EventArgs e)
    {
        ISessionFactory sessionFactory = (ISessionFactory) Application["NHSessionFactory"];
        Context.Items["NHSession"] = sessionFactory.OpenSession();
    }
 
    protected void Application_EndRequest(object sender, EventArgs e)
    {
        ISession session = (ISession) Context.Items["NHSession"];
        session.Dispose();
    }
 
    protected void Application_End(object sender, EventArgs e)
    {
        ISessionFactory sessionFactory = (ISessionFactory)Application["NHSessionFactory"];
        sessionFactory.Dispose();
    }
}

The Application_Start method is responsible for creating my session factory by calling the CreateSessionFactory method and storing it at the application level.  The CreateSessionFactory method sets the connection string and sets up the auto mapping by calling the CreateAutomappings.  This method sets the auto mapping configuration which defines what classes to automatically and overrides the table name that my User class should map to.  The auto mapping configuration provides quite a lot of functionality not covered in this article but you can find some examples of configuration at http://wiki.fluentnhibernate.org/Auto_mapping.

In the Application_BeginRequest method I retrieve the my application’s session factory, open a new session and attach it to the current requests context so it can be accessed in my ASP.NET pages:

protected void Page_Load(object sender, EventArgs e)
{
    ISession session = (ISession) Context.Items["NHSession"];
    CreateUsers(session);
 
    var users = from u in session.Query<User>()
                select u;
 
    grdUsers.DataSource = users;
    grdUsers.DataBind();
}
 
private void CreateUsers(ISession session)
{
    if(session.Query<User>().Count() < 3)
    {
        using(ITransaction transaction = session.BeginTransaction())
        {
            for (int i = 1; i <= 3; i++)
            {
                User user = new User
                {
                    EmailAddress = string.Format("user{0}@test.com", i),
                    Password = "password"
                };
                session.Save(user);
            }
 
            transaction.Commit();
        }
    }
}

The first line of this method retrieves the session from the request context and can then be used to query the database.  The “CreateUsers” method shows a simple insert into the database using a transaction.  This is followed by a really simple Linq expression which queries the database for all of the User records.  I should point out that in order to use Linq expressions for queries I needed add a using statement for the NHibernate.Linq namespace.

This basic set up of Fluent NHibernate is okay but it could be improved upon so I’m going to write a follow up article on using Fluent NHibernate with dependency injection to improve the structure of the code.  And as promised the download link for the code can be found below; in order to build this project you will need to have NuGet installed as I’m using the NuGetPowerTools package to retrieve all of the required DLLs when the project is built.

Download Link: http://www.jason-mitchell.com/Uploads/Fluent_NHibernate_Getting_started.zip

First I want to provide a bit of context on how DateTime.Now is being called.  My game engine includes a messaging system so that objects can create and publish messages to the game so they can be consumed by subscribed objects.  Each message generates a time stamp for itself using DateTime.Now.  The demo game has been purposefully set up to create 800 objects each of which send out new messages every frame.

The following screenshots are from the profiler run with the DateTime.Now call still in the code.  This first image shows the CPU usage ratio between the full update and draw processes:

The following image shows the call to the constructor containing the usage of DateTime.Now.  Note that the usage for the function calling this code (the blue box on the left) is 35.8%.

Lastly, this image shows the CPU percentage used for the DateTime.Now call.

I was really quite surprised to see how much CPU time the DateTime.Now call was using.  I then removed the call and ran the CPU profiler to see how the results changed.  The first image is of the Game.Run() call again showing the ratio between the update and draw methods.  Already it’s clear that removing the DateTime.Now call has improved things since the CPU usage is split more evenly.

The following image shows the call to the constructor which used to contain the call to DateTime.Now.  Notice that the usage for the code calling this function has dropped from 35.8% to 0.9% which is a massive change!

Because the results of this performance test were so surprising I decided to do a bit of googling around the performance of DateTime.Now and it didn’t take very long to find an article confirming that this call is expensive.  The article also states that using DateTime.UtcNow is much faster however I plan on staying away from using DateTime in my game engine.  You can read the article at http://bit.ly/zTJaaT.

When I started looking at the repository pattern I found that a lot of the samples on the internet used explicitly typed repositories such as ICustomerRepository and IOrderRepository.  However for a website I’m currently working on all of my CRUD operations were pretty much the same and I wanted to reduce the amount of code I needed to write so I implemented a basic generic repository which would work with any of my data model classes.

The following code snippet  is the interface for the basic repository I’ve been using:

public interface IRepository
{
    void Save();
 
    IQueryable Query(Expression<Func<T, bool>> filter = null) where T : class;
    T SingleOrDefault(Expression<Func<T, bool>> predicate) where T : class;
    void Insert(T entity) where T : class;
    void Update(T entity) where T : class;
    void Delete(T entity) where T : class;
}

This interface only defines the most basic data access operations and should probably be expanded on to provide support for beginning, committing and rolling back transactions.

The following class is an implementation of IRepository which has been implemented to abstract access to an Entity Framework Code First data context:

public class EntityFrameworkRepository : IRepository
{
    private readonly SiteDataContext dataContext;
 
    public EntityFrameworkRepository(SiteDataContext dataContext)
    {
        this.dataContext = dataContext;
    }
 
    public void Save()
    {
        dataContext.SaveChanges();
    }
 
    public IQueryable Query(Expression<Func<T, bool>> filter = null) where T : class
    {
        IQueryable query = dataContext.Set<T>();
 
        if (filter != null)
            query = query.Where(filter);
 
        return query;
    }
 
    public T SingleOrDefault(Expression<Func<T, bool>> predicate) where T : class
    {
        return dataContext.Set<T>().SingleOrDefault(predicate);
    }
 
    public void Insert(T entity) where T : class
    {
        dataContext.Set<T>().Add(entity);
    }
 
    public void Update(T entity) where T : class
    {
        DbEntityEntry entityEntry = dataContext.Entry(entity);
        if(entityEntry.State == EntityState.Detached)
        {
            dataContext.Set<T>().Attach(entity);
            entityEntry.State = EntityState.Modified;
        }
    }
 
    public void Delete(T entity) where T : class
    {
        dataContext.Set<T>().Remove(entity);
    }
}

There’s nothing particularly complicated about this class so  I’m just going to give a quick example on how to use it and leave it at that!  If you have the following class defined in an Entity Framework Code First data context:

public class Customer
{
    [Key]
    public int ID { get; set; }
 
    [Required]
    public string FirstName { get; set; }
 
    [Required]
    public string LastName { get; set; }
}

You could query your customer data really easily using a LINQ expression:

var customers = from c in repository.Query()
                where c.FirstName == "Jason"
                select c;

or a lambda expression:

var customer = repository.Query(c => c.FirstName == "Jason");

For more information about the repository pattern see: http://msdn.microsoft.com/en-us/library/ff649690.aspx

The following PowerShell code shows a basic function which can be used to toggle workflows on a list off and on.  It shouldn’t take much work to convert this to C# if needed.

$snapin = "Microsoft.SharePoint.PowerShell"
if((Get-PSSnapin -Name $snapin -ErrorAction SilentlyContinue) -eq $null)
{
    Add-PsSnapin $snapin
}
 
$spWeb = Get-SPWeb http://sharepoint-site-url
 
function toggle-workflows($listName, $enabled)
{
    $prevVersionPattern = ".+`(Previous.+`)"
    $spList = $spWeb.GetList("/Lists/$listName")
    $spListWorkflows = $spList.WorkflowAssociations
 
    $latestWorkflow = $spListWorkflows | where-object {
          -not ($_.Name -match $prevVersionPattern) } | select-object -first 1
    if($latestWorkflow)
    {
        write-host "$listname workflow: $enabled" -fore yellow
    	$latestWorkflow.AutoStartCreate = $enabled
    	$spListWorkflows.Update($latestWorkflow)
    }
}

This function retrieves the specified list finds the first associated workflow which doesn’t have the “(Previous.. )” text in its name and sets it to the specified enabled status.  If you have more than one active associated workflow on your list this code will need to be update to handle an array of workflows instead of just a single result.

This project uses a simple WCF service to get some text from the database on the server and to store details of clicks within the game in the database.  On the server-side it uses LINQ to SQL to interact with the database for retrieving and adding records.

Before running this sample you should probably do a full rebuild of the solution and then update the service reference in the WindowsGame1 project.  Get it from the link below:

Download: http://www.jason-mitchell.com/Uploads/XNAWCFSample-20_09_2011.zip

The incoming tabular data stream (TDS) remote procedure call (RPC) protocol stream is incorrect. Parameter 3 (“@p0″): The supplied value is not a valid instance of data type float. Check the source data for invalid values. An example of an invalid value is data of numeric type with scale greater than precision.

This error message was accompanied with the following stack trace showing the exception being thrown from deep within the bowels of LINQ to SQL:

System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Boolean breakConnection) +2062078
System.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection) +5050204
System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning() +234
System.Data.SqlClient.TdsParser.Run(RunBehavior runBehavior, SqlCommand cmdHandler, SqlDataReader dataStream, BulkCopySimpleResultSet bulkCopyHandler, TdsParserStateObject stateObj) +2275
System.Data.SqlClient.SqlDataReader.ConsumeMetaData() +33
System.Data.SqlClient.SqlDataReader.get_MetaData() +86
System.Data.SqlClient.SqlCommand.FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, String resetOptionsString) +311
System.Data.SqlClient.SqlCommand.RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, Boolean async) +987
System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method, DbAsyncResult result) +162
System.Data.SqlClient.SqlCommand.RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, Boolean returnStream, String method) +32
System.Data.SqlClient.SqlCommand.ExecuteReader(CommandBehavior behavior, String method) +141
System.Data.SqlClient.SqlCommand.ExecuteDbDataReader(CommandBehavior behavior) +12
System.Data.Common.DbCommand.ExecuteReader() +12
System.Data.Linq.SqlClient.SqlProvider.Execute(Expression query, QueryInfo queryInfo, IObjectReaderFactory factory, Object[] parentArgs, Object[] userArgs, ICompiledSubQuery[] subQueries, Object lastResult) +1266
System.Data.Linq.SqlClient.SqlProvider.ExecuteAll(Expression query, QueryInfo[] queryInfos, IObjectReaderFactory factory, Object[] userArguments, ICompiledSubQuery[] subQueries) +113
System.Data.Linq.SqlClient.SqlProvider.System.Data.Linq.Provider.IProvider.Execute(Expression query) +344
System.Data.Linq.StandardChangeDirector.DynamicInsert(TrackedObject item) +151
System.Data.Linq.StandardChangeDirector.Insert(TrackedObject item) +235
System.Data.Linq.ChangeProcessor.SubmitChanges(ConflictMode failureMode) +336
System.Data.Linq.DataContext.SubmitChanges(ConflictMode failureMode) +378
System.Data.Linq.DataContext.SubmitChanges() +23

The exception message is very specific about what the problem actually was: “The supplied value is not a valid instance of data type float”.  After a bit of searching the internet I found that the issue could be caused by trying to insert a double with an actual value of “NaN” or negative/positive infinity.  After a bit of investigation I was able to confirm that a value of “NaN” was being passed in therefore causing this exception.

After a bit more searching I found out that that a “NaN” value is generated as the result of dividing 0 by 0.  In the project I’ve been working on this calculation is entirely possible as it performs calculations using external data.  To fix the issue I determined what calculation was generating the “NaN” values and used the double.IsNaN method to check for any invalid values and replaced them with 0.

I decided to post this project because I’ve been at a loss for what to write about recently and I thought this project was so strange that I thought I should share it.  The project was made in XNA 3.0 or 3.1 and may not work anymore depending on what has changed with Twitter’s API; I really don’t know and I haven’t run the game.

Download: http://www.jason-mitchell.com/Uploads/TwitterTicTacToe_24-08-2011.zip

The idea of this project was pretty simple.  I wanted to get the RGB camera stream of me goofing around and use it as the background in an XNA application.  I also wanted to try out some skeleton tracking functionality to test when my hands are intersecting with hot spots (represented as semi-transparent squares) on the screen.  As it turns out, this project was pretty simple and quick to make and overall I’m really quite impressed with how the SDK is to use.

This project makes use of a couple of simple extension methods I created and is fairly heavily based on the samples which get installed with the Kinect SDK.

Download: http://jason-mitchell.com/Uploads/XNA_And_Kinect-28_06_11.zip