Introduction
There has been, and still is a lot of discussion going around of what kind of technique a developer in general should use to represent the data from the DataLayer through the BusinessLayer to the Presentation Layer. In common, there are 2 main "ideas" floating around, those who swear the "one and only object Paradigm" (thus them who use an O/R mapping tool to map the database fields to custom object properties), and those who are using the intermediate of the DataSet (typed) to present the Data in the Presentation Layer.
Some years ago, as being a .NET Architect for a while now, i had to make this difficult decision. As, at that time binding custom business object in the .NET framework wasn't as trivial as it is now, I decided to create BusinessObjects holding a "typed dataset" as data datacontainer and implementing some base "Business Classes" to forsee a general way of validating the data in the 'rows' of the DataContainer.
For all, there's one constant, in modern development, we should implement separate layers/tiers in our development (and for ones : a layer is a logical separation of our code, a tier is a physical separation of the code, which means that a logical layered application will run on a single machine, some logic (like remoting or WebService) enhancments should be added to make the layers run on separate tiers (machines)).
Allright, so I decided to choose the DataSet "camp" of the story, and ... neverthless some people think that DataSets (typed) are lazy and dumb containers creating a lot of overhead, I felt (and still feel ...) comfortable with this dumb implementation in my Business Layer ! No O/R mapping to forsee, data in the DataBase is brought in a Transparent way to the Presentation Layer and relational data is a piece of cake ! Allright ... if you change the "DataBase", you have to do some "plumbing" to make the program compile again (as with pure customobjects you won't get errors, but if you forget to add the new properties to you're bizzclasses (for those who discard themselves from code generators ...) you will not be noticed from having new property data ...
The 2 worlds of "DataCentric" (DataSets) and "Object Centric" (Custom Objects) will probably never reconcile, but as binding custom businessobjects in .NET 2.0 and automated data-access (SQl-Server only !) code generation become more mature, I'll put the spot on reconciling those 2 in the next Article.
I will be presenting a simple logically layered framework implementing a "pure businessobjects" layer for DataBinding to "the Presentation Layer" and using the new featured data-access capabilities in .NET 2.0 (yep ! which are based on (typed) DataSets !!!) to render the data to our custom business objects. And for sake of simplicity, we will keep stuck with realy simple BusinessObjects (so omitting caching, bizzrules and so forth) ...
The reason why I want to post this Article, is because I already saw some articles or partial code projects explaining some O/R mapping and databinding principles, but it's hard to find a real wel documented and full flavoured example on the net. So, not only implementing the "Get()" part (that's the easy part !) but also explaining the "Save()" part (that's the hard one !), and not only for simple data objects, but for more real world related "parent-child" data. Well ... if you're looking for such a fully flavoured example, start reading this article and I hope you'll enjoy the contents !
This article will be presented as a "step-by-step" tutorial, so you can create the project from scratch or look right into the demo code if you want to ...
Using the code
Step 1 : Creating the Data Access Layer
Alright ! Let's hit the road starting with building the Data Access Layer. First we will create an empty C# .NET "Solution", call it "DCAF" (DataCentricApplicationFrameWork) . Next Add a C# "Library" type project to the Solution, called "DCAF.DataLayer". So far you should have next view (see Fig1.).
Fig 1. Initial Solution
For the purpose of our demo, we will use the Northwind database and creating a form which shows us all customers and related orders. So, our "DataAccessLayer" will hold a typed dataset called CustomerOrderTS to serve this purpose. So select "Add" , next "New Item" in the Solution Explorer of the current DataLayer Project, next select "DataSet" from the displayed template list and call it CustomerOrderTDS.xsd. Next select the TypedDataSet in the Solution Explorer, and click on the server explorer link in the Left Panel. Now you should see the data connections panel appearing in the left pane (see Fig2.).
Fig 2. Server Explorer
No we will add our DataBase DataSource, thus the Customer and Order tables from the NortWhind Database. For doing this, first "right-click" the Data Connections item, and select Add Connection from the rollout. Next select your SQL-Server instance, select the NorthWind database from the DataBase rollout and hit the "OK" button. (see fig3.).
Fig 3. Add Connection
Next you should see the NortWind Database in the left panel, now rollout the Treeview for the Tables component, select Customers and Orders tables (see Fig 4.) and drag them to the middle panel empty container for the CustomerOrdersTDS. Tables are automatically added to the surface.
Fig 4. Create DataSet (typed)
Going to delve deeper in the created code for the typed dataset is beyond the scop of this article, but note that tables + relations as known in the NorthWind Database are added, and each table has his own TableAdapter right out of the Box. Each TableAdapter has a by default created access method to load all table data. We will meet the use of those TableAdapters further in the document, when creating the data service classes.
Now that we have created our DataContainers, we have to create our data service classes. Those classes will be used as intermediate between our DataAccessLayer and the BusinessLayer. In fact our data service classes will request the data from the DataBaseServer, put them in a TypedDataSet (for our demo, the one we created a minute ago) and deliver the DataSet to our Custom BusinessObjects.
Before implementing all this service stuff, we should add one method to our created Typed DataSet, which is a method that will grab our Customer and Order data in one single batch. We will add this code as a method to the Partial Class definition (which is new in 2.0) of our typed dataset. For doing this, select CustomerOrdersTDS and select the "Code" icon of the Solution Explorer . This should result in the code as mentioned in Fig 5.
Fig 5. Partial Class Definition
Now we will add the code involved to retrieve the batch query for customers and orders
using DCAF.DataLayer.CustomerOrderTDSTableAdapters;
namespace DCAF.DataLayer {
partial class CustomerOrderTDS
{
public static CustomerOrderTDS GetCustomerOrders()
{
CustomersTableAdapter custAdapter = new CustomersTableAdapter();
OrdersTableAdapter ordAdapter = new OrdersTableAdapter();
CustomerOrderTDS ds = new CustomerOrderTDS();
custAdapter.Fill(ds.Customers);
ordAdapter.Fill(ds.Orders);
return ds;
}
}
}
As you can notice from the code, the static method GetcustomerOrders() returns the data required for our Customer and Order BusinessObject in one single track.
The last step which we have to take when developing our DataLayer, is the construction of our Service class which will be the intermediate between our DataLayer and the BusinessClasses involved.
So let's start by creating a new class, called CustomerOrderService.csThe end result is shown in the code next beneath:
using System;
using System.Collections.Generic;
using System.Text;
using DCAF.DataLayer.CustomerOrderTDSTableAdapters;
namespace DCAF.DataLayer
{
public class CustomerOrderService
{
#region "Storage"
private CustomersTableAdapter m_customersAdapter = null;
protected CustomersTableAdapter CustomersAdapter
{
get
{
if (m_customersAdapter == null)
{
m_customersAdapter = new CustomersTableAdapter();
}
return m_customersAdapter;
}
}
private OrdersTableAdapter m_ordersAdapter = null;
protected OrdersTableAdapter OrdersAdapter
{
get
{
if (m_ordersAdapter == null)
{
m_ordersAdapter = new OrdersTableAdapter();
}
return m_ordersAdapter;
}
}
#endregion "Storage"
#region "Public Interface
public CustomerOrderTDS.CustomersDataTable GetCustomers()
{
return CustomersAdapter.GetData();
}
public CustomerOrderTDS.OrdersDataTable GetOrders()
{
return OrdersAdapter.GetData();
}
public CustomerOrderTDS GetCustomerOrders()
{
return CustomerOrderTDS.GetCustomerOrders();
}
#endregion "Public Interface"
}
}
As you can retrieve from the code, we use the separate TableAdapters for retrieving atomic table data, and use or enhanced partial typed dataset method to retrieve customers and orders in a single track. As you may noticed, for returning the single Customer or Order table data, we just use the default method GetData() on the Adapter, nothing more is involved here !
All right, that's all what is concerned about the DataLayer and DataLayer service classes, let's move to our Business Layer right away !
Step 2 : Creating the Custom Business Layer
First thing to do is to add a new project to our solutions, again, it's type is a ClassLibrary, call it DCAF.BusinessLayer.
Because our Custom BusinessObjects should be knowing where to get their data, we should at this point add a reference to the DCAF.DataLayer Assembly. This can be easily done by selecting References in the project folder, next right-mouse click, choose "Add reference", go to the Projects tab and select the Assembly, just as shown in Fig 6.
Fig 6. Adding Assembly reference to the project
Next, add 2 classes to the project, called CustomerBO (which will hold the Customer definition) and OrderBO (which will hold the Order definition).
using System;
using System.Collections.Generic;
using System.Text;
using DCAF.DataLayer;
using DCAF.DataLayer.CustomerOrderTDSTableAdapters;
namespace DCAF.BusinessLayer
{
public class CustomerBO
{
private string m_CustomerId;
private string m_CompanyName;
private List<OrderBO> m_Orders = new List<OrderBO>();
public string CustomerId
{
get { return m_CustomerId; }
set { m_CustomerId = value; }
}
public string CompanyName
{
get { return m_CompanyName; }
set { m_CompanyName = value; }
}
public List<OrderBO> Orders
{
get { return m_Orders; }
}
}
}
The Customer Business Object class contains 2 properties, one for it's ID, and one for it's Name, and holds a Collection of Orders (List) Also Note the using of the DCAF.DataLayer references here, we'll come back to this in a minute !
namespace DCAF.BusinessLayer
{
public class OrderBO
{
private int m_OrderId;
private string m_ProductName;
private CustomerBO m_Customer;
private DateTime m_OrderDate;
public CustomerBO Customer
{
get { return m_Customer; }
set { m_Customer = value; }
}
public int OrderId
{
get { return m_OrderId; }
set { m_OrderId = value; }
}
public string ProductName
{
get { return m_ProductName; }
set { m_ProductName = value; }
}
public DateTime OrderDate
{
get { return m_OrderDate; }
set { m_OrderDate = value; }
}
}
}
The Orders table on the other side, contains also some property values and a reference to it's containing customer !
And finally ... we should implement our O/R mapping function to Fill our Custom BusinessObjects with Data ! For this purpose, i've implemented next method (explanation follows after the code segment !). Method should be added to the CustomerBO class !
public static List<CustomerBO> GetCustomerOrders()
{
CustomerOrderService dataService = new CustomerOrderService();
CustomerOrderTDS dataContainer;
dataContainer = new CustomerOrderTDS();
dataContainer.Merge(dataService.GetCustomerOrders());
List<CustomerBO> custList = new List<CustomerBO>();
foreach (CustomerOrderTDS.CustomersRow custRow in
dataContainer.Customers.Rows)
{
CustomerBO customer = new CustomerBO();
ORM.RelationalToObject(customer, custRow);
CustomerOrderTDS.OrdersRow[] orderRows =
(CustomerOrderTDS.OrdersRow[])custRow
.GetChildRows("FK_Orders_Customers");
int numOrder = 0;
foreach (CustomerOrderTDS.OrdersRow orderRow in
orderRows)
{
numOrder++;
OrderBO order = new OrderBO();
ORM.RelationalToObject(order, orderRow);
order.Customer = customer;
order.ProductName = string.Format("Product
{0}-{1}", order.OrderId, numOrder);
order.Initializing = false;
customer.Orders.Add(order);
}
customer.Initializing = false;
custList.Add(customer);
}
return custList;
}
So, we create a static method called GetCustomerOrders which returns a List of CustomerObjects (note : you can also use the generic counterpart of List, List<T>). First, we grab our data through the DataService in our Typed DataSet. Next we cycle through the DataContainer Rows for Customer, add Customer Info, get the ChildRows() for Orders, Add OrderInfo and finally adding the Customer object to the List.
To simplify the task of O/R mapping, I've added a class ORM to the Project. This class holds 2 methods, one for mapping the relational data to the object properties (called ORM.RelationalToObject) and another for mapping the properties back to relational data when saving the object, and this in a dynamic manner, so the methods can be re-used for any table/object mapping scenario. The code beneath shows the method for RelationalToObject mapping. The opposite methode will be explained when we describe our save routine.
public static void RelationalToObject( object p_obj, DataRow p_dataRow)
{
PropertyDescriptorCollection props = TypeDescriptor.GetProperties(p_obj);
foreach (DataColumn column in p_dataRow.Table.Columns)
{
for (int propertyIndex = 0; propertyIndex < props.Count; propertyIndex++)
{
PropertyDescriptor prop;
try
{
prop = props[propertyIndex];
}
catch
{
continue;
}
if (prop.PropertyType.GetInterface("IList") == null)
{
if (prop.Name.Trim().ToLower() == column.ColumnName.Trim().ToLower())
{
prop.SetValue(p_obj, p_dataRow[column]);
}
}
}
}
We're done with our BusinessLayer, and ones more, just for this demo, I kept to a very basic implementation of the BusinessObject, without being concerned about BizzRules, Caching, PropertyChanged Notification (will be included when describing the Save() part) and so on, cause those implementations are beyond the scope of this article.
Step 3 : Creating the Presentation Layer
Presenting the Data in the Windows Form
Well, now that we are finished with all the plumbing code for the DataLayer and BusinessLayer we want to vizualize our business data in the Presentation Layer. You will notice that separating the logic in layers, does not only result in more easily maintainable code, but adds also a great number of transparancy to the development cycle, which means that the learning curve for the Presentatien Layer programmer is less time conzuming, because the Presentation Layer programmer does not to be aware of the implementation details of the other layers (business en data), he can just grab the ready made custom object and concentrate on presenting them in the Presentation Layer.
First thing todo is adding a new project, this time we're talking about a Windows Application. So start adding a new project to the Solution and call it CDAF.PresentationLayer and rename the Form1 class to CustomerAdmin.
In this demo, we want to represent our customers and related orders, each in a grid related to each others. So the first thing the Presentation Layer programmer has to do is adding a DataSource to the project. You can achieve this by selecting Data and select next Add New DataSource ... on the menu (see Fig.7).
Fig 7. Add a new DataSource to the project
Next choose object as DataSource (see Fig. 8) and "Click" the "Next" button.
Fig 8. Add an object DataSource
Next we have to choose the object location for the DataSource, this means we have to add a reference to our BusinessLayer Assembly ! Click "Add Reference" add this point (see Fig. 9).
Fig 9. Add a reference to the object location Assembly
Next you have to select the DCAF.BusinessLayer Assembly from the Project tab list (see Fig. 10).
Fig 10. Select the Assembly Reference
Next we have to Choose our object to Bind to. Select the CustomerBO at this point (see Fig. 11).
Fig 11. Select the Object to DataBind
Finally click "Next", then "Finish". Notice that a DataSources folder has been added to the properties of our Presentation Layer Project (see Fig. 12).
Fig 12. Embedded DataSources in the Presentation Layer
Allright ! Now that we have our DataSource added to the Project, we will add object instances for our Customer and Order BusinessObject. So, first select Show DataSources from the Data tab (see Fig. 13).
Fig 13. Show DataSources
As you can see (see Fig 14.), the DataSources panel on the left shows our CustomerBO object. At this point, first select CustomerBO grid icon and drag to the form, next do the same for Orders grid Icon.
Fig 14. DataSources Panel
Finally, the form should show up as follow (see Fig. 15).
Fig 15. Initial Object Bound Customer Form
Isn't this an impressive enhancement of the VS IDE ?
The IDE did not only add our grids, but also a bindingnavigator, customerbindingsource and orderbindingsource (see Fig. 16), just right out of the box ! By default the CustomerGrid.DataSource is bound to the customerBOBindingSource, the OrderGrid.DataSource is bound to the ordersBindingSource and the customerBOBindingNavigator.DataSource is bound to the customerBOBindingSource.
Fig 16. Binding Tools
So, what's left for the UI programmer is getting the Data from our CustomerBO and binding the appropriate BindingSources, as you can see from the code below !
private void CustomerAdmin_Load(object sender, EventArgs e)
{
customerBOBindingSource.DataSource = DCAF.BusinessLayer.CustomerBO
.GetCustomerOrders();
ordersBindingSource.DataSource = customerBOBindingSource;
ordersBindingSource.DataMember = "Orders";
}
Now Hit 'F5' and smile ! You see from the result (see Fig 17.) that our grids are loaded smoothly. Select another customer and you will see that the order grid automatically adapt his bindings to reflect the right data !
Fig 17. CustomerAdmin
As you can see from the OrderGrid, we're still left with a minor problem. For the Customer Column, we would like to see the CustomerID instead of the Customer Object type declaration. The reason why the grid displays the Customer Object Type declaration, is due to the nature of the Bound Column. If you open the Grid properties for the OrderGird, and select the Columns (Collection) property, then you will see that the column is bound to the instance of the Customer Object reference in the OrderObject. Now, if we want instead to have some "meaningfull" data in the column, let's say CustomerID, we have to subscribe to the CellFormatting event of the OrderGrid and add the code as mentioned Below.
private void OnCellFormatting(object sender,
DataGridViewCellFormattingEventArgs e)
{
if (ordersDataGridView.Columns[e.ColumnIndex]
.DataPropertyName == "Customer")
{
object currentCustomer = customerBOBindingSource.Current;
PropertyDescriptorCollection props = TypeDescriptor
.GetProperties(currentCustomer);
PropertyDescriptor propDesc = props.Find("CustomerID", true);
try
{
e.Value = propDesc.GetValue(currentCustomer).ToString();
}
catch
{
e.Value = "[UNDEFINED]";
}
}
}
If you re-run the application after adapting the code, you will see that only the CustomerID column is bound ! (see Fig. 18).
Fig 18. CustomerAdmin Enhanced
Update the DataBase with New, Added & Deleted data
So far, we've been adding code to bind the data from the DataLayer to the Data Aware components (DataGridView) of the Presentation Layer. At this point, users can add, delete or modify customer or order related data through the interface of the DataGridView. After adding, deleting or modifying data, the user can choose to update the entered information to the Database. In the remainder section of this article we will describe the necessary steps involved to update the database with then newly, modified or deleted data.
There's quit some code involved to update our CustomObjects to the Datalayer, first, we'll start by adding two list instances as private members of our Customer Administration form. These list instances will keep track of deleted customers and orders.
private List<CustomerBO> m_deletedCustomers = null;
private List<OrderBO> m_deletedOrders = null;
Next, we should handle the AddingNew event of the customerBoBindingSource which handles the Add of a new CustomerObject for the BindingSource. (See Fig. 19).
Fig 19. Handling the AddingNew event for the CustomerBindingSource
The code which handles the add of a new customer to our CustomerBindingSource is shown here below.
private void customerBOBindingSource_AddingNew(object sender,
AddingNewEventArgs e)
{
CustomerBO customer = new CustomerBO();
customer.IsNew = true;
customer.IsDirty = true;
customer.CompanyName = "<new Customer>";
customer.CustomerId = "<new CustomerID>";
e.NewObject = customer;
customer = null;
}
The same eventhandler should be activated for our OrderBindingSource. Note (see code below) that the code which is responsible for adding a new order should also take a reference to the Parent collection (Customer). As or orders object has to hold an unique OrderID, we will set this ID to a negative incremental value. Our "Orders" DataSet contains an OrderID column which has been set as an AutoIncremental Column. The ID set in the OrderObject is set to a negative value to avoid conflicts when inserting a new order row in the DataBase. When inserting a new Row in the OrderTable at ServerSide, the DataBase server will add the new OrderID and assing a new unique OrderID which will be returned in the Update DataSet and should be syncronized with the Object Values at the ClientSide (I'll explain this feature in next ยง of this document).
private void ordersBindingSource_AddingNew(object sender,AddingNewEventArgs e)
{
OrderBO order = new OrderBO();
order.IsNew = true;
order.IsDirty = true;
order.OrderDate = DateTime.Today;
order.ProductName = "<new productname>";
m_lastOrderID--;
order.OrderId = m_lastOrderID;
CustomerBO currentCustomer = (CustomerBO)customerBOBindingSource.Current;
if (!(currentCustomer == null))
{
order.Customer = currentCustomer;
}
else
{
throw new NullReferenceException("Customer for Order not found !");
}
e.NewObject = order;
order = null;
}
Handling the modified event is quite more transparent to the Presentation Layer developer. There are a few classes involved to handle the property modified portion of the CustomerBO or OrderBO. We'll discuss these classes step by step. These helper classes are implemented in the Business Layer Assembly of the Project.
Let's start first with the IEventPublisher interface. This interface holds the blueprint for the Object Property Modification event. Let's take a closer look at this interface class:
public interface IEventPublisher
{
void RegisterListener<T>(T p_listener) where T : IEventListener;
void UnregisterListener<T>(T p_listener) where T : IEventListener;
void NotifyListeners();
bool IsDirty {get; set;}
bool Initializing { get; set;}
}
The IEventPublisher Interface holds method interfaces for registering or unregistering listener objects, notify the listeners when an object property has changed their values, and 2 property settings, first the IsDirty property which puts the attached object in a modified state, and the Initializing property which is set to true while loading the object data (so preventing to launch the modified events while loading the data in the objects).
Next we take at a look at the IEventListener interface. This interface holds a reference to the Publisher object (in our case the customer or order object) and descibes the method signature of the method that is involved to handle the "modified" event for the object properties.
public interface IEventListener
{
void OnNotification(IEventPublisher p_publisher);
}
The Publisher class is the base class for each custom object business class. Is BusinessObject derives directly from the Publisher Class. The Publisher class holds the methods to "Register" or "Unregister" Listener Objects. Listener Objects are those objects which will be Notified of changes in the Properties of the BusinessObject Class. A typical listener could be a Windows Form. This base class also contains some base properties which sets the BusinessObjects to some initial state like "IsNew", "IsDirty" (modified) of "IsInitializing" state.
public abstract class Publisher : IEventPublisher
{
private delegate void m_eventHandler(IEventPublisher p_publisher);
private event m_eventHandler m_event;
#region "IEventPublisher Implementation"
public void RegisterListener<T>(T p_listener) where T : IEventListener
{
m_event += new m_eventHandler(p_listener.OnNotification);
}
public void UnregisterListener<T>(T p_listener) where T : IEventListener
{
m_event -= new m_eventHandler(p_listener.OnNotification);
}
public void NotifyListeners()
{
if (m_event != null)
m_event(this);
}
protected bool m_isDirty = false;
public bool IsDirty
{
get { return m_isDirty; }
set { m_isDirty = value; }
}
protected bool m_initializing = true;
public bool Initializing
{
get { return m_initializing; }
set { m_initializing = value; }
}
protected bool m_isNew = false;
public bool IsNew
{
get { return m_isNew; }
set { m_isNew = true; }
}
#endregion "IEventPublisher Implementation"
}
The ObjectChanged Listener class hold the OnNotification method which is executed when Properties of the BusinessObjectClass (which are registered to the NotifyChanged Event) get changed.
public class ObjectChangedListener : IEventListener
{
#region "IEventListener Members"
public void OnNotification(IEventPublisher p_publisher)
{
if (!p_publisher.Initializing)
{
p_publisher.IsDirty = true;
}
}
#endregion "IEventListener Members"
}
In this case (see code below) the Notification event is attached to theset property. So when a property value changed the event will be thrown (properties of our CustomerBO).
public string CustomerId
{
get { return m_CustomerId; }
set
{
m_CustomerId = value;
NotifyListeners();
}
}
public string CompanyName
{
get { return m_CompanyName; }
set
{
m_CompanyName = value;
NotifyListeners();
}
}
When the user hits the save button, next code will be executed to update our backend database with the added, modified or deleted objects. As a lot of code is involved here, i've implemented the code explanation within the source.
private void customerBOBindingNavigatorSaveItem_Click(object sender,
EventArgs e)
{
this.Validate();
customerBOBindingSource.EndEdit();
ordersBindingSource.EndEdit();
List<CustomerBO> changedCustomers = null;
List<OrderBO> changedOrders = null;
foreach (object obj in customerBOBindingSource)
{
CustomerBO customer = (CustomerBO)obj;
if (customer.IsDirty)
{
if (changedCustomers == null)
changedCustomers = new List<CustomerBO>();
changedCustomers.Add(customer);
}
foreach (OrderBO order in customer.Orders)
{
if (order.IsDirty)
{
if (changedOrders == null)
changedOrders = new List<OrderBO>();
changedOrders.Add(order);
}
}
customer = null;
}
if (changedCustomers != null || changedOrders != null ||
m_deletedCustomers != null || m_deletedOrders !=
null)
{
bool IsUpdateOK = true;
try
{
int numUpdate = m_customerBO
.SaveCustomerOrders(changedCustomers,
m_deletedCustomers, changedOrders,
m_deletedOrders);
MessageBox.Show(string.Format("{0} rows were
successfully updated to the database !",
numUpdate.ToString()));
}
catch (Exception ex)
{
IsUpdateOK = false;
MessageBox.Show(ex.Message, "Error Occured
Update Failed!");
}
finally
{
if (IsUpdateOK)
{
if (changedOrders != null)
{
m_customerBO
.SyncroOrderID(changedOrders);
}
if (changedCustomers != null)
{
foreach (CustomerBO customer in
changedCustomers)
{
customer.IsDirty = false;
customer.IsNew = false;
}
changedCustomers = null;
}
if (changedOrders != null)
{
foreach (OrderBO order in changedOrders)
{
order.IsDirty = false;
order.IsNew = false;
}
changedOrders = null;
}
m_deletedCustomers = null;
m_deletedOrders = null;
ordersDataGridView.Refresh();
}
}
}
}
While Added and Modified objects can be traced in the contained list, deletes can not. So we have to keep trace of those objects manualy. For this reason we have to implement next event handlers in the code.
At the definition section :
public partial class CustomerAdmin : Form
{
private CustomerBO m_customerBO;
private List<CustomerBO> m_deletedCustomers = null;
private List<OrderBO> m_deletedOrders = null;
. . .
}
Code which takes care of deleting a Customer or Order object:
private void customerBODataGridView_UserDeletingRow(object sender,
DataGridViewRowCancelEventArgs e)
{
OnCustomerOrderDelete(sender,e);
}
private void OnCustomerOrderDelete(object sender,
DataGridViewRowCancelEventArgs e)
{
if (m_deletedCustomers == null)
m_deletedCustomers = new List<CustomerBO>();
m_deletedCustomers.Add((CustomerBO)e.Row.DataBoundItem);
if (((CustomerBO)e.Row.DataBoundItem).Orders != null)
{
if (m_deletedOrders == null)
m_deletedOrders = new List<OrderBO>();
m_deletedOrders.AddRange(((CustomerBO)
e.Row.DataBoundItem).Orders);
}
}
private void ordersDataGridView_UserDeletingRow(
object sender, DataGridViewRowCancelEventArgs e)
{
OnSingleOrderDelete(sender,e);
}
private void OnSingleOrderDelete(object sender,
DataGridViewRowCancelEventArgs e)
{
if (m_deletedOrders == null)
m_deletedOrders = new List<OrderBO>();
m_deletedOrders.Add((OrderBO)e.Row.DataBoundItem);
}
At last, our BusinessLayer Class takes care of handling the update to the DAL. The implementation as shown beneath also handles DbConcurrency issus in an Optimistic way.
public int SaveCustomerOrders(List<CustomerBO> p_addedOrModifiedCustomers,
List<CustomerBO> p_deletedCustomers,
List<OrderBO> p_AddedOrModifiedorders,
List<OrderBO> p_deletedOrders)
{
CustomerOrderService dataService = new
CustomerOrderService();
if (p_deletedCustomers != null)
{
foreach (CustomerBO deletedCustomerObject in
p_deletedCustomers)
{
CustomerOrderTDS.CustomersRow deletedCustomerRow
= m_dataContainer.Customers.NewCustomersRow();
deletedCustomerRow =
m_dataContainer.Customers
.FindByCustomerID(deletedCustomerObject
.CustomerId);
if (deletedCustomerRow != null)
{
deletedCustomerRow.Delete();
}
}
}
if (p_deletedOrders != null)
{
foreach (OrderBO deletedOrderObject in
p_deletedOrders)
{
CustomerOrderTDS.OrdersRow deletedOrderRow =
m_dataContainer.Orders.NewOrdersRow();
deletedOrderRow =
m_dataContainer.Orders.FindByOrderID(
deletedOrderObject.OrderId);
if (deletedOrderRow != null)
{
deletedOrderRow.Delete();
}
}
}
if (p_addedOrModifiedCustomers != null)
{
foreach (CustomerBO addedOrModifiedCustomerObject in
p_addedOrModifiedCustomers)
{
if (addedOrModifiedCustomerObject.IsNew)
{
CustomerOrderTDS.CustomersRow newCustomerRow
= m_dataContainer.Customers
.NewCustomersRow();
ORM.ObjectToRelational(
addedOrModifiedCustomerObject,
newCustomerRow);
m_dataContainer.Customers
.AddCustomersRow(newCustomerRow);
}
else
{
CustomerOrderTDS.CustomersRow
modifiedCustomerRow = m_dataContainer
.Customers.NewCustomersRow();
ORM.ObjectToRelational(
addedOrModifiedCustomerObject,
modifiedCustomerRow);
if (modifiedCustomerRow != null)
{
CustomerOrderTDS.CustomersRow
customerRowToModify =
m_dataContainer.Customers
.FindByCustomerID(
modifiedCustomerRow.CustomerID);
if (customerRowToModify != null)
{
for (int i = 0; i < m_dataContainer
.Customers
.Columns
.Count; i++)
{
customerRowToModify[i] =
modifiedCustomerRow[i];
}
}
}
}
}
}
if (p_AddedOrModifiedorders != null)
{
foreach (OrderBO addedOrModifiedOrderObject in
p_AddedOrModifiedorders)
{
if (addedOrModifiedOrderObject.IsNew)
{
CustomerOrderTDS.OrdersRow newOrderRow =
m_dataContainer.Orders.NewOrdersRow();
ORM.ObjectToRelational(
addedOrModifiedOrderObject, newOrderRow);
newOrderRow.CustomerID =
addedOrModifiedOrderObject
.Customer
.CustomerId;
m_dataContainer.Orders
.AddOrdersRow(newOrderRow);
}
else
{
CustomerOrderTDS.OrdersRow
modifiedOrderRow = m_dataContainer
.Orders
.NewOrdersRow();
ORM.ObjectToRelational(
addedOrModifiedOrderObject,
modifiedOrderRow);
if (modifiedOrderRow != null)
{
CustomerOrderTDS.OrdersRow
orderRowToModify = m_dataContainer
.Orders
.FindByOrderID(
modifiedOrderRow.OrderID);
if (orderRowToModify != null)
{
for (int i = 0; i < m_dataContainer
.Orders
.Columns
.Count; i++)
{
System.Data.DataColumn column =
orderRowToModify
.Table.Columns[i];
if (!column.ReadOnly)
{
orderRowToModify[i] =
modifiedOrderRow[i];
}
}
orderRowToModify.CustomerID =
addedOrModifiedOrderObject
.Customer.CustomerId;
}
}
}
}
}
if(m_dataContainer.HasChanges())
{
bool updateOK = true;
try
{
return dataService
.SaveWithTransaction(
m_dataContainer,false);
}
catch (DBConcurrencyException dbconcEx)
{
string message = dbconcEx.Message + "\r\n";
message += "Persist changes to the DataBase
[Yes]\r\n" +
"Reload the changed Data from the
Server [No]";
string caption = "DbConcurrency !";
MessageBoxButtons buttons =
MessageBoxButtons.YesNo;
DialogResult result;
result = MessageBox.Show(message, caption,
buttons);
if (result == DialogResult.Yes)
{
try
{
return dataService
.SaveWithTransaction(
m_dataContainer, true);
}
catch (Exception ex)
{
m_dataContainer.RejectChanges();
updateOK = false;
throw ex;
}
}
else
{
try
{
if (m_dataContainer.HasErrors)
{
if (m_dataContainer
.Customers.HasErrors)
{
CustomerOrderTDS.CustomersRow[]
customerErrorRows
= (CustomerOrderTDS.
CustomersRow[])
m_dataContainer
.Customers.GetErrors();
foreach (CustomerOrderTDS
.CustomersRow
customerErrorRow
in customerErrorRows)
{
m_dataContainer
.Customers
.Merge(
dataService
.GetCustomerRow(
customerErrorRow
.CustomerID));
}
foreach (CustomerBO
customerObject
in p_addedOrModifiedCustomers)
{
CustomerOrderTDS
.CustomersRow customerRow =
(CustomerOrderTDS
.CustomersRow)
m_dataContainer
.Customers
.FindByCustomerID(
customerObject
.CustomerId);
bool isErrorRow = false;
foreach
(CustomerOrderTDS
.CustomersRow
customerErrorRow
in customerErrorRows)
{
if (customerErrorRow
.CustomerID ==
customerObject
.CustomerId)
{
isErrorRow = true;
break;
}
}
if (customerRow != null &&
isErrorRow)
{
ORM.RelationalToObject(customerObject, <BR> customerRow);
}
}
}
if (m_dataContainer.Orders.HasErrors)
{
CustomerOrderTDS.OrdersRow[] orderErrorRows
= (CustomerOrderTDS.OrdersRow[])
m_dataContainer.Orders.GetErrors();
foreach (CustomerOrderTDS.OrdersRow orderErrorRow
in orderErrorRows)
{
m_dataContainer.Orders.Merge(
dataService.GetOrderRow(orderErrorRow.OrderID));
}
foreach (OrderBO orderObject <BR> in p_AddedOrModifiedorders)
{
CustomerOrderTDS.OrdersRow orderRow =
(CustomerOrderTDS.OrdersRow)
m_dataContainer.Orders.FindByOrderID(<BR> orderObject.OrderId);
bool isErrorRow = false;
foreach (CustomerOrderTDS.OrdersRow orderErrorRow <BR> in orderErrorRows)
{
if (orderErrorRow.OrderID == <BR> orderObject.OrderId)
{
isErrorRow = true;
break;
}
}
if (orderRow != null && isErrorRow)
{
ORM.RelationalToObject(orderObject, <BR> orderRow);
}
}
}
}
}
catch (Exception ex)
{
m_dataContainer.RejectChanges();
updateOK = false;
throw ex;
}
}
}
finally
{
if (updateOK)
{
m_dataContainer.AcceptChanges();
}
}
}
return 0;
}
Voila . . . that's all folks ! Hope you enjoyed reading the article.
