Entity Framework and T4: Generating GetHashCode() for your entities

A simple Entity Framework T4 template that generates GetHashCode() method

Table of contents

GetHashCode() overview

A hash code is a numeric value that is used to identify an object during equality testing, and it can also serve as an index for an object in a collection, such as a List, Dictionary or HashTable.

The problem is that the default .NET implementation of GetHashCode() does not guarantee unique values for different values, so you should override this method and provide your own implementation.

Some rules for implementing GetHashCode() are:

  • If two objects compare as equal, the GetHashCode method for each object must return the same value. However, if two objects do not compare as equal, the GetHashCode methods for the two object do not have to return different values.
  • The GetHashCode method for an object must consistently return the same hash code as long as there is no modification to the object state
  • For the best performance, a hash function must generate a random distribution for all input
  • Implementations of the GetHashCode method must not result in circular references (it can lead to a StackOverflowException).
  • Implementations of the GetHashCode method must not throw exceptions.

This is a short overview of GetHashCode() method, taken from MSDN. You can read more here: Object.GetHashCode Method

Implementing GetHashCode()

I found a great post on StackOverflow on this topic. Jon Skeet has provided a good and simple implementation. Basically, you need to use prime numbers like 17, 23, 29, 31 in the hash code calculation. I decided to include also the type of the object in the calculation, because two objects with identical properties/values can return the same hash code.

public class Organisation
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string Country { get; set; }

	public override int GetHashCode()
	{
		unchecked
		{
			int multiplier = 31;
			int hash = GetType().GetHashCode();

			hash = hash * multiplier + Id.GetHashCode();
			hash = hash * multiplier + (Name == null ? 0 : Name.GetHashCode());
			hash = hash * multiplier + (Country == null ? 0 : Country.GetHashCode());

			return hash;
		}
	}
}

Using T4 templates to generate GetHashCode()

T4 is a code generator built right into Visual Studio. You can generate any text file using T4 templates: C#, javascript, HTML, XML and many others. If you’ve never heard about it, this is a good place to start:

T4 (Text Template Transformation Toolkit) Code Generation – Best Kept Visual Studio Secret

I’ve modified the ADO.NET C# POCO Entity Generator template to generate GetHashCode() method for each entity in the model. Feel free to download the demo project (VS2010).

References

Downloads

Download the demo project (VS2010): T4-GetHashCode.rar

Technorati Tags: , , , ,

Advertisements

Entity Framework and T4: Generate Specification Objects for your entities

Learn how to use Specification Pattern and how to generate Specification Objects for your Entity Framework entities using T4 templates.

Table of contents

Specification Pattern Overview

According to Martin Fowler and Eric Evans, a specification define a set of conditions that a candidate object must fulfill in order to meet the specification. Specifications can be used for:

  • Selection: When you need to select a set of objects based on some criteria
  • Validation: when you need to check that only suitable objects are used for a certain purpose

The Specification Pattern can be represented like this in .NET (using generics):

public interface ISpecification<T> where T : class
{
    Expression<Func<T, bool>> GetExpression();
    bool IsSatisfiedBy(T entity);
}

We can also create Composite Specifications by combining other specifications – this allow us to reuse existing specifications to create more complex ones.

Using Specification Pattern

I’m using the MVC Music Store database, this is the model:

Music Store Model
And now some examples. I will assume that you have a repository like this (I’m using this implementation):

public IQueryable All<T>(Expression<Func<bool, T>> expression) where T : class

A generic Specification class

public class Specification<T> : ISpecification<T> where T : class
{
    private Expression<Func<T, bool>> expression;

    public Expression<Func<T, bool>> GetExpression()
    {
        return expression;
    }

    public Specification(Expression<Func<T, bool>> expression)
    {
        this.expression = expression;
    }

    public bool IsSatisfiedBy(T entity)
    {
        var query = (new[] { entity }).AsQueryable();

        return query.Any(this.expression);
    }
}

Creating specifications

Using the generic class to create specifications:

  • One specification for jazz albums
  • One specification for cheap albums (price between 1 and 10)
public static ISpecification<Album> JazzAlbumSpecification
{
	get
	{
		return new Specification<Album>(
			x => x.Genre.Name == "Jazz"
		);
	}
}

public static ISpecification<Album> CheapAlbumSpecification
{
	get
	{
		return new Specification<Album>(
			x => x.Price >= 1 && x.Price <= 10
		);
	}
}

Selecting objects

var albums = from x in repository.All<Album>(JazzAlbumSpecification.GetExpression())
             select x;

Performing validation

Album metalAlbum = GetMetalAlbum();
Album jazzAlbum = GetJazzAlbum();

bool isJazzAlbum = JazzAlbumSpecification.IsSatisfiedBy(metalAlbum); 
isJazzAlbum = JazzAlbumSpecification.IsSatisfiedBy(jazzAlbum);

Composing specifications

Existing specifications can be combined to form more complex ones. Using these extension methods it’s easy to create composite specifications (see this article to understand how to combine lambda expressions):

public static ISpecification<T> And<T>(this ISpecification<T> first, ISpecification<T> second) where T : class
{
    return new Specification<T>(
        first.GetExpression()
        .And(second.GetExpression())
    );
}

public static ISpecification<T> Or<T>(this ISpecification<T> first, ISpecification<T> second) where T : class
{
	return new Specification<T>(
        first.GetExpression()
        .Or(second.GetExpression())
    );
}

The specifications defined above can now be combined to compose a new specification like this:

ISpecification<Album> cheapJazzAlbumSpecification = JazzAlbumSpecification.And(CheapAlbumSpecification);

// using the specification to select all cheap jazz albums
var cheapJazzAlbums = from x in repository.All<Album>(cheapJazzAlbumSpecification.GetExpression())
                      select x;

Using T4 to generate Specification Objects

T4 is a code generator built right into Visual Studio. You can generate any text file using T4 templates: C#, javascript, HTML, XML and many others. If you’ve never heard about it, this is a good place to start:

T4 (Text Template Transformation Toolkit) Code Generation – Best Kept Visual Studio Secret

I’ve created a T4 template that generates automatically all the Specification Objects, one for each entity in our model. All the generated objects have all the public properties of their respective entities, including association properties. All objects were marked with the [Serializable] attribute, so you can easily serialize it if you need.

In a previous article I’ve created query objects for Entity Framework, I’m generating exactly the same properties in this template. You can see a complete description of the generated properties here.

This is the generated object model:


The previous specifications can now be written like this:

public static ISpecification<Album> JazzAlbumSpecification
{
    get
    {
        return new AlbumSpecification() {
            Genre = new GenreSpecification() { Name = "Jazz" }
        };
    }
}

public static ISpecification<Album> CheapAlbumSpecification
{
    get
    {
        return new AlbumSpecification() {
            PriceFrom = 1,
            PriceTo = 10
        };
    }
}

Configuration

In the demo solution double-click ModelSpecification.tt and change the following lines, according to your needs:

string inputFile = @"Model.edmx";
string namespaceName = @"MusicStore.Model";
string filenameSuffix = "Specification.gen.cs";

When you save the template file or you rebuild the project the code will be regenerated. If you don’t want to generate the code, remove the value of the Custom Tool property in the property browser of the template file (by default the value is TextTemplatingFileGenerator).

References

[1] Specification Pattern

[2] Specification (Martin Fowler/Eric Evans)

[3] T4 (Text Template Transformation Toolkit) Code Generation – Best Kept Visual Studio Secret

[4] LINQ to Entities: Combining Predicates

[5] Implementing ISession in EF4

Downloads

Download the demo project: MusicStore-T4-Specification.rar


ASP.NET MVC Localization: Generate resource files and localized views using custom templates

Use ASP.NET MVC T4 custom templates to generate resource files and localized views.

Table of contents

Overriding ASP.NET MVC custom templates

The Add View dialog perform code generation that use T4 templates behind the scenes. These templates can be modified to customize the generated code from these tools. You can also add custom templates.

Basically you have to copy the default templates to your project. This is the path:

[Visual Studio Install Directory]\Common7\IDE\ItemTemplates\[CSharp | VisualBasic]\Web\MVC\CodeTemplates\

I have created a custom template that generates resource files (.resx), and I have modified the default templates to use the generated resource files.

Views Templates

You can find more information here:

T4 Templates: A Quick-Start Guide for ASP.NET MVC Developers

Understanding .resx file format

From MSDN [1]:

The .resx resource file format consists of XML entries, which specify objects and strings inside XML tags. One advantage of a .resx file is that when opened with a text editor (such as Notepad or Microsoft Word) it can be written to, parsed, and manipulated.(…) Each entry is described as a name/value pair.(…) When a string is added to a .resx file, the name of the string is embedded in a <data> tag, and the value is enclosed in a <value> tag

For a resource file like this:

You have the corresponding XML:

I created a custom template that generates the resource file in the specified format.

Continue reading

Entity Framework and T4: Generate Query Objects on the fly, part 1

Generate Query Objects on the fly for your Entity Framework entities using T4 templates. Don’t worry about LINQ, let the objects do all the work for you.

Table of contents

  • Configuration
  • References
  • Downloads
  • I’ve read some stuff about T4 templates in the last 2-3 years, but only recently I decided to give it a try. My first attempt was to generate Query Objects for Entity Framework, that’s what I’ll talk about in this article – what’s their purpose and how to use them.

    In part 2 I’ll create a demo ASP.NET MVC application that uses query objects created with this template. I already have another T4 template that creates javascript objects for my entities, and I’m developing a custom ASP.NET view template for those objects.

    Many thanks to Colin Meek [4], his work has really helpful.

    What is a Query Object?

    A Query Object is an object that represents a database query [1]:

    A Query Object is an interpreter [Gang of Four], that is, a structure of objects that can form itself into a SQL query. You can create this query by referring to classes and fields rather than tables and columns. In this way those who write the queries can do so independently of the database schema and changes to the schema can be localized in a single place.

    Assuming that you have a repository like this (I’m using this implementation):

    public IQueryable All<T>(Expression<Func<bool, T>> expression) where T : class
    

    Instead of:

    var albuns = from x in repository.All<Album>()
                     where x.Artist.Name == "Metallica"
                     && x.Genre.Name.Contains("Metal")
                     && x.Price >= 5 && x.Price
                     select x;
    

    You can do this way:

    var search = new AlbumSearch();
    search.PriceFrom = 5;
    search.PriceTo = 10;
    search.Artist = new ArtistSearch(){ Name = "Metallica" };
    search.Genre = new GenreSearch(){ NameContains = "Metal" };
    
    var albuns = from x in repository.All<Album>(search.GetExpression())
                      select x;
    

    Continue reading