Question

我正在为人力资源系统开发系统。有会计员工和程序员员工。在加入公司的第一个月，员工没有任何角色。一名员工可以同时是会计师和程序员。我有一个由以下代码显示的设计。

现在，我需要通过实现新功能来增强系统：

终止所有会计师。（终止表示将员工的状态设置为IsActive = false）。问题是我不能在没有检查的情况下将所有会计师直接设置为非活动状态。我需要检查一下他是否还有其他角色。

如何重新构造这些类以使终止函数更自然OO？

更新

我正在寻找一个有@AlexDev答案的EF Database First解决方案模型和数据库架构的答案。

C＃代码

List<Accountant> allAccountants =  Get All accountants from database

public class Employee
{
    public int EmpID { get; set; }
    public DateTime JoinedDate { get; set; }
    public int Salary { get; set; }
    public bool IsActive { get; set; }
}


public class Accountant : Employee
{
    public Employee EmployeeData { get; set; }
}

public class Programmer : Employee
{
    public Employee EmployeeData { get; set; }
}

enter image description here

@AlexDev回答

public class Employee
{
...
IList<Role> Roles;
bool isActive;

public void TerminateRole(Role role)
{
    Roles.Remove(role);
    if(Roles.Count == 0)
    {
        isActive = false;
    }
}
}

public class Role
{
 abstract string Name { get;}
}

public class ProgrammerRole : Role
{
 override string Name { get { return "Programmer"; } }
}

参考

Answer 1

要使用您正在使用的结构，除了可能会将新角色添加到系统中以及C＃中不存在的新角色之外，您还需要为会计师和程序员进行多重继承。你应该考虑不同的设计。一种可能性：

public class Employee
{
    ...
    IList<Role> Roles;
    bool isActive;

    public void TerminateRole(Role role)
    {
        Roles.Remove(role);
        if(Roles.Count == 0)
        {
            isActive = false;
        }
    }
}

public class Role
{
    abstract string Name { get;}
}

public class ProgrammerRole : Role
{
    override string Name { get { return "Programmer"; } }
}

然后，您可以为每种类型子类化Role，并且您可以决定仅终止一个角色或所有角色。

Answer 2

我正在编写一个新的答案，因为从你添加的问题的模式中我假设你不会继承Role。此外，如果您使用NHibernate，请不要忘记使用公共虚拟属性。

public class Employee
{
    ...
    public virtual IList<Role> Roles { get; set; }
    public virtual bool isActive { get; set; }

    public virtual void TerminateRole(Role role)
    {
        Roles.Remove(role);
        if(Roles.Count == 0)
        {
            isActive = false;
        }
    }
}

public class Role
{
    public virtual int RoleID { get; set; }
    public virtual string Name { get; set; } 
}

并映射：

public class EmployeeMap : ClassMap<Employee>
{
    public EmployeeMap()
    {
        Id(x => x.EmpId);
        Map(x => x.JoinedDate)
        Map(x => x.Salary);
        Map(x => x.IsActive);
        HasManyToMany(x => x.Roles).Cascade.AllDeleteOrphan().Table("EmployeeRole")
    }
}

public class RoleMap : ClassMap<Role>
{
    public RoleMap()
    {
        Id(x => x.RoleID);
        Map(x => x.RoleName);
    }
}

Answer 3

public abstract class AbstractEmployee
{
    ...
    public abstract bool IsActiveAccountant { get; set; }
    public abstract bool IsActiveProgrammer { get; set; }
    public bool IsActive() { get { return bitwise or of all roles; } }
}

public class NewEmployee : AbstractEmployee
{
    ...
    public override bool IsActiveAccountant { get; set; }
    public override bool IsActiveProgrammer { get; set; }
}

public class Programmer : AbstractEmployee
{
    ...
    public override bool IsActiveAccountant { get; set; }
    public override bool IsActiveProgrammer { get; set; }
}

<强>缺点：

添加了每个新的系统范围角色，您必须修改类

<强>优点：

您不需要搜索会计师
程序员可以拥有IsActiveAccountant的空实现，因为无论如何这个角色对他们都是无效的
NewEmployee可以同时拥有多个角色

如果引入新角色的开销很大，我会坚持搜索

Answer 4

我在Prefer composition over inheritance?

中的回答

我将首先检查 - 是否存在“is-a”关系。如果存在，我通常会检查以下内容：

是否可以实例化基类。也就是说，基类是否可以是非抽象的。如果它可以是非抽象的，我通常更喜欢组合

例如1.会计是员工。但我不会使用继承，因为可以实例化Employee对象。

E.g 2. Book是SellingItem。 SellingItem无法实例化 - 它是抽象概念。因此我将使用inheritacne。 SellingItem是一个抽象基类（或C＃中的接口）

使用Composition为“is - a”关系的问题

4 个答案: