[C#] Heredar constructores

[Siuto]

Quiero hacer algo que no se si se puede, a ver si me dice alguien...

Código (csharp) [Seleccionar] Expandir

class Padre
{
   public Padre(String cadena)
   {
       // ... Explota si la cadena llega con alguna mayuscula
   }
}

class Hijo : Padre
{
   public Hijo(String cadena) : base(cadena)
   {
       cadena = cadena.ToLower();
   }
}


¿Como debo hacer para pasar la cadena en minuscula a la clase padre? porque haciendolo de esa forma no sirve de nada ya que primero se llama al constructor de la clase Padre y despues se pasa a minuscula la cadena.

La clase que llamo padre en este ejemplo es una clase de .NET en mi caso por lo que no puedo modificarla.

[[D4N93R]]

Hola,

A ver, la clase Hijo no puede aceptar la cadena en mayúscula, pues la pasas a minúsculas al momento de pasarsela al constructor:

Código (csharp,4) [Seleccionar] Expandir


    class Hijo : Padre
    {
        public Hijo(String cadena)
            : base(cadena.ToLower())
        {
           
        }
    }


Un saludo!

PD: Eso debe funcionar x)

[BETA_V]

de esta manera

Código (csharp) [Seleccionar] Expandir


public Hijo(string cadena): base(cadena.ToLower())


[Siuto]

Es una linda solucion es pero no me sirve porque en relidad estoy haciendo la verificacion de mas de un parametro y lo que verfico en unos depende de lo que hay en los otros, algo asi:

Código (csharp) [Seleccionar] Expandir

class Padre
{
   public Padre(String c1, String c2)
   {
       // ... Explota si la cadena llega con alguna mayuscula
   }
}

class Hijo : Padre
{
   public Hijo(String c1, String c2) : base(c1, c2)
   {        
       if (c1.length > c2.Length) c1 = c1.ToLower();
       else c2 = c2.ToLower();
   }
}


No se si ahora quedo muy claro el ejemplo :S, se entiende?

[[D4N93R]]

Siuto, no se si esto funcione, en teoría debería x)

En cualquier clase, ya sea Hijo, u otra clase con Utilities que tengas, agregas un método static, al que llamas y haces esa condición. No se si sea la mejor manera, si a alguien se le ocurre algo mejor, me avisa X).

Código (csharp) [Seleccionar] Expandir

class Padre
{
    public Padre(String c1, String c2)
    {
        // ... Explota si la cadena llega con alguna mayuscula
    }
}

class Hijo : Padre
{
    public Hijo(String c1, String c2) : base(Hijo.Validate(c1,c2), Hijo.Validate(c1, c2))
    {       
       
    }
    public static string Validate(string c1, c2)
    {
        if (c1.length > c2.Length) return c1.ToLower();
        else return c2.ToLower();
    }
}

Jamás había visto la necesidad de hacer algo así. Cual es la clase base de la que estás heredando? a ver si es la mejor vía.

Un saludo!

[jlrvpuma]

Siuto, si lo que necesitas es verificar los parámetros puedes usar la solución del método estático, pero si son muchos parámetros el código se vería muy feo, para evitar esto puedes hacer las verificaciones en el cuerpo del constructor; es decir entre { y },aunque de esta forma prescindirías del constructor en la clase Padre, no estaría haciendo nada. Al parecer debes construir un objeto complejo, a mi se me ocurre que te caería a pelo usar el patrón Builder(patrón de diseño de software),éste patrón se usa cuando el algoritmo de construcción de un objeto complejo debe ser independiente del objeto y el proceso de construcción debe permitir diferentes representaciones del objeto. Este patrón es muy simple y facil de implementar.
Un ejemplo sencillo:

Código [Seleccionar] Expandir


public class Computadora
{
//Propiedades
public string Marca{get;set;}
public string Tipo{get;set;}

//Metodos
public override string  ToString()
{
return "Computadora Marca: " + Marca + ". Tipo: " + Tipo +".";
}
}


public abstract class Builder
{
public Computadora pc;

public abstract void SetMarca();
public abstract void SetTipo();
}

public class Laptop:Builder
{
public override void SetMarca()
{
pc.Marca = "HP";
}
public override void SetTipo()
{
pc.Tipo = "Laptop";
}
}//fin Laptop

public class Desktop:Builder
{
public override void SetMarca()
{
pc.Marca = "Patito";
}
public override void SetTipo()
{
pc.Tipo = "Escritorio";
}
}//fin Desktop

public class Director
{
public void ConstruirMaquina(Builder builder)
{
builder.SetMarca();
builder.SetTipo();
}
}

/****** Esto en la clase Main *********************/
public static void Main(string[] args)
{
Builder  builder;
Director director = new Director();
Console.WriteLine("Presiona el 1 para construir una laptop y 2 para una pc de escritorio");
switch(Console.ReadLine())
{
case "1":
builder = new Laptop();
break;
case "2":
builder = new Desktop();
break;
}

//construye la máquina:
director.ConstruirMaquina(builder);
Console.WriteLine("Se ha construido una {0}", builder.ToString());

}//Fin main



Como ves el objeto Computadora no tiene nada que ver con  su construción y además permite varias
representaciones. En fin, espero haber ayudado, disculpa el código, pero es que no sé cómo ponerlo formateado como uds lo han hecho.

[[D4N93R]]

No creo que sea buena idea , más bien la primera que dices (de un método estático) me gustó más.

En caso de que un constructor necesite muchos parámetros se puede recurrir siempre a un struct.