将IDataRecord个别记录分组到集合

Question

I have data as listed below in database.

I have following data access layer code that is working for simple scenarios.. But for the above scenario, I need result based on employeeID grouping .. All roles for an employee should come under one Employee object.

How can we achieve this by modifying the following data access code using the generic delegate features of C# ?

Note: I am looking for a solution that does not use DataTable (since DataTable loads all data upfront and is slower than the IDataRecord approach).

REFERENCES

1. An Elegant C# Data Access Layer using the Template Pattern and Generics
2. Using C# generics and factory classes to map IDataReader to POCO

Data Transfer Object

public class Role
{
    public int RoleID { get; set; }
    public string RoleName { get; set; }
}


public class Employee
{
    public int EmployeeID { get; set; }
    public string EmployeeName { get; set; }
    public List<Role> Roles { get; set; }

    //IDataRecord Provides access to the column values within each row for a DataReader
    //IDataRecord is implemented by .NET Framework data providers that access relational databases.

    //Factory Method
    public static Employee EmployeeFactory(IDataRecord record)
    {
        return new Employee
        {
            EmployeeID = (int)record[0],
            EmployeeName = (string)record[1]
        };
    }
}

Common DAL

public class MyCommonDAL
{
    public static IEnumerable<T> ExecuteQueryGenericApproach<T>(string commandText, List<SqlParameter> commandParameters, Func<IDataRecord, T> factoryMethod)
    {
        string connectionString = @"Server=TRVMVSDDVXXXX;Database=AS400_Source;User Id=XXXXXXXX;Password=XXXXXXX";

        //Action, Func and Predicate are pre-defined Generic delegates.
        //So as delegate they can point to functions with specified signature.

        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            using (SqlCommand command = new SqlCommand())
            {
                command.Connection = connection;
                command.CommandType = CommandType.Text;
                command.CommandText = commandText;
                command.CommandTimeout = 0;
                command.Parameters.AddRange(commandParameters.ToArray());

                connection.Open();
                using (var rdr = command.ExecuteReader())
                {
                    while (rdr.Read())
                    {
                        yield return factoryMethod(rdr);
                    }
                    rdr.Close();
                }
            }
        }
    }
}

Specific DAL

public class MyEmployeeDAL
{
    public List<Employee> GetEmployees(string excludedEmployee)
    {


        List<SqlParameter> commandParameters = new List<SqlParameter>()
                                                {
                                                    new SqlParameter {ParameterName = "@ExcludedEmployee", 
                                                                      Value = excludedEmployee, 
                                                                      SqlDbType = SqlDbType.VarChar}
                                                };


        string commandText = @"SELECT E.EmployeeID,E.EmployeeName,R.RoleID,R.RoleName FROM dbo.EmployeeRole ER
                                INNER JOIN dbo.Employee E  ON E.EmployeeID= ER.EmployeeID
                                INNER JOIN dbo.[Role] R ON R.RoleID= Er.RoleID 
                                WHERE EmployeeName <> @ExcludedEmployee";

        IEnumerable<Employee> employees = MyCommonDAL.ExecuteQueryGenericApproach<Employee>(commandText, commandParameters, Employee.EmployeeFactory);
        return employees.ToList();
    }
}

Client

    static void Main(string[] args)
    {
        MyEmployeeDAL logDAL = new MyEmployeeDAL();
        List<Employee> logSeverities = logDAL.GetEmployees("test");
    }

Answer 1

You should add new flat class

public class RoleAndEmployee
{
    public int RoleID { get; set; }
    public string RoleName { get; set; }
    public int EmployeeID { get; set; }
    public string EmployeeName { get; set; }

    public static Employee EmployeeFactory(IDataRecord record)
    {
        return new RoleAndEmployee
        {
            EmployeeID = (int)record[0],
            EmployeeName = (string)record[1],
            RoleID = (int)record[2],
            RoleName = (string)record[3]
        };
    }
}

and call (i hope, i write it correct without IDE):

IEnumerable<Employee> employees = MyCommonDAL.ExecuteQueryGenericApproach<RoleAndEmployee>(commandText, commandParameters, RoleAndEmployee.EmployeeFactory)
    .GroupBy(c=>new {c.EmployeeId, c.EmployeeName}, c=>new{c.RoleId, c.RoleName})
    .Select(k=>new Employee{EmployeeId=k.Key.EmployeeId, EmployeeName= k.Key.EmployeeName, Roles = k.ToList()});

Update: If you don't want introduce flat class, you can use next approach:

public static Employee EmployeeFactory(IDataRecord record)
{
    var employee = new Employee
    {
        EmployeeID = (int)record[0],
        EmployeeName = (string)record[1],
        Roles = new List<Role>()
    };
    employee.Roles.Add(new Role{RoleID = (int)record[2], roleName=(string)record[3]});
    return employee;
}

IEnumerable<Employee> employees = MyCommonDAL.ExecuteQueryGenericApproach
    <Employee>(commandText, commandParameters, Employee.EmployeeFactory)
        .GroupBy(
            x => new { x.EmployeeID, x.EmployeeName},
            (key, group) => 
                new Employee
                    {
                        EmployeeId=key.EmployeeID, 
                        EmployeeName=key.EmployeeName,
                        Roles = group.SelectMany(v => v.Roles).ToList()
                    }).ToList();

Answer 2

For so to happen you need to assign values to Roles property of your Employee objects.

In factoryMethod you need to find distinct employees create object of the same and assign corresponding roles that you get from your query.

This may help you query your table that you have got as a result.

Answer 3

After executing logDAL.GetEmployees("test") in your specific DAL, just group them.

IEnumerable<Employee> employees = MyCommonDAL.ExecuteQueryGenericApproach
        <Employee>(commandText, commandParameters, Employee.EmployeeFactory);
employees = employees.GroupBy(
                x => new
                    {
                        x.EmployeeID, 
                        x.EmployeeName
                    },
                (key, groupedEmployees) => 
                    new Employee
                        {
                            EmployeeId=key.EmployeeID, 
                            EmployeeName=key.EmployeeName,
                            Roles = groupedEmployees.SelectMany(v => v.Roles)
                        });
return employees.ToList();