Jorge Fioranelli

Metrics in Brownfield Applications

noreply@blogger.com (Jorge Fioranelli) — Tue, 13 Dec 2011 16:59:20 PST

Brownfield applications are everywhere, and as we all know, in most of the cases their codebases are quite messy.

During the last weeks, I have been reading a really nice book called "Brownfield Application Development in .Net" (by Kyle Baley and Donald Belcham). If you are currently working in a brownfield project and have the feeling that you could improve your career finding another job, I would recommend you to read this book first. And then, if after reading it you can't improve the application, you can go and find a better job. As they say, "change the environment, or change the environment" :).

Working in a brownfield project means that you have a version of the application running in production, probably a large amount of bugs to fix, some new features to add and a lot of places where the code could be improved.

So now the question is: how can we convince our manager to let us spend some of our time improving the existing code instead of adding new features?

Certainly that is not an easy task, but here there are some good reasons to do it:

Experienced developers don't want to touch messy codebases, so your manager will end up having a lot of junior developers and staff turnover.
Changing existing features or adding new ones is easier when the codebase is clean (and probably the amount of time required is less).
When developers are proud of the codebase, they are more committed with the quality and don't let anyone to mess it up.

So, how do metrics can help to achieve this? Well, managers love numbers, if they see numbers, they can measure progress, they can show graphs to their bosses and they can understand (or at least try to) how the application is improved.

Here you have a list of metrics that can be useful in a brownfield application (for more details, see chapter 5 of the book):

Code Coverage: percentage of the code that is covered by tests.
Cyclomatic Complexity: how complex is the application, measuring the numbers of paths in the code (if, loops).
Class Coupling: how dependent are the classes on other classes (there are two types: afferent and efferent).
Cohesion: how strongly-related are functions and responsibilities.
Distance form the main sequence: using abstractness and instability determines which classes are in the zone of pain and which ones are in the zone of uselessness.
Depth of inheritance: how many levels of inheritance the classes have.
Maintainability Index: using complexity and lines of code determines how maintainable the code is.

Selecting and measuring some of these metrics will help you to understand which are the pain points and will allow you to show your manager the improvements the team has done.

For more information about metrics you can check this post of Scott Hanselman and this document about NDepend metrics.

As a final thought, just a warning, metrics are just that: metrics. They should be applied with common sense. Be careful managing the manager's expectations and be sure that the entire team agrees with them.

MsmqException (0xC00E0051) 60 seconds after a WCF Service is executed

noreply@blogger.com (Jorge Fioranelli) — Wed, 20 Jul 2011 21:26:53 PDT

I know that this is the type of posts that only few people will find interesting.
But so many times I googled about some weird exception message, found that another developer wrote about it and saved me hours of work, that now, after spending several days trying to solve this issue, I feel an obligation to post about it.

Symptoms

When using NetMsmqBinding with a transactional queue and a Service is exposed with more than one Endpoint (two o more svc files with the same service type defined in the markup), a MsmqException is sometimes thrown just 60 seconds after the message is processed.

MyService1.svc

<%@ServiceHost language="c#" Debug="true" Service="Service" %>

MyService2.svc

<%@ServiceHost language="c#" Debug="true" Service="Service" %>

Web.config

<service name="Service">
  <endpoint contract="IService1" binding="netMsmqBinding" 
    address="net.msmq://localhost/private/MsmqService/Service1.svc" />
  <endpoint contract="IService2" binding="netMsmqBinding" 
    address="net.msmq://localhost/private/MsmqService/Service2.svc" />
</service>

Code

public class Service : IService1, IService2 {...}

Exception
System.ServiceModel.MsmqException (0xC00E0051): An error occurred while receiving a message from the queue: Unrecognized error -1072824239 (0xc00e0051). Ensure that MSMQ is installed and running. Make sure the queue is available to receive from. at System.ServiceModel.Channels.MsmqInputChannelBase.TryReceive(TimeSpan timeout, Message& message) at System.ServiceModel.Dispatcher.InputChannelBinder.TryReceive(TimeSpan timeout, RequestContext& requestContext) at System.ServiceModel.Dispatcher.ErrorHandlingReceiver.TryReceive(TimeSpan timeout, RequestContext& requestContext)

Note: You won't see the exception unless you enable the WCF Trace (system.diagnostics) or add an IErrorHandler.

Cause

This issue occurs because the SMSvcHost.exe is activating two ServiceHost instances using the *same* endpoint when a new message arrives.

While the first instance receives and process the message, committing the corresponding COM+ transaction, the second instance creates another COM+ transaction and waits for another incoming message.

After 60 seconds, the second transaction is aborted (COM+ timeout error 0xC00E0051) and the exception is thrown.

Resolution

Instead of creating one Service with two Endpoints, you need to create two separate Services with just one Endpoint each of them.

MyService1.svc

<%@ServiceHost language="c#" Debug="true" Service="Service1"%>

MyService2.svc

<%@ServiceHost language="c#" Debug="true" Service="Service2"%>

Web.config

<service name="Service1">
  <endpoint contract="IService1" binding="netMsmqBinding" 
    address="net.msmq://localhost/private/MsmqService/Service1.svc" />
</service>
<service name="Service2">
  <endpoint contract="IService2" binding="netMsmqBinding" 
    address="net.msmq://localhost/private/MsmqService/Service2.svc" />
</service>

Code

public class Service1 : IService1 {...}
public class Service2 : IService2 {...}

After doing that, only one instance of the ServiceHost is created, so the COM+ timeout exception is not thrown anymore.

I have created a bug in connect.microsoft.com: http://connect.microsoft.com/wcf/feedback/details/680020/msmqexception-0xc00e0051-60-seconds-after-a-wcf-service-is-executed

Additional Information

When the exception is thrown, sometimes the ServiceHost faults and the SMSvcHost.exe process doesn't call it again.

The following fix seems to solve this issue: 2504602 (download).

Another way to solve this is to attach a handler to the ServiceHost.Faulted event and re-create the ServiceHost every time this happens (for more details see this link).

Converting any object to dynamic

noreply@blogger.com (Jorge Fioranelli) — Mon, 20 Jun 2011 23:18:26 PDT

There are some scenarios in which it is useful to convert an already created object to a dynamic one, so then we can take advantage of the Dynamic Language Runtime introduced in .Net 4.0.

Two common scenarios where this conversion is useful are:

Passing an anonymous type to another method/object.
Adding a new property to an existing object.

The following code converts any object to an ExpandoObject reading all the properties of the former and adding them to the latter.

public static class DynamicExtensions
{
    public static dynamic ToDynamic(this object value)
    {
        IDictionary<string, object> expando = new ExpandoObject();

        foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(value.GetType()))
            expando.Add(property.Name, property.GetValue(value));

        return expando as ExpandoObject;
    }
}

Using ToDynamic() to pass an anonymous type to another method

IEnumerable<dynamic> goldCustomersWithZipCode = Customers
  .Where(c => c.Type == CustomerType.Gold)
  .Select(c => new { c.Id, c.Name, c.Address.ZipCode  }.ToDynamic());

ListCustomersByZipCode(goldCustomersWithZipCode);

Using ToDynamic() to add a new property

Customer customer = Customers.First(c => c.Id == 1);
dynamic customerWithLastPurchase = customer.ToDynamic();
customerWithLastPurchase.LastPurchase = customer.Purchases.Last();

DisplayCustomerSummary(customerWithLastPurchase);

Entity Framework POCO Proxies in Asp.Net MVC

noreply@blogger.com (Jorge Fioranelli) — Tue, 17 May 2011 16:22:39 PDT

As many of you already know, the asp.net MVC framework has the ability of creating a model instance each time an http post is executed. In the following picture you can see that the component that performs that task is the ModelBinder.

It is also true that the way in which Entity Framework implements "lazy load" on POCOs is replacing the real objects with proxies. So when the context returns an entity from the database, a proxy is returned instead of the real entity (for more information about EF proxies just follow this link).

But, what if the entity is not created by the context? How can the ModelBinder create a proxy instead of the real entity?

In order to do that, we need to call the Create method of the EF DbSet and it will create the proxy for us. The following snippet shows how:

var productProxy = modelContext.Products.Create();

Now let's put this behavior inside our own ModelBinder:

public class EntityModelBinder : DefaultModelBinder
{
    protected override object CreateModel(ControllerContext controllerContext,
                                          ModelBindingContext bindingContext, 
                                          Type modelType)
    {
        // Get the EF context using an IoC container
        var modelContext = DependencyResolver.Current.GetService<IModelContext>();

        var set = modelContext.Set(modelType);

        if (set != null)
            return set.Create(modelType);

        return base.CreateModel(controllerContext, bindingContext, modelType);
    }
}

Finally, we need to configure our new ModelBinder in the Application_Start (Global.asax).

public class MvcApplication : System.Web.HttpApplication
{
    protected void Application_Start()
    {
        ...
        ModelBinders.Binders.DefaultBinder = new EntityModelBinder();
    }
}

So now, we can use the lazy load feature inside our controllers:

public class ProductController : Controller
{
    [HttpPost]
    public ActionResult Edit(Product product)
    {
        modelContext.Entry(product).State = EntityState.Modified;

        // Use "lazy load" to get the Category object from the DB
        var threshold = product.Category.PriceThreshold;

        ...
    }
}

The source code of this sample can be downloaded from this link (MVC v3 + EF v4.1).

N-Tiers using POCOs and Entity Framework - Part Six: Source Code

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Feb 2011 20:49:24 PST

I have finally managed to find some time to publish the source code of the post series I wrote some months ago (about how to build an n-tier application using Entity Framework and POCOs).

As this is a complete solution integrated with an IoC container (in this case, MEF), some of the already published code has changed. I have updated the previous posts so that both the source code and the snippets are synchronized.

You can download the source code from here:

Hope this helps.

Posts in this series:

OData validation using DataAnnotations

noreply@blogger.com (Jorge Fioranelli) — Wed, 23 Feb 2011 22:07:19 PST

WCF DataServices (OData) becomes more popular every day. If you need to expose data between different applications or even between different tiers of the same application, it is definitely a really good option.

Unfortunately, one of the missing features of the current version (v4.0) is the validation using DataAnnotations (if you want that feature to be implemented in the next version, just vote for it here). In this post I am going to show how to implement this validation using a ChangeInterceptor. I hope it helps you.

Update [24 Feb 2011]: OData team is working in a better solution to this scenario, for more details click here.

Here we have a Customer object (POCO) that is mapped in the Entity Framework model:

public class Customer
{
    public int Id { get; set; }

    [Required]
    public string Name { get; set; }
}

As you can see, the Name property is decorated with the Required attribute (DataAnnotations).

In the following code snippet we can see the WCF DataService that is exposing the Customers EntitySet:

public class WcfDataService : DataService<DatabaseEntities>
{
    public static void InitializeService(DataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("Customers", EntitySetRights.All);
        config.DataServiceBehavior.MaxProtocolVersion =
                                          DataServiceProtocolVersion.V2;
    }
}

So far nothing new. The first thing we need to do in order to add the validation logic is to create a ChangeInterceptor method:

public class WcfDataService : DataService<DatabaseEntities>
{
    ...

    [ChangeInterceptor("Customers")]
    public void ValidateCustomers(Customer customer, UpdateOperations operation)
    {
       // Validation logic
    }
}

After that, we just need to add the following validation logic:

[ChangeInterceptor("Customers")]
public void ValidateCustomers(Customer customer, UpdateOperations operation)
{
    // Only validates on inserts and updates
    if (operation != UpdateOperations.Add && 
        operation != UpdateOperations.Change)
        return;

    // Validation
    var validationContext = new ValidationContext(customer, null, null);
    var result = new List();
    Validator.TryValidateObject(customer, validationContext, result, true);

    if(result.Any())
        throw new DataServiceException(
            result
            .Select(r => r.ErrorMessage)
            .Aggregate((m1, m2) => String.Concat(m1, Environment.NewLine, m2)));
}

As you can see I am using the Validator class (System.ComponentModel.DataAnnotations namespace) and I am throwing a DataServiceException in case the validator finds any error.

Edit: The last parameter of the TryValidateObject method (validateAllProperties) should be set to true, otherwise it will only validate the [Required] attribute. More about this issue here.

If you are using the MetadataType attribute instead of having the DataAnnotation attributes in your POCO, you need to add some additional lines of code in order to support that. Check the attached source code to see how to do it.

Finally, in the client we are going to receive a DataServiceRequestException that will contain the error we sent from the server.

try
{
    var serviceUri = new Uri("http://localhost:4799/WcfDataService.svc")
    
    var context = new DatabaseEntities(serviceUri);

    var customer = new Customer();

    context.AddToCustomers(customer);

    Console.WriteLine("Calling data service...");

    context.SaveChanges();

    Console.WriteLine("Insert successful");

}
catch (DataServiceRequestException ex)
{
    if(ex.InnerException != null && ex.InnerException.Message != null)
        Console.WriteLine(ex.InnerException.Message);
    else
        Console.WriteLine(ex.ToString());
}

As you can see, our original error message is now wrapped inside an xml document (the serialized original exception). If you need to get the original message from there, you can either read the xml or use the code shown by Phani Raj in this post.

To download the source code, just click here.

Soft-Delete and Entity Framework

noreply@blogger.com (Jorge Fioranelli) — Mon, 13 Dec 2010 20:15:37 PST

It is very common to find enterprise applications where entities shouldn't be removed from the database, but just "marked" as deleted. If you are using Entity Framework, you can use the following approach. I hope this post helps you!

Firstly, we need to identify which entities are the ones that should support the soft-delete behavior. In order to do that we can use the following interface:

public interface ISoftDeleteEntity
{
    bool Deleted { get; set; }
}

We can use partial classes in order to implement the interface, so there is no need to modify the auto-generated classes.

public partial class Customer : ISoftDeleteEntity
{
}

Finally, we need to override the SaveChanges of the ObjectContext in order to get the deleted entities and run the soft-delete logic.

public partial class DatabaseEntities
{
    public override int SaveChanges(SaveOptions options)
    {
        var deletedEntities = GetDeletedEntities();

        SoftDelete(deletedEntities);

        return base.SaveChanges(options);
    }

    private List<ISoftDeleteEntity> GetDeletedEntities()
    {
        return ObjectStateManager
            .GetObjectStateEntries(EntityState.Deleted)
            .Select(entry => entry.Entity)
            .OfType<ISoftDeleteEntity>()
            .ToList();
    }

    private void SoftDelete(List<ISoftDeleteEntity> deletedEntities)
    {
        deletedEntities.ForEach(e =>
        {
            ObjectStateManager.ChangeObjectState(e, EntityState.Modified);
            e.Deleted = true;
        });
    }
}

As you can see in the code snippet, first of all we are obtaining all the entities that are going to be deleted and that implement the ISoftDeleteEntity interface. After that, we are changing their state to modified and setting the Deleted property.

Note: If the changes were not detected yet (WCF DataServices scenario), you should call the DetectChanges method before obtaining the deleted entities. The attached source code shows how to do it.

You can download the sample code from here.

Entity Framework at Alt.Net Hispano

noreply@blogger.com (Jorge Fioranelli) — Tue, 07 Dec 2010 22:07:05 PST

On 17th November I had the pleasure of participating as speaker in a virtual alt.net meeting (VAN) about Entity Framework. The meeting was organized by the alt.net hispano community (spanish language).

The video of the meeting (in spanish language) can be downloaded from here:

The slides and the code can be downloaded from the following links:
- Slides
- Code

Unable to display content. Adobe Flash is required.

I would like to thank Jorge Gamba (@jorgegamba) for the organization and Fabio Maulo (@fabiomaulo) for his collaboration.

N-Tiers using POCOs and Entity Framework - Part Five: DataAccess Layer

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Feb 2011 20:46:12 PST

Edit: Code updated

This layer has the responsibility to manage the database-related operations. It access to the Entity Framework context in order to query, update, add and delete Entities.

Since the domain objects shouldn’t have access to the EF context, they must call the Repositories to perform all data-related operations. Repositories have the responsibility to manage the entity’s CRUD operations (Create, Read, Update and Delete).

namespace Business.Infrastructure.Repositories
{
  public class OrderRepository : IOrderRepository
  {
    private readonly ModelContext context;

    public OrderRepository(ModelContext context)
    {
      this.context = context;
    }

    public Order Get(int id)
    {
      return context.Orders.Include("Product")
          .Single(o => o.Id == id);
    }

    public Order Update(Order order, bool loadOriginal = false)
    {
      if (loadOriginal)
        context.Orders.FirstOrDefault(o => o.Id == order.Id);

      var updatedOrder = context.Orders.ApplyCurrentValues(order);

      LoadProduct(updatedOrder);
            
      return updatedOrder;
    }

    private void LoadProduct(Order order)
    {
      if(order.Product == null)
        context.LoadProperty(order, o => o.Product);
    }
    ...
  }
}

In the above code snippet we can see the Update() method implementation of the OrderRepository. Once this method is called it will apply the new values received from the business layer using the ApplyCurrentValues() that EF provides to update disconnected Entities. Then, after applying these new values, the Repository will load from the database the Product associated to the Order (see note about the Lazy Load EF feature).

The ApplyCurrentValues() method doesn’t persist the domain changes, they are going to be persisted when the Unit Of Work’s Save() method is executed by the Application Service.

namespace Business.Infrastructure.UnitOfWork
{
  public class ModelContext : ObjectContext, IUnitOfWork
  {
    public ModelContext() 
    : base("name=ShopEntities", "ShopEntities")
    {
      ContextOptions.LazyLoadingEnabled = false;
    }

    private ObjectSet<Product> products;
    public ObjectSet<Product> Products
    {
      get
      {
        return products 
          ?? (products = CreateObjectSet<Product>());
      }
    }

    private ObjectSet<Order> orders;
    public ObjectSet<Order> Orders
    {
      get
      {
        return orders
          ?? (orders = CreateObjectSet<Order>());
      }
    }

    public void Save()
    {
      SaveChanges();
    }
    ...
  }

  public interface IUnitOfWork : IDisposable
  {
    void Save();
  }
}

Finally, it is important to mention that the EF context should have the LazyLoadingEnabled option set to false. Since the POCOs are accessed from different tiers, the Lazy Load feature shouldn’t be enabled.

Note: The Lazy Load EF feature allows us to automatically request associations to the database when their properties are accessed [Fowler, PEAA].

Conclusion

Developing n-tier applications is not an easy task; most scenarios use customized DTOs and translators in order share data between the tiers.

On the other hand, trying to reuse same objects in both tiers usually forces us to put state and behavior in different objects.

But combining POCOs, extension methods and Entity Framework in an n-tier application we can obtain the following benefits:

Entities with state and behavior (properties + extension methods)
Reuse of Entities in both tiers (as presentation model and business entities)
No mapping/translation needed

References:

Fowler, PEAA: Fowler, Martin. Patterns of Enterprise Application Architecture, Boston, MA: Addison-Wesley 2003.

Posts in this series:

N-Tiers using POCOs and Entity Framework - Part Four: Business Layer

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Feb 2011 20:45:13 PST

Edit: Code updated

The business layer will receive the POCO from the presentation layer and it will execute all the business logic applicable, calling the data access layer when it is necessary.

In order to communicate both tiers, the business layer exposes Application Services implemented using Windows Communication Foundation (WCF). These Application Services shouldn’t have any business logic; they have the responsibility to expose business operations to the presentation layer. The only two things that they should do are to call the business domain and to coordinate the Unit of Work pattern in order to persist all entities’ changes in a centralized point per WCF request.

namespace Business.Application.Services
{
  public class SalesModuleAppService : ISalesModuleAppService
  {
    private readonly IShopDomainService shopDomainService;
    private readonly IUnitOfWork unitOfWork;

    public SalesModuleAppService()
    {
        shopDomainService = // Get IShopDomainService from IoC Container
        unitOfWork = // Get IUnitOfWork from IoC Container
    }

    public void ProcessOrder(Order order)
    {
      shopDomainService.ConfirmOrder(order);

      unitOfWork.Save();
    }
    ...
  }
}

Note: Since this example is about updating an existing Order, if the Application Service receives a DTO instead of the Entity, you should retrieve the original Order and then set its properties using the values of the DTO.

As we can see, the Application Service is calling the ConfirmOrder() method of the Domain Service in order to execute the business logic. This method has the responsibility to coordinate the cancellation of the old order and the confirmation of the new one. In order to do that, it has to obtain the already persisted Order and cancel it, then to apply the new values in the ORM context (using the OrderRepository) and finally to execute the confirmation logic of the new Order.

namespace Business.Domain.Services
{
  public class ShopDomainService : IShopDomainService
  {
    private readonly IOrderRepository orderRepository;

    public ShopDomainService(IOrderRepository orderRepository)
    {
      this.orderRepository = orderRepository;
    }

    public void ConfirmOrder(Order order)
    {
      if (!order.IsNew())
      {
        var originalOrder = orderRepository.Get(order.Id);
        originalOrder.Cancel();
      }

      var currentOrder = order.IsNew() 
        ? orderRepository.Insert(order) 
        : orderRepository.Update(order);

      currentOrder.Confirm();
    }
    ...
  }
}

Note: Domain Services (ShopDomainService) have different purpose than Application Services (SalesModuleAppService). While the first ones are business-oriented, providing stateless business operations, the second ones act as boundary to the business layer, exposing its operations to other tiers.

In the following code snippets we can see a partial implementation of the extension methods applicable to the Order and the Product Entities, containing their corresponding business logic.

namespace Business.Domain.Entities
{
  public static class OrderExtensions
  {
    public static void Confirm(this Order order)
    {
      // Here run the business rules 
      // (e.g. to verify the customer's status)

      order.Product.SubstractStock(order.Quantity);
      ...
    }

    public static void Cancel(this Order order)
    {
      order.Product.RestoreStock(order.Quantity);
      ...
    }
    ...
  }
}

namespace Business.Domain.Entities
{
  public static class ProductExtensions
  {
    public static void SubstractStock(this Product product, int quantity)
    {  
      if(quantity > product.Stock)
        throw new InvalidOperationException("Insufficient stock");

      product.Stock -= quantity;
      ...
    }

    public static void RestoreStock(this Product product, int quantity)
    {
      product.Stock += quantity;
      ...
    }
    ...
  }
}

References:

Evans, DDD: Evans, Eric. Domain-Driven Design: Tackling Complexity in the Heart of Software, Boston, MA: Addison-Wesley 2004.

Posts in this series:

N-Tiers using POCOs and Entity Framework - Part Three: Presentation Layer

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Feb 2011 20:44:32 PST

Edit: Code updated

The presentation tier is a web application implemented using ASP.NET MVC. It has the goal of interacting with the user, executing only the logic related to the user interface.

In the Model-View-Controller (MVC) pattern, the View has the responsibility to render the model to the user while the Controller has the ability to obtain the user’s input and to process it.

@using (Html.BeginForm()) {
    @Html.ValidationSummary(true)
    <fieldset>
        <legend>Order</legend>

        <div class="editor-label">
            @Html.LabelFor(model => model.Product)
        </div>
        <div class="editor-field">
            @Html.DropDownListFor(model => model.Product_Id, 
              new SelectList(ViewBag.Products, "Id", "Description"), 
              "- Select -")
            @Html.ValidationMessageFor(model => model.Product_Id)
        </div>

        <div class="editor-label">
            @Html.LabelFor(model => model.Quantity)
        </div>
        <div class="editor-field">
            @Html.EditorFor(model => model.Quantity)
            @Html.ValidationMessageFor(model => model.Quantity)
        </div>

        <p>
            <input type="submit" value="Create" />
        </p>
    </fieldset>
}

namespace Presentation.Controllers
{
  public class OrderController : Controller
  {
    private readonly ISalesModuleAppService salesModuleAppService;

    public OrderController(ISalesModuleAppService salesModuleAppService)
    {
      this.salesModuleAppService = salesModuleAppService;
    }

    [HttpPost]
    public ActionResult Edit(Order order)
    {
      salesModuleAppService.ProcessOrder(order); // WCF Call

      return RedirectToAction("Index");
    }
    ...
  }
}

In the previous code snippet we can see how the Controller is calling the method ProcessOrder() of the of the Application Service (located in the business tier) in order to execute the corresponding business logic. We can also see that the Controller is sending the recently updated Order (POCO) as parameter.

References:

Fowler, PEAA: Fowler, Martin. Patterns of Enterprise Application Architecture, Boston, MA: Addison-Wesley 2003.

Posts in this series:

N-Tiers using POCOs and Entity Framework - Part Two: Model and Entities

noreply@blogger.com (Jorge Fioranelli) — Mon, 27 Sep 2010 21:29:09 PDT

Following Domain Driven Design (DDD) principles [Evans, DDD], the domain should be represented by objects with state and behavior, using a rich object-oriented model. Additionally, in n-tier applications it is ideal to reuse as many objects as you could in order to reduce code duplication.

However, the object’s behavior is usually very different in each tier; for example, in the business tier the behavior is often business-oriented and it shouldn’t be executed in the presentation tier.

To solve this problem, we can use POCOs with only state (properties), and add behavior to them using extension methods in the business tier.

Note: Although extension methods provide a good extensibility mechanism, they have some limitations. For example, they don’t support late-bound polymorphism (virtual methods).

In the following code snippet we can see the Order and Product POCOs, related each other through the Product and the Product_ID properties.

namespace Common.Domain.Entities
{
  public class Order
  {
    public int Id { get; set; }
    public Product Product { get; set; }
    public int Product_ID { get; set; }
    public int Quantity { get; set; }
    ...
  }

  public class Product
  {
    public int Id { get; set; }
    public string Description { get; set; }
    public int Stock { get; set; }
    ...
  }
}

Note: EF supports two types of associations: Navigation Properties (Product property) and Foreign Key Properties (Product_ID property). While the first ones allow you to “navigate” from one object to the other, the second ones are very useful in “disconnected” scenarios.

And as we mentioned before, the behavior of both objects is added using the extension methods defined in the following classes.

namespace Business.Domain.Entities
{
  public static class OrderExtensions
  {
    public static void Confirm(this Order order) { ... }
    public static void Cancel(this Order order) { ... }
    ...
  }

  public static class ProductExtensions
  {
    public static void SubstractStock(this Product product) { ... }
    public static void RestoreStock(this Product product) { ... }
    ...
  }
}

This allows us to call the specific domain behavior using the entity instance.

using Common.Domain.Entities;
using Business.Domain.Entities;
...

order.Confirm();

It is also important to mention that there are some scenarios where the entity does not match with the data that should be shown in the presentation layer, e.g. let’s say it is required to show the customer’s name and the description of the latest ten products that he or she ordered. In those cases it could be a better option to create a customized Data Transfer Object (DTO) in order to transfer over the wire only the data needed.

Note: If your architecture must support “cross-process change tracking”, I recommend you to use the “self-tracking entities” EF feature, an excellent feature designed for n-tier applications. Since it increases the amount of data that is sent over the wire, you should use this feature only if it is required.

References:

Evans, DDD: Evans, Eric. Domain-Driven Design: Tackling Complexity in the Heart of Software, Boston, MA: Addison-Wesley 2004.

Posts in this series:

N-Tiers using POCOs and Entity Framework - Part One: Architecture

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Feb 2011 20:42:41 PST

The ADO.NET Entity Framework comes with features like “persistence ignorance” and “POCO support” which allow the use of simple objects as persistent entities and the development of n-tier applications in an easier way.

The purpose of these post series is to show an example of an n-tier application that takes advantage of these features.

In n-tier architectures, each tier can be executed in a different process and potentially in a different server. In fact, every application that uses a database server and an internet browser has at least three tiers, so it could be considered an n-tier application. Nevertheless, in the .NET world it is very common to catalog as n-tier applications those in which the .NET code is separated by at least two processes, generally using technologies such as SOAP Web Services, .NET Remoting or Windows Communication Foundation (WCF).

The example application has the following architecture:

The application’s architecture is split into two tiers:

The presentation tier, which has the responsibility to execute the user interface logic using the “Model-View-Controller” (MVC) pattern [Fowler, PEAA].
The business tier, which contains all the business and data access logic. This tier uses the “Unit of Work” and “Repository” patterns [Fowler, PEAA] combined with an Object Relational Mapper (Entity Framework).

In this architecture, the Model and the Entities are represented by the Plain Old CLR Objects (POCOs) that are serialized and transported over the wire between both tiers.

Note: Plain Old CLR Objects (POCOs) are ordinary .NET classes without any infrastructure-related stuff. POCOs don’t have to inherit from a certain base class or to implement a specific interface. They are clean objects with persistence ignorance [Nilsson, ADDDP].

References:

Fowler, PEAA: Fowler, Martin. Patterns of Enterprise Application Architecture, Boston, MA: Addison-Wesley 2003.
Nilsson, ADDDP: Nilsson, Jimmy. Applying Domain-Driven Design and Patterns with examples in C# and .NET, Boston, MA: Addison-Wesley 2006.

Posts in this series:

WPF Commands in IronPython

noreply@blogger.com (Jorge Fioranelli) — Tue, 02 Feb 2010 07:25:03 PST

Dependency Properties and Commands are very useful WPF features.

In my last post I wrote about how to use Dependency Properties in IronPython. In this post we will see how to implement and use the WPF RelayCommand (for more details see WPF Apps With The Model-View-ViewModel Design Pattern).

import clr

clr.AddReference("WindowsBase")
clr.AddReference("PresentationCore")
clr.AddReference("PresentationFramework")

from System import (
EventArgs
)

from System.Windows import (
DependencyObject
)

from System.Windows.Input import (
ICommand
)

class RelayCommand(ICommand):

    def __init__(self, executeFunction, canExecuteFunction):
        self._executeFunction = executeFunction
        self._canExecuteFunction = canExecuteFunction
        self._handlers = []

    def CanExecute(self, parameter):
        return self._canExecuteFunction(parameter)

    def add_CanExecuteChanged(self, handler):
        self._handlers.append(handler)

    def remove_CanExecuteChanged(self, handler):
        self._handlers.remove(handler)

    def canExecuteChanged(self):
        for handler in self._handlers:
            handler(self, EventArgs.Empty)

    def Execute(self, parameter):
        self._executeFunction(parameter)
        self.canExecuteChanged()

class Planning(DependencyObject):

    _sessionProperty = None

    def __new__(cls):
       if not Planning._sessionProperty:
            Planning._sessionProperty = DependencyProperty.Register(
                "session", clr.GetClrType(Session), clr.GetClrType(Planning))
        return DependencyObject.__new__(cls)

    def __init__(self):
        self.loginCommand = RelayCommand(lambda p : self.login(p), lambda p : not self.session)
    def login(self, user):
        self.session = Session(user)

    def getSession(self):
        return self.GetValue(Planning._sessionProperty)

    def setSession(self, value):
        self.SetValue(Planning._sessionProperty, value)

    session = property(getSession, setSession)

WPF Dependency Properties in IronPython

noreply@blogger.com (Jorge Fioranelli) — Thu, 11 Feb 2010 15:13:32 PST

One of the best features added to WPF are Dependency Properties. Dependency properties use a combination of a property and a static field (a class field in python).

As follows you will find an example:

import clr

clr.AddReference("WindowsBase")
clr.AddReference("PresentationCore")
clr.AddReference("PresentationFramework")

from System.Windows import (
DependencyObject, DependencyProperty
)

Using an IronPython object from C#

noreply@blogger.com (Jorge Fioranelli) — Sun, 27 Dec 2009 15:26:31 PST

The new keyword “dynamic” added to C# (.Net 4.0) allows you to interoperate with any dynamic language such as IronPython or IronRuby.

This new feature bypasses any static type checking at compile time, assuming that any operation is allowed. But, if it is not allowed, an error will be showed at run time.

For example, the following Customer “IronPython Class” is invoked from the C# code as a dynamic object:

IronPython code (Sample.py)

# Function (method) that creates a new Customer
def CreateCustomer(firstName, lastName):
return Customer(firstName, lastName)

# Customer object
class Customer(object):

    # Initialization (constructor)
    def __init__(self, firstName, lastName):
        self._firstName = firstName
        self._lastName = lastName

    # Function (method) that print the customer
    def printNames(self):
        print self._firstName + ' ' + self._lastName

C# code (Program.cs)

using Microsoft.Scripting.Hosting;
using IronPython.Hosting;

class Program
{
static void Main(string[] args)
{

        ScriptRuntime py = Python.CreateRuntime();
        dynamic sample = py.UseFile("Sample.py");
        dynamic customer = sample.CreateCustomer("Paul", "Smith");
        customer.printNames();
    }
}

You can download the source code here.

Using PLINQ to improve performance

noreply@blogger.com (Jorge Fioranelli) — Tue, 22 Dec 2009 02:45:58 PST

The version 4.0 of .Net has a new feature called “Parallel LINQ” or PLINQ. If you use LINQ to filter or process a large amount of objects in memory and/or it is required a high-cost evaluation, PLINQ is for you.

PLINQ segments the source in parts and it uses different threads in order to process each segment.

var validCustomers = allCustomers.AsParallel()
.Where(c => c.IsValid())
.ToArray();

Here you can download the sample code.

For more details I recommend you to watch the Igor Ostrovsky presentation in the PDC 2009 webpage.

Entity Framework 4.0 - Foreign Key Relationships

noreply@blogger.com (Jorge Fioranelli) — Tue, 01 Dec 2009 16:33:13 PST

The current version of EF (v3.5) maps table relationships as properties, hiding database foreign-key columns. However, there are some scenarios where you don’t need the entire referenced object to do some operation, you only need its “Id” (foreign key).

For example, in a web application it is very common to use combo-boxes in order to assign relationships. In these scenarios, after a post-back it is necessary to re-create the model and its relationships (using combo-boxes “selected values”). Since you don’t have the referenced objects, you must get them from the database or use “Stub Entities” to simulate them.

To solve this problem, the version 4.0 will also allow you to map foreign-key columns as properties, making it easier.

More info: http://blogs.msdn.com/adonet/archive/2009/11/06/foreign-key-relationships-in-the-entity-framework.aspx.

WF Course

noreply@blogger.com (Jorge Fioranelli) — Thu, 17 Dec 2009 03:07:17 PST

Last week I was teaching a three days course about WF (Windows Workflow Foundation).

The content was the following:

Day One
Introduction
Parameters
Conditions
Persistence
WebServices
LocalServices

Day Two
Errors
FaultHandlers
Transactions
Compensation
Compensation + Transaction

Day Three
Parallel Execution
WCF
Tracking
Custom Activities
WF v4 Overview
Questions

Here you can download the presentation (in Spanish).

And here is the code: DayOne, DayTwo and DayThree.

POCO in Entity Framework 4.0

noreply@blogger.com (Jorge Fioranelli) — Wed, 14 Oct 2009 04:44:49 PDT

The new version (4.0) of Entity Framework allows us to use “Plain Old CLR Objects” as entities. In the current version (3.5) every entity must inherit from EntityObject, but in the new version it is possible to use a simple POCO:

public class Order
{
public Guid Id { get; set; }
public Product Product { get; set; }
public int Quantity { get; set; }
}

In order to use this new feature it is necessary to follow these three steps:
1. Create the edmx file (ModelEntities).
2. Turn off the code generation removing the value of the “Custom Tool” property.
3. Create the context this way:

public class ModelContext : ObjectContext
{
public ModelContext() : base("name=ModelEntities", "ModelEntities")
{
}

public ObjectSet<Order> Orders
{
get { return base.CreateObjectSet<Order>(); }
}
}

More information:
POCO in the Entity Framework: Part 1 - The Experience
POCO in the Entity Framework: Part 2 – Complex Types, Deferred Loading and Explicit Loading
POCO in the Entity Framework: Part 3 – Change Tracking with POCO

Default Endpoints in WCF 4.0

noreply@blogger.com (Jorge Fioranelli) — Sun, 11 Oct 2009 11:53:46 PDT

One of the hardest things in WCF is its configuration. When you try to host a service without an endpoint declared in the configuration, an exception is thrown (a classic mistake).

But this will change with the new version of the framework (in fact it has already changed in the beta 1).

When you are hosting a service without any endpoint configured, the ServiceHost will read the service’s Uri and will create a default endpoint choosing one of de following bindings:
- http: basicHttpBinding
- net.tcp: netTcpBinding
- net.pipe: netNamedPipeBinding
- net.msmq: netMsmqBinding

More information: A Developer’s Introduction to Windows Communication Foundation (WCF) .NET 4 Beta 1

Mocking WCF Services

noreply@blogger.com (Jorge Fioranelli) — Sat, 10 Oct 2009 17:53:24 PDT

In my last post I showed how to decouple the service consumer from the service proxy using the ServiceLocator pattern.

In order to mock the WCF service, it is necessary to create the following ServiceClientStub:

public class ServiceClientStub<TServiceInterface> : IServiceClient<TServiceInterface>
where TServiceInterface : class
{
private TServiceInterface serviceMock;

public ServiceClientStub(TServiceInterface serviceMock)
{
this.serviceMock = serviceMock;
}

public TServiceInterface Service
{
get { return serviceMock; }
}

public void Dispose() { }
}

This allows you to test the service consumer without the service implementation (using Moq):

var result = ...
var mock = new Mock<IServiceA>();
mock.Setup(s => s.Operation()).Returns(result);
ServiceLocator.Register<IServiceClient<IServiceA>>(
() => new ServiceClientStub<IServiceA>(mock.Object));

Using ServiceLocator to call a WCF Service

noreply@blogger.com (Jorge Fioranelli) — Mon, 19 Oct 2009 04:41:35 PDT

In my last post, I published a simple ServiceLocator, it may help you to decouple the service consumer from service proxy.

To do this, it is necessary to create a generic interface:

public interface IServiceClient<TServiceInterface> : IDisposable
where TServiceInterface : class
{
TServiceInterface Service { get; }
}

And it is the implementation using the ClientBase of WCF:

public class ServiceClient<TServiceInterface> :
       ClientBase<TServiceInterface>,
       IServiceClient<TServiceInterface>
       where TServiceInterface : class
{
public TServiceInterface Service
{
    get { return base.Channel; }
}

void IDisposable.Dispose()
{
    try
    {
      base.Close();
    }
    catch (CommunicationException)
    {
      base.Abort();
    }
    catch (TimeoutException)
    {
      base.Abort();
    }
    catch (Exception)
    {
      base.Abort();
      throw;
    }
}
}

Then, you can register and use the ServiceClient this way:

// Service Registration
ServiceLocator.Register<IServiceClient<IServiceA>>(() => new ServiceClient<IServiceA>());

// Service Resolving
using (var client = ServiceLocator.Resolve<IServiceClient<IServiceA>>())
{
client.Service.Operation();
}

A simple ServiceLocator with support for WCF, Web and Thread contexts

noreply@blogger.com (Jorge Fioranelli) — Fri, 09 Oct 2009 05:01:44 PDT

Last week I wrote a very simple ServiceLocator that supports single and multiple instances. It has three different containers:

- WCF: It supports single instances on the same OperationContext.
- Web: It supports single instances on the same HttpContext.
- Thread: It supports single instances on the same Thread.

Every container implements the ISingleInstanceContainer interface:

interface ISingleInstanceContainer
{
bool IsSuitable { get; }
T Register<T>(T instance);
T Resolve<T>();
}

The IsSuitable method evaluates if the context is suitable for every container:

class SingleInstanceWcfContainer : ISingleInstanceContainer
{
public bool IsSuitable
{
get { return OperationContext.Current != null; }
}
...
}

class SingleInstanceWebContainer : ISingleInstanceContainer
{
public bool IsSuitable
{
get { return HttpContext.Current != null; }
}
...
}

In the following example, you can see how to register the ServiceA as “multiple instances” and the ServiceB as “single instance”:

// Multiple Instances Registration
ServiceLocator.Register<IServiceA>(() => new ServiceA());

// Single Instance Registration
ServiceLocator.Register<IServiceB>(() => new ServiceB()).SingleInstance();

// Resolving Instances
IServiceA serviceA = ServiceLocator.Resolve<IServiceA>();
IServiceB serviceB = ServiceLocator.Resolve<IServiceB>();

Here you can download the code.
.

Mocking Views

noreply@blogger.com (Jorge Fioranelli) — Thu, 23 Jul 2009 08:51:30 PDT

In my last post, I've shown how to implement a simple MVC over ASP.NET.

As you can see in the picture, every View implements an interface which exposes the events and methods of the View.

The Controller uses the View’s interface, so it is possible to mock the View in order to test the Controller without the aspx page running.

In the example of the last post, the View’s interface exposes these members:

internal interface ICustomersView
{
event EventHandler<GenericEventArgs<string>> FindCustomer;
void FillCustomers(IList<Customer> customers);
}

So, you can mock the View and raise the FindCustomer event this way (I am using the MOQ library):

Mock<ICustomerView> mock = new Mock<ICustomerView>();

CustomersController controller = new CustomersController(mock.Object);

mock.Raise(v => v.FindCustomer+= null,

new GenericEventArgs<string>(searchPattern));