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
Recently, I had to setup Unity IoC container in an existing ASP.NET 3.5 Web Forms application. This application had not only web pages (.aspx files), but also some Web Services (.asmx files). After some research, I found out David Hayden’s screencast: Unity IoC and ASP.NET screencast – Dependency Injection into Web Pages.
You can use a similar technique for your Web Services – that’s what I’ll show you in this article.
Table of contents
You have the following interface and its implementation:
public interface ILogger
{
void Write(string message);
}
public class DebugLogger : ILogger
{
public void Write(string message)
{
Debug.WriteLine(message);
}
}
The first step is to setup Unity Container in Global.asax file. This is a good place to do it because it can be accessed either by web pages or by web services.
The CreateContainer() method is the place where the dependencies are specified.
public class Global : HttpApplication, IContainerAccessor
{
private static IUnityContainer _container;
public static IUnityContainer Container
{
get
{
return _container;
}
private set
{
_container = value;
}
}
IUnityContainer IContainerAccessor.Container
{
get
{
return Container;
}
}
protected void Application_Start(object sender, EventArgs e)
{
CreateContainer();
}
protected virtual void CreateContainer()
{
IUnityContainer container = new UnityContainer();
container.RegisterType<ILogger, DebugLogger>();
Container = container;
}
}
Create a generic BaseService that all your services will inherit from. The dependencies will be injected when you create an instance of the service (default constructor).
public abstract class BaseService<T> : System.Web.Services.WebService where T : class
{
public BaseService()
{
InjectDependencies();
}
protected virtual void InjectDependencies()
{
HttpContext context = HttpContext.Current;
if (context == null)
return;
IContainerAccessor accessor = context.ApplicationInstance as IContainerAccessor;
if (accessor == null)
return;
IUnityContainer container = accessor.Container;
if (container == null)
throw new InvalidOperationException("Container on Global Application Class is Null. Cannot perform BuildUp.");
container.BuildUp(this as T);
}
}
Now all you need to do is to inherit from the BaseService and invoke its base constructor.
Don’t forget to add the [Dependency] attribute to your dependency, and it has to be public.
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class DummyService : BaseService<DummyService>
{
[Dependency]
public ILogger Logger
{
get;
set;
}
public DummyService() : base()
{
}
[WebMethod]
public string HelloWorld(string name)
{
string message = string.Format("Hello World, {0}!", name);
this.Logger.Write(message);
return message;
}
}
That’s it! Now you just need to compile and run the application and see it in action 
Feel free to download the demo application
Download the demo project (VS2010): UnityAsmxWebServices.zip
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
