Home / Questions / 3253
Accepted
Elvira
Asked: 2020-01-28 14:24:04 +0800 CST 2020-01-28 14:24:04 +0800 CST

使用适用于不同对象的方法

  • 772

我有一个系统可以处理我工作的公司中多种类型的工人角色（大约 30 个）。它们都有共同的数据（例如个人数据）。我想提高效率的是为许多类型的工人重用方法代码。其中一些类是: Manager，每个Director类都Employee必须检查其输入时间，而我使用另一个名为 的类来执行此操作Company，因此我为该类提供了三种方法：

public class Company
{
    public void CheckIn(Director Person)
    {

    }

    public void CheckIn(Employee Person)
    {

    }

    public void CheckIn(Manager Person)
    {

    }
}

根据进入公司的角色，整个建筑物的入口处会发生不同的事情。我希望我让自己明白了。

c#

7 Answers

  1. 您可以使用继承类或接口Persona，其中您提到的所有类的所有公共成员都包含它

    所以你只有一种方法CheckIn：

    public void CheckIn(Persona persona){

}

    例如：

    带接口

    interface IPersona
{

    string Nombre { get; set; }
    string Apellido { get; set; }
    DateTime FechaIngreso {get; set;}
    //un Largo etc.
}

    接口中的属性注意事项

    和一堂课

       public abstract class Persona { //puede ser abstracta o no
        string Nombre { get; set; }
        string Apellido { get; set; }
        DateTime FechaIngreso {get; set;}

        public void MetodoGenerico(){
        }
   }

    无论哪种方式，您都需要在“孩子”中引用它们，在您的班级中，Director您必须拥有

    public class Director : IPersona //La I es por convención al usar Interfaces

    任何一个

    public class Director : Persona

    无论您选择哪种方式，都会大大加快您的开发速度。

    • 11
  2. Best Answer

    当然，您可以做的是使用接口。接口允许您为类建立规则（法律上它们必须具有的属性和方法）。下面是一个代码示例：

    public interface ICommonDataBetweenWorkers
    {
        string Name { get; set; }
        string Identifier { get; set; }
    }

 public class Employee : ICommonDataBetweenWorkers
    {
        public string Name { get; set; }

        public string Identifier { get; set; }
    }

    public class Manager : ICommonDataBetweenWorkers
    {
        public string Name { get; set; }

        public string Identifier { get; set; }
    }

    public class Director : ICommonDataBetweenWorkers
    {
        public string Name { get; set; }

        public string Identifier { get; set; }
    }

    public class Company
    {
        public void CheckIn(ICommonDataBetweenWorkers Person)
        {
            Console.WriteLine(Person.Name);
            Console.WriteLine(Person.Identifier);

            if (Person is Manager)
            {
                //Do something
            }
            else if(Person is Director)
            {
                //Do something
            }

            else if(Person is Employee)
            {
                //Do something

            }
            /*
             * No importa si es manager, director o employee. Mientras implementan la interfaz
             * compartirán los mismos miembros.
             */
        }

    当你调用你的检查输入法时，你会这样做：

     static void Main(string[] args)
        {
            Company C = new Company();

           //Cuando sea Employee
            C.CheckIn(new Employee());

            //Cuando sea Manager
            C.CheckIn(new Manager());

            //Cuando sea Director
            C.CheckIn(new Director());

            //Cuando sea otra cosa
            C.CheckIn(new OtherRoleThatYouHave());
        }
    • 8

  3. 根据你说的

    它们都有共同的数据（例如个人数据）。我想让效率更高的是为多种类型的工人重用方法代码

    除了使用接口的选项之外，也许使用一些属性就足够了Person，例如Person.Rol，除了有一种按角色检查的类型之外，还可以使用一些属性来为您提供类的角色，例如CheckingType，将不同的角色分组为类似的行为。

    if (Person.Rol.CheckingType == Administrative)
{
//Turno administrativo
}
else if (Person.Rol.CheckingType == Supervisor)
{
//Turno gerentes/supervisores
}
else
{
//Los demás empleados
}
    • 4

  4. 由于您没有指定 CheckIn 方法中的代码，因此我将尝试以最一般的方式回答：

    首先，您应该尝试的第一件事是创建一个工作接口，其中包含必须对所有人通用的字段和方法。例如：

    public interface IRol
{
    int Id { get; set; }
    int HoraMaximaDeLlegada { get; set; }
}

    然后每种类型的worker都可以实现这些字段和方法

    public class Director: IRol
{
    public int Id { get; set; }
    public int HoraMaximaDeLlegada { get; set; } 
}

public class Employee: IRol
{
    public int Id { get; set; }
    public int HoraMaximaDeLlegada { get; set; } 
}

public class Manager: IRol
{
    public int Id { get; set; }
    public int HoraMaximaDeLlegada { get; set; } 
}

    以这种方式假设例如我们有以下类

    public class CheckIn
{
    public int Id { get; set; }
    public int PersonId { get; set; }
    public DateTime FechaCheckIn { get; set; }
    public bool EsTarde { get; set; }
}

    您的方法可以简化为：

    public class Company
{
    public void CheckIn(IRol person)
    {
        // Acá puedes usar todos los campos disponibles en IRol para realizar la tarea que necesites
        // Ejemplo de implementación
        var now = DateTime.Now;
        var checkIn = new CheckIn
        {
            PersonId = person.Id,
            FechaCheckIn = now,
            EsTarde = now > DateTime.Today.AddHours(person.HoraMaximaDeLlegada)
        };
        //... Hacer algo con ese nuevo checkIn
    }
}

    但这并不总是可能的。

    如果由于某种原因您无法修改类以使它们无法实现相同的接口怎么办。即使这些类没有相同的字段怎么办？

    这可以通过适配器模式解决

    interface此模式用于更改您需要使其适应特定 API 的类的“接口”（一般使用的术语，与C# 不同）

    例如，我们有以下类：

    public class Director
{
    public int Id { get; set; }
    // Al ser el director no tiene una hora maxima de llegada
}

public class Employee
{
    public int Id { get; set; }
    public int HoraDeEntrada { get; set; } 
}

public class Manager
{
    public int Id { get; set; }
    public int PuedeLlegarHasta { get; set; }
}

    在这种情况下，我们可以创建一个标准化接口的适配器

    public abstract class BaseRolAdapter : IRol
{
    public int Id { get; set; }
    public abstract int HoraMaximaDeLlegada { get; set; }

    public BaseRolAdapter(int id)
    {
        Id = id;
    }
}

    然后我们可以为每个角色创建一个子类型

    public class EmployeeAdapter : BaseRolAdapter
{
    public readonly Employee Employee;

    public override int HoraMaximaDeLlegada
    {
        get { return Employee.HoraDeEntrada; }
        set { Employee.HoraDeEntrada = value; }
    }

    public EmployeeAdapter(Employee person)
        : base(person.Id)
    {
        Employee = person;
    }
}

public class ManagerAdapter : BaseRolAdapter
{
    public readonly Manager Manager;

    public override int HoraMaximaDeLlegada
    {
        get { return Manager.PuedeLlegarHasta; }
        set { Manager.PuedeLlegarHasta = value; }
    }

    public ManagerAdapter(Manager person)
        : base(person.Id)
    {
        Manager = person;
    }
}

public class DirectorAdapter : BaseRolAdapter
{
    public readonly Director Director;

    public override int HoraMaximaDeLlegada
    {
        get { return 24; /* Con esto el Director nunca llegara tarde */ }
        set { }
    }

    public DirectorAdapter(Director person)
        : base(person.Id)
    {
        Director = person;
    }
}

    每个实现都可以有自己的逻辑

    那么班级Company将是这样的

    public class Company
{
    public void CheckIn(BaseRolAdapter person) // o IRol en lugar de BaseRolAdapter  si implementaba la interfaz
    {
        // Acá puedes usar todos los campos disponibles en IRol para realizar la tarea que necesites
        // Ejemplo de implementación
        var now = DateTime.Now;
        var checkIn = new CheckIn
        {
            PersonId = person.Id,
            FechaCheckIn = now,
            EsTarde = now > DateTime.Today.AddHours(person.HoraMaximaDeLlegada)
        };
        //... Hacer algo con ese nuevo checkIn
    }
}

    通过这种方式，您可以使 CheckIn 方法始终依赖于单个类或接口，而不是针对每种类型的员工都有一个。

    De todas maneras estas solo son algunas ideas, tu caso puede variar considerablemtente pero la idea es la misma, estandarizar la interfaz para poderla hacer única para todo tipo de clases.

    • 4

  5. 为了尊重这些概念SOLID，您不应根据您必须验证的人使用任何 if 或 swith 应用逻辑。

    这就是为什么我想摆出这样的姿势

    public abstract class Person {

    public virtual void CheckIn()
    {
        //implementacion por defecto de la validacion
        //usas el "this"" para hacer referencia al objeto
     }

}

public class Director: Person
{

    public override void CheckIn()
    {
        //implementacion para el director
        //usas el this para hacer referencia al objeto
    }

}

public class Employee: Person
{

    public override void CheckIn()
    {
       //implementacion para el empleado
       //usas el this para hacer referencia al objeto
     }

}

public class Manager: Person
{
   //este hace uso de la implementacion base
}

public class Company
{
    public void CheckIn(Person person)
    {
       person.CheckIn();
    }

}

    正如您将看到的继承，您可以使类实现其具体验证。你会这样调用它吗

    Company company = new Company();
company.CheckIn(new Director());

    在这种情况下，使用 avirtual来定义基本实现，因此您只需要在必要时覆盖，但如果您不想，您可以定义一个方法，如abstract

    • 3

  6. 我想添加我的答案，尽管我建议（像其他人一样）在对象上使用接口，但是另一个选项如下：

        private void CheckIn(object person)
    {
        if (person is Director)
        {
            // lógica 1
            return;
        }

        if (person is Manager)
        {
            // lógica 2
            return;
        }

        if (person is Employee)
        {
            // lógica 3
            return;
        }

        throw new Exception("No es de un tipo aceptado por la función.")
    }

    问候，这里你提到了“是”

    • 1

  7. También se puede utilizar una definición de una clase con parámetros genéricos

    public EmpleadoCompany<T> where T: ICommonDataBetweenWorkers
{
   public metodo1(T empleado1)
   {
      .....
   }

....


}
    • -1