Let'us suppose we want to build a mail to trade a Total Return Swap to be send to a broker
1) Interface Layer: We first create a ITrsMailDataProvider and define its interface
Option Explicit Public Function RetrieveBody(irsId As String, fundId As String) As Parameters 'No Code Here End Function Public Function RetrieveHeader(irsId As String, fundId As String) As HeaderDTO 'No Code Here End Function2) DAL: We then create a TrsMailDataExcelProvider that implements teh ITrsMailDataProvider interface. You can use some mock data for testing. If you are getting data from Access just go ahead and create your TRSMailDataAccessProvider that implements the same interface
2) Interface Layer: Then we need to Create a IProviderFactory. This will be the abstract factory that define the abstract methods that return our interface ITrsMailDataProvider or a IIrsMailDataProvider. The idea is that the abstract providers will be produced by your abstract factory. The business layer will use only those interface and will know nothing about which concrete provider it is in use
This class will look like
Class IProviderFactory
GetTrsMailDataProvider as ITrsMailDataProvider //only method signature
GetIrsMailDataProvider as IIrsMailDataProvider //only method signature
End Class
3) DAL Layer: We then need a class that implement the IProviderFactory. For Example a ExcelProviderFactory will take care to create of the MailDataProvider that have Excel as source.
Option Explicit Implements IProviderFactory Private mTrsMailDataProvider As TrsMailDataExcelProvider Private mIrsMailDataProvider As IrsMailDataExcelProvider Private Function IProviderFactory_GetIrsMailDataProvider() As IIrsMailDataProvider If mIrsMailDataProvider Is Nothing Then Set mIrsMailDataProvider = New IrsMailDataExcelProvider Else 'Do Nothing End If Set IProviderFactory_GetIrsMailDataProvider = mIrsMailDataProvider End Function Private Function IProviderFactory_GetTrsMailDataProvider() As ITrsMailDataProvider If mTrsMailDataProvider Is Nothing Then Set mTrsMailDataProvider = New TrsMailDataExcelProvider Else 'Do Nothing End If Set IProviderFactory_GetTrsMailDataProvider = mTrsMailDataProvider End Function
4) BLL: Finally we will have the client of the Abstract Factory, as for the Abstract factory Pattern. We will call this class the DataProvider (this can be a static class in c# ore moduel in VBA) and it will sit in the business Layer. This Class has the main objective to
use the IProviderFactory interface to produce our Trs and Irs MailDataProvider. The diffuclt part here is that this class should istantiate a Real istance of the abstract class IProviderFactory, but as we know we want the business Layer to be agnostic of the DAL. To get this result in C# we can use reflection. We can just write a method so that it loads a .dll specified in a config file as a string, and create an istance of a class from this dll.
This way to reference to the DAL Layer are necessary. In VB 6.0 this is can be done with CreateObject.
Option Explicit Private mFactory As IProviderFactory Public Function IrsMail() As IIrsMailDataProvider Set IrsMail = Factory.GetIrsMailDataProvider() End Function Public Function TrsMail() As ITrsMailDataProvider Set TrsMail = Factory.GetTrsMailDataProvider() End Function Private Function Factory() As IProviderFactory 'Insert Code here 'This cose should use a config file and reflection to choose 'which concrete factory instantiate. Createobject could be used in VB 6.0 'to make this class decouple with the DAL Layer 'We keep things ease here. If (mFactory Is Nothing) Then Set mFactory = New ExcelProviderFactory 'I really should be using CreateObject 'to keep the class decoupled from the DAL End If Set Factory = mFactory End Function
4) So fare we have done the following
a) Business Layer --> Interface Layer -->; DataBase Layer
b) In the Interface Layer we have implemented the Model Provider Pattern and the Abstract Factory Pattern. Those class are just interface that define the methods that the business Layer can call to accesss the data
c) In the DAL we have the real providers that just implement the provider interfaces and the real factory that just implement the factory methods.
d) The transfer of the data between DAL and Business Layer is done using some object that are on the common layer such as MailDTO (data transfer object) or the Parameters collections (this is an utility object)
e) The client of the abstract factory, the one we called DataProvider, is in the BLL and it stores in as a private field a reference to the IProviderFactory. This is where the magic happen: we can just switch the RealProvider withouth having to change any of the code that regards the BLL or Interface Layer.
Posts
