Conversion implicita y explicita entre tipos personalizados (Custom Types)

Solo para recodar, solo para recordar , conversión implícita:



int a = 35;
double b = a;


Y conversión explícita:



string num = “56”;
int
numero;
int.TryParse(num, out
numero);
//TryParse retorna falso si no se puede convertir la cadena
Console.WriteLine(numero); //56


Ahora que pasa si quiero que mi clase tipoB, se pueda convertir explícitamente o implícitamente a mi clase tipoA. Pues nosotros podemos implementar nuestras propias conversiones, tenemos la clase tipoB:



public class tipoB
{
  public string
name;

  public tipoB(string
pname)
  {
    name = pname;
  }

  public
override string
ToString()
  {
    return “tipoB-“
+ name;
  }
}


Ahora nuestro clase tipoA:



public class tipoA
{
  public string
name;

  public
tipoA (string
pname)
  {
    name = pname;
  }
 
  public
override string
ToString()
  {
    return “tipoA-“
+ name;
  }


  ////habilitando conversion implicita desde tipoB a tipoA
  //public static implicit operator tipoA(tipoB arg)
  //{
  // tipoA tip = new tipoA(arg.name);
  // return tip;
  //}

  /
/convertir explicitamente desde tipoB a tipoA
  public static explicit operator tipoA(tipoB
arg)
  {
    tipoA tip = new tipoA
(arg.name);
    return
tip;
  }
}


Como podemos ver usando las palabras reservadas implicit operator o explicit operator podemos definir conversiones explícitas/implícitas para nuestros tipos personalizados, veamos la aplicación:



static void Main(string[] args)
{
  tipoB tipB = new tipoB(“hola”);
  Console.WriteLine(“objeto inicial: “ + tipB.ToString());

  //conversion implicita a tipoA
  //tipoA tipA = tipB;

  //Conversion explicita a tipoA
  tipoA tipA = (tipoA)tipB;

  Console
.WriteLine(“despues de conversion: “
+ tipA.ToString());
  Console.ReadLine();
}


Hay que tener en cuenta solo se puede declarar un tipo de conversión, es decir declaramos la conversión como implicit o como explicit pero no podemos declarar las dos para convertir el tipoX al tipoY. Por eso hemos comentado la conversión implicit mostrada arriba, de lo contrario mostrará un error en tiempo de compilación. Ojo, eso solo en la declaración, ya que si declaramos una conversión implícita la podemos usar de forma implícita o explicíta, si la declaramos como explícita solo la podremos usar como explícita.


P.D.: Se pudo mejorar la construcción de la clase usando propiedades, y otras mejores prácticas, pero no es el objetivo de este post, el objetivo es mostrar la conversión de tipos personalizados .


Tarea: Investigar sobre TryParse


Saludos,



Post cruzado desde starrillo blog

Un comentario sobre “Conversion implicita y explicita entre tipos personalizados (Custom Types)”

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *