相同的类实现，只是不同的父级，如何处理？

Question

我有两个类的定义如下：

public class RoleButton: Button
{
   protected bool PrimaryRole;
    protected bool SecondaryRole;

    private string _role;
    private AuthenticatedPage CurrentPage
    {
        get { return (AuthenticatedPage)Page; }
    }

    protected UserInfo CurrentUser
    {
        get { return CurrentPage.CurrentUser; }
    }

    protected void SetRole(string role)
    {
        _role = role;
    }

    protected override void OnPreRender(EventArgs e)
    {
        base.OnInit(e);

        if (CurrentUser.IsSuperAdmin) return;
        DataTable dt = CommandController.GetButtonRoleForUserByPortalID(CurrentUser.UserID,
                                                                        ConvertUtility.ToInt32(AppEnv.PortalId()));

        if (dt.Rows.Count > 0)
        {
            if (dt.Rows.Count > 1)
            {
                PrimaryRole = ConvertUtility.ToBoolean(dt.Rows[0][_role]);
                SecondaryRole = ConvertUtility.ToBoolean(dt.Rows[1][_role]);

                if (!PrimaryRole && !SecondaryRole)
                {
                    Visible = false;
                }
                else
                {
                    Visible = true;
                }
            }
            else
            {
                PrimaryRole = ConvertUtility.ToBoolean(dt.Rows[0][_role]);
                Visible = PrimaryRole;
            }
        }
        else
        {
            Visible = false;
        }     
}


public class RoleImageButton: ImageButton
{
   ///
   ///same as above
   ///
}

这些类的实现完全相同，因此我想删除此重复项，但我不知道执行此操作的技术。

你能告诉我如何做到这一点吗？

Answer 1

关键点是您是否需要访问任何这些类的私有变量或特定于它们的属性。

当您想要封装和共享行为时，可以使用命令模式。它看起来像这样：

public interface ICommand {
    void ExecuteOnPreRender(WebControl control, EventArgs args);
}

//  This class encapsulates the functionality common
//  to both OnPreRender commands
public class SharedPreRenderCommand : ICommand {
    public void ExecuteOnPreRender(WebControl control, EventArgs args) {
        //  Modify the size, border, etc... any property that is 
        //  common to the controls in question
    }
}

public class RoleImageButton : ImageButton {

    private ICommand onPreRenderCommand = null;

    public void SetPreRenderCommand (ICommand command) {
        onPreRenderCommand = command;
    }

    protected override void OnPreRender(EventArgs args) {
        if (null != onPreRenderCommand) {
            onPreRenderCommand.ExecuteOnPreRender(this, args);
        }
        else {
            base.OnPreRender(args);
        }
    }
}


public class RoleButton : Button {

    private ICommand onPreRenderCommand = null;

    public void SetPreRenderCommand (ICommand command) {
        onPreRenderCommand = command;
    }

    protected override void OnPreRender(EventArgs args) {
        if (null != onPreRenderCommand) {
            onPreRenderCommand.ExecuteOnPreRender(this, args);
        }
        else {
            base.OnPreRender(args);
        }
    }
}

这允许您封装和提取功能...当然，限制是您无法访问私有或受保护的成员，或特定于 RoleButton 的成员等，因为您必须传递一个公共的基地的命令。无法访问 RoleButton/RoleImageButton 特定的成员应该不是问题；如果您的代码使用特定于其中任何一个的任何内容，则它不能是通用代码:)

如果您必须访问私有/受保护的成员，则需要创建一个公开属性的接口，并为 RoleButton 和 RoleImageButton 单独实现它，并将该接口传递给命令...但随后您基本上会强制这些属性公开，并使其他类可以访问它们。如果您绝对需要这样做，我可以给您一些示例代码来向您展示如何操作，但这确实不是一个好主意。

您真正追求的是多重继承，这是 C# 不支持的概念。

编辑

有两种方法可以给这只猫换皮...我推荐第一种，它是将要在命令中更改的变量封装起来将其作为参数传递，如下所示：

//  Encapsulate these fields if you want to be PC
public class Roles {
    public bool PrimaryRole;
    public bool SecondaryRole;
}

public class RoleButton: Button {
    protected Roles buttonRoles;    
    ...
}

public class SharedPreRenderCommand : ICommand {

    public void ExecuteOnPreRender(WebControl control, Roles roles, EventArgs args) {
        //  Modify the Roles class, which the RoleButton or 
        //  RoleImageButton has a handle to
    }

}

或者，将 Roles 类设为结构体并通过 ref 传递它。这可以防止您暴露自己的角色，从而使它们受到保护。我编写的命令模式代码中的其他所有内容均按原样使用。

第二种方法甚至不值得一提……我会在胁迫下放弃它，但这是一个坏主意，我不想推广它，除非它被折磨得离我而去。
：D

HTH，
詹姆斯

Answer 2

您可以有一个包含其他按钮类型的 RoleButton 类吗？

如果 Button 和 ImageButton 都有一个共同的基础或实现像 IButton 这样的接口，您可能会得到如下的结果：

class RoleButton : IButton
{
  private Button _realButton;

  public RoleButton(Button realButton) { _realButton = realButton; }

  // IButton implementation delegates non-role stuff to _realButton
}

这样您就不会最终重复 RoleButton 代码：

var roleButton = new RoleButton(myButton);
var roleImageButton = new RoleButton(myImageButton);

Answer 3

我将创建一个派生自 Button 的 BaseButton 类。如果每个按钮有任何特定的更改，则从 BaseButton 派生，如下所示：

public class BaseButton : Button
{
   ///
   protected override void OnPreRender(EventArgs e)
   {
      // Common base implementationi
   }         
}

public class ImageButton: BaseButton
{
   // Specific implementation
   public ImageButton()
   {
      this.Name = "ImageButton";
   }
}

public class RoleButton: BaseButton
{
   // Specific implementation
   public RoleButton()
   {
      this.Name = "RoleButton";
   }
}

Answer 4

您可以使用T4 模板。将允许您拥有一个包含一次实现的单个文件（模板），并且它将为您生成具有相同实现的两个类。 （当然，代码仍然会在编译后的程序集中重复，但至少不再有保持它们同步的维护问题。）