implemento de la misma clase, solo padres diferentes, ¿cómo lidiar con esto?

Question

que tienen dos clases que define así:

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 
    /// 
} 

la aplicación de estas clases son exactamente los mismos, así que quiero eliminar esta duplicación, pero no conocer la técnica para hacer esto.

¿Puede mostrarme la forma de hacerlo?

Answer 1

Crearía una clase BaseButton que se deriva de Button. Si hay algún cambio específicas a cada botón, a continuación, proceder de la siguiente manera 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 2

Se puede usar un T4 template. Le permitiría tener un solo archivo (la plantilla) que contiene la implementación una vez, y generaría las dos clases con las implementaciones idénticas para usted. (Por supuesto, el código aún estaría duplicado en el ensamblado compilado, pero al menos ya no existe ese problema de mantenimiento para mantenerlos sincronizados).

Answer 3

¿Puede tener una clase RoleButton que se ajuste a otros tipos de botones?

Si Button y ImageButton ambos tienen una base común o implementan una interfaz como IButton que podría tener algo como esto:

class RoleButton : IButton 
{ 
    private Button _realButton; 

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

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

De esa manera usted no termina encima de duplicar su código RoleButton:

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

Answer 4

El punto de disparo es si necesita o no acceder a variables privadas de cualquiera de esas clases, o propiedades que son específicas para ellas.

Cuando desee encapsular y compartir el comportamiento, utilice el Patrón de comando. Se ve algo como:

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); 
     } 
    } 
} 

Esto le permite encapsular y extraer funcionalidad ... la limitación, por supuesto, es que no se puede tener acceso a los miembros privados o protegidos, o miembros específicos a RoleButton, etc., porque tienes que pasar una base común al comando. No poder acceder a los miembros específicos de RoleButton/RoleImageButton no debería ser un problema; su código no puede ser código común si utiliza algo específico para cualquiera de estos:)

Si tiene que acceder a miembros privados/protegidos, deberá crear una interfaz que exponga las propiedades e implementarlo por separado para tanto RoleButton como RoleImageButton, y pasan esa interfaz al comando ... pero básicamente estás forzando esas propiedades a ser públicas y hacerlas accesibles a otras clases. Si es absolutamente necesario que haga esto, puedo darle un código de muestra para mostrarle cómo, pero realmente no es una buena idea.

Lo que realmente buscas es herencia múltiple, un concepto que C# no admite.

EDITAR

Hay dos maneras de pelar este gato ...Lo recomendaría el primero, que es encapsular las variables que se van a cambiar en su mando y pasarlo como un parámetro, como por ejemplo:

// 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 
    } 

} 

otra parte, hacer la clase Roles una estructura y pase por ref. Esto le impide exponer sus roles, lo que le permite mantenerlos como protegidos. Todo lo demás del código de patrón de comando que escribí se usa tal cual.

El segundo enfoque ni siquiera vale la pena mencionarlo ... Lo abandonaré bajo coacción, pero es una mala idea, no me gustaría promocionarlo a menos que me torturaran. : D

HTH,
James