Contenedor genérico para exponer instancias de POCO a otros AppDomains: ¿cómo funciona?

Question

estoy intrigado por este respuesta de otro hilo SO, y esperaba que alguien pudiera ayudarme a arrojar algo de luz sobre el concepto.

Digamos que tengo un AppDomain principal y un grupo de AppDomains secundarios, que son creados e inicializados por el AppDomain principal.En pseudocódigo:

Dominio de aplicación principal:

class Parent
{
    public void InitChildren(IList<ChildInfo> children)
    {
        foreach (var childInfo in children)
        {
            var ad = CreateNewChildAppDomain();
            var child = (Child)ad.CreateInstanceAndUnwrap(typeof(Child));
            child.Init(this);
        }
    }

    public void Register(BasePoco info)
    {
        // Do something with info.
    }
}

Dominio de aplicación infantil:

class Child : MarshalByRefObject
{
    public void Init(Parent parent)
    {
        parent.Register(new Container<MyInfo>(new MyInfo()));
    }
}

class MyInfo : BasePoco // <- not a MarshalByRefObject!
{
    public MyInfo() { ... }
}

Durante Init(), un dominio de aplicación secundario crea una instancia de un objeto POCO, que por definición no se puede serializar.Supongamos también que no podemos modificarlo en ese sentido.

La respuesta vinculada sugiere que envolverlo en un Container<T> (que a su vez es marshalable) debería permitir que se pase de nuevo al dominio de aplicación principal.Entiendo esto porque es el proxy para Container<MyInfo> ejemplo que realmente se transmite.

Lo que no entiendo es cómo el dominio de aplicación principal puede acceder a la instancia de POCO en el contenedor a través del proxy del contenedor.Veo el operador de conversión implícito sobrecargado en Container<T> y entiendo que devuelve la instancia de POCO contenida.Pero esa instancia no se está representando en sí misma: ¡todavía está en el dominio de aplicación secundario!Entonces, ¿no debería esto romperse?

¿Qué está pasando realmente aquí?

Answer 1

Tan pronto como el contenedor devuelva la instancia que vive en el otro AppDomain (ya sea que esto ocurra a través de la propiedad Value o del operador de conversión implícito), el objeto se ordenará. Si se trata de un MarshalByRefObject, se generará un nuevo proxy para que pueda acceder a él. De lo contrario, el objeto se copiará (ordenado por valor, serializado) en el dominio de la aplicación actual.

Lo único con lo que la clase de Contenedor que se muestra en esa pregunta puede ayudar es si desea mantener un proxy para otro objeto que no se debe ordenar. Pero en este caso, no debe acceder a la propiedad Value ni utilizar el operador de conversión implícito del AppDomain donde reside el proxy, ya que esto provocaría que el objeto en el contenedor se clasifique. Aún así, podría usar el contenedor como argumento en un método en un objeto que vive en el mismo AppDomain que el objeto Container, por lo que básicamente le permite mantener una referencia a un objeto no marshallable (no serializable y no MarshalByRef, o de un tipo en un ensamblado que no se puede cargar en el AppDomain con el proxy, etc.) y pasarlo como un " handle " ;.