Question

I Am creating a web application and first use Entity Framework. I created Entity Data Model and now I am not sure, how to proceed now.

Premise: My database is really simple (Rating, WebPage, Visitor) and database tables corresponds to the business objects.

My suggestion is 3tier architecture but how to make it?

1. It is good idea create partial classes with the same name as Entity Framework objects (Rating, Visitor) and declare here new methods (GetAverageRating()…)? Or is better create some VisitorProvider, RatingProvider and place logic here?

2. It is better use EF objects in BLL and Presentation Layer or I should create my own BO objects on my BLL layer and transform EF object to BO?

3. I’m think, it is more practical use static methods on my DAL than instantiate classes on BLL. Do you agree?

Can you recommend me some best practices? I have many ideas how to create it, but I do not know what is the right.

Answer 1

3 layer architecture is quite popular but what it really means?

1. Presentation layer
2. Application layer
3. Database layer

If you ask what each layer means you can be pretty sure you will get several different answers. You can further divide each layer into sublayer and build layered hell like:

1. Client side presentation layer
2. Server side view layer
3. Controller layer
4. Service facade layer
5. Service layer
6. Domain objects layer
7. Repository + Factory layer
8. ORM layer
9. Stored procedure layer
10. Database view layer
11. Database table layer

WTF? That is just example that application can be easily over architected. It can go even worse if you insist that only neighbours can exchange data and if you decide to add special type of objects to be exchanged between layers instead of flowing sing set of objects through multiple layers.

Add layers which you need to make you more comfortable with developing the application and which will do reasonable separation of concerns and maintainability needed for the scale of your application. You can simply do the most simplest application which will be used just few weeks and must be developed as fast as possible. In such case you can do that within few days simply by using ASP.NET web forms and data source controls (or ASP.NET dynamic data). It can be badly extensible but in such situation it is exactly what you need to implement application quickly. Writing layers and doing all the stuff around maintainability and extensibility is reasonable if you need it. Another quick prototyping technique is ASP.NET MVC Scaffolding which can create quick multilayered skeleton of the application which can be further modified.

1. Both approaches are correct and it only depends on the approach you like. The first is called active record pattern but it is not used very often with entity framework. The second approach is more popular. You can either use EF directly in some middle class which you called Provider (common name is also Service). This class will do both data access logic and business logic. In more complex applications developers like to somehow wrap EF to separate class following repository pattern and call the repository either from service or directly from web app. code behind or controller (depending on amount of business logic). Try to do it without repository first. My personal opinion is that people should start to use repository only once they understand EF itself.
2. Again both approaches are correct. In a simple application it is fully acceptable to create EF model with POCO classes (EFv4.x) and use them in all layers. If you are using ASP.NET MVC you can find that you need special classes as view models to fully represent needs of your individual views. In a more complex application you can have separate objects exposed from a business layer – this is especially used if the business layer is exposed as a remote service (WCF).
3. It depends how you write these DAL methods – it is absolutely necessary to not share the EF context among requests! It also depends if you want to write some test or not. Layer defined by static methods is something which goes directly against testable architecture where you want unit test just single layer (unit testing with EF can be hard). It also depends if you want to use dependency injection which is based on instances.