DbTransaction类和C＃中的接口

Question

I came across an example of the implementation an an interface. Portion of code is

public partial interface IDataProvider
{
    DataTable GetEmployeeAbsenceDurationTypes();

    void AlterEmployeeAbsenceDurationTypes(DataTable lookUpTable);
}

public partial class DataProvider : IDataProvider
{    

    public DataTable GetEmployeeAbsenceDurationTypes()
    {
        return GetEmployeeAbsenceDurationTypes((DbTransaction)null);
    }
    public DataTable GetEmployeeAbsenceDurationTypes(DbTransaction tran)
    {
        //Db Operations
    }
}

My first question is about this "DbTransaction" class. Its not in my project, is it a build in class?

My second question is, why in the DataProvider (the implementing class), the function is calling another overload of itself?

Answer 1

DbTransaction is a common base-class for representing database transactions in ADO.NET; each actual ADO.NET provider subclasses this (typically) - for example SqlTransaction : DbTransaction (the sql-server client).

Calling an overload of self is a common way of implementing optional parameters, without code duplication prior to their addition in C# 4.0. In this case, that is essentially a pre-4.0 way of implementing:

public DataTable GetEmployeeAbsenceDurationTypes(DbTransaction tran = null) {...}

either implementation (overloads or optional parameter) allows usage of the form:

obj.GetEmployeeAbsenceDurationTypes(); // without transaction
obj.GetEmployeeAbsenceDurationTypes(tran); // with transaction

Answer 2

The first question is impossible to answer for sure without seeing the whole code, but it's probably referring to System.Data.Common.DbTransaction .

As for the implementation - presumably it's a way of reusing the code, that's all. If the implementation of the method with a parameter can handle a parameter value of null as "do it in a new transaction" (or whatever the behaviour of the parameterless method should be) naturally, why wouldn't you want one overload to call the other?