Question

I am creating a Data Access Layer in C# for an SQL Server database table. The data access layer contains a property for each column in the table, as well as methods to read and write the data from the database. It seems to make sense to have the read methods be instance based. The question I have is regarding handling the database generated primary key property getter/setter and the write method. As far as I know I have three options…

Option 1: Using a static method while only allowing a getter on the primary key would allow me to enforce writing all of the correct values into the database, but is unwieldy as a developer.

Option 2: Using and instance based write method would be more maintainable, but I am not sure how I would handle the get/set on the primary key and it I would probably have to implement some kind of validation of the instance prior to writing to the database.

Option 3: Something else, but I am wary of LINQ and drag/drop stuff, they have burned me before.

Is there a standard practice here? Maybe I just need a link to a solid tutorial?

Answer 1

You might want to read up on active record patterns and some examples of them, and then implement your own class/classes.

Here’s a rough sketch of a simple class that contains some basic concepts (below).

Following this approach you can expand on the pattern to meet your needs. You might be OK with retrieving a record from the DB as an object, altering its values, then updating the record (Option2). Or if that is too much overhead, using a static method that directly updates the record in the database (Option1). For an insert, the database (SP/query) should validate the natural/unique key on the table if you need to, and probably return a specific value/code indicating a unique constraint error). For updates, the same check would need to be performed if allowing natural key fields to be updated.

A lot of this depends on what functionality your application will allow for the specific table.

I tend to prefer retrieving an object from the DB then altering values and saving, over static methods. For me, it’s easier to use from calling code and can handle arcane business logic inside the class easier.

public class MyEntityClass
{
    private int _isNew;
    private int _isDirty;
    private int _pkValue;
    private string _colValue;

    public MyEntityClass()
    {
        _isNew = true;
    }

    public int PKValue
    {
        get {return _pkValue;}
    }

    public string ColValue
    {
        get {return _colValue;}

        set
        {
            if (value != _colValue)
            {
                _colValue = value;
                _isDirty = true;
            }
        }
    }

    public void Load(int pkValue)
    {
        _pkValue = pkValue;

        //TODO: query database and set member vars based on results (_colVal)

        // if data found
        _isNew = false;
        _isDirty = false;
    }

    public void Save()
    {
        if (_isNew)
        {
            //TODO: insert record into DB
            //TODO: return DB generated PK ID value from SP/query, and set to _pkValue
        }
        else if (_isDirty)
        {
            //TODO: update record in DB
        }
    }
}