Primeiro, a pergunta: as especificações do CLR garantem que o código em execução em vários domínios do aplicativo dentro do mesmo processo compartilhará o mesmo espaço de endereço? Ao "compartilhar o espaço de endereço", quero dizer que os ponteiros para a memória alocados em um dos domínios do aplicativo serão válidos para leitura e gravação em todos os domínios do aplicativo hospedados no mesmo processo.

Considere este exemplo auto-contido ilustrando a questão: o programa aloca umWorker objeto em um domínio de aplicativo separado. oWorker aloca um bloco de memória para 10.000 inteiros e preenche-o com dados. O programa, em seguida, chama todo o limite de domínio do aplicativo para obter o ponteiro para o bloco alocado e verifica que ele pode ler cada um dos 10.000 itens.

using System;
using System.Reflection;
using System.Runtime.InteropServices;

namespace crossapp {
    public class Worker : MarshalByRefObject {
        private readonly IntPtr myData;
        public const int DataLength = 10000;
        public Worker() {
            Console.Error.WriteLine(
                "Memory allocation happens in app domain '{0}'"
            ,   Assembly.GetExecutingAssembly().FullName
            );
            myData = Marshal.AllocHGlobal(sizeof(int) * DataLength);
            unsafe {
                var ptr = (int*) myData.ToPointer();
                for (var i = 0 ; i != DataLength ; i++) {
                    ptr[i] = 2*i + 1;
                }
            }
        }
        public IntPtr GetData() {
            return myData;
        }
    }
    class Program {
        static void Main() {
            var ad = AppDomain.CreateDomain("New domain");
            var wrk = (Worker)ad.CreateInstanceAndUnwrap(
                Assembly.GetExecutingAssembly().FullName
            ,   "crossapp.Worker"
            );
            var data = wrk.GetData();
            var badCount = 0;
            unsafe {
                var ptr = (int*)data.ToPointer();
                for (var i = 0 ; i != Worker.DataLength ; i++) {
                    var expect = 2*i + 1;
                    if (ptr[i] != expect) {
                        Console.Error.WriteLine(
                            "Mismatch in position {0}: {1} != {2}"
                        ,   i, expect, ptr[i]
                        );
                        badCount++;
                    }
                }
                if (badCount == 0) {
                    Console.Error.WriteLine(
                        "All {0} items have matched."
                    ,   Worker.DataLength
                    );
                } else {
                    Console.Error.WriteLine(
                        "Found {0} mismatches out of {1}."
                    ,   badCount
                    ,   Worker.DataLength
                    );
                }
            }
        }
    }
}

Eu corri isso muitas vezes, e funcionou toda vez. Intuitivamente, isso deve funcionar: afinal, os domínios do aplicativo estão em um único processo, portanto, eles devem compartilhar o mesmo espaço de endereço virtual. No entanto, isso parece uma exploração de um recurso que a Microsoft pode remover a qualquer momento. Há algo na especificação do CLR que confirme ou negue a legitimidade desse truque?

Caso você esteja se perguntando por que estou fazendo uma pergunta tão estranha, estou procurando uma maneira de passar grandes quantidades (em gigabytes) de dados pelos limites do domínio do aplicativo, com sobrecarga mínima no espaço e no tempo. Esta seria minha solução ideal se eu pudesse provar sua legitimidade.