I had this discussion many times over the last few years:
Opinions on this subject vary a lot. This purpose of this article is to provide you some basic guidelines and why you should follow them.
Table of contents
Select method is used to project each element of a sequence into a new form, i.e. it can be used to map a collection of one type to a collection of another type. In this article I’ll show you a simple approach that will allow you to reuse the code used in the Select method.
Table of contents
Consider the following model:
Let’s suppose that you have a services layer, so you don’t want to expose your domain objects directly to the client applications. Instead you create a set of data contracts (or DTOs, if you prefer):
At some stage you’ll have to convert those Domain objects to data contracts. This is a common way of doing it:
var details = repository.All<Album>().Select(album => new AlbumDetail {
AlbumId = album.AlbumId,
Price = album.Price,
Title = album.Title,
ArtistId = album.ArtistId,
GenreId = album.GenreId,
ArtistName = (album.Artist == null) ? null : album.Artist.Name,
GenreName = (album.Genre == null) ? null : album.Genre.Name
});
There is a problem with this approach – if you need to query the same collection but using different criteria you have to duplicate the code inside the Select method.
In order to reuse the code, we can create a method that converts Album objects (Domain) to data contract objects:
private static AlbumSummary CreateAlbumSummary(Album album)
{
return new AlbumSummary {
AlbumId = album.AlbumId,
Title = album.Title,
ArtistName = (album.Artist == null) ? null : album.Artist.Name
};
}
private static AlbumDetail CreateAlbumDetail(Album album)
{
return new AlbumDetail {
AlbumId = album.AlbumId,
Price = album.Price,
Title = album.Title,
ArtistId = album.ArtistId,
GenreId = album.GenreId,
ArtistName = (album.Artist == null) ? null : album.Artist.Name,
GenreName = (album.Genre == null) ? null : album.Genre.Name
};
}
Using the code:
var albums = Albums.Select(CreateAlbumDetail); var albumsByGenre = Albums.Where(x => x.GenreId == genreId).Select(CreateAlbumDetail); // alternative way var albums2 = Albums.Select(x => CreateAlbumDetail(x)); var albumsByGenre2 = Albums.Where(x => x.GenreId == genreId).Select(x => CreateAlbumDetail(x));
The previous solution solves the code reusability problem, but there’s still a tight coupling between components. Abstractions should be used to implement loose coupling between components – in this case, to abstract the mapping code.
Step 1: define a contract (interface) with a method that converts one object of type TSource to an object of type TDestination:
public interface IObjectMapper
{
TDestination Map<TSource, TDestination>(TSource source);
}
Step 2: create a class that implements IObjectMapper (click to expand):
public class ObjectMapper : IObjectMapper
{
private Dictionary<Type, Func<object, object>> Mappers = new Dictionary<Type, Func<object, object>>
{
{ typeof(Tuple<Album, AlbumDetail>), CreateAlbumDetail },
{ typeof(Tuple<Album, AlbumSummary>), CreateAlbumSummary }
// more mappings here
// ....
};
public TDestination Map<TSource, TDestination>(TSource source)
{
if(source == null)
return default(TDestination);
Func<object, object> mapper = null;
Type key = typeof(Tuple<TSource, TDestination>);
if(Mappers.TryGetValue(key, out mapper))
{
var newObject = mapper(source);
return (TDestination) newObject;
}
string errorMessage = string.Format("Invalid mapping (Source: {0}, Destination: {1})";,
typeof(TSource).FullName,
typeof(TDestination).FullName);
throw new InvalidOperationException(errorMessage);
}
private static object CreateAlbumDetail(object source)
{
var album = source as Album;
return new AlbumDetail {
AlbumId = album.AlbumId,
Price = album.Price,
Title = album.Title,
ArtistId = album.ArtistId,
GenreId = album.GenreId,
ArtistName = (album.Artist == null) ? null : album.Artist.Name,
GenreName = (album.Genre == null) ? null : album.Genre.Name
};
}
private static object CreateAlbumSummary(object source)
{
var album = source as Album;
return new AlbumSummary {
AlbumId = album.AlbumId,
Title = album.Title,
ArtistName = (album.Artist == null) ? null : album.Artist.Name
};
}
}
Using the mapper in a LINQ expression – convert an Album collection to an AlbumSummary collection:
IObjectMapper mapper = new ObjectMapper();
IEnumerable<AlbumSummary> summaries = repository.All<Album>()
.Select(mapper.Map<Album, AlbumSummary>);
Using the mapper for a single object:
var album = new Album {
AlbumId = 1,
Price = 10.0m,
Title = "The Dreamer",
Artist = new Artist { ArtistId = 1, Name = "José James" },
Genre = new Genre { GenreId = 1, Name = "Jazz" }
};
IObjectMapper mapper = new ObjectMapper();
AlbumDetail albumDetail = mapper.Map<Album, AlbumDetail>(album);
Some NUnit tests:
[Test]
public void Given_a_non_existing_mapping_when_mapping_object_then_should_throw_InvalidOperationException()
{
// arrange
IObjectMapper mapper = new ObjectMapper();
var albumDetail = new AlbumDetail();
// act/assert
Assert.Throws<InvalidOperationException>(() =>
// non-existing mapping
mapper.Map<AlbumDetail, AlbumSummary>(albumDetail)
);
}
[Test]
public void Given_an_album_when_mapping_to_album_summary_should_equals_expected_album_summary()
{
// arrange
IObjectMapper mapper = new ObjectMapper();
var album = new Album {
AlbumId = 4,
Price = 10.0m,
Title = "Heritage",
Artist = new Artist { ArtistId = 4, Name = "Opeth" },
Genre = new Genre { GenreId = 4, Name = "Metal" }
};
var expectedAlbumSummary = new AlbumSummary {
AlbumId = 4,
ArtistName = "Opeth",
Title = "Heritage"
};
// act
AlbumSummary albumSummary = mapper.Map<Album, AlbumSummary>(album);
// assert
Assert.AreEqual(albumSummary, expectedAlbumSummary);
}
In this article you learned how to reuse the code used in the Select method, and how you can use that code to map single objects. But writing mapping code is tedious and time consuming. There are mapping tools out there that can make your life easier – AutoMapper is one of them. I’ve used it in the past and I definitely recommend it. So, why use Automapper? Quoting their website:
“What makes AutoMapper interesting is that it provides some interesting conventions to take the dirty work out of figuring out how to map type A to type B. As long as type B follows AutoMapper’s established convention, almost zero configuration is needed to map two types”
“Mapping code is boring. Testing mapping code is even more boring. AutoMapper provides simple configuration of types, as well as simple testing of mappings”
Download the demo project (VS2010): LINQ-Select.zip
This is the first of a 2 series articles about how to perform bulk inserts in your .NET applications, using a SQL Server database.
In this article I’ll show how to create a wrapper object for SqlBulkCopy that can do a bulk insert for a collection of objects. In the second article I’ll show how that wrapper can be easily integrated with Entity Framework (creating extension methods for DbContext and ObjectContext).
Table of contents
I am working in an application that parses Excel files and creates an object for each line. After some validations and properties mapping the objects are then being inserted in a database table, one by one. At the beggining this wasn’t a big problem because the number of objects to insert in the database was small, but now there can be files with thousands of rows, so using Entity Framework isn’t the best way to do it (currently Entity Framework has no support for bulk insert operations).
I decided to use the object SqlBulkCopy because it seemed the best and easiest option for performing a bulk insert in a SQL Server database. I created a wrapper for SqlBulkCopy – BulkCopy.cs. This class works the same way as SqlBulkCopy but has some extra features.
The following properties are available:
And these are the methods available (see examples below):
public void WriteToServer<T>(IEnumerable<T> items) where T : class; public void WriteToServer<T>(IEnumerable<T> items, SqlBulkCopyOptions options) where T : class; public void WriteToServer<T>(IEnumerable<T> items, SqlBulkCopyOptions options, IEnumerable<SqlBulkCopyColumnMapping> columnMappings) where T : class;
BulkCopy.cs source code (click to expand):
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data.SqlClient;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using BulkCopy.Extensions;
namespace BulkCopy
{
/// <summary>
/// Lets you efficiently bulk load a SQL Server table with data from another source.
/// This is a wrapper class for <see cref="SqlBulkCopy"/>
/// </summary>
public class BulkCopy
{
/// <summary>
/// Name of the destination table on the server
/// </summary>
public string DestinationTableName { get; set; }
/// <summary>
/// Number of rows in each batch.
/// At the end of each batch, the rows in the batch are sent to the server.
/// </summary>
public int? BatchSize { get; set; }
/// <summary>
/// Database connection string
/// </summary>
public string ConnectionString { get; set; }
/// <summary>
/// Filters the properties to be included
/// </summary>
public Func<PropertyDescriptor, bool> ExpressionFilter { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="BulkCopy<T>"/> class.
/// </summary>
public BulkCopy()
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BulkCopy<T>"/> class.
/// </summary>
public BulkCopy(string connectionString)
{
this.ConnectionString = connectionString;
}
/// <summary>
/// Copies all items in a collection to a destination table
/// </summary>
/// <param name="dataTable">The items that will be copied to the destination table</param>
/// <param name="options">A combination of values from the System.Data.SqlClient.SqlBulkCopyOptions
/// enumeration that determines which data source rows are copied to the destination table. <see cref="SqlBulkCopyOptions"/></param>
public virtual void WriteToServer<T>(IEnumerable<T> items) where T : class
{
WriteToServer(items, SqlBulkCopyOptions.Default);
}
/// <summary>
/// Copies all items in a collection to a destination table
/// </summary>
/// <param name="dataTable">The items that will be copied to the destination table</param>
/// <param name="options">A combination of values from the System.Data.SqlClient.SqlBulkCopyOptions
/// enumeration that determines which data source rows are copied to the destination table. <see cref="SqlBulkCopyOptions"/></param>
public virtual void WriteToServer<T>(IEnumerable<T> items, SqlBulkCopyOptions options) where T : class
{
DataTable dataTable = (this.ExpressionFilter == null) ? items.ToDataTable() : items.ToDataTable(this.ExpressionFilter);
WriteToServer(dataTable, options);
}
/// <summary>
/// Copies all items in a collection to a destination table
/// </summary>
/// <param name="dataTable">The items that will be copied to the destination table</param>
/// <param name="options">A combination of values from the System.Data.SqlClient.SqlBulkCopyOptions
/// enumeration that determines which data source rows are copied to the destination table. <see cref="SqlBulkCopyOptions"/></param>
/// <param name="columnMappings">Returns a collection of System.Data.SqlClient.SqlBulkCopyColumnMapping items.
/// Column mappings define the relationships between columns in the data source and columns in the destination.</param>
public virtual void WriteToServer<T>(IEnumerable<T> items, SqlBulkCopyOptions options, IEnumerable<SqlBulkCopyColumnMapping> columnMappings) where T : class
{
DataTable dataTable = (this.ExpressionFilter == null) ? items.ToDataTable() : items.ToDataTable(this.ExpressionFilter);
WriteToServer(dataTable, options, columnMappings);
}
/// <summary>
/// Copies all rows in the supplied System.Data.DataTable to a destination table
/// </summary>
/// <param name="dataTable">A System.Data.DataTable whose rows will be copied to the destination table</param>
private void WriteToServer(DataTable dataTable)
{
WriteToServer(dataTable, SqlBulkCopyOptions.Default);
}
/// <summary>
/// Copies all rows in the supplied System.Data.DataTable to a destination table
/// </summary>
/// <param name="dataTable">A System.Data.DataTable whose rows will be copied to the destination table</param>
/// <param name="options">A combination of values from the System.Data.SqlClient.SqlBulkCopyOptions
/// enumeration that determines which data source rows are copied to the destination table. <see cref="SqlBulkCopyOptions"/></param>
private void WriteToServer(DataTable dataTable, SqlBulkCopyOptions options)
{
var columnMappings = from x in dataTable.Columns.Cast<DataColumn>()
select new SqlBulkCopyColumnMapping(x.ColumnName, x.ColumnName);
WriteToServer(dataTable, options, columnMappings);
}
/// <summary>
/// Copies all rows in the supplied System.Data.DataTable to a destination table
/// </summary>
/// <param name="dataTable">A System.Data.DataTable whose rows will be copied to the destination table</param>
/// <param name="options">A combination of values from the System.Data.SqlClient.SqlBulkCopyOptions
/// enumeration that determines which data source rows are copied to the destination table. <see cref="SqlBulkCopyOptions"/></param>
/// <param name="columnMappings">Returns a collection of System.Data.SqlClient.SqlBulkCopyColumnMapping items.
/// Column mappings define the relationships between columns in the data source and columns in the destination.</param>
private void WriteToServer(DataTable dataTable, SqlBulkCopyOptions options, IEnumerable<SqlBulkCopyColumnMapping> columnMappings)
{
// table name matching:
// checks for DestinationTableName value
// if null or empty, checks for dataTable.TableName
string destinationTableName =
(string.IsNullOrWhiteSpace(DestinationTableName) ? null : DestinationTableName)
?? (string.IsNullOrWhiteSpace(dataTable.TableName) ? null : dataTable.TableName);
if(string.IsNullOrWhiteSpace(destinationTableName))
throw new ArgumentException("destinationTableName cannot be null or empty");
using(var bulkCopy = new SqlBulkCopy(this.ConnectionString, options))
{
bulkCopy.DestinationTableName = destinationTableName;
if(this.BatchSize.HasValue)
bulkCopy.BatchSize = this.BatchSize.Value;
foreach(var mapping in columnMappings)
bulkCopy.ColumnMappings.Add(mapping);
bulkCopy.WriteToServer(dataTable);
}
}
}
}
The BulkCopy object is using internally some extension methods that converts a collection of objects to a DataTable. (taken from SO’s post Generic List to DataTable, with some small modifications).
Click to expand the source code:
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Data;
using System.ComponentModel;
namespace BulkCopy.Extensions
{
public static class DataExtensions
{
/// <summary>
/// Basic data types
/// </summary>
private static Type[] dataTypes = new[] {
typeof(byte)
,typeof(sbyte)
,typeof(short)
,typeof(ushort)
,typeof(int)
,typeof(uint)
,typeof(long)
,typeof(ulong)
,typeof(float)
,typeof(double)
,typeof(decimal)
,typeof(bool)
,typeof(char)
,typeof(Guid)
,typeof(DateTime)
,typeof(DateTimeOffset)
,typeof(byte[])
,typeof(string)
};
/// <summary>
/// Converts a generic List to a DataTable
/// <see cref="http://stackoverflow.com/a/5805044"/>
/// </summary>
/// <typeparam name="T">Type of the object to convert to DataTable</typeparam>
/// <param name="data">Data to be converted</param>
/// <returns>The converted DataTable</returns>
public static DataTable ToDataTable<T>(this IList<T> data)
{
IEnumerable<PropertyDescriptor> properties = from x in TypeDescriptor.GetProperties(typeof(T)).Cast<PropertyDescriptor>()
where IsBasicType(x.PropertyType)
select x;
DataTable table = GetDataTable(data, properties);
return table;
}
/// <summary>
/// Converts a generic List to a DataTable
/// <see cref="http://stackoverflow.com/a/5805044"/>
/// </summary>
/// <typeparam name="T">Type of the object to convert to DataTable</typeparam>
/// <param name="data">Data to be converted</param>
/// <returns>The converted DataTable</returns>
public static DataTable ToDataTable<T>(this IList<T> data, Func<PropertyDescriptor, bool> expression)
{
var properties = TypeDescriptor.GetProperties(typeof(T))
.Cast<PropertyDescriptor>()
.Where(expression);
DataTable table = GetDataTable(data, properties);
return table;
}
/// <summary>
/// Converts an IEnumerable to a DataTable
/// <see cref="http://stackoverflow.com/a/5805044"/>
/// </summary>
/// <typeparam name="T">Type of the object to convert to DataTable</typeparam>
/// <param name="data">Data to be converted</param>
/// <returns>The DataTable</returns>
public static DataTable ToDataTable<T>(this IEnumerable<T> data)
{
return data.ToList().ToDataTable();
}
/// <summary>
/// Converts an IEnumerable to a DataTable
/// <see cref="http://stackoverflow.com/a/5805044"/>
/// </summary>
/// <typeparam name="T">Type of the object to convert to DataTable</typeparam>
/// <param name="data">Data to be converted</param>
/// <param name="expression">Predicate to filter the properties of <typeparamref name="T"/> to be included to the DataTable</param>
/// <returns>The DataTable</returns>
public static DataTable ToDataTable<T>(this IEnumerable<T> data, Func<PropertyDescriptor, bool> expression)
{
return data.ToList().ToDataTable(expression);
}
#region Private methods
private static bool IsBasicType(Type type)
{
type = Nullable.GetUnderlyingType(type) ?? type;
return type.IsEnum || dataTypes.Contains(type);
}
private static DataTable GetDataTable<T>(this IList<T> data, IEnumerable<PropertyDescriptor> mappedProperties)
{
DataTable table = new DataTable();
// columns
foreach(PropertyDescriptor prop in mappedProperties)
{
table.Columns.Add(prop.Name, Nullable.GetUnderlyingType(prop.PropertyType) ?? prop.PropertyType);
}
// row values
foreach(T item in data)
{
DataRow row = table.NewRow();
foreach(PropertyDescriptor prop in mappedProperties)
{
object value = prop.GetValue(item) ?? DBNull.Value;
row[prop.Name] = value;
}
table.Rows.Add(row);
}
return table;
}
#endregion
}
}
Assuming a table named dbo.Albums (I’m using Mvc Music Store model):
This example shows how to use a model object whose property names match the database column names from the table above:
public class Album
{
public virtual int AlbumId { get; set; }
public virtual int GenreId { get; set; }
public virtual int ArtistId { get; set; }
public virtual string Title { get; set; }
public virtual decimal Price { get; set; }
public virtual string AlbumArtUrl { get; set; }
}
All you need to do is to specify the connection string and the destination table:
IEnumerable<Album> data = GetData();
var bulkCopy = new BulkCopy() {
ConnectionString = ConnectionString,
DestinationTableName = "dbo.Albums"
};
bulkCopy.WriteToServer(data);
Using the model from the previous example, you can specify some other options:
IEnumerable<Album> data = GetData();
var bulkCopy = new BulkCopy() {
BatchSize = 200,
ConnectionString = ConnectionString,
DestinationTableName = "dbo.Albums"
};
// SqlBulkCopyOptions.CheckConstraints: Check constraints while data is being inserted.
// By default, constraints are not checked.
bulkCopy.WriteToServer(data, SqlBulkCopyOptions.CheckConstraints);
This example shows how to use a model object whose property names don’t match the database column names:
public class Album
{
public virtual int Id { get; set; }
public virtual int GenreId { get; set; }
public virtual int ArtistId { get; set; }
public virtual string AlbumTitle { get; set; }
public virtual decimal Price { get; set; }
public virtual string AlbumArtImage { get; set; }
}
In this case we have to create the column mappings. It can be done like this:
private static IEnumerable<SqlBulkCopyColumnMapping> GetColumnMappings()
{
yield return new SqlBulkCopyColumnMapping("Id", "AlbumId");
yield return new SqlBulkCopyColumnMapping("GenreId", "GenreId");
yield return new SqlBulkCopyColumnMapping("ArtistId", "ArtistId");
yield return new SqlBulkCopyColumnMapping("AlbumTitle", "Title");
yield return new SqlBulkCopyColumnMapping("Price", "Price");
yield return new SqlBulkCopyColumnMapping("AlbumArtImage", "AlbumArtUrl");
}
Finally, the bulk insert can be done this way:
IEnumerable<Album> data = GetData();
IEnumerable<SqlBulkCopyColumnMapping> mappings = GetColumnMappings();
var bulkCopy = new BulkCopy() {
ConnectionString = ConnectionString,
DestinationTableName = "dbo.Albums"
};
bulkCopy.WriteToServer(data,SqlBulkCopyOptions.Default, mappings);
This example shows how to filter the properties of a model object to be used in the bulk insert:
public partial class Album
{
public virtual int AlbumId { get; set; }
public virtual int GenreId { get; set; }
public virtual int ArtistId { get; set; }
public virtual string Title { get; set; }
public virtual decimal Price { get; set; }
public virtual string AlbumArtUrl { get; set; }
public virtual string P1 { get; set; }
public virtual string P2 { get; set; }
}
Properties P1 and P2 don’t match any column of the table above, so they cannot be used in the bulk insert operation. Creating a filter to exclude those properties and using it can be done like this:
// properties to exclude from mapping
var nonMappedProperties = new string[] { "P1", "P2" };
Func<PropertyDescriptor, bool> expression = x =>
!nonMappedProperties.Contains(x.Name);
IEnumerable<Album> data = GetData();
var bulkCopy = new BulkCopy() {
BatchSize = 200,
ConnectionString = ConnectionString,
DestinationTableName = "dbo.Albums",
ExpressionFilter = expression
};
bulkCopy.WriteToServer(data, SqlBulkCopyOptions.CheckConstraints);
That’s it! In the next article I’ll show you how to integrate easily this wrapper class in Entity Framework (creating extension methods for DbContext and ObjectContext).
Download the demo project (VS2010): BulkCopy-part1.zip
Microdata vocabularies provide the semantics, or meaning of an Item. You can use Metadata Providers to add microdata to your ASP.NET MVC applications.
Table of contents
I’ve been reading lately some stuff about HTML5 , and one of the things that I really liked was microdata. I’ve been googling and I was surprised that I almost couldn’t find any information about how to use it in ASP.NET, that’s why I’ve decided to write this article.
The HTML5 microdata specification is a way to label content to describe a specific type of information—for example, reviews, person information, or events. Each information type describes a specific type of item, such as a person, and event, or a review. For example, an event has the properties venue, starting time, name, and category.
A common HTML code block:
<div>My name is Bob Smith but people call me Smithy. Here is my home page: <a href="http://www.example.com">www.example.com</a> I live in Albuquerque, NM and work as an engineer at ACME Corp.</div>
Using microdata:
<div itemscope itemtype="http://data-vocabulary.org/Person"> My name is <span itemprop="name">Bob Smith</span> but people call me <span itemprop="nickname">Smithy</span>. Here is my home page: <a href="http://www.example.com" itemprop="url">www.example.com</a> I live in Albuquerque, NM and work as an <span itemprop="title">engineer</span> at <span itemprop="affiliation">ACME Corp</span>. </div>
More info (see also the References section):
HTML5 Microdata: Why isn’t anyone talking about it?
This attribute is used to “decorate” model properties with microdata. It can be used directly in the model properties, or it can be used in a MetadataType class, exactly the same way that DataAnnotations are used.
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
public class MicrodataAttribute : Attribute
{
public bool ItemScope { get; set; }
public string ItemType { get; set; }
public string ItemId { get; set; }
public string ItemProperty { get; set; }
public string ItemReference { get; set; }
public MicrodataAttribute()
{
}
public MicrodataAttribute(string property)
{
this.ItemProperty = property;
}
public RouteValueDictionary GetAttributes()
{
var attributes = new RouteValueDictionary();
if(this.ItemScope)
attributes.Add("itemscope", "itemscope");
if(!string.IsNullOrEmpty(this.ItemType))
attributes.Add("itemtype", this.ItemType);
if(!string.IsNullOrEmpty(this.ItemId))
attributes.Add("itemid", this.ItemId);
if(!string.IsNullOrEmpty(this.ItemProperty))
attributes.Add("itemprop", this.ItemProperty);
if(!string.IsNullOrEmpty(this.ItemReference))
attributes.Add("itemref", this.ItemReference);
return attributes;
}
}
I decided to create a custom Model Metadata Provider that inherits from DataAnnotationsModelMetadataProvider, because I wanted to use my provider in a similar way.
public class MicrodataModelMetadataProvider : DataAnnotationsModelMetadataProvider
{
protected override ModelMetadata CreateMetadata(
IEnumerable<Attribute> attributes,
Type containerType,
Func<object> modelAccessor,
Type modelType,
string propertyName)
{
ModelMetadata metadata = base.CreateMetadata(
attributes,
containerType,
modelAccessor,
modelType,
propertyName);
// if no property name is specified, use fully qualified name of the Type
string key = string.IsNullOrEmpty(propertyName) ?
modelType.FullName :
propertyName;
var microdata = attributes.OfType<MicrodataAttribute>().FirstOrDefault();
if(microdata != null)
metadata.AdditionalValues[key] = microdata.GetAttributes();
return metadata;
}
}
Initialize it in Global.asax:
protected void Application_Start()
{
// code ommited for brevity
// .....
ModelMetadataProviders.Current = new MicrodataModelMetadataProvider();
}
public static class MicrodataExtensions
{
// Strongly-typed helper:
// Html.GetMicrodataFor(x => x.Name)
public static RouteValueDictionary GetMicrodataFor<TModel, TProperty>(
this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
{
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
string propertyName = GetMemberName(expression);
return GetValuesFromMetadata(metadata, propertyName);
}
// Non strongly-typed helper:
// Html.GetMicrodataFor("Name")
public static RouteValueDictionary GetMicrodata<TModel>(
this HtmlHelper<TModel> htmlHelper, string propertyName)
{
ModelMetadata metadata = ModelMetadata.FromStringExpression(propertyName, htmlHelper.ViewData);
return GetValuesFromMetadata(metadata, propertyName);
}
// Gets microdata attributes for class type
public static RouteValueDictionary GetMicrodataForType<TModel>(
this HtmlHelper<TModel> htmlHelper)
{
ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(TModel));
string propertyName = typeof(TModel).FullName;
return GetValuesFromMetadata(metadata, propertyName);
}
#region Private methods
private static RouteValueDictionary GetValuesFromMetadata(ModelMetadata metadata, string propertyName)
{
if(metadata == null)
return new RouteValueDictionary();
RouteValueDictionary values = metadata.AdditionalValues.Any(x => x.Key == propertyName) ?
metadata.AdditionalValues[propertyName] as RouteValueDictionary :
new RouteValueDictionary();
return values;
}
private static string GetMemberName<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression)
{
if(expression == null)
return typeof(TModel).FullName;
var memberExpression = expression.Body as MemberExpression;
if(memberExpression == null)
return string.Empty;
return memberExpression.Member.Name;
}
#endregion
}
Using the code is really easy. You just need to decorate your model class with Microdata attributes. Please note that you can use attributes for validation exactly the same way:
[Microdata(ItemScope = true, ItemType = "http://schema.org/Person")]
public class Person
{
[Required]
[Microdata("name")]
public string Name { get; set; }
[Required]
[Microdata("email")]
public string Email { get; set; }
[Required]
[Microdata("telephone")]
public string PhoneNumber { get; set; }
[Microdata("birthDate")]
public DateTime BirthDate { get; set; }
}
As an alternative, create a Metadata class instead:
[MetadataType(typeof(PersonMetadata))]
public class Person
{
public string Name { get; set; }
public string Email { get; set; }
public string PhoneNumber { get; set; }
public DateTime BirthDate { get; set; }
}
[Microdata(ItemScope = true, ItemType = "http://schema.org/Person")]
public partial class PersonMetadata
{
[Required]
[Microdata("name")]
public string Name { get; set; }
[Required]
[Microdata("email", ItemReference="abc")]
public string Email { get; set; }
[Required]
[Microdata("telephone", ItemId="123")]
public string PhoneNumber { get; set; }
[Microdata("birthDate")]
public DateTime BirthDate { get; set; }
}
Finally, use the HTML helpers in your views to get microdata attributes:
And that’s it! This is the output:
Feel free to download the demo projet.
[1] HTML5 Microdata: Why isn’t anyone talking about it?
[2] Getting started with schema.org
[3] ASP.NET MVC 2 Templates, Part 2: ModelMetadata
[4] Model Metadata and Validation Localization using Conventions
[5] ASP.NET MVC: Create Custom Attributes for MetaData
Download the demo project: MvcMicrodata.rar
Learn how to use Specification Pattern and how to generate Specification Objects for your Entity Framework entities using T4 templates.
Table of contents
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:
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.
I’m using the MVC Music Store database, this is the 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
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);
}
}
Using the generic class to create specifications:
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
);
}
}
var albums = from x in repository.All<Album>(JazzAlbumSpecification.GetExpression())
select x;
Album metalAlbum = GetMetalAlbum(); Album jazzAlbum = GetJazzAlbum(); bool isJazzAlbum = JazzAlbumSpecification.IsSatisfiedBy(metalAlbum); isJazzAlbum = JazzAlbumSpecification.IsSatisfiedBy(jazzAlbum);
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;
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
};
}
}
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).
[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
Download the demo project: MusicStore-T4-Specification.rar
Use ASP.NET MVC T4 custom templates to generate resource files and localized views.
Table of contents
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.
You can find more information here:
T4 Templates: A Quick-Start Guide for ASP.NET MVC Developers
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.
This article is intended to provide a brief introduction to the Strategy Design Pattern, and how can help us to improve our User Interface code.
You have a blog application and you want to limit user actions based on their roles.
You have the following roles:
and the following actions:
The table below shows the actions per role type
|
Actions |
User |
Writer |
Editor |
|
New post |
x |
||
|
Edit post |
x |
||
|
Submit post |
x |
||
|
Reject post |
x |
||
|
Publish post |
x |
Role type is represented by an enumeration:
public enum RoleType
{
User,
Writer,
Editor
}
What’s the best solution for our problem?
