将匿名类型列表转换为特定类类型的列表

Question

I have an abstract class "Employee".

I have a factory method that extends on this Employee class to query the database to return a list of all active employees:-

 public static class EmployeeExtentions
    {
        public static List<Employee> FireEmployees(this List<Employee> AllCitiesEmps)
        {
            List<Employee> employees = new List<Employee>();

            using (var ctx = new hr_employeeEntities())
            {
                var emp = (from x in ctx.F_Emp
                           join y in ctx.HR_EMPLon (x.employee_id).ToString() equals y.EMPLID
                           where x.employment_status == "A"
                           select new { x, y }).ToList();

                // emp.ForEach( x => { employees.Add(new Employee(employees)); });
                //var emps = emp.Select(x => PropertyCopy<Employee>.CopyFrom(x)).ToList();    
                //emp.ForEach(x => { employees.Add(new Employee(x)); });

            }
            return employees;
        }
    }

The var 'emp' is a list of all active employees but an anonymous list. I want to convert this into a strongly typed List of type Employee. I have 3 commented statements in my code which were my attempts.

Answer 1

What is the relationship between F_Emp and HR_EmpLon? It seems that these are loosely coupled through Employee_Id / EMPID depending on the table, but which table represents "Employee"?

Firstly: This does not look like it needs to be an extension method. Extension methods are meant for creating a method that will apply to a given instance of a variable. In this case "AllCitiesEmps" you are not using this instance, so at a minimum this could just be a Static method on Employee itself. (Frankly though, better served as a Repository method)

If Employee is mapped to F_Emp then the join is unnecessary:

public static List<Employee> FireEmployees()
{
    using (var context = new hr_employeeEntities())
    {
        var employees = context.F_Emp
            .Where(x => x.employment_status == "A")
            .ToList();
        return employees;
    }
}

If Employee maps to the HR_EmpLon table and these tables do not share a common FK between them: (Disclaimer, this is a stab from memory, so it may need some tweaking. I rarely ever need to use explicit joins.)

public static List<Employee> FireEmployees()
{
    using (var context = new hr_employeeEntities())
    {
        var employees = context.HR_EMPLon
            .Join(context.F_Emp, 
                h => h.EMPLID, 
                e => e.employee_id.ToString(),
                (h, e) => new {HREmployee = h, FEmployee = e})
            .Where(x => x.FEmployee.employment_status == "A")
            .Select(x => x.HREmployee)
            .ToList();
        return employees;
    }
}

If an Employee is not an entity mapped to either table, but represents a mix of data from these two tables, then I would recommend setting up a View in your database to join this data, and map your entity to the view.

Answer 2

You can try something like this:

public static class EmployeeExtentions
{
    public static List<Employee> FireEmployees(this List<Employee> AllCitiesEmps)
    {
        List<Employee> employees = new List<Employee>();

        using (var ctx = new hr_employeeEntities())
        {
            var emp = (from x in ctx.F_Emp
                       join y in ctx.HR_EMPL on (x.employee_id).ToString() equals y.EMPLID
                       where x.employment_status == "A"
                       select new
                       {
                           x.employee_id,
                           x.employment_status,
                           //x.OtherProperties
                           y.EMPLID,
                           //y.OtherProperties
                       }).ToList();

            employees = emp.Select(x => (new EmployeeDerived { EmployeeId = x.employee_id, EmploymentStatus = x.employment_status }) as Employee).ToList();

        }
        return employees;
    }

    private class EmployeeDerived : Employee
    {

    }    
}

Please note, you will need to create a new derived type though, as you can't directly cast to an abstract type.