- What Does This Chapter Cover?
- Creating a Class
- Defining Properties
- Defining Methods
- Building a Base Business Object Class
- Conclusion
This chapter is from the book
This chapter is from the book
This chapter is from the book
Building a Base Business Object Class
Business objects have standard housekeeping tasks that they must perform. For example, they must keep track of their state (unchanged, added, modified, deleted). The purpose of a base business object class is to define a standard set of operations that are applicable to all business objects. This keeps the housekeeping code out of the business objects themselves.
Creating base classes was covered in detail in Chapter 4, which demonstrated how to build a base form class. This section provides information on building a base business object class. For all the definitions, benefits, and techniques of building a base class, see Chapter 4.
Creating the Base Business Object Class
The primary code in a business object base class is housekeeping code—code that manages the object state, whether it is "dirty" (meaning changed), and whether it is valid. The base business object class performs any task that is common for all the business objects.
To create a base business object class:
Add a project item to your business object Class Library project using the Class template.
If you created your own class template, you can use it here.
Use a clear name for the base business object class. This helps you (and your project team) keep track of the base class.
Add code as desired.
Add any code that is common to the business objects to the base business object class.
As an example, the base business object class can keep track of the object state. The code required for this has three parts. First, the set of valid business object states must be defined. Then one or more properties must be created to expose the state. Finally, a method is needed to manage the state.
The set of valid business object states can be implemented using an enumeration, defined with the Enum keyword. An enumeration defines a set of named constants whose underlying type is an integer. You can define the integer assigned to each constant; otherwise, the enumeration sets each constant to a sequential integer value starting with 0.
For example, the business object state values are defined in an enumerated type as follows:
Public Enum EntityStateEnum
Unchanged
Added
Deleted
Modified
End Enum
In this example, the value of Unchanged is 0, Added is 1, and so on. Any variable declared to be of this enumeration type can be assigned to one of these defined constants.
A business object's state is exposed by defining a property that gets and sets the object's state. For example, an EntityState property could be defined as follows:
Private _EntityState As EntityStateEnum
''' <summary>
''' Gets the business object state
''' </summary>
''' <value>Unchanged, Added, Deleted, or Modified</value>
''' <returns>Value identifying the entity's state</returns>
''' <remarks></remarks>
Protected Property EntityState() As EntityStateEnum
Get
Return _EntityState
End Get
Private Set(ByVal value As EntityStateEnum)
_EntityState = value
End Set
End Property
Notice that the property uses the Protected keyword to ensure that it can be accessed only by classes that inherit from this base class. The setter uses the Private keyword to ensure that code outside of the class cannot modify the entity's state.
You may want to define other properties that expose the object state in different ways. For example, it is common for a business object to have a Boolean IsDirty property that identifies whether an entity has been changed. Although the EntityStateEnum could be used to determine this, adding an IsDirty property provides a shortcut:
''' <summary>
''' Gets whether the business object has changes
''' </summary>
''' <value>True or False</value>
''' <returns>True if there are unsaved changes;
''' False if not</returns>
''' <remarks></remarks>
Protected ReadOnly Property IsDirty() As Boolean
Get
Return Me.EntityState <> EntityStateEnum.Unchanged
End Get
End Property
This property does not have its own private backing variable. Instead, it uses the value of the EntityState property.
You also need code that manages the state. This is normally implemented as a method:
''' <summary>
''' Changes the state of the entity
''' </summary>
''' <param name="dataState">New entity state</param>
''' <remarks></remarks>
Protected Sub DataStateChanged(ByVal dataState As EntityStateEnum)
' If the state is deleted, mark it as deleted
If dataState = EntityStateEnum.Deleted Then
Me.EntityState = dataState
End If
' Only set data states if the existing state is unchanged
If Me.EntityState = EntityStateEnum.Unchanged _
OrElse dataState = EntityStateEnum.Unchanged Then
Me.EntityState = dataState
End If
End Sub
This code sets the state appropriately. This is not as simple as just assigning the state to the value passed in to the method, because some states cannot be changed. For example, if the state is already defined to be Added, further changes to the object leave the state as Added. And if the state is Deleted, it does not matter which other state it was; it needs to be deleted.
In your code, call DataStateChanged with a state of Added when the user creates a new item. Call DataStateChanged with a state of Deleted when the user deletes an item. Call DataStateChanged with a state of Modified whenever the user changes any of the data associated with an object. Because you defined all your object data with properties, you can add the call to DataStateChanged to the setter for each property, as described in the next section.
Building a base business object class keeps the majority of the housekeeping code out of the business object class itself and lets you focus on the unique business rules and business processing code required for the specific business object.
Inheriting from the Base Business Object Class
After you create a base business object class, you use it by inheriting from it. Each business object class that needs to manage its state can inherit from the base business object class. The business object then has access to the properties and methods from the base business object class.
The Inherits keyword specifies that a class inherits from another class. Add the Inherits keyword to any business object class as follows:
Public Class Product
Inherits PTBOBase
The class, in this case Product, then has all the properties and methods from the base business object class. You can easily see this by typing Me. somewhere within a property or method of the Product class. The Intellisense List Members box displays properties and methods of both the base class (PTBOBase) and the derived class (Product in this case).
To take advantage of the code in the base business object class, the derived classes can use the properties and methods of the base class. For example, when a property in the business object is changed, the code calls the DataStateChanged method in the base business object class to correctly set the business object state.
The code in the ProductName property provides an example:
Public Property ProductName() As String
Get
Return _ProductName
End Get
Set(ByVal value As String)
If _ProductName <> value Then
Dim propertyName As String = "ProductName"
Me.DataStateChanged(EntityStateEnum.Modified)
_ProductName = value
End If
End Set
End Property
The setter code first determines whether the value is the same as it was. If so, it does not reset it. If the value is indeed changed, the setter sets a variable for the property's name. The DataStateChanged method in the base business object class is then called and passed a state of Modified. Finally, the property value is changed to the passed-in value.
In every derived class, modify each updatable property to include similar code. When any property value changes, the object is marked as modified. This ensures that each object is aware of its state so that it can react accordingly.
Overriding Base Class Members
Sometimes the derived class needs to modify the functionality of one of the base class members. When this is required, you can override the base class member by implementing the property or method in the derived class. When the property or method is called, the implementation in the derived class overrides the implementation from the base class.
For example, say that one business object requires some additional processing in the base class DataStateChanged method. To override this method, implement the method in the business object using the exact same method signature:
''' <summary>
''' Changes the state of the entity
''' </summary>
''' <param name="dataState">New entity state</param>
''' <remarks></remarks>
Protected Sub DataStateChanged(ByVal dataState As EntityStateEnum)
MyBase.DataStateChange(dataState) ' Performs base processing
' Do unique code
...
End Sub
Notice that this code calls the base business object class to perform its processing and then performs its unique processing. It could instead perform its processing first and then call the base business object class. Or it can do all of its own processing.
Use overriding whenever the derived class needs its own implementation of a property or method in the base class.