Use Of Generics - Build Code Discipline In Repository Classes

While there can be number of usage of Generics in C# Classes, I have used it many a times to induce coding discipline and bring commonality in method signatures.

Background

 

While there can be a number of usages of Generics in C# Classes, I have used it many a times to induce coding discipline and bring commonality in method signatures. As an Architect, I found it often difficult to control the burst of public methods written by multiple developers, specially when you are executing the project in Agile mode. Generics gives me a handle there. 

 

I primarily use it in the repository classes where you finally persist or fetch the data into your datastore. Whether you are using Entity Framework or any other ORM, ORACLE or SQL Server, this approach always works. So here we go!

 

Firstly I will define a Generic Class that would encapsulate all possible (that I could think of !)  Methods. This will become the base.

public interface IEntityOperations<T> where T: new()
{
    //Get all the items of type T
    List<T> GetAll();

    //Get all the items based on the Where condition. Use the dictionary input param to send the multiple
    //conditions, parameters etc.
    List<T> GetAllWhere(Dictionary<string, string> kvpairs);

    //Save the entity and return the PK of the newly created record
    string Save(T obj);

    //Update based on the Where condition. Return whether the update was success or not.
    bool UpdateWhere(Dictionary<string, object> kvSet, Dictionary<string, object> kvWhere);

    //Delete based on the where condition. Return whether the delete was success or not
    bool DeleteWhere(Dictionary<string, object> kvWhere);

}

For my illustration, I have taken two simple entity class - A Student and a Department. The respective operations for each of this entity is named StudentOperation and DepartmentOperation.

public class Student
{
    public long StudentID { get; set; }
    public string FullName { get; set; }
    public DateTime DOB { get; set; }
}

public class Department
{
    public long DepmtID { get; set; }
    public string DepmtName { get; set; }
    public string DepmtSubject { get; set; }
}

The code intellisense helps you implement the operation class, as soon as you inherit from the Generic class. Choose the option "Implement interface" and it will populate the full code for you. That rocks !

 

 

Following the above action, here are the operation classes. I have only implemented the Save() method for this blog purpose in both the operation classes. Also, note that in the DepartmentOperation class, I have added a new override method GetAllWhere() with a different signature, to show that you can write more public functions as you desire, as long as you complete the contract of the interface that you inherited.

public class StudentOperation : IEntityOperations<Student>
{
    public bool DeleteWhere(Dictionary<string, object> kvWhere)
    {
        throw new NotImplementedException();
    }

    public List<Student> GetAll()
    {
        throw new NotImplementedException();
    }

    public List<Student> GetAllWhere(Dictionary<string, string> kvpairs)
    {
        throw new NotImplementedException();
    }

    public string Save(Student obj)
    {
        Console.WriteLine("I am currently in " + nameof(Save) + " method of class " + nameof(StudentOperation));
        return obj.StudentID.ToString();
        //throw new NotImplementedException();
    }

    public bool UpdateWhere(Dictionary<string, object> kvSet, Dictionary<string, object> kvWhere)
    {
        throw new NotImplementedException();
    }

}

public class DepartmentOperation : IEntityOperations<Department>
{
    public bool DeleteWhere(Dictionary<string, object> kvWhere)
    {
        throw new NotImplementedException();
    }

    public List<Department> GetAll()
    {
        throw new NotImplementedException();
    }

    public List<Department> GetAllWhere(Dictionary<string, string> kvpairs)
    {
        throw new NotImplementedException();
    }

    //this is a over ride method just to show the implementation that you can write
    //more variance of functions based on your need.
    public List<Department> GetAllWhere(params object[] csv)
    {
        throw new NotImplementedException();
    }

    public string Save(Department obj)
    {
        //throw new NotImplementedException();
        Console.WriteLine("I am currently in " + nameof(Save) + " method of class " + nameof(DepartmentOperation));
        return obj.DepmtID.ToString();
    }

    public bool UpdateWhere(Dictionary<string, object> kvSet, Dictionary<string, object> kvWhere)
    {
        throw new NotImplementedException();
    }

}

 Finally, our client program (Console app), where we will make the calls to respective classes.

class Program
{
    static void Main(string[] args)
    {

        //Demo
        DemoOfGenerics();

        Console.ReadLine();
    }

    static void DemoOfGenerics()
    {
        Console.WriteLine("Student (S) / Department (D) ?");
        string choice = Console.ReadLine().ToUpper();

        if (choice == "S")
        {
            IEntityOperations<Student> studentOperation = new StudentOperation();
            Student s = new Student() { StudentID = 12000, FullName = "Jack Turner", DOB = Convert.ToDateTime("12-Mar-2002") };
            var val = studentOperation.Save(s);
            Console.WriteLine("Student added with ID: S" + val.ToString());
        }
        else if (choice == "D")
        {
            IEntityOperations<Department> depmtOperation = new DepartmentOperation();
            Department d = new Department() { DepmtID = 45000, DepmtName = "Electronics Engineering", DepmtSubject = "Electronics" };
            var val = depmtOperation.Save(d);
            Console.WriteLine("Depmt added with ID: D" + val.ToString());
        }
        else
        {
            Console.WriteLine("Please insert only S or D.");
        }
    }
}

Here is the Console output after running the program with the different input options,

Student (S) / Department (D) ?
s
I am currently in Save method of class StudentOperation
Student added with ID: S12000

Student (S) / Department (D) ?
d
I am currently in Save method of class DepartmentOperation
Depmt added with ID: D45000

Conclusion

1. You can bring in discipline in method definitions and avoid unnecessary public methods explosion. This approach is handy when you are working with a large team or a complex / mission critical project code.
2. You are free to add more overrides of the methods
3. You can assess the commonality of the methods and create common utility functions. i.e. If the Save() method has similar checks of valid parameters or the Get() methods have similar methods for null colaesing; you can create common functions for such operations and further improve reusability.
4. The generics can play an important role if the logic to chose the entity is dynamically decided. 

 

Please share your comments and let me know your feedback. It would be great if you can share your user stories that you think fit the bill, or have a question on how to do it. I would love to learn. Until then, stay safe and stay blessed!

 

Thank You !