Контексты .NET vs RealProxy

      //
      //  Пример неудачной реализации “глобального” контекста
      //
[Context("Global")]
publicclass CBOGlobal : ContextBoundObject
{
}

publicvoid CBOGlobal_Test()
{
  CBOGlobal obj1 = new CBOGlobal();
  CBOGlobal obj2 = new CBOGlobal();
}

      //
      // Реализация ServerContextSink.
      // Использование этого приемника приведет к тому, что все создаваемые 
      // объекты попадут в один "глобальный" контекст.
      //
      class GlobalSink : IMessageSink
{
  static IMessageSink _nextSink;
  static Context _globalContext;

  public GlobalSink(IMessageSink nextSink)
  {
    //// Приемник, передаваемый в поле nextSink, – это своеобразный вход // для обработки сообщения пришедшего в контекст. В случае реализации // “глобального” контекста нам нужно запомнить самый первый приемник // и сохранить его в static-поле – все сообщения будут идти через него.//if (_nextSink == null)
    {
      _nextSink = nextSink;
    }
  }
  // // Обработка сообщения. // Этот приемник запоминает контекст, в котором он создан,// и при создании новых объектов автоматически создает их// в уже существующем.//public IMessage SyncProcessMessage(IMessage msg)
  {
    IConstructionCallMessage ccm = msg as IConstructionCallMessage;
    if (ccm == null)
    {
      //// Очевидно, что пришло сообщение IMethodCallMessage.// Эти сообщения приходят уже после создания объекта,// и в нашем случае они будет приходить уже в «правильном»// контексте.//return _nextSink.SyncProcessMessage(msg);
    }

    //// Если понадобится использовать подобную реализацию на практике, // то здесь нужно будет вставить код, который определяет какой // контекст надо использовать на основе аргументов конструктора.// if (_globalContext == null)
    {
      _globalContext = System.Threading.Thread.CurrentContext;
    }
    
    //// Перед созданием объекта необходимо проверить, в каком контексте // мы находимся. Если идентификаторы текущего контекста и сохраненного // “глобального” совпадают, то сообщение (IMessage) передается в приемник, // хранящийся в поле _nextSink. Если-же контекст не совпал, то мы сохраняем // параметры вызова в экземпляре класса ContextWorkItem и, используя метод // Context.DoCallBack, переходим в интересующий нас контекст.//if (_globalContext.ContextID !=  
      System.Threading.Thread.CurrentContext.ContextID)
    {
      ContextWorkItem workItem = new ContextWorkItem(this, msg);
      _globalContext.DoCallBack(new 
        CrossContextDelegate(workItem.ProcessMessage));
      return workItem.Result; 
    }
    //// Мы находимся в нужном контексте и самое время // завершить создание объекта.//return _nextSink.SyncProcessMessage(msg);
  }
  public IMessageSink NextSink
  { 
    get { return _nextSink; }
  }
  //// ContextWorkItem – этот класс нам нужен для использования в // методе Context.DoCallback.//class ContextWorkItem 
  {
    IMessageSink _sink;
    IMessage _source;
    IMessage _result;

    public ContextWorkItem(IMessageSink sink, IMessage source)
    {
      _sink = sink;
      _source = source;
    }
    publicvoid ProcessMessage()
    {
      _result = _sink.SyncProcessMessage(_source);
    }
    public IMessage Result
    {
      get { return _result; }
    }
  }
}

      //
      // Использование двух атрибутов - суровая необходимость,
      // в противном случае каждый объект будет создан в своем контексте
      // и ничего работать не будет.
      //
[Singleton, Global]
publicclass CBOSingleton : ContextBoundObject
{
  privatestring _property;
  publicstring Property
  {
    get { return _property; }
    set { _property = value; }
  }
}

[AttributeUsage(AttributeTargets.Class)]
publicclass SingletonAttribute : ContextAttribute, IContributeObjectSink
{
  public SingletonAttribute() : base ("SingletonContext")
  {
  }
  public IMessageSink GetObjectSink(MarshalByRefObject obj,
                                    IMessageSink nextSink)
  {
    // // “Объектный” приемник. Он запомнит первый переданный экземпляр // MarshalByRefObject obj и именно ему будет передевать все // приходящие вызовы// returnnew SingletonSink(obj, nextSink);
  }

  //// Реализация ObjectSink.// Использование этого приемника приведет к тому, что // все вызовы будут обрабатываться только одним объектом // (поле _singleton)//class SingletonSink : IMessageSink
  {
    IMessageSink _nextSink;
    static MarshalByRefObject _singleton;

    public SingletonSink(MarshalByRefObject singleton, IMessageSink nextSink)
    {
      _nextSink = nextSink;
      if (_singleton == null)
      {
        _singleton = singleton;
      }
    }
    ////  Делаем вызов RemotingServices.ExecuteMessage только для//  "первого объекта". Кстати, именно использование //  ExecuteMessage потребовало использования GlobalAttribute.//  Связано это с тем, что ExecuteMessage должен вызываться только //  в "родном" контексте объекта. В противном случае произойдет следующее: //  будет произведена проверка контекста (а так как текущий контекст и //  контекст объекта не совпадают, это приведет к //  повторному вызову RealProxy.Invoke).//public IMessage SyncProcessMessage(IMessage msg)
    {
      IConstructionCallMessage ccm = msg as IConstructionCallMessage;
      if (ccm == null)
      {
        ////  Пришло сообщение IMethodCallMessage. //  Для реализации Singleton-поведения мы обрабатываем его, используя//  объект, сохраненный в static-поле _singleton//return RemotingServices.ExecuteMessage(_singleton,
          (IMethodCallMessage) msg);
      }
      return _nextSink.SyncProcessMessage(msg);
    }
    public IMessageSink NextSink
    { 
      get { return _nextSink; }
    }
  }
}

//// Пример использования Singleton-класса//class TestConsole
{
  staticvoid Main(string[] args)
  {
    CBOSingleton obj1 = new CBOSingleton();
    CBOSingleton obj2 = new CBOSingleton();

    obj1.Property = "Singleton: OK";
    Console.WriteLine(obj2.Property);
  }
}

      //
      //  Реализация "Queued" контекста.
      //
      public
      class QueuedContext : Context
{
  privatebool _isPaused;
  private System.Collections.Queue _messageQueue;

  ////  Конструктор. //  Полностью формирует контекст.//public QueuedContext()
  {
    _messageQueue = new System.Collections.Queue();
    _isPaused = true;

    //// Мы добавляем свойство, реализующее интерфейс IContributeQueueSink.// В дальнейшем реализованный приемник будет либо сохранять все вызовы во// внутренней очереди, либо “прозрачно” пропускать их через себя.// this.SetProperty(new ContributeQueueSink());
    //// Контекст обязательно нужно “зафиксировать” – // пока это не сделано, использовать его по назначению нельзя.// this.Freeze();
  }

  ////  Помещение сообщения во внутреннюю очередь.//internalvoid AddMessage(QueuedMessage message) 
  {
    lock (_messageQueue.SyncRoot)
    {
      _messageQueue.Enqueue(message);
    }
  }
  
  ////  Создание нового экземпляра класса.//publicobject CreateInstance(Type serverType) 
  {
    ////  Реализация этого класса не приводится. //  Единственная его задача – вызов CreateInstanceImpl.//
    CreateInstanceWorkItem workItem = new CreateInstanceWorkItem(this, 
      serverType);
    
    ////  Вызов метода CreateInstance не приведет к переключению контекста. //  Здесь нам приходится делать это самостоятельно//
    DoCallBack(new CrossContextDelegate(workItem.CreateInstance));

    return workItem.Result;
  }

  ////  Приостанавливает вызов методов. //  Все сообщения будут направляться в очередь//publicvirtualvoid Pause()
  {
    _isPaused = true;
  }

  ////  "Запускает" контекст и обрабатывает накопившиеся сообщения//publicvirtualvoid Resume()
  {
    _isPaused = false;
    DoCallBack(new CrossContextDelegate(DispatchQueuedMessages));
  }

  ////  Обработка накопившихся сообщений и очистка очереди//privatevoid DispatchQueuedMessages()
  {
    lock (_messageQueue.SyncRoot)
    {
      while (_messageQueue.Count > 0)
      {
        QueuedMessage message = (QueuedMessage) _messageQueue.Dequeue();
        message.Dispatch();
      }
    }
  }  

  ////  Вспомогательный класс для создания объектов через Context.DoCallBack//internalclass CreateInstanceWorkItem
  {
    Type _serverType;
    object _result;

    public CreateInstanceWorkItem(QueuedContext context, Type serverType)
    {
      _serverType = serverType;
    }

    publicvoid CreateInstance()
    {
      if (!serverType.IsContextful)
      {
        thrownew InvalidCastException();
      }
      _result = _serverType.GetConstructor(Type.EmptyTypes).Invoke(null);
    }

    publicobject Result
    {
      get { return _result; }
    }
  }

  ////  Свойство контекста. //  Здесь еще надо добавить реализацию IContributeServerContextSink //  и соответствующего приемника.//  Это нужно для того, чтобы нельзя было создавать новые объекты //  в "приостановленном" контексте (во избежание возможных проблем)//internalclass ContributeQueueSink : IContextProperty, IContributeObjectSink
  {
    publicbool IsNewContextOK(Context newCtx)
    {
      returntrue;
    }

    public IMessageSink GetObjectSink(MarshalByRefObject obj, 
      IMessageSink nextSink)
    {
      returnnew QueuedObjectSink(
        (QueuedContext) System.Threading.Thread.CurrentContext, 
        obj, nextSink);
    }
  }

  ////  Сообщение. //  Инкапсулирует "приемник" и сообщение в сериализированной форме.//  internalclass QueuedMessage 
  {
    IMessageSink _sink;
    MemoryStream _stream;

    public QueuedMessage(IMessageSink sink, IMessage message)
    {
      _sink = sink;        
      _stream = new MemoryStream();

      BinaryFormatter formatter = new BinaryFormatter( 
        new RemotingSurrogateSelector(), 
        new StreamingContext(StreamingContextStates.Remoting));

      ////  Переводим сообщение в сериализированную форму//
      formatter.Serialize(_stream, message);
      _stream.Position = 0;
    }

    ////  Обработать сохраненное сообщение//publicvoid Dispatch()
    {
      ////  Восстанавливаем сообщение из сериализированной формы и обрабатываем его//
      BinaryFormatter formatter = new BinaryFormatter(
        new RemotingSurrogateSelector(), 
        new StreamingContext(StreamingContextStates.Remoting));
      IMessage message = (IMessage) formatter.Deserialize(_stream);
      _sink.SyncProcessMessage(message);
    }
  }

  ////  Реализация "объектного" приемника.//  Осуществляет проверку контекста и, по ее результатам, ставит //  сообщение в очередь или обрабатывет его.//internalclass QueuedObjectSink : IMessageSink
  {
    private QueuedContext _context;
    private IMessageSink _nextSink;
    private MarshalByRefObject _instance;

    public QueuedObjectSink(QueuedContext context, 
      MarshalByRefObject instance, IMessageSink nextSink)
    {
      _context = context;
      _nextSink = nextSink;
      _instance = instance;
    }

    public IMessage SyncProcessMessage(IMessage msg)
    {
      if (!_context.IsPaused)
      {
        ////  Контекст находится в “online” - вызываем //  RemotingServices.ExecuteMessage для немедленной обработки вызова//return RemotingServices.ExecuteMessage(_instance, 
                                               (IMethodCallMessage) msg);
      }
      else
      {
        ////  Сохраняем пришедшее сообщение во внутренней очереди//
        _context.AddMessage(new QueuedMessage(this, msg));
        returnnew ReturnMessage(null, (IMethodCallMessage) msg);
      }
    }
  }
}

////  Этот объект поможет проверить работу созданного контекста//publicclass CBOQueue : ContextBoundObject
{
  publicvoid Method1()
  {
    Console.WriteLine("Method1");
  }

  publicvoid Method2()
  {
    Console.WriteLine("Method2");
  }
}

////  Демонстрация использования//class TestConsole
{
  staticvoid Main(string[] args)
  {
    QueuedContext context = new QueuedContext();
    
    ////  Создаем экземпляр класса CBOQueue в Queued контексте//
    CBOQueue queue = (CBOQueue) context.CreateInstance(typeof(CBOQueue));
    Console.WriteLine("Context paused");
    context.Pause();

    queue.Method1();
    queue.Method2();

    Console.WriteLine("Context resumed");
    ////  Два предыдущих вызова Method1 и Method2 будут обработаны только сейчас//
    context.Resume();
  }
}

      public
      class MyCustomProxy: RealProxy
{
  private MarshalByRefObject target;
  public MyCustomProxy(Type serverType, MarshalByRefObject mbr) 
          : base (serverType)
  {
    target = mbr;
  }

  publicoverride IMessage Invoke(IMessage msg)
  {
    if (msg is IConstructionCallMessage)
    {
      RealProxy rp = RemotingServices.GetRealProxy(target);
      rp.InitializeServerObject((IConstructionCallMessage) msg);

      return EnterpriseServicesHelper.CreateConstructionReturnMessage     
        ((IConstructionCallMessage) msg, 
        (MarshalByRefObject) GetTransparentProxy());
    }
    return RemotingServices.ExecuteMessage(target, 
      (IMethodCallMessage) msg);
  }
}

      //
      //  Реализация RealProxy на основе существующей инфраструктуры контекстов
      //
[CBOProxy]
publicclass CBOTest : ContextBoundObject
{
  public CBOTest()
  {
  }

  publicvoid TestMethod()
  {
    Console.WriteLine("From Context");
  }
}

publicclass CBOProxy : RealProxy
{
  ////  Для реализации proxy воспользуемся инфраструктурой контекстов//
  Context _innerContext;

  public CBOProxy(Type serverType)
    : base (serverType)
  {
    _innerContext = new Context();
    _innerContext.Freeze();
  }
  
  publicoverride IMessage Invoke(IMessage msg)
  {
    ObjectCall call = new ObjectCall(this, msg);

    Console.WriteLine("Begin: {0}", msg.Properties["__MethodName"]);
    IConstructionCallMessage ccm = msg as IConstructionCallMessage;
    if (ccm != null) 
    {
      _innerContext.DoCallBack(
                               new CrossContextDelegate(call.Initialize));
    }
    else 
    {
      _innerContext.DoCallBack(
                               new CrossContextDelegate(call.Execute));        
    }
    Console.WriteLine("End: {0}", msg.Properties["__MethodName"]);

    return call._returnMessage;
  }    
  
  ////  Вспомогательный объект для хранения параметров вызова.//class ObjectCall
  {
    internal CBOProxy _proxy;
    internal IMessage _callMessage;
    internal IMessage _returnMessage;

    public ObjectCall (CBOProxy proxy, IMessage callMessage)
    {
      _proxy = proxy;
      _callMessage = callMessage;
    }

    ////  Вызов конструктора и инициализация//publicvoid Initialize()
    {
      ////  Вызов InitializeServerObject создаст //  экземпляр "серверного" объекта//  и свяжет TransparentProxy с текущим контекстом//
      _returnMessage = _proxy.InitializeServerObject(
          (IConstructionCallMessage) _callMessage);
    }

    ////  Вызов методов. //  Стоит обратить внимание, что в момент вызова этого метода//  значение свойства Context.InternalContextID == __TP.stubData//  В противном случае вызов RemotingServices.ExecuteMessage //  приведет к зацикливанию.//publicvoid Execute()
    {
      _returnMessage = RemotingServices.ExecuteMessage(
          (MarshalByRefObject)_proxy.GetTransparentProxy(), 
          (IMethodCallMessage) _callMessage);
    }
  }
}

[AttributeUsage(AttributeTargets.Class)]
publicclass CBOProxyAttribute : ProxyAttribute
{
  publicoverride MarshalByRefObject CreateInstance(Type serverType)
  {
    ////  При необходимости делегируем все в стандартную реализацию//if((RemotingConfiguration.IsWellKnownClientType(serverType) != null) || 
       (RemotingConfiguration.IsRemotelyActivatedClientType(serverType)  !=null))
    {
      returnbase.CreateInstance (serverType);
    }
    else
    {
      ////  Создаем собственный Proxy//return (MarshalByRefObject)new CBOProxy(serverType).GetTransparentProxy();        
    }
  }
}

class TestConsole
{
  staticvoid Main(string[] args)
  {
    CBOTest cboTest = new CBOTest();
    cboTest.TestMethod();
  }
}

      //
      //  Stub для проверки контекста. 
      //  На входе: EAX == stubData
      //  На выходе EAX == 0 - ContextMatch
      //        EAX != 0 - ContextNoMatch
      //  Есть предчувствие, что будет работать только для x86 :)
      //
__declspec(naked) staticvoid ContextCheck()
{    
  __asm 
  {       
    push ebx
    mov  ebx, [eax + 4]
    or   ebx, ebx
    jz   _notmatch // Получилось так, что объект еще // до конца не инициализирован
    mov    eax, fs:[0x18]    // Оптимизированная версия 
    mov    eax, [eax + 0x24] // GetCurrentThreadID
    sub    eax, ebx

_notmatch:
    pop    ebx
    ret
  }
}

public __gc class ApartmentProxy : public RealProxy
{    
  //// Helper для передачи сообщения между потоками//
  __nogc class ApartmentMessage 
  {
    private:
      HANDLE m_hEvent;
    public:
      void * _proxy;
      void * _message;
      void * _result;

    public:
      ApartmentMessage(ApartmentProxy * proxy, IMessage * message)
      {
        m_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);          
        
        _proxy = static_cast<void *> 
                    (static_cast<IntPtr>(GCHandle::Alloc(proxy)));
        _message = static_cast<void *>
                    (static_cast<IntPtr>(GCHandle::Alloc(message)));
        _result = 0;
      }

      virtual ~ApartmentMessage()
      {
        GCHandle::op_Explicit(IntPtr(_proxy)).Free();
        GCHandle::op_Explicit(IntPtr(_message)).Free();
        GCHandle::op_Explicit(IntPtr(_result)).Free();
      }
      
      IMessage* Result()
      {
        return static_cast<IMessage*> 
                      (GCHandle::op_Explicit(IntPtr(_result)).Target);
      }

      ////  Методы синхронные - надо ждать//void Wait()
      {
        DWORD dwWaitResult;
        
        do {
          dwWaitResult = WaitForSingleObjectEx(m_hEvent, INFINITE, TRUE);
        }
        while (dwWaitResult != WAIT_OBJECT_0 || dwWaitResult == WAIT_ABANDONED);
      }

    
      ////  Обработчик APC вызовов//static VOID CALLBACK APCProc(ULONG_PTR dwParam)
      {
        ApartmentMessage* message = reinterpret_cast<ApartmentMessage*> 
                                      (dwParam);
        message->Dispatch();
      }
      
  private: 
      ////  Обработать сообщение//void Dispatch()
      {
        IMessage* pMessage = static_cast<IMessage*> 
                   (GCHandle::op_Explicit(IntPtr(_message)).Target);
        ApartmentProxy* pProxy = static_cast<ApartmentProxy*> 
                   (GCHandle::op_Explicit(IntPtr(_proxy)).Target);
        
        try 
        {
          _result = static_cast<IntPtr>(GCHandle::Alloc(
              RemotingServices::ExecuteMessage(
                static_cast<MarshalByRefObject*> 
                (pProxy->GetTransparentProxy()),
                static_cast<IMethodCallMessage*>(pMessage)))
              ).ToPointer();
        }
        __finally {
          //// Вызов обработан – теперь мы можем отпустить ожидающий нас поток.//
          SetEvent(m_hEvent);
        }
      }
    };
  private:
    HANDLE m_hThread;
    Object * m_lock;

  public: 
    ApartmentProxy(Type* serverType) 
      : RealProxy(serverType, 
        IntPtr(ContextCheck), __box(IntPtr(0)))
    {
      m_lock = new Object();
      HANDLE __pin * pThread = &m_hThread;
      DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), pThread, 0, FALSE, DUPLICATE_SAME_ACCESS);
    }

  private:
    ~ApartmentProxy()
    {
      CloseHandle(m_hThread);
    }
  
  public: 
    void AttachObject(MarshalByRefObject * mbr)
    {
      AttachServer(mbr);
    }

    IMessage* Invoke(IMessage* msg)
    {      
      try 
      {
        //// Блокируем Invoke от использования из других потоков.//
        System::Threading::Monitor::Enter(m_lock);
        IConstructionCallMessage* ccm = 
          dynamic_cast<IConstructionCallMessage*> (msg);
        if (ccm != 0)
        {
          ////  Завершаем инициализацию//
          RealProxy::SetStubData(this, __box(IntPtr((void*)GetCurrentThreadId())));
          IMethodReturnMessage* mrm = InitializeServerObject(ccm);

          return mrm;
        }  

        ApartmentMessage Message(this, msg);
        //// Используя стандартные возможности WinAPI по асинхронному вызову// процедур, посылаем в нужный поток полученное сообщение.//
        QueueUserAPC(ApartmentMessage::APCProc, m_hThread, (ULONG_PTR) &Message);
        Message.Wait();
        
        return Message.Result();
      }
      __finally
      {
        System::Threading::Monitor::Exit(m_lock);
      }
    }  
};

      //
      // Не стоит особенно рассчитывать, что реализации ManagedStub, отличные 
      // от приведенной, будут работать (да и работа этого на 100% не гарантируется :) 
      //
      public
      class AdvancedProxy : RealProxy
{
    public AdvancedProxy(Type serverType) 
        : base (serverType, StubData.StubPointer(), StubData.defaultData)
    {

    }    

    ////  У данного класса порядок следования полей совпадает //  с порядком полей в классе __TransparentProxy.//class StubData
    {      
        internalstaticobject defaultData = newobject();
		
        object _realProxy;
        object _stubData;

        bool CheckContext()
        {
            ////  В этом методе this (передается в регистре ECX) это //  указатель на __TransparentProxy, а не на StubData //  как можно было бы подумать //return _stubData == StubData.defaultData;
        }

        ////  Получим указатель на stub метод//internalstatic IntPtr StubPointer()
        {
            MethodInfo checkContext = typeof(StubData).GetMethod(
                "CheckContext", 
                BindingFlags.NonPublic | BindingFlags.Instance);

            return checkContext.MethodHandle.GetFunctionPointer();
        }

        ////  Для подавления предупреждений компилятора//  В реальности мы даже не будем создавать экземпляры этого класса//
        StubData()
        {
            _realProxy = 0;
            _stubData = 0;
        }
    }    

    ////  В данной реализации RealProxy мы перехватываем только создание объекта, //  все остальные вызовы будут выполняться без перехвата.//publicoverride IMessage Invoke(IMessage msg)
    {   
        IConstructionCallMessage ccm = (IConstructionCallMessage) msg;
        RealProxy.SetStubData(this, newobject());

        return InitializeServerObject(ccm);
    }
}