1

The past few days I have done a lot of research using the DAL/BLL/UI approach without a very clear understanding of how it will apply to my project. In the past, I have left out the BLL connecting my UI directly to the Data Access Layer (LINQtoSQL dbml). But, I do not think this is a good idea where I work now(or maybe even in the past) because we have a lot of different applications and I'd like to use the same DAL/BLL as they are built.

My question is, how does the BLL help me when, in most of my applications, all I really do is use the LinqtoSqlDataSource/GridView to connect to my datacontext to take care of all the updating/edit, etc. Also, each new web application will, at some level, require unique changes to the DAL/BLL to get the require data, possibly affecting other apps using the same DAL/BLL. Is this reuse of the DAL/BLL the right way of doing this or am I missing something?

I think the BLL comes in when I need to build, for example, a security classes for the various web applications that will be built. But, when I use the Linqtosqldatasource, why would I bother to connect it to the BLL?

DAL

  • LinqToSQL dbml DataContext.
  • Does using LinqToSQL change how I should use this design?

BLL

  • Security for various website used by company.
  • Query DAL return what(?) when using LinqToSQLDatSource., functions that handle various results sets(I am really unsure how this should work with BLL, sorry if the question is unclear)

UI

  • Reference only the BLL?
Dan
  • 79
  • 1
  • 2
  • 13

2 Answers2

2

The DAL and BLL are separated by one often subtle, but key difference; business logic. Sounds moronically simple, but let me explain further because the distinctions can be VERY fine and yet impact architecture in huge ways.

Using Linq2SQL, the framework generates very simple objects that will each represent one record in one table. These objects are DTOs; they are lightwight, POCO (Plain Ol' CLR Object) classes that have only fields. The Linq2SQL framework knows how to instantiate and hydrate these objects from DB data, and similarly it can digest the data contained in one into SQLDML that creates or updates the DB record. However, few or none of the rules governing the relationship between fields of various objects are known at this level.

Your actual domain model should be smarter than this; at least smart enough to know that a property on an Order object named SubTotal should be equal to the sum of all ExtendedCosts of all OrderLines, and similarly, ExtendedCost should be the product of the UnitPrice and the Quantity. In many modern programs, your domain forms part of your BLL, at least to this extent. The objects created by Linq2SQL probably shouldn't have to know all this, especially if you aren't persisting SubTotal or ExtendedCost. If you rely on the Linq2SQL DTOs, you've basically tied yourself to what's called an Anemic Domain Model, which is a known anti-pattern. If the domain object can't keep itself internally consistent at least, then any object that works with the domain object must be trusted to keep it that way, requiring all those objects to know rules they shouldn't have to.

The UI should know about the domain, or if you prefer it should know some abstracted way to get the data from the domain for read-write purposes (generally encapsulated in objects called Controllers, which work with the domain layer and/or Linq2SQL). The UI should NOT have to know about the DB in any program of moderate size or larger; either the domain objects can hydrate themselves with a reference to objects in the DAL, or they are produced by custom objects in the DAL that you create to do the hydration, which are then given to the controller. The connected ADO model and interop with GridViews is admirable, but it doesn't allow for abstraction. Say you wanted to insert a web service layer in between the domain and UI, to allow the UI to be located on a mobile app that worked with data in your warehouse. You'd have to rebuild your UI, because you can no longer get objects from Linq2SQL directly; you get them from the web services. If you had a Controller layer that talked to Linq2SQL, you could replace that layer with controllers that talked to the web services. It sounds like a minor difference; you always have to change something. But, now you're using EXACTLY the same UI on the mobile and desktop apps, so changes at THAT layer don't have to be made twice just because the two layers get data different ways.

KeithS
  • 70,210
  • 21
  • 112
  • 164
  • Your answer and this http://stackoverflow.com/questions/3952534/communication-between-bll-and-dal have given me some insight into the domain aspect except I still do not understand what it is. Can you elaborate? – Dan Dec 08 '10 at 21:47
  • The "domain" is basically the collection of "stateful business objects"; in a progrma like Quickbooks, for example, an Invoice may be a domain object. These objects usually map very closely to the data structure of an RDBMS, and are responsible for maintaining a consistent data state (and so they are the usual place for data-level validation and for updating "calculated fields" like totals. – KeithS Dec 01 '11 at 23:26
  • Exactly how much logic the domain layer should have is a constant source of disagreement among programmers. Basically, the more an object knows about itself and objects around it, the more reasons that object has to change; this violates SOLID's Single Responsibility Principle which states that an object should have exactly ONE reason to change. However, if a domain class has the single responsibility of storing state, that creates an anti-pattern known as an Anemic Domain Model that requires changing multiple objects (domain class, validator, persister) to make even small business changes. – KeithS Dec 01 '11 at 23:30
0

This is a great question that I have been mulling over with our catalog app for a year now. A specific instance for me might help you with the pattern.

I have a page to display the contents of a shopping cart. In the 'early days' this page had a grid populated by the results of a SQL stored procedure that, given the order number, listed the items in the cart.

Now I have a 'cart' BLL object which contains a collection of 'row' objects. The grid is the same, but the data source is the cart's rows.

Why did I do this? Initially, not becuase of any fancy design patterns. I had so many special cases to handle based on fields in each row AND I had other places I needed to show the same cart-content data, it just made more sense to build the objects. Now a cart loads from a repository and my pages have no idea what that repository does. Heck, for testing, it's hard-coded cart data.

The cart then uses a repository to load up the rows. Each row has logic to maniuplate itself, not knowing where the data came from.

Hopefully that helps?

n8wrl
  • 19,439
  • 4
  • 63
  • 103