| || ||
| || || Chapter I
The last article added to the series is WCF by Example - Chapter XIV - Validation &
Exception Management, this article was added early Jan 2011 and discusses
how to implement the IDataErrorInfo interface in combination with Validation attributes.
This approach provides a comprehensive validation mechanism that works both in the client and
server side. The article also discusses exception and warning management.
Recently, a re-factor of the client services components have taken place reducing the number of required artifacts in the client side
when a new contract is created or methods are added or amended. The code is already on Codeplex on the trunk branch. Existing articles will need revision as result of these changes, code at the branches will also require changes.
In Dec 2010, the server side of the application was deployed to Azure, a ready-to-run client is available on codeplex. The WPF client can invoke
methods to a WebRole deployed in Azure. This source code can be found at CodePlex at eDirectory.WPFClient.Azure.zip
You may want to follow series/code updates at:
This article is the first of a series that discusses how to design and develop a
WPF client using WCF for communication and NHibernate for persistence purposes.
Designing enterprise applications requires a comprehensive set of skills. In small
and medium projects allocation of time and resources could be not feasible to the
extent that is in larger projects, it is at this time where a source for best practices
and patterns can become very beneficial. There are plenty articles, books and other
materials covering specific aspects but it is almost impossible to find a single
place where all the technologies and patterns are used in conjunction providing
a comprehensive discussion of the why and how.
The intention of these articles is to provide an example of how a full enterprise
application is developed from the early stages to a full functional stage. The articles
build on top of each other where new aspects are covered or/and existing functionality
is enhanced as a result of aligning the architect to the business non-functional
It is assumed in the series that Agile practices are followed so the solution's
architect focuses in providing flexible mechanisms for RAD, DDD and TDD methodologies.
One key aspect of the architect is the requirement to be able to deploy a full-functional
client for business exploration purposes that requires a minimum infrastructure
footprint; avoiding databases, deployment to IIS and so on.
The architect requirements are as follow:
- Rich client using WPF
- Client connects to server using WCF services
- NHibernate is used for persistence purposes
- Client application can be run against in-memory repositories (Exploration Client)
- Deployment of the exploration client must be kept simple
- The application must be easily testable, tests can be run against in-memory or NHibernate
- We have full control over the client and server components
- We are creating the database from scratch, we are not using some legacy database
- We are deploying the server components using IIS7 and WAS; we will use TCP/IP
- We have full design control over the PK in the database tables, we will using unique
long fields for all our entities in this project
The eDirectory solution
We are going to start using a very simple business scenario in our series, the focus
on the series is the architecture not the business domain. We may extend our domain
in the future if we find that we want to explore some more complex architect concepts.
The business domain is based in a simple list of contacts, it is currently
so simple that one single entity is only required: Customer. The solution name is
The source code can be found at codeplex: WCF by Example
The latest version can be found at the trunk branch, each chapter is located at
its own tag branch. You may want to use the browse function within Codeplex to navigate
among the branches.
The eDirectory application defines three well differentiated application components:
the database, server and client.
Within the client and server the application is structured into layers, in most
cases the layers are stacked one beside each other, continuous layers are provided
with decoupled mechanisms so different implementations can be used. Some services
are available across multiple layers.
As we earlier mentioned, we have full control of the clients and server. So we will
not relay on late service discovery, instead the service contracts are available
at both sides of the application. This is also true for the DTOs and some common
business validation. As a result, a Common assembly is defined that contains components
shared by the server and client applications.
In the server side we find the core components, the business domain declares the
business entities and their behavior (action methods). Then services are declared
that exposes our domain action methods. The services for persistence and
serialisation constraints only expose DTOs between the client and server. As a result,
the transformation of entities to DTOs needs to be addressed in a comprehensive
In order to decouple our business domain from the database, the repository
components are responsible for the persistence of our entities. We will define a
generic interface between these two layers. Two concrete implementations of the
repositories are available: in-memory and NHibernate.
The transaction manager is our "unit of work" implementation. It is responsible
for our business transactions and the handling of business messages (warnings and
Finally, but not the least, we have the client components. The client is a WPF application
designed using the MVVM pattern. This pattern provides a neat view XAML component
with none or very little code behind, the binding capabilities of XAML in conjunction
with the ViewModel class leverages how the client renders the DTOs provided by the
The client decouples the service layers into two main components. The adapter is
responsible for the managing of business messages retrieved during the execution
of services. The WCF Proxy layer is responsible for the management of WCF services,
the design is neat and is a nice way of decoupling the client from the WCF service.
Available articles in Codeproject
Available chapters (source code) in Codeplex
|| Chapter I - Baseline
|| Chapter II - Response
|| Chapter III - Response
|| Chapter IV - Transaction Manager
|| Chapter V - Service Locator
|| Chapter VI - Baseline MVVM
|| Chapter VII - Contract Locator
|| Chapter VIII - RelayCommand
|| Chapter IX - Notify Property Changed Pattern
|| Chapter X - Dependency Injection
|| Chapter XI - NHibernate Implementation
|| Chapter XII - WCF Implementation
|| Chapter XIII - Business Domain Extension
|| Azure Solution - In-memory mode WebRole
|| Chapter XIV - Validation & Exception Management
|| Client re-factor: ServiceAdapter & CommandDispatcher pattern
| Azure Deployment - In-memory WebRole
|| Source code is available
| Azure Deployment - NHibernate WebRole
| Existing chapters revision as a result of client re-factor
14 June 2010 - Introduction article was created.
28 June 2010 - Chapter I is done and series are published.
05 July 2010 - Chapter II was added to the series
10 July 2010 - Chapter III was added to the series
16 July 2010 - Chapter IV was added to the series
23 July 2010 - Chapter V was added to the series
31 August 2010 - Chapter VI was added to the series
04 September 2010 - Chapter VII was added to the series
15 September 2010 - Chapter VIII was added to the series
19 September 2010 - Chapter IX was added to the series
07 October 2010 - Source code for Chapter XII is available at CodePlex
16 October 2010 - Chapter X was added to the series
04 November 2010 - Chapter XI was added to the series
24 November 2010 - Chapter XII was added to the series
12 December 2010 - In-memory WebRole is deployed to MS Azure
19 December 2010 - Chapter XIII was added to the series
07 January 2011 - Chapter XIV was added to the series
09 February 2011 - Chapter XIV section 2 was added to the series
07 October 2011 - Client re-factor was made available on Codeplex