Jorge Fioranelli

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

2010-09-04T19:01:00.007+10:00

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: Independent Associations (Product property) and Foreign Key Associations (Product_ID property). While the first ones are the most popular because are more object-oriented, the second ones are very useful in “disconnected” scenarios (e.g. when you need to update the relationship and you don’t have access to the EF context).

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.

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

2010-09-01T18:56:00.001+10:00

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 Dependency Properties in IronPython

2010-01-30T01:54:00.001+11:00

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
)

WPF Commands in IronPython

2010-02-03T02:25:00.001+11:00

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)

Using an IronPython object from C#

2009-12-28T10:26:00.001+11:00

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

2009-12-22T21:44:00.001+11:00

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.

WF Course

2009-11-26T22:45:00.001+11:00

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.

Entity Framework 4.0 - Foreign Key Relationships

2009-12-01T11:33:00.000+11:00

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.

Using ServiceLocator to call a WCF Service

2009-09-09T00:49:00.000+10:00

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();
}

POCO in Entity Framework 4.0

2009-10-14T22:44:00.001+11:00

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

2009-10-11T13:03:00.000+11:00

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

2009-09-29T10:53:00.000+10:00

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));

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

2009-08-19T22:00:00.000+10:00

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

2009-07-23T21:18:00.002+10:00

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));

A simple MVC implementation for ASP.NET (not ASP.NET MVC)

2009-06-30T23:06:00.000+10:00

Recently I have designed an architecture which supports the MVC pattern over the ASP.NET platform for an existing application.

It is well known that new ASP.NET MVC Framework is the best option to implement the MVC pattern, but it is also true that is difficult to adapt existing applications to this framework. So, I have designed an alternative and very simple solution in order to reach the same goal: MVC over ASP.NET.

In the architecture designed, every View implements an interface which acts as contract between the View and the Controller. This interface exposes the events and methods of the View.

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

The Controller has to attach itself to the events and call to the methods of the View Interface.

internal class CustomersController : ControllerBase<ICustomerView>
{

public CustomersController(ICustomersView view) : base(view)
{
view.FindCustomers += new EventHandler<GenericEventArgs<string>>(view_FindCustomers);
}

private void view_FindCustomers(object sender, GenericEventArgs e)
{
IList<Customer> customers = FindCustomers(e.Argument);
View.FillCustomers(customers);
}

private IList<Customer> FindCustomers(string customersSearchPattern)
{
// Use the model in order to find customers
}

}

As you can see, the Controller receives the interface of the View and it doesn't know nothing about the View Implementation, so you can test the Controller using a mocked View.

Then, you need to create the ASP.NET WebForm that implements the ICustomerView interface.

public partial class CustomersView :
ViewBase<CustomersController, ICustomersView>, ICustomerView
{

public event EventHandler<GenericEventArgs<string>> FindCustomers;

public void FillCustomers(IList<Customer> customers)
{
customersGrid.DataSource = customers;
customersGrid.DataBind();
}

protected void OnFindCustomers(GenericEventArgs<string> args)
{
    if(FindCustomers != null)
    {
      FindCustomer(this, args)
    }
}

protected void btnSearch_Click(object sender, EventArgs e)
{
OnFindCustomer(new GenericEventArgs<string>(txtSearch.Text));
}

}

Finally, the classes that you need to implement this architecture are the following:

internal abstract partial class ViewBase<TController, TViewInterface>:
Page
where TViewInterface : class
{

public ViewBase()
{
Type controllerType = typeof(TController);
Activator.CreateInstance(controllerType, this as TViewInterface);
}

}

internal abstract class ControllerBase<TViewInteface>
where TViewInteface : class
{

public TViewInteface View { set; get; }

public ControllerBase(TViewInteface view)
{
View = view;
}

}

internal class GenericEventArgs<TArgument> : System.EventArgs
{
public GenericEventArgs()
{
}

public GenericEventArgs(TArgument argument)
{
Argument = argument;
}

public TArgument Argument { get; set; }

}

DDD with WCF

2009-05-22T21:57:00.008+10:00

Most books and articles explain how to use DDD with "one-server" architecture. But when you try to design a distributed architecture (ui and business layer), things get harder.

It is generally accepted that it's better not to distribute your application (see Martin Fowler's First Law of Distribution), but sometimes it is necessary.

In my opinion WCF services are "application services" of DDD. They provide access to the business layer.

The main problem of this architecture is that entities must live only on the business layer, because entities have methods that musn't be executed on the ui layer.

To solve it, it is necesary to create datacontracts (DTOs) in order to pass information between both layers and to map them with each entity.

Alt.Net in Buenos Aires

2009-05-14T21:28:00.010+10:00

Last saturday I participated in the first alt.net open space organized in Argentina.

These were the discussions:

I took part in the following subjects:
- SOA and ESB
- OpenSource in Argentina
- ORM Techniques
- DDD with WCF and EF

Zaiden, Rodolfo and I talking with Martin Salias

It was a very good experience. Thanks to the attenders, and specially to the organizers (Carlos Peix, Martin Salias and Miguel Saez).

Agile at ManageIt Event

2009-04-24T21:09:00.000+10:00

Last tuesday I took part as speaker in the session "Management of development teams", during the event "Manage IT" (UADE).

In this session Rodolfo Finochietti, Nicolás Mohamed, Mariano Sanchez and I talked about our experiences using agile methodologies in different Lagash projects.

The agenda was the following:
- Introduction
- Iterations
- Planning
- Scrum Board y Burndown Chart
- Testing
- Daily Meetings
- Retrospectives

Here you can download the presentation (in Spanish).

Thanks to the attendants.

Webcast about CloudServices

2009-01-17T21:16:00.001+11:00

Yesterday Rodolfo Finochietti and I have participated as speakers in the Microsoft Webcast "Extending the Application Platform with Cloud Services".

We presented the following points:
- Azure Services
- Access Control
- Sql DataServices
- Service Bus
- CRM Online

The presentation is available in English and Spanish.

Thanks to the attenders.

Using NMock2

2008-10-20T23:05:00.018+11:00

In unit testing, sometimes it is needed to isolate the dependencies in order to test a specific part of the application.

One way to do that is using mock objects. They simulate the behavior of real objects and is not needed the entire application for the test.

For example, in a Restaurant, the Waiter's job depends on the Cook's job . So, when you test the Waiter's job, you will test the job of the two employees.

If you want to test only de Waiter's job, you need to create a mock object in order to simulate the other employee's jobs.

NMock2 is one option to create mock objects. It can be downloaded from http://www.nmock.org/. As follows you will find the code to create the mock of the Cook using NMock2:

// Create the order and dishes for the test
Order order = CreateOrder();
List<Dish> dishes = CreateDishes(order);

// Create the mock of the Cook
Mockery mockery = new Mockery();
ICook cook = mockery.NewMock<ICook>();
Expect.Once.On(cook).Method("GetDishes").With(order)
.Will(Return.Value(dishes));

// Asign the mock object as Cook of the restaurant
Restaurant.Cook = cook;

// Send the order to the Waiter
Waiter waiter = new Waiter();
waiter.ProcessOrder(order);

The previous code builds a mock that expects one execution of the GetDishes method with the order as a parameter, and it must return the list of dishes specified.

So, when this test is executed, the Waiter uses the mock of the Cook, which returns the dishes that we have created.

For more details about creating mocks, you can watch the video (in Spanish language) with the entire explanation and download the presentation and code (in Spanish language).

Thanks to Miguel and Rodolfo for helping me with the video.

Technight about Interoperability in WCF

2008-09-12T11:16:00.011+10:00

I have recently participated as speaker at the Technight about "Interoperability in WCF" together with Rodolfo Finochietti and Ariel Krakovski. The event took place on 29 August in Microsoft Argentina.

The agenda was the following:
- WCF Extensibility
- Web Services Interoperability
- Contracts and Versioning
- Problems
- REST
- ADO.NET Data Services
- LINQ
- High Performace Computing
- SQL Server
- POP3

Samples and the presentation can be downloaded from Rodolfo's weblog.

Thanks to all the attendants and to Rodolfo, Ariel and Miguel.

Never forget to log

2008-09-21T06:17:00.023+10:00

Most software problems appear during implementation phases. When software is used in production environments, it's very common to see problems that you've never seen before. And when problems appear, there isn't time to reproduce them and to debug the code.

There are different ways to log information in .net, these are the most used:

- Event Log

- Trace / Debug

- Performance Counters

- WMI

If you use logging, you will be able to diagnose problems and might find errors wich couldn't be yours (until this happens, the problem is always yours).

Using the EventLog

2008-10-14T08:21:00.016+11:00

Many applications report errors with the EventLog because it provides a simple and centralized way to log. If you use the EventLog you won't have to worry about the size or location of the log.

Some Tips:

Use the EventLog not only for errors. Warnings and other messages are useful in order to understand the application behavior in production environments.

If the Source hasn't been created yet, it will be created with the first entry. That operation needs special permissions so, if the application doesn't run with administrator permissions, you must create the Source previously (see EventLogInstaller class).

Use some mechanism in order to filter the type of message you want to log. If not, you will have the EventLog full of messages that you don't need. (see TraceSwitch class).

Don't forget to use the Event ID. There are many management applications (i.e. MOM/SCOM) that use this information to take different actions.

You should document every entry. It will be useful when you are not there to give support.

For more details see the EventLog class documentation.