No se puede transmitir de la clase principal a la clase secundaria

Estoy tratando de transmitir de una clase principal a una clase secundaria pero obtengo una InvalidCastException. La clase secundaria solo tiene una propiedad de tipo int. ¿Alguien sabe lo que tengo que hacer?

Una forma sencilla de abatir en C # es serializar el padre y luego deserializarlo en el hijo.

 var serializedParent = JsonConvert.SerializeObject(parentInstance); 
 Child c  = JsonConvert.DeserializeObject<Child>(serializedParent);

Tengo una aplicación de consola simple que convierte un animal en un perro, usando las dos líneas de código anteriores aquí

No puedes convertir un mamífero en un perro, podría ser un gato.

No se puede meter una comida en un sándwich, podría ser una hamburguesa con queso.

No se puede convertir un automóvil en un Ferrari; puede ser un Honda, o más específicamente, no se puede convertir un Ferrari 360 Modena en un Ferrari 360 Challange Stradale; hay partes diferentes, aunque ambos son Ferrari 360.

La instancia a la que se refiere la referencia de su clase base no es una instancia de su clase secundaria. No hay nada malo.

Más específicamente:

Base derivedInstance = new Derived();
Base baseInstance = new Base();

Derived good = (Derived)derivedInstance; // OK
Derived fail = (Derived)baseInstance; // Throws InvalidCastException

Para que el reparto sea exitoso, la instancia a la que estás rebajando debe ser una instancia de la clase a la que estás rebajando (o al menos, la clase a la que estás rebajando debe estar dentro de la jerarquía de clases de la instancia); de lo contrario, el el elenco fallará.

Hay algunos casos en los que tal reparto tendría sentido.
En mi caso, estaba recibiendo una clase BASE a través de la red y necesitaba más funciones. Así que derivarlo para manejarlo de mi lado con todas las campanas y silbidos que quería, y convertir la clase BASE recibida en la DERIVED simplemente no era una opción (lanza InvalidCastException of Course)

Una SOLUCIÓN práctica de pensar fuera de la caja fue declarar una clase EXTENSION Helper que NO estaba heredando la clase BASE en realidad, sino que la INCLUYE como miembro.

public class BaseExtension
{
   Base baseInstance;

   public FakeDerived(Base b)
   {
      baseInstance = b;
   }

   //Helper methods and extensions to Base class added here
}

Si tiene un acoplamiento suelto y solo necesita un par de características adicionales para la clase base sin REALMENTE tener una necesidad absoluta de derivación, esa podría ser una solución rápida y sencilla.

He visto a la mayoría de la gente decir que el casting explícito de padre a hijo no es posible, eso en realidad no es cierto. Tomemos un comienzo revisado e intentemos probarlo con ejemplos.

Como sabemos en .net todos los castings tienen dos amplias categorías.

1. Para el tipo de valor
2. Para el tipo de referencia (en su caso, su tipo de referencia)

El tipo de referencia tiene otros tres casos situacionales principales en los que puede encontrarse cualquier escenario.

De hijo a padre (conversión implícita: siempre con éxito)

Caso 1. Hijo de cualquier padre directo o indirecto

Employee e = new Employee();
Person p = (Person)e; //Allowed

Padre a hijo (transmisión explícita: puede tener éxito)

Caso 2. Variable principal que contiene el objeto principal (no permitido)

Person p = new Person();  // p is true Person object
Employee e = (Employee)p; //Runtime err : InvalidCastException <-------- Yours issue

Caso 3. Variable principal que contiene el objeto secundario (siempre correcto)

Nota: Debido a que los objetos tienen naturaleza polimórfica, es posible que una variable de un tipo de clase principal contenga un tipo secundario.

Person p = new Employee(); // p actually is Employee
Employee e = (Employee)p; // Casting allowed

Conclusión: Después de leer sobre todo, espero que ahora tenga sentido como es posible la conversión de padres a hijos (Caso 3).

Respuesta a la pregunta :

Tu respuesta es en el caso 2, donde puedes ver que tal conversión no está permitida por OOP y estás tratando de violar una de las reglas básicas de OOP, así que elige siempre la ruta segura.

Además, para evitar situaciones excepcionales, .net ha recomendado el uso de operadores is / as que le ayudarán a tomar decisiones informadas y proporcionar un casting seguro.

Eso violaría los principios orientados a objetos. Yo diría que una solución elegante aquí y en otras partes del proyecto es usar un marco de mapeo de objetos como AutoMapper para configurar una proyección.

Aquí hay una configuración un poco más compleja de la necesaria, pero lo suficientemente flexible para la mayoría de los casos:

public class BaseToChildMappingProfile : Profile
{
    public override string ProfileName
    {
        get { return "BaseToChildMappingProfile"; }
    }

    protected override void Configure()
    {
        Mapper.CreateMap<BaseClass, ChildClassOne>();
        Mapper.CreateMap<BaseClass, ChildClassTwo>();
    }
}


public class AutoMapperConfiguration
{
    public static void Configure()
    {
        Mapper.Initialize(x =>
        {
            x.AddProfile<BaseToChildMappingProfile>();
        });
    }
}

Cuando la aplicación comienza a llamar AutoMapperConfiguration.Configure()y luego puede proyectar así:

ChildClassOne child = Mapper.Map<BaseClass, ChildClassOne>(baseClass);

Las propiedades se asignan por convención, por lo que si la clase se hereda, los nombres de las propiedades son exactamente iguales y la asignación se configura automáticamente. Puede agregar propiedades adicionales ajustando la configuración. Consulte la documentación .

Paul, no preguntaste "¿Puedo hacerlo?". ¡Asumo que quieres saber cómo hacerlo!

Tuvimos que hacer esto en un proyecto: hay muchas clases que configuramos de manera genérica solo una vez, luego inicializamos propiedades específicas para las clases derivadas. Utilizo VB, por lo que mi muestra está en VB (noogies difíciles), pero robé la muestra VB de este sitio que también tiene una mejor versión de C #:

http://www.eggheadcafe.com/tutorials/aspnet/a4264125-fcb0-4757-9d78-ff541dfbcb56/net-reflection--copy-cl.aspx

Código de muestra:

Imports System
Imports System.Collections.Generic
Imports System.Reflection
Imports System.Text
Imports System.Diagnostics

Module ClassUtils

    Public Sub CopyProperties(ByVal dst As Object, ByVal src As Object)
        Dim srcProperties() As PropertyInfo = src.GetType.GetProperties
        Dim dstType = dst.GetType

        If srcProperties Is Nothing Or dstType.GetProperties Is Nothing Then
            Return
        End If

        For Each srcProperty As PropertyInfo In srcProperties
            Dim dstProperty As PropertyInfo = dstType.GetProperty(srcProperty.Name)

            If dstProperty IsNot Nothing Then
                If dstProperty.PropertyType.IsAssignableFrom(srcProperty.PropertyType) = True Then
                    dstProperty.SetValue(dst, srcProperty.GetValue(src, Nothing), Nothing)
                End If
            End If
        Next
    End Sub
End Module


Module Module1
    Class base_class
        Dim _bval As Integer
        Public Property bval() As Integer
            Get
                Return _bval
            End Get
            Set(ByVal value As Integer)
                _bval = value
            End Set
        End Property
    End Class
    Class derived_class
        Inherits base_class
        Public _dval As Integer
        Public Property dval() As Integer
            Get
                Return _dval
            End Get
            Set(ByVal value As Integer)
                _dval = value
            End Set
        End Property
    End Class
    Sub Main()
        ' NARROWING CONVERSION TEST
        Dim b As New base_class
        b.bval = 10
        Dim d As derived_class
        'd = CType(b, derived_class) ' invalidcast exception 
        'd = DirectCast(b, derived_class) ' invalidcast exception
        'd = TryCast(b, derived_class) ' returns 'nothing' for c
        d = New derived_class
        CopyProperties(d, b)
        d.dval = 20
        Console.WriteLine(b.bval)
        Console.WriteLine(d.bval)
        Console.WriteLine(d.dval)
        Console.ReadLine()
    End Sub
End Module

Por supuesto, esto no es realmente un casting. Está creando un nuevo objeto derivado y copiando las propiedades del padre, dejando las propiedades del hijo en blanco. Eso es todo lo que necesitaba hacer y parece que es todo lo que necesitas hacer. Tenga en cuenta que solo copia propiedades, no miembros (variables públicas) en la clase (pero puede extenderlo para hacer eso si es una vergüenza exponer miembros públicos).

La transmisión en general crea 2 variables que apuntan al mismo objeto (mini tutorial aquí, por favor no me arrojes excepciones de casos de esquina). ¡Esto tiene ramificaciones significativas (ejercicio para el lector)!

Por supuesto, tengo que decir por qué el lenguaje no te deja ir de la base a la instancia derivada, sino al revés. Imagine un caso en el que puede tomar una instancia de un cuadro de texto winforms (derivado) y almacenarlo en una variable de tipo control Winforms. Por supuesto, el 'control' puede mover el objeto alrededor de OK y usted puede lidiar con todas las cosas de 'control' sobre el cuadro de texto (por ejemplo, arriba, izquierda, propiedades de texto). Las cosas específicas del cuadro de texto (por ejemplo, .multiline) no se pueden ver sin lanzar la variable de tipo 'control' apuntando al cuadro de texto en la memoria, pero todavía está ahí en la memoria.

Ahora imagina que tienes un control y quieres ponerle una variable de tipo cuadro de texto. Al Control en la memoria le falta 'multilínea' y otras cosas de caja de texto. Si intenta hacer referencia a ellos, ¡el control no hará crecer mágicamente una propiedad de varias líneas! La propiedad (mírala como una variable miembro aquí, que realmente almacena un valor, porque está activado en la memoria de la instancia del cuadro de texto) debe existir. Ya que está lanzando, recuerde, tiene que ser el mismo objeto al que está apuntando. Por tanto, no se trata de una restricción de lenguaje, es filosóficamente imposible de aplicar casos de esa manera.

La instancia del objeto debe crearse utilizando el tipo de la clase secundaria, no puede convertir una instancia de tipo principal a un tipo secundario

En cuanto a mí, fue suficiente copiar todos los campos de propiedad de la clase base al padre así:

using System.Reflection;

public static ChildClass Clone(BaseClass b)
{
    ChildClass p = new ChildClass(...);

    // Getting properties of base class

    PropertyInfo[] properties = typeof(BaseClass).GetProperties();

    // Copy all properties to parent class

    foreach (PropertyInfo pi in properties)
    {
        if (pi.CanWrite)
            pi.SetValue(p, pi.GetValue(b, null), null);
    }

    return p;
}

Aquí se puede encontrar una solución universal para cualquier objeto.

A partir de C # 7.0, puede usar la palabra clave is para hacer esto:

Con esas clases definidas:

class Base { /* Define base class */ }
class Derived : Base { /* Define derived class */ }

Luego puedes hacer algo como:

void Funtion(Base b)
{
    if (b is Derived d)
    {
        /* Do something with d which is now a variable of type Derived */
    }
}

Lo que equivaldría a:

void Funtion(Base b)
{
    Defined d;
    if (b is Derived)
    {
        d = (Defined)b;
        /* Do something with d */
    }
}

Ahora puedes llamar:

Function(new Derived()); // Will execute code defined in if

Tanto como

Function(new Base()); // Won't execute code defined in if

De esa manera, puede estar seguro de que su abatimiento será válido y no lanzará una excepción.

Para lanzar, el objeto real debe ser de un Tipo igual o derivado del Tipo al que estás intentando lanzar ...

o, para decirlo de la manera opuesta, el tipo al que está intentando convertirlo debe ser el mismo o una clase base del tipo real del objeto.

si su objeto real es de tipo Baseclass , entonces no puede convertirlo en una clase derivada Type ...

Una variación del enfoque de serialización para quienes usan ServiceStack:

var child = baseObject.ConvertTo<ChildType>();

o el más detallado:

var child = baseObject.ToJson().FromJson<ChildType>();

La serialización de ServiceStack puede ser súper rápida y todo eso, pero claramente, esta no es una solución para conversiones masivas en transferencias de baja latencia, ni para tipos muy complejos. Es probable que sea obvio para cualquiera que use ServiceStack, pero pensé en aclararlo antes de los comentarios.