Recently, I started working on a new ASP.NET MVC 2 project and I wanted to reuse
the data access (LINQ to SQL) and business logic methods (WCF RIA Services) that had been developed for a previous project that used Silverlight for
the front-end. I figured that I would be able to instantiate
the various DomainService classes from within my controller’s action methods, because after all,
the code for those services didn’t look very complicated. WRONG! I didn’t realize at first that some of
the functionality is handled automatically by
the framework when
the domain services are hosted as WCF services. After some initial searching, I came across an invaluable post by Joe McBride, which described how to get RIA Service .svc files to work
in an MVC 2 Web Application, and another by Brad Abrams. Unfortunately, Brad’s solution was for an earlier preview release of RIA Services and no longer works with
the version that I am running (PDC Preview). I have not tried
the RC version of WCF RIA Services, so I am not sure if any of
the issues I am having have been resolved, but I wanted to come up with a way to reuse
the shared libraries so I wouldn’t have to write a non-RIA version that basically did
the same thing.
The classes I came up with work with
the scenarios I have encountered so far, but I wanted to go ahead and post
the code
in case someone else is having
the same trouble I had. Hopefully this will save you a few headaches! 1. Querying When I first tried to use a DomainService class to perform a query inside one of my controller’s action methods, I got an error stating that “This DomainService has not been initialized.” To solve this issue, I created an extension method for all DomainServices that creates
the required DomainServiceContext and passes it to
the service’s Initialize() method. Here is
the code for
the extension method; notice that I am creating a sort of mock HttpContext for those cases when
the service is running outside of IIS, such as during unit testing! public static class ServiceExtensions { /// <summary> /// Initializes
the domain service by creating a new <see cref="DomainServiceContext"/> /// and calling
the base DomainService.Initialize(DomainServiceContext) method. /// </summary> /// <typeparam name="TService">The type of
the service.</typeparam> /// <param name="service">The service.</param> /// <returns></returns> public static TService Initialize<TService>(this TService service) where TService : DomainService { var context = CreateDomainServiceContext(); service.Initialize(context); return service; } private static DomainServiceContext CreateDomainServiceContext() { var provider = new ServiceProvider(new HttpContextWrapper(GetHttpContext())); return new DomainServiceContext(provider, DomainOperationType.Query); } private static HttpContext GetHttpContext() { var context = HttpContext.Current; #if DEBUG // create a mock HttpContext to use during unit testing... if ( context == null ) { var writer = new StringWriter(); var request = new SimpleWorkerRequest("/", "/", String.Empty, String.Empty, writer); context = new HttpContext(request) { User = new GenericPrincipal(new GenericIdentity("debug"), null) }; } #endif return context; } } With that
in place, I can use it almost as normally as my first attempt, except with a call to Initialize(): public ActionResult Index() { var service = new NorthwindService().Initialize(); var customers = service.GetCustomers(); return View(customers); } 2. Insert / Update / Delete Once I got
the records showing up, I was trying to insert new records or update existing data when I ran into
the next issue. I say issue because I wasn’t getting any kind of error, which made it a little difficult to track down. But once I realized that that
the DataContext.SubmitChanges() method gets called automatically at
the end of each domain service submit operation, I could start working on a way to mimic
the behavior of a hosted domain service. What I came up with, was a base class called LinqToSqlRepository<T> that basically sits between your implementation and
the default LinqToSqlDomainService<T> class. [EnableClientAccess()] public class NorthwindService : LinqToSqlRepository<NorthwindDataContext> { public IQueryable<Customer> GetCustomers() { return this.DataContext.Customers; } public void InsertCustomer(Customer customer) { this.DataContext.Customers.InsertOnSubmit(customer); } public void UpdateCustomer(Customer currentCustomer) { this.DataContext.Customers.TryAttach(currentCustomer, this.ChangeSet.GetOriginal(currentCustomer)); } public void DeleteCustomer(Customer customer) { this.DataContext.Customers.TryAttach(customer); this.DataContext.Customers.DeleteOnSubmit(customer); } } Notice
the new base class name (just change LinqToSqlDomainService to LinqToSqlRepository). I also added a couple of DataContext (for Table<T>) extension methods called TryAttach that will check to see if
the supplied entity is already attached before attempting to attach it, which would cause an error! 3. LinqToSqlRepository<T> Below is
the code for
the LinqToSqlRepository class.
The comments are pretty self explanatory, but be aware of
the [IgnoreOperation] attributes on
the generic repository methods, which ensures that they will be ignored by
the code generator and not available
in the Silverlight client application. /// <summary> /// Provides generic repository methods on top of
the standard /// <see cref="LinqToSqlDomainService<TContext>"/> functionality. /// </summary> /// <typeparam name="TContext">The type of
the context.</typeparam> public abstract class LinqToSqlRepository<TContext> : LinqToSqlDomainService<TContext> where TContext : System.Data.Linq.DataContext, new() { /// <summary> /// Retrieves an instance of an entity using it's unique identifier. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <param name="keyValues">The key values.</param> /// <returns></returns> [IgnoreOperation] public virtual TEntity GetById<TEntity>(params object[] keyValues) where TEntity : class { var table = this.DataContext.GetTable<TEntity>(); var mapping = this.DataContext.Mapping.GetTable(typeof(TEntity)); var keys = mapping.RowType.IdentityMembers .Select((m, i) => m.Name + " = @" + i) .ToArray(); return table.Where(String.Join(" && ", keys), keyValues).FirstOrDefault(); } /// <summary> /// Creates a new query that can be executed to retrieve a collection /// of entities from
the <see cref="DataContext"/>. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <returns></returns> [IgnoreOperation] public virtual IQueryable<TEntity> GetEntityQuery<TEntity>() where TEntity : class { return this.DataContext.GetTable<TEntity>(); } /// <summary> /// Inserts
the specified entity. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <param name="entity">The entity.</param> /// <returns></returns> [IgnoreOperation] public virtual bool Insert<TEntity>(TEntity entity) where TEntity : class { //var table = this.DataContext.GetTable<TEntity>(); //table.InsertOnSubmit(entity); return this.Submit(entity, null, DomainOperation.Insert); } /// <summary> /// Updates
the specified entity. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <param name="entity">The entity.</param> /// <returns></returns> [IgnoreOperation] public virtual bool Update<TEntity>(TEntity entity) where TEntity : class { return this.Update(entity, null); } /// <summary> /// Updates
the specified entity. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <param name="entity">The entity.</param> /// <param name="original">The original.</param> /// <returns></returns> [IgnoreOperation] public virtual bool Update<TEntity>(TEntity entity, TEntity original) where TEntity : class { if ( original == null ) { original = GetOriginal(entity); } var table = this.DataContext.GetTable<TEntity>(); table.TryAttach(entity, original); return this.Submit(entity, original, DomainOperation.Update); } /// <summary> /// Deletes
the specified entity. /// </summary> /// <typeparam name="TEntity">The type of
the entity.</typeparam> /// <param name="entity">The entity.</param> /// <returns></returns> [IgnoreOperation] public virtual bool Delete<TEntity>(TEntity entity) where TEntity : class { //var table = this.DataContext.GetTable<TEntity>(); //table.TryAttach(entity); //table.DeleteOnSubmit(entity); return this.Submit(entity, null, DomainOperation.Delete); } protected virtual bool Submit(Object entity, Object original, DomainOperation operation) { var entry = new ChangeSetEntry(0, entity, original, operation); var changes = new ChangeSet(new ChangeSetEntry[] { entry }); return base.Submit(changes); } private TEntity GetOriginal<TEntity>(TEntity entity) where TEntity : class { var context = CreateDataContext(); var table = context.GetTable<TEntity>(); return table.FirstOrDefault(e => e == entity); } } 4. Conclusion So there you have it, a fully functional Repository implementation for your RIA Domain Services that can be consumed by your ASP.NET and MVC applications. I have uploaded
the source code along with unit tests and a sample web application that queries
the Customers table from inside a Controller, as well as a Silverlight usage example. As always, I welcome any comments or suggestions on
the approach I have taken. If there is enough interest, I plan on contacting Colin Blair or maybe even
the man himself, Brad Abrams, to see if this is something worthy of inclusion
in the WCF RIA Services Contrib project. What do you think? Enjoy!
