Let imaging that you have a OraDal and SQLDal data components. Each of these
components has an overrided GetCustomers() methods. You have a common
DataController component that will instantiate required DB component depends
on your configuration settings and delegate all your request.

Everyting BAL should know it's the GetCustomers() method

[quoted text, click to view]

---
WBR,
Michael Nemtsev :: blog: http://spaces.msn.com/members/laflour

"At times one remains faithful to a cause only because its opponents do not
cease to be insipid." (c) Friedrich Nietzsche

Hi Michael,

That's perfect....however there are just a few problem with the behavior you
described.

I am ok with the centralized DataController that expose a method
GetCustomers(),
and I am ok that somewhere in the datacontroller I read the configuration
file to know which DAL (OraDAL, SqlDAL) should I use.
In this case the DataController should expose all methods of my DAL even if
I don't need to view them.

For example I could code something like this:

CustomerCollection collCustomer = DataController.GetCustomers()
CategoryCollection collCustomer = DataController.GetCategory()

instead of

CustomerCollection collCustomer = myCustomerController.GetCustomers()
CategoryCollection collCustomer = myCategoryController.GetCategory()

and I don't like to have a huge class that expose all the methods I need for
my applications. This class could grow up to infinite methods
However independently from which approch a person likes I cannot understand
how can I avoid reflection inside the DataController
in order to do not reference the DAL assemblies inside the project and
mantaining the DAL assemblies separated.

here is my sample code to allow you see my implementation.

[Common Interface IUser.cs - Assembly MyApp.IData.dll]

public interface IUser
{
User GetUser(int UserID);
}

[SQL DAL doUser.cs - Assembly MyApp.Sql.dll]

public class doUser : doBase, IUser
{
public User GetUser(int UserID)
{
//SQL SPECIALIZED CODE
}
}

[ORACLE DAL doUser.cs - Assembly MyApp.Ora.dll]

public class doUser : doBase, IUser
{
public User GetUser(int UserID)
{
//ORACLE SPECIALIZED CODE
}
}


[Factory User.cs - Assembly MyApp.Factory.dll]

public class User
{
public static EnterprisePortalSolution.IData.IUser Create()
{
string providerAssembly =
ConfigurationSettings.AppSettings["DataProviderAssembly"];
string className = providerAssembly + ".doUser";

return
(EnterprisePortalSolution.IData.IUser)Assembly.Load(providerAssembly).CreateInstance(className);
}
}


[Business Layer boUser.cs - Assembly MyApp.Business.dll]
public class boUser
{
public User GetUser(int UserID)
{

User user = new UnknownUser();

IUser dal = EnterprisePortalSolution.Factory.User.Create();

try
{
user = dal.GetUser(UserID);
}
catch(Exception ex)
{
throw;
}
return user;
}
}

At the end it seems to me like move the use of reflection from BLL to DAL.

And the transaction?


Anyway I like this discussion :)