Raffaeu Bermuda Blog

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 06.

Raffaeu — Sun, 08 Nov 2009 21:13:00 GMT

Configure your Customer lookup and run it on IIS 7.0

In the previous article we saw how to use WCF (a basic approach) and what we should keep in consideration if we want to use SOA as our repository.

Now we need to:

Change the WCF service to point to a real database
Test the service
Build a web site to host our service
Host the web site on IIS 7.0
The the final result

Change the Customer service to reflect our database.

First of all let’s open the ServiceLibrary project and change the ICustomerService interface to reflect this:

  1: [ServiceContract]
  2: interface ICustomerService {
  3: 
  4:  [OperationContract]
  5:  IList<CustomerDto> GetCustomers();
  6: 
  7:  [OperationContract]
  8:  IList<CustomerDto> GetFilteredCustomers(string searchCriteria);
  9: 
 10: }

For our menu we need two methods. The first one will retrieve all the available customers, in alphabetical order; the second one will filter this results, in order to show us only the customers that match our search criteria.

The concrete implementation of this contract will consequently change in this way:

  1: List<CustomerDto> Customers = new List<CustomerDto>();
  2: IRepository customerRepository = 
  3:    new Repository(new ADVConnection());

Of course, in order to declare our Repository we need to add a reference to the DataLayer project in our WCF service. We need also to reference the entity framework .dll “System.data.entity” and we need also to add the connectionString section in the app.config of our WCF service, otherwise when we will instantiate a new database session (new ADVConnection()) the Visual Studio will throw an error “configuration not found … ”. This happens because the WCF is the final layers so you can use in .NET just one config file in the final layer (UI).

Now, what we want to do, is to populate the list of customer, in our service library, with the customers available in the database. Because our service is a singleton, we will do that when the first user will call the service:

  1: public CustomerService() {
  2:     var result = from c in customerRepository.GetAll<Customer>() orderby c.FirstName, c.LastName select c;
  3:     foreach (var customer in result) {
  4:         Customers.Add(
  5:             new CustomerDto() { 
  6:                 Id = customer.CustomerID, 
  7:                 FullName = customer.FirstName + " " + customer.LastName
  8:             }
  9:         );
 10:     }
 11: }
 12: 
 13:

Now, this piece of code is pretty easy and ugly. We should use something like AutoMapper to populate on fly our DTO but I want to show you exactly what happens behind the scene.
We takes all the available customers from the database and one by one, we fill up the Dto with the resultset.
A niece solution here would be also to use an extension method and do something like “from c in customers select c.ToDto()” that may returns a IList<CustomerDto>.

The two methods will change consequently in this way:

  1: public IList<CustomerDto> GetCustomers() {
  2:     return Customers;
  3: }

And the filtered version will change in this way:

  1: public IList<CustomerDto> GetFilteredCustomers(string searchCriteria) {
  2:  return Customers.FindAll(
  3:   delegate(CustomerDto c) { 
  4:    return c.FullName.ToLower()
  5:     .Contains(searchCriteria.ToLower()); 
  6:   }
  7:  );
  8: }
  9:

We just said to the List “Hey, looks inside the items and whether the items lower case contains this word, keep it”. Using this approach will allow us to keep clean the in memory list of customers and retrieve only the customers that match the criteria.

Test the environment.

Now if we press F5 our project will compile but when we will try to call the GetCustomers, we will receive this error:

Visual Studio is pretty nasty in this, because whatever you will say in the app.config, it will use a different app.config “on fly” when you test your service. So in the service windows, click on the app.config under the customer service and change it in this way:

By default WCF doesn’t allow to carry out more than few bytes on our messages, but because we are retrieving a list of 800 entities … we should increase this parameter.
Remember that everything has a cost in resources and it is not a good practice to send and receive a lot of megabytes of message content. Consider using pagination and other tricks.

Now we need to expose this service on a web site. Why? Because when we will develop the UI we will add a reference to an host web site service, like http://raffaeu.com/service/Customer.svc and not to a dev address like http://localhost:9080/PrismTutorial…

Create a host web site and install it on IIS 7.

We need to add a new web site application on our solution, but it has to be a WCF Service web site solution, like the picture below:

Delete all the content except the service.svc file and the web.config.

First add a new reference to our project ServiceLibrary.
Then add the connection string to the web.config file.

Finally, change the service.svc to customer.svc and change the HTML code in this way:

  1: <%@ 
  2:    ServiceHost Language="C#" 
  3:    Debug="true" 
  4:    Service="PrismTutorial.ServiceLibrary.CustomerService" 
  5: %>

Cool, now let’s modify the web.config of our WCF web site and we are done.

I just said to the new endpoint to point to our .dll service library and to expose the contract IServiceContract. The same step we did previously to the service library layer.

If you now press F5 you can see the process running under ASP.NET. Of course we need to install it on IIS in order to have a common address for our future services. Because the web site points to our project, every time we will change the WCF library this will automatically change in the web service. Of course when we will create new contracts we will need to define new endpoint in both layers.

Note: if you have, like me, Windows 7 and you want to follow this step, you need to install and configure IIS 7 and WCF for IIS. You can do that by following this simple and useful post.

Open IIS 7 and install the new application by creating a new application that will point to our project:

If everything is ok, you will be able to browse the folder of this web.app, click on the .svc file, and select Browse.

You should get this result:

Considerations.

This tutorial shows how to create and host a WCF service using Visual Studio and IIS 7. Starting from the next tutorial I will not show you anymore this part as you can use this article as a reference.

We will create new services and contracts and we will call them asynchronously inside WPF UI.

I use this approach to get the data on my applications as I can manage better the points of failure of my applications and keep the code separated and clean. If something change on the customer service I can simply add a new method and all the previous versions of my software will continue to work. If my WCF service crashes I can change the web app to point to a different .dll and everything will continue to work.

Stay tuned as from the next time we will start to build the UI. We will talk about Prism, regions IoC and more.

Tags: WCF WPF Prism Composite application

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 05.

Raffaeu — Sun, 08 Nov 2009 14:24:00 GMT

Update: source code and documentation are now available on CodePlex at this address: http://prismtutorial.codeplex.com/

Starting with WCF.

Today we will see how WCF works and what are the best practices we should use in order to keep our application safe and maintainable.

WCF startup.

I assume that you know already what is WCF and what’s the difference between WCF and the old Web Service technology. If you don’t, this is a nice overview of WCF, and this is a nice overview of the differences from these 2 technologies.

The big difference from using a normal data access layer and a SOA service is in the architecture. We must keep in consideration, always, that we are working with a message service and that all the information are serialized and passed through the network. This point it’s really important because the most common error I saw using WCF is to serialize directly the entities in the domain model …

Let’s keep as an example our Customer entity.

We have a lot of information in this graph and I am pretty sure that we will use those information only when we will look at the details of each customer, so it completely doesn’t make any sense to carry all these information with us for all the time.

Let’s have a break and let’s see what will be the final result of our application using a sketch. (I use Microsoft Expression Blend sketch available for trial here). The style is modified by me to reflect Balsamiq, another Sketch flow design software.

What we will do, when the navigation bar will be open to the Customer section, we will load a list of Customers, but we need only the Id and a FullName that will represent the customer. Then if the user will click on a customer, we will load an additional view with all the details. To accomplish this data transformation we will use a Dto (Data transfer object)

“The Data Transfer Object "DTO", is a simple serializable object used to transfer data across multiple layers of an application. The fields contained in the DTO are usually primitive types such as strings, boolean, etc. Other DTOs may be contained or aggregated in the DTO.”

directly inside WCF. In this way we will have a light version of our customer entity that will be carried over the network.

Customer Dto.

Let’s create a new WCF project in our solution and add a new class. The class will be a serialized light version of our Customer entity.

  1: using System.Runtime.Serialization;
  2: 
  3: namespace PrismTutorial.WCF {
  4: 
  5:     [DataContract]
  6:     public class CustomerDto {
  7:         [DataMember]
  8:         public int Id { get; set; }
  9:         [DataMember]
 10:         public string FullName { get; set; }
 11:     }
 12: }
 13:

First of all, the DataContract attribute. This attribute identifies the entity CustomerDto as serializable. Through the attribute DataMember we are saying that both the Id and the FullName properties will be serialized.

In order to use this Dto, we need a service contract that will allows us to do some simple operations with the Dto. The service contract will expose the operations that we will allow to the end user.

Let’s add a new interface on our WCF project that will look in this way:

  1: using System.Collections.Generic;
  2: using System.ServiceModel;
  3: 
  4: namespace PrismTutorial.WCF {
  5: 
  6:     [ServiceContract]
  7:     interface ICustomerService {
  8:     
  9:         [OperationContract]
 10:         void AddCustomer(CustomerDto customer);
 11:         
 12:         [OperationContract]
 13:         void DeleteCustomer(CustomerDto customer);
 14:         
 15:         [OperationContract]
 16:         IList<CustomerDto> GetCustomers();
 17:     
 18:     }
 19: }
 20:

The two attributes that we use now are ServiceContract and OperationContract. The first one will identify the Interface as a WCF contract. Using this attribute we are going to say to WCF: “Hey this is the contract that I want to expose, so let’s look inside and see if there is anything useful for you”.

The second attribute is identifying our method as visible to the contract. Of course we can have also some methods that we want to include in the service but that we don’t want to expose to the public.

After that we need to implement in a concrete class our contract and implement the operations. This is just an example so we will have an internal IList of Dto and we will use the operations just to interact with the list exposed by the service.

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Web;
  5: using System.ServiceModel;
  6: 
  7: namespace PrismTutorial.WCF {
  8:     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
  9:     public class CustomerService : ICustomerService {
 10: 
 11:         IList<CustomerDto> Customers = new List<CustomerDto>();
 12: 
 13:         #region ICustomerService Members
 14: 
 15:         public void AddCustomer(CustomerDto customer) {
 16:             Customers.Add(customer);
 17:         }
 18: 
 19:         public void DeleteCustomer(CustomerDto customer) {
 20:             Customers.Remove(customer);
 21:         }
 22: 
 23:         public IList<CustomerDto> GetCustomers() {
 24:             return Customers;
 25:         }
 26: 
 27:         #endregion
 28:     }
 29: }
 30:

The only notable thing here is the attribute ServiceBehavior that explains how our service will be created. In this case we said that the first call will activate the service, so it’s like using a SingleTon pattern. Of course the service behavior attribute has a lot of options.

We can also use this code in order to be sure that our entity will be correctly removed. Change the intenal IList to a List<T> and change the DeleteCustomer method in this way:

  1: public void DeleteCustomer(CustomerDto customer) {
  2:    Customers.Remove(Customers.Find(
  3:       c => c.Id.Equals(customer.Id))
  4:    );
  5: }
  6:

Configure the service.

Now that we have our basic service we have to build the solution CTRL+SHIFT+B and then right click on the app.config and select Configure. We will see a window like this one:

First of all click on service one and point to the compile .dll in order to have the service to Customer Service and not Service1.

Now select the endpoint in the service node and again, change it to point to our .dll and select the ICustomerService.

Now if you press F5 and set the WCF as the startup project, you will be prompt by this windows that is the default test window of Visual Studio 2008 for WCF.

By clicking on a method you will be prompted by a default view that allows us to interact with the service in testing mode.

You can test it by using the addCustomer a couple of times and then the GetCustomers. You will find in the message the customers you previously added.

Considerations.

In this post we saw how WCF works so now we can do our considerations and create the service for each entity or view, it depends on how you want to structure your software. Of course we should do something better like sending a response message each time we do an operation, or get back the changed list of customers each time we do a CRUD operation.

The are also other considerations using WCF and attributes that we didn’t see this time. This will be part of the next tutorial.

Finally, I want to give you some tips using WCF that I have found in the pattern and practices on MSDN web site.

Always consider to use versioning with your data contracts
http://msdn.microsoft.com/en-us/library/ms733832.aspx
Version you contract to avoid “breaking changes”
http://msdn.microsoft.com/en-us/library/ms731060.aspx
Load balancing with WCF
http://msdn.microsoft.com/en-us/library/ms730128.aspx
Mehran Nikoo best practices
http://mehranikoo.net/CS/archive/2008/05/31/WCF_5F00_Best_5F00_Practices.aspx
Web service software factory for creating robust WCF applications
http://msdn.microsoft.com/en-us/library/cc487895.aspx

Enjoy this tutorial and stay tuned for the next one!

Tags: WCF Prism WPF Composite application

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 04.

Raffaeu — Sun, 01 Nov 2009 19:41:00 GMT

Service Oriented Application.

Introduction.

The first problems I always encounter when I design a scalable, multi-tier application are:

Work on a disconnected environment but be able to work with the data previously downloaded.
Keep always the data up to date, notify the users when the data changes.
Threading and UI performances, do not provide frozen screen when the user requests the data.
Synchronization from the database and the disconnected environment.

Those are common problems of a complex software and can be solved using a SOA service solution and WPF for the UI. Of course WPF and WCF by themselves cannot help us without a strong and well designed solution.

The idea of having a SOA service for the communication will give us the ability to design something like this:

Where we will have 1 or more databases, remotely stored somewhere; a distributed SOA service that will allow our software to operate with the remote data, and maybe to have also some security concerns; the final Client application that will be build using some techniques, in order to use the full power of this kind of solution.

Of course this sketch is fancy and cool but it doesn’t give us anything more than a .PNG file that we can present to the CTO or to the customer! What you have to do in order to transform the sketch in a real solution, it’s complex and hard.

Consideration when working with SOA Services.

The first consideration we have to do, if we decide to leave the DAL on a remote web service, and work with a completely disconnected environment, is the data synchronization and the data concurrency.

Let’s make a very simple self explanatory workflow.

We have the order 10-AED-2020 and is opened remotely by 3 employees in the same time. Everyone makes a change to the row, and then they all try to save the changes. What will happen? … a mess …

Usually, what I do, is to “virtually” lock the record so when someone else try to open the row, the UI notifies that the row is already opened by someone else. Then when the “someone else” save or close the row, we notify the changes to everybody.

The second problem can be called routing messaging approach.
Also for this problem I have drawn a simple workflow. (Sorry guys but I love Visio!)

The process is described below:

The Vendor requests for a new order
The software submit the request to the service and wait
The service creates the order
The service gives back to the client the new order created

As you can see we can have two different type of message: a single way message (the request) and a request and response message (create order), that has a delay time.

Of course there are many others considerations but for now this is enough for what we are going to do.

Some interesting articles.

Before writing XML or C# code I wish you will have the time to read those articles that I have found really interesting, especially if you had never step into an n-tier application.

MSDN – Build service oriented app

The Entity Framework In Layered Architectures

Patterns for Flexible WCF services

In the next tutorial we will write the code to exposes our entities through WCF, but of course we will not expose directly them but an “alias”. I will show the differences from using a DTO or something else.

Stay tuned!

Tags: WCF WPF Prism Composite application

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 03.

Raffaeu — Sun, 01 Nov 2009 13:56:00 GMT

Update: source code and documentation are now available on CodePlex at this address: http://prismtutorial.codeplex.com/

Value and business validation with Enterprise Library 4.1 and Entity Framework.

In this article I will show you how to validate a domain using the enterprise library 4.1 over the Entity Framework.

First of all I want to talk about the validation and the thousands of implementations you can find over the web. In my opinion there are 2 different types of validation. The value validation and the business validation.

What’s the difference? The first, the value validation should validate an entity against it’s value content. For example, the entity order should have a validation of type NotNull inside it’s Id field, or a LengthValidation inside it’s order number, in order to reflect the corresponding field in the database table. In this way we will execute a value validation in our domain model, before sending the data to the Data Access Layer.

The second validation is the business validation and it can be accomplished with a lot of different ways. The most common is the hard coded way that personally, I don’t really like it. What’s a business validation? Let’s say we have an order entity and we have a rule that says “if the total order is grater than 1,000 $ apply 10% of discount”. This is a business rule that force our entity to change its value after some business considerations.

Available validation framework for NET.

I use for my value validation the Enterprise Library Validation block and I have found it really useful. The only problem is that this framework forces you to use the decorator pattern, so we hard code our entity with the value validation rules. This approach is fine, but only if related to the values. You can also include the value validation in a separate XML file, and this is the solution we will use later.

Another interesting framework is the Validation Framework project on Codeplex, that similar to the EL, uses decorator and generics to validate our entities.

Very powerful but with an high learning curve is the powerful SPRING.NET framework, that inside its application blocks has a space also for the validation. What I really like about SPRING.NET is the fact that you will not hard code anything because the entire validation is in a separate XML file. But remember that the learning curve is pretty complex because SPRING.NET is a full IoC tool, so everything is under the concept of be “Injected”.

Finally, my friend Simone Chiaretta, suggested me this open source framework: Fluent Validation, that has a nice procedural implementation:

  1: using FluentValidation;
  2: 
  3: public class CustomerValidator: AbstractValidator<Customer> {
  4:   public CustomerValidator() {
  5:     RuleFor(customer => customer.Surname).NotEmpty();
  6:     RuleFor(customer => customer.Forename).NotEmpty().WithMessage("Please specify a first name");
  7:     RuleFor(customer => customer.Company).NotNull();
  8:     RuleFor(customer => customer.Discount).NotEqual(0).When(customer => customer.HasDiscount);
  9:     RuleFor(customer => customer.Address).Length(20, 250);
 10:     RuleFor(customer => customer.Postcode).Must(BeAValidPostcode).WithMessage("Please specify a valid postcode");
 11:   }
 12: 
 13:   private bool BeAValidPostcode(string postcode) {
 14:     // custom postcode validating logic goes here
 15:   }
 16: }
 17: 
 18: Customer customer = new Customer();
 19: CustomerValidator validator = new CustomerValidator();
 20: ValidationResult results = validator.Validate(customer);
 21: 
 22: bool validationSucceeded = results.IsValid;
 23: IList<ValidationFailure> failures = results.Errors;
 24:

The only real business validator framework for NET that I know and that I use in production is IBM iLOG for NET a real powerful engine for business validation that keeps separate your domain model from the business rules. It’s cool and probably it needs just 10 articles only in order to describe it, so you can have a look at the official web site. This is a simple screenshot of how it works:

Enterprise Library Validation with Entity Framework.

The first problem we have using this framework is the way we can apply the decorator pattern on it. Why? Because in Visual Studio the EF model is built through a DSL tool called Entity Framework designer. So each time we change the model, our validation decorations are lost through the way …

So let’s add a reference to the enterprise library validation block in our project and let’s try to understand how we can use them in a productive way.

The first approach is to overwrite with the partial attribute our domain entity is a way like this one:

  1: public partial class Customer {
  2:     
  3:     public bool IsValid { get { return Validate(); } }
  4: 
  5:     private bool Validate() {
  6:         //validation implementation
  7:         return true;
  8:     }
  9: }

and then validate the entity inside the Validate method. Of course because we cannot use the partial attribute for a property we need to find a different way to grab our validation attributes. From XML?

Good so first of all we need a basic validation class that will validate every single entity using the generics. This solution is the only affordable because the entity generated with EF inherits already from EntityObject class.

  1: public static class EntityValidator<T> {
  2: 
  3:     public static Dictionary<string,string> ValidationErrors { get; set; }
  4: 
  5:     public static bool Validate<T>(T entity) {
  6:         ValidationResults results = Validation.ValidateFromConfiguration<T>(entity);
  7:         if (results.IsValid) {
  8:             return true;
  9:         } else {
 10:             foreach (var error in results) {
 11:                 ValidationErrors.Add(error.Key, error.Message);
 12:             }
 13:             return false;
 14:         }
 15:     }
 16: 
 17: }
 18:

Now we can do the validation in this way from the repository, for example:

  1: public int Add<T>(T entity) {
  2:     ADVConnection context = GetObjectContext();
  3:     if (EntityValidator<T>.Validate(entity)) {
  4:         context.AddObject(typeof(T).Name, entity);
  5:         int result = context.SaveChanges();
  6:         ReleaseObjectContextIfNotReused();
  7:         return result;
  8:     }
  9:     return -1;
 10: }
 11:

An then we can handle that return –1 in a way that we prefer, maybe we can catch it in the “presenter” and interact with the UI. We just need to keep alive the validation errors generated by the method Validate<T>.

Entity Framework mapping file.

The Entity Framework works similar to NHibernate, so for each business object we have a mapping file. If you open the .edmx file with a right click->open with-> XML editor, you will get an XML representation of your model, similar to this file:

  1: <EntityType Name="Customer">
  2:   <Key>
  3:     <PropertyRef Name="CustomerID" />
  4:   </Key>
  5:   <Property Name="CustomerID" Type="int" Nullable="false" StoreGeneratedPattern="Identity" />
  6:   <Property Name="NameStyle" Type="bit" Nullable="false" />
  7:   <Property Name="Title" Type="nvarchar" MaxLength="8" />
  8:   <Property Name="FirstName" Type="nvarchar" Nullable="false" MaxLength="50" />
  9:   <Property Name="MiddleName" Type="nvarchar" MaxLength="50" />
 10:   <Property Name="LastName" Type="nvarchar" Nullable="false" MaxLength="50" />
 11:

As you can see, we have already all the rules in place, so we do not need to declare anything. For example, the EF already knows that the Title field should be at most, 8 characters long and can be null. Unfortunately, with the version 3 of EF those rules cannot be connected to the Enterprise Library, easily.

How we can handle this in our static validator using generics?

Close you Visual Studio solution, and navigate to your Enterprise Library installation folder.

Open the .exe called EntLibConfig.exe. The first screenshot you will se is something like this:

Click on the file menu and open the app.config file in the layer PrismTutorial.DataLayer.App.Config and you will load the configuration file inside this tool.

Now, click on the root of your application and select new validation application block. The result should something like this:

Now we can create a Rule, or a Rule Set and then we can load our domain model and associate those rules with every entity.

In order to load the domain model, choose new Type, in the type window, select the PrismTutorial.DataLayer.DomainModel.dll using this button:

At this point you can use the search filter of this window to load one entity per time. I started with the Customer entity. The final result is this one:

Finally, right click on the customer and select new rule set and give it a name. In this rule set we will contain all the rules associated with this entity.
Now, on the ruleset node, choose select members and here it’s the magic!!

Finally, you will have now the node Customer showing for every loaded field, an additional node. From here you can select any field and add a new validator. You can include the message template, the type of validation and so on …

This is my final result:

If you open Visual Studio, you will find the app.config file changed. Of course you cannot change the app.config file when the solution is open because in my case, I work under source control and the app.config is locked.

  1:   <configSections>
  2:     <section name="validation" type="Microsoft.Practices.EnterpriseLibrary.Validation.Configuration.ValidationSettings, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
  3:     <section name="dataConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Data.Configuration.DatabaseSettings, Microsoft.Practices.EnterpriseLibrary.Data, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
  4:   </configSections>
  5:

And the Customer validation rules.

  1:     <type defaultRuleset="CustomerValidation" assemblyName="PrismTutorial.DataLayer, Version=1.0.0.0, Culture=neutral, PublicKeyToken=d5210384f83ebb19"
  2:       name="PrismTutorial.DataLayer.Customer">
  3:       <ruleset name="CustomerValidation">
  4:         <properties>
  5:           <property name="CustomerID" />
  6:           <property name="NameStyle" />
  7:           <property name="Title" />
  8:           <property name="FirstName" />
  9:           <property name="MiddleName" />
 10:           <property name="LastName" />
 11:           <property name="Suffix" />
 12:           <property name="CompanyName">
 13:             <validator negated="false" messageTemplate="Company name cannot be null."
 14:               messageTemplateResourceName="" messageTemplateResourceType=""
 15:               tag="" type="Microsoft.Practices.EnterpriseLibrary.Validation.Validators.NotNullValidator, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
 16:               name="Not Null Validator" />
 17:             <validator lowerBound="0" lowerBoundType="Ignore" upperBound="100"
 18:               upperBoundType="Inclusive" negated="false" messageTemplate="Company Name cannot be long more than 100 characters."
 19:               messageTemplateResourceName="" messageTemplateResourceType=""
 20:               tag="" type="Microsoft.Practices.EnterpriseLibrary.Validation.Validators.StringLengthValidator, Microsoft.Practices.EnterpriseLibrary.Validation, Version=4.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
 21:               name="String Length Validator" />

Finally I just want to remember you that you can integrate this editor inside Visual Studio 2008 SP1.

Note: With Visual Studio 2010 and the Entity Framework 4.0, this problem is going to be deprecated because the EF 4 allows us to build POCO object like in NHibernate, so we can then use the decorator pattern or any other type of validation pattern.

Tags: Prism WPF WCF Composite application

Book review: Beginning ASP.NET MVC 1.0

Raffaeu — Sun, 25 Oct 2009 15:45:00 GMT

A dear friend of mine, Simone Chiaretta, ASP.NET MVP wrote an interesting book about ASP.NET MVC in collaboration with Keyvan Nayyeri.

The book is Beginning ASP.NET MVC 1.0, edited by Wrox, available on Amazon.com at this address for the price of 31.49 USD.

I am going to write a review of this book because, first of all, I know Simone and his professionalism. Second, because I am working now on an ASP.NET MVC project in my company, and this book was really helpful for me, so I am pretty sure that it will be the same for you guys.

Summary and structure of the book.

The book has 19 chapters plus a couple of appendixes. Each chapter covers a specific argument. At the end of each chapter there is always a section for the exercises and a summary section. The first thing you will like about this book is the huge amount of sample code!

At the end of the book there is the appendix B that contains all the solutions related to each exercise, so you won’t get lost.

The appendix A has a lot of useful links that you can follow, resources, links, books and more.

Finally there is the index that is done for a “dev” reader. It’s not a normal index but an index divided by alphabetic order that includes also all those components and “code” that you will find in the book. So you will find, for example, the page that talks about “NHibernate”.

Case studies.

What I really liked about this book is the 2 case studies that you will find at the end. Simone has created these 2 case studies that will reflect 2 real solutions, one is a blog and the second one is … a surprise. I am not going to tell you everything because you must buy it.

This is something really well done as you will apply all the knowledge you got through the book into 2 real solutions!

Chapters.

Of course I am not going to describe each chapter, but this is the list of chapters so you can understand why this book is so well done, IMHO:

MVC pattern
WebForm VS MVC
Getting started
The model
The controller
The view
Routing
Unite test concepts
Testing ASP.NET MVC
Components
Action filters
AJAX
Deployment
Leveraging ASP.NET WebForm futures
Authentication and authorization
Extend ASP.NET MVC
Migrating from ASP.NET
Case studies
Resources
Exercises solutions

Final Considerations.

I am a NET developer, most of time I develop Silverlight/WPF or WinForm applications. For fun I did a couple of ASP.NET MVC applications in the bank where I was working before, but my knowledge about ASP.NET MVC was relative to those projects.

Now that I got this book, I was able to read all the aspect of MVC pattern applied to ASP.NET and I feel comfortable to build a real application with this framework.

I did a real ASP.NET MVC application for the Company where I am working now, and I was able to do everything is less than 1 week, including the use of JQuery and AJAX.

I am really satisfied of this book and I hope that you will buy it as it is a very nice and well written book that will drive you inside this pretty cool framework.

Thanks Simone and Keyyvan for your effort!

Tags: Beginning ASP.NET MVC 1.0

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 02.

Raffaeu — Sun, 25 Oct 2009 14:05:00 GMT

Update: source code and documentation are now available on CodePlex at this address: http://prismtutorial.codeplex.com/

Build a generic repository with the Entity Framework.

In the previous series of articles about M-V-VM we used the AdventureWorks database, available on CodePlex.
After this article (configure a data layer with LinQ-to-SQL) I have got some reader’s emails asking me this and that. So, I am going to give you all those answers right now.

Download and configure the Adventure Works database.

On my dev PC I have SQL Server 2008 Standard version, but this tutorial is working also with the express or any other version.

Go to CodePlex Adventure Works web site project and download the AW available version (light and full). I have downloaded the package called ”Adventure Works All Databases”.
Go into the folder tree Tools/Samples and you will find the .mdf and .ldf and also the T-SQL script if you want to run it from a prompt command line.
Open your SSMS and from the master database, install the version that you prefer. My samples work with both version, as I use always the Adventure Works LT (Light version).

Mandatory: as I use Windows Authentication in all my samples, you must fix that in your local Db and change the connection string in my samples.

Open Visual Studio and create the folder three.

As we are going to work with an enterprise application, in order to simulate the 3 tiers, I have created 3 solution folders, one for the data service, one for the client part and one for the test. We will expand these folders during the building process.

The initial solution three will be:

Solution name: PrismTutorial
DataLayer: PrismTutorial.DataLayer
TDD: Test.DataLayer
Consuming Service: PrismTutorial.WCF

Working with Entity Framework.

In the first series of tutorials, we used LinQ-to-SQL because:

It’s easier, It’s faster, It uses the relation 1 to 1 with the database tables and so on.

For this tutorial we are going to use the Entity Framework because this one is the real OR/M coming from Microsoft so in an enterprise application it’s better to spend more time and effort on building something stronger and reusable.

Open you VS data layer solution, right click and add an new component, ADO.NET Entity Data Model and configure it to reflect the Adventure Works LT database installed into your machine.

After that VS will show up a entity model designer window very similar to the one that we used with Linq-to-SQL.

If you want to be compliant with my settings, this is how I have configured my Entity Framework:

It’s time to play, the Entity Framework repository wrap!

Like any software architect, I try to fit always everything in a more generic, reusable and more readable pattern. If we want to have a reusable UnitOfWork associated with a Repository engine, we must wrap the Entity Framework inside something more generics. Here comes the pain ….

The final result I would like to have is this one:

IRepository interface.

First of all we have to define a generic contract (interface) that we will use as our repository. As we want to be generic we need something like this:

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq.Expressions;
  4: 
  5: namespace PrismTutorial.DataLayer {
  6:     public interface IRepository:IDisposable {
  7:         //Add a new Entity
  8:         int Add<T>(T entity);
  9:         //Count the number of entities available
 10:         long Count<T>();
 11:         //Count using a filer
 12:         long Count<T>(Expression<Func<T, bool>> expression);
 13:         //Delete an existing entity
 14:         int Delete<T>(T entity);
 15:         //List all the available entities
 16:         IList<T> GetAll<T>();
 17:         //List the entities using a filter
 18:         IList<T> GetAll<T>(Expression<Func<T, bool>> expression);
 19:         //Get a single entity
 20:         T GetSingle<T>(Expression<Func<T,bool>> expression);
 21:         //Update an existing entity
 22:         int Update<T>(T entity);
 23:     }
 24: }
 25:

At this point we have a generic implementation of the repository pattern and we do not need to worry about what we are going to save, update or delete.

BaseRepository to handle the dispose of the data context.

The second problem that we have to fix is more related to how the entity framework uses the context in a web application. I have found this article over the web: http://blog.zoolutions.se/post/2009/03/26/Generic-Repository-for-Entity-Framework.aspx, really interesting, so I am going to use the same type of solution.

We need a simple base class that is going to handle the data context and close it if not needed. We can also use the using clause in each method of our repository. I want to use this solution just because it’s more clean and doesn’t force me to write too much code inside the final repository.

  1: using System;
  2: using System.Collections.Generic;
  3: using System.Linq;
  4: using System.Text;
  5: 
  6: namespace PrismTutorial.DataLayer {
  7:     public abstract class BaseRepository {
  8:         //Our entity framework engine used in the solution
  9:         internal ADVConnection _context;
 10:         //Switch that tells us if the datacontext is reused
 11:         internal bool _contextReused;
 12:         
 13:         //This return the current, or a new connection through the EF
 14:         public ADVConnection GetObjectContext() {
 15:             if (!_contextReused) {
 16:                 return new ADVConnection();
 17:             }
 18:             return _context;
 19:         }
 20: 
 21:         //This is the public method that we will call from our repository
 22:         public void ReleaseObjectContextIfNotReused() {
 23:             if (!_contextReused) {
 24:                 ReleaseObjectContext();
 25:             }
 26:         }
 27: 
 28:         //Simple dispose of the current EF
 29:         public void ReleaseObjectContext() {
 30:             if (_context != null) {
 31:                 _context.Dispose();
 32:             }
 33:             _contextReused = false;
 34:         }
 35:     }
 36: }

Cool, we just need now to wrap all together and play with the data.

The concrete repository.

For the repository pattern there are two implementations, one is to keep everything generic and have 1 repository for the entire domain. The second one is to have a repository for each entity, like UserRepository, ProductRepository, and implement the CRUD operations related to the entity, like AddUser, AddProduct and so on.

I would suggest the second solution only if you need to include some business logic in your CRUD operations or there are some special development requirements. So let’s go for the easier and faster solution, he first one.

In the constructor of our repository we need to pass an instance of the UnitOfWork that in our case is the Entity Framework, like we do with the session with NHibernate.

  1: namespace PrismTutorial.DataLayer {
  2:     public class Repository:BaseRepository,IRepository {
  3: 
  4:         #region Base Implementation
  5: 
  6:         private bool _disposed;
  7:         //Here we pass the connection and we flag the contextReused
  8:         //so we can use the repository with the using clause ...
  9:         public Repository(ADVConnection context) {
 10:             this._context = context;
 11:             this._contextReused = true;
 12:         }
 13: 
 14:         #endregion

Then we have also to implement the IDisposable interface in order to clean-up the connection after each call:

  1:         #region Disposable
  2:         //Dispose implementation
  3:         public void Dispose() {
  4:             DisposeObject(true);
  5:             GC.SuppressFinalize(this);
  6:         }
  7:         //Distructor
  8:         ~Repository() {
  9:             DisposeObject(false);
 10:         }
 11:         //Concrete private implementation of the dispose method
 12:         private void DisposeObject(bool disposing) {
 13:             if (_disposed) {
 14:                 return;
 15:             }
 16:             if (disposing) {
 17:                 if (_context != null) {
 18:                     _context.Dispose();
 19:                 }
 20:                 _disposed = true;
 21:             }
 22:         }
 23:         #endregion

Now we can go ahead and implement each C.R.U.D. method and reflects the changes in the entity framework.

The save method is pretty straightforward, we add an object to our context, using it’s FullTypeName and we persist the changes in the database.

  1:         public int Add<T>(T entity) {
  2:             ADVConnection context = GetObjectContext();
  3:             context.AddObject(typeof(T).Name, entity);
  4:             int result = context.SaveChanges();
  5:             ReleaseObjectContextIfNotReused();
  6:             return result;
  7:         }

Same for the count methods except that we have to create an ObjectQuery that it’s nothing more than a translated query using the T object passed as a parameter.

  1:         public long Count<T>() {
  2:             ADVConnection context = GetObjectContext();
  3:             var query = new ObjectQuery<T>(
  4:                 typeof(T).Name, 
  5:                 context, 
  6:                 MergeOption.NoTracking);
  7:             int count = query.Count();
  8:             ReleaseObjectContextIfNotReused();
  9:             return count;
 10:         }
 11: 
 12:         public long Count<T>(Expression<Func<T, bool>> expression) {
 13:             ADVConnection context = GetObjectContext();
 14:             var query = new ObjectQuery<T>(
 15:                 typeof(T).Name, 
 16:                 context, 
 17:                 MergeOption.NoTracking)
 18:                 .Where(expression);
 19:             int count = query.Count();
 20:             ReleaseObjectContextIfNotReused();
 21:             return count;
 22:         }
 23:

The only part that you may not know is the parameter MergeOption used in the objectquery constructor. MergeOption has the following values (from the source of the NET Framework) :

  1: namespace System.Data.Objects {
  2:     // Summary:
  3:     //     Specifies how objects being loaded into the object context are merged with
  4:     //     objects already in the object context.
  5:     public enum MergeOption {
  6:         // Summary:
  7:         //     Objects that already exist in the object context are not loaded from the
  8:         //     persisted store. This is the default behavior for queries or when calling
  9:         //     the System.Data.Objects.DataClasses.EntityCollection<TEntity>.Load(System.Data.Objects.MergeOption)
 10:         //     method on an System.Data.Objects.DataClasses.EntityCollection<TEntity>.
 11:         AppendOnly = 0,
 12:         //
 13:         // Summary:
 14:         //     Objects are always loaded from the persisted store. Any property changes
 15:         //     made to objects in the object context are overwritten by the store values.
 16:         OverwriteChanges = 1,
 17:         //
 18:         // Summary:
 19:         //     When an object exists in the object context, it is not loaded from the persisted
 20:         //     store. Any property changes made to objects in the object context are preserved.
 21:         //     This is used to force changes to objects in the object context to save successfully
 22:         //     after an System.Data.OptimisticConcurrencyException has occurred. For more
 23:         //     information, see Saving Changes and Managing Concurrency (Entity Framework).
 24:         PreserveChanges = 2,
 25:         //
 26:         // Summary:
 27:         //     Objects are maintained in a System.Data.EntityState.Detached state and are
 28:         //     not tracked in the System.Data.Objects.ObjectStateManager.
 29:         NoTracking = 3,
 30:     }
 31: }
 32:

Then we need to implement the delete command. Because we are working on a disconnected environment, first of all we need to get the original object from the repository. Then, we delete it.

  1: public int Delete<T>(T entity) {
  2:     ADVConnection context = GetObjectContext();
  3:     object originalItem;
  4:     EntityKey key = context.CreateEntityKey(typeof(T).Name, entity);
  5:     if(context.TryGetObjectByKey(key, out originalItem)){
  6:         context.DeleteObject(originalItem);
  7:     }
  8:     int result =  context.SaveChanges();
  9:     ReleaseObjectContextIfNotReused();
 10:     return result;
 11: }
 12:

Now the easy part, GetAll and GetAll using an expression for the criteria.

  1: public IList<T> GetAll<T>() {
  2:     ADVConnection context = GetObjectContext();
  3:     IList<T> list = context
  4:         .CreateQuery<T>(
  5:         "[" + typeof(T).Name + "]")
  6:         .ToList();
  7:     ReleaseObjectContextIfNotReused();
  8:     return list;
  9: }
 10:

With the criteria:

  1: public IList<T> GetAll<T>(Expression<Func<T, bool>> expression) {
  2:     ADVConnection context = GetObjectContext();
  3:     IList<T> list = context
  4:         .CreateQuery<T>(
  5:         "[" + typeof(T).Name + "]")
  6:         .Where(expression)
  7:         .ToList();
  8:     ReleaseObjectContextIfNotReused();
  9:     return list;
 10: }
 11:

Just a little note here. If you watch this piece of code:

.CreateQuery<T>(
"[" + typeof(T).Name + "]") here I am using the CreateQuery method to get an ObjectQuery object using the generics. Unfortunately this method requires the name of the entity, so we use Reflection and get the name with the method typeof.

The GetSingle method is the same, we just retreive the FirstOrDefault result of our query:

  1: public T GetSingle<T>(Expression<Func<T, bool>> expression) {
  2:     ADVConnection context = GetObjectContext();
  3:     T result = context
  4:         .CreateQuery<T>(
  5:         "[" + typeof(T).Name + "]")
  6:         .Where(expression)
  7:         .FirstOrDefault();
  8:     ReleaseObjectContextIfNotReused();
  9:     return result;
 10: }
 11:

And finally, the update method that is going to save the changes we did to an entity.

  1: public int Update<T>(T entity) {
  2:     ADVConnection context = GetObjectContext();
  3:     object originalItem;
  4:     EntityKey key = context.CreateEntityKey(typeof(T).Name, entity);
  5:     if(context.TryGetObjectByKey(key, out originalItem)){
  6:         context.ApplyPropertyChanges(typeof(T).Name,entity);
  7:     }
  8:     int result = context.SaveChanges();
  9:     ReleaseObjectContextIfNotReused();
 10:     return result;
 11: }
 12:

Like we did with the delete method, first of all we need to retrieve the original instance of the entity, then we simply apply the changes we got from the “working” entity, using the method ApplyPropertyChanges and finally we save everything.

Conclusions.

In this article we saw how to work with the entity framework and build a repository pattern around it. The next step will be to include business and value validation to our entities. We will use the enterprise library 4.1.

Stay tuned!

Tags: WPF Prism Entity Framework WCF

Build enterprise application with WPF, WCF, Entity Framework and Prism. Tutorial 01.

Raffaeu — Sun, 20 Sep 2009 19:29:39 GMT

Update: source code and documentation are now available on CodePlex at this address: http://prismtutorial.codeplex.com/

In these series of articles I will show you how to build an enterprise application using the most recent Microsoft’s technologies like: WPF with PRISM for the UI, Entity Framework for the Data Layer and WCF for the persistence service.

Specifications.

We will build a 3 tiers application that will spread the responsibility through 3 different machines (virtually because the Visual Studio solution is only one).

SQL Server
It will contain the database and the database objects
IIS 7
Data access layer with Entity Framework
WCF host service for the persistence
WCF host service for the security access
PRISM (Composite WPF application)
This layer will use the PRISM pattern to render a WPF modular application

This is the schema of our tiers:

Prerequisites and Source code.

As I did for my previous series of post about MVVM and WPF, I will share a CodePlex project for anyone of you that want to reuse the project for professional or testing purposes, I will use the Adventure works database available in the CodePlex web site and I will use the PRISM pattern.

Prerequisites:

Visual Studio 2008 with SP1 available for trial on Microsoft web site.
NET 3.5 SP1 available on MSDN.
SQL Server 2008 Express Edition.

As we are going to use some very well known patterns and methodologies, like: Factory pattern, Inversion of Control, POCO objects, Test Driven Development; I suggest to anyone of you to have a look at:

Martin Fowler articles and patterns.
Gang of Four NET patterns.
Composite UI Application for Silverlight and WPF.
At least, basic knowledge of XAML syntax and how WPF works.

Those are part of the patterns and methodologies we will use. It is not mandatory to know them but if you have at least a look, it will be easier to follow the next articles.

For today it’s enough, be ready with your PC and from the next article we will start to build the database and the Data access layer.

Tags: WPF PRISM Entity Framework WCF

Virtualizing SQL Server, some tips.

Raffaeu — Wed, 26 Aug 2009 17:17:00 GMT

I just got these considerations about virtualizing SQL Server on VMWare from my Boss and I would like to share them with you.

General comments on problems encountered and why people not virtualizing SQL

Storage ( most people just do not have enough spindles to start with and then when people consolidate they use less spindles not more, error in design and understanding of basic i/o principles )
Queue lengths are a problem so add as many paths to storage as possible.
Using vmware makes sequential reads look more like random reads due to interleaving of traffic across vm’s
Ensure all dbs ( data, temp, log etc ) are on separate vmdks or preferably rdms, improves i/o queue throughput
Memory ( ensure you set min, max reservations per vm to avoid swapping )
1 database instance per vmhost ( to allowing you to tweak memory / priorities as required )
Use the latest intel chips, as provide biggest reduction in latencies for vm tasks

Following a thru 6 results in linear performance until the cpu saturates around 90%.

Basically they said VMware is never the bottleneck ...

Assuming the rules above are followed you should then consider tweaking the following:

Tweak the o/s first to allow large pages and ensure alignment with storage ( gives +6% improvement )
Turn on sql priority boost in SQL and ensure correct O/S drivers installed in host ( gives +14% when used with 1. )
Turn on static transmit coalescing in ESX networking ( gives +1%, so they advise don’t bother )

They are interesting considerations. Honestly, I know there are some “how to” and some “best practices” when you prepare a SQL environment. Using separate HD for separate files (mdf, ldf), keep system database separate from user database in different disks, split big tables in different location, maintain the indexes and so on … Unfortunately when you reflect this to a Virtual Environment, everything changes.

I didn’t find yet a good documentation about virtualizing SQL but I just tried to build a Clustered environment with Windows 2008 R2 x64 and SQL 08 x64 SP1 and the Quad Core I used for my experiments was not enough …

Tags: SQL server vmware virtualize sql server

BizTalk 2009, cannot create project.

Raffaeu — Tue, 25 Aug 2009 12:46:00 GMT

In the last days we have received an update for Visual Studio 2008 SP1. The update is 365 MB and it’s called the “Security Update for Microsoft Visual Studio 2008 Service Pack 1 (KB971092)”.

After you install this update, when you try to create a new project on BizTalk 2009, you receive in the bottom bar, a notification that says “Unable to create the Project”.

The first solution is:

Open BizTalk 2009 DVD > Select Install BizTalk
Choose the option Repair
Reboot the server

If you are lucky now you are able to work again with BizTalk 09. If you are not lucky (like me … ) there is an additional step:

REBOOT!!

Tags: BizTalk 2009

BizTalk 2009 tutorials available.

Raffaeu — Mon, 24 Aug 2009 14:35:00 GMT

I am starting to work on a really interesting project where BizTalk and WCF will be the keys.

I have used in the past WCF and I am not worried about it, I like it and it’s better than the old Web Services.

Unfortunately I know BizTalk but I still do not master it. Over the network I didn’t find anything really useful but Microsoft has tons of tutorials and how to.

Overview of BizTalk 2009 http://www.microsoft.com/biztalk/en/us/roadmap.aspx
Getting Started http://msdn.microsoft.com/en-us/library/aa560946%28BTS.10%29.aspx
Step-by-step with some databases (Oracle, Siebel …) http://msdn.microsoft.com/en-us/library/aa560946%28BTS.10%29.aspx
Common Tasks http://msdn.microsoft.com/en-us/library/aa548054%28BTS.10%29.aspx
Complete guide to BizTalk 2009 http://msdn.microsoft.com/en-us/library/aa548004%28BTS.10%29.aspx

Also, if you need to start with WCF and the NET Framework 3.5, here is what I have found over the network:

Probably in the next days I will start to evaluate some books about BizTalk 2009 and WCF. If anyone of you want to ask me to evaluate a book about WCF or BizTalk, I would really appreciate.

Stay tuned!