Question

I’m currently creating objects for an application of mine when this stuff come to mind. I know that using DBML’s over Manual Creation of classes(see class below) can improve the speed of my application development but I’m really confused of what would be the other disadvantages and advantages of using DBML’s over Manual Creation of classes like what I’m doing below thanks for all people who would help. 🙂

[Serializable]
public class Building
{
    public Building()
    {
        LastEditDate = DateTime.Now.Date;
        LastEditUser = GlobalData.CurrentUser.FirstName + " " + GlobalData.CurrentUser.LastName;
    }

    public int BuildingID { get; set; }
    public string BuildingName { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastEditDate { get; set; }
    public string LastEditUser { get; set; }

    public static bool CheckIfBuildingNameExists(string buildingName, int buildingID = 0)
    {
        return BuildingsDA.CheckIfBuildingNameExists(buildingName, buildingID);
    }

    public static Building CreateTwin(Building building)
    {
        return CloningUtility.DeepCloner.CreateDeepClone(building);
    }

    public static List<Building> GetBuildingList()
    {
        return BuildingsDA.GetBuildingList();
    }

    public static List<Building> GetBuildingList(bool flag)
    {
        return BuildingsDA.GetBuildingList(flag).ToList();
    }

    public static Building SelectBuildingRecord(int buildingId)
    {
        return BuildingsDA.SelectBuilding(buildingId);
    }

    public static void InsertBuildingRecord(Building building)
    {
        BuildingsDA.InsertBuilding(building);
    }

    public static void UpdateBuildingRecord(Building building)
    {
        BuildingsDA.UpdateBuilding(building);
    }

    public static void DeleteBuildingRecord(int building)
    {
        BuildingsDA.DeleteBuilding(building);
    }
}

and my DAL is like this:

internal static class BuildingsDA
{
    internal static Building SelectBuilding(int buildingId)
    {
        SqlCommand commBuildingSelector = ConnectionManager.MainConnection.CreateCommand();
        commBuildingSelector.CommandType = CommandType.StoredProcedure;
        commBuildingSelector.CommandText = "Rooms.asp_RMS_Building_Select";
        commBuildingSelector.Parameters.AddWithValue("BuildingID", buildingId);

        SqlDataReader dreadBuilding = commBuildingSelector.ExecuteReader();
        if (dreadBuilding.HasRows)
        {
            dreadBuilding.Read();
            Building building = new Building();
            building.BuildingID = int.Parse(dreadBuilding.GetValue(0).ToString());
            building.BuildingName = dreadBuilding.GetValue(1).ToString();
            building.IsActive = dreadBuilding.GetValue(2).ToString() == "Active";
            building.LastEditDate = dreadBuilding.GetValue(3).ToString() != string.Empty ? DateTime.Parse(dreadBuilding.GetValue(3).ToString()) : DateTime.MinValue;
            building.LastEditUser = dreadBuilding.GetValue(4).ToString();
            dreadBuilding.Close();
            return building;
        }
        dreadBuilding.Close();
        return null;
    }

    ....................
}

I would also want to know if what could be the faster between the two methods of OOP implementation thanks 🙂

Answer 1

DBML

Pros:

1. You can get your job done fast!

Cons:

1. You can’t shape your entity the way you want, for example you need 5 columns from the table but it has 10 columns you will get all of them, at least its schema. If you don’t care much about data volum
2. You client side will have dependency with DAL (Data Access Layer), if you change property name, type in DAL you need to change in both BLL (Business Logic Layer) and client (Presentation Layer)

If you manual create class you might take a little bit more time to code but you get more flexible with it. Your client code will not depend on your DAL, any changes on DAL will not cause problems on client code.