イグトランスの頭の中（のかけら）

// HandleStream.h
#pragma once
 
#include <atlbase.h>
#include <atlcom.h>
 
class ATL_NO_VTABLE HandleStream
  : public ATL::CComObjectRootEx<ATL::CComMultiThreadModelNoCS>
  , public IStream
{
public:
  BEGIN_COM_MAP(HandleStream)
     COM_INTERFACE_ENTRY(ISequentialStream)
     COM_INTERFACE_ENTRY(IStream)
  END_COM_MAP()
 
  STDMETHOD(Read)(
    _Out_writes_bytes_to_(cb, *pcbRead) void* pv,
    _In_ ULONG cb,
    _Out_opt_ ULONG* pcbRead) override
  {
    DWORD read;
    if (!ReadFile(m_h, pv, cb, &read, nullptr))
      return ATL::AtlHresultFromLastError();
    if (pcbRead != nullptr)
      *pcbRead = read;
    return read < cb ? S_FALSE : S_OK;
  }
  STDMETHOD(Write)(
    _In_reads_bytes_(cb) const void* pv,
    _In_ ULONG cb,
    _Out_opt_ ULONG* pcbWritten) override
  {
    DWORD written;
    if (!WriteFile(m_h, pv, cb, &written, nullptr))
      return ATL::AtlHresultFromLastError();
    if (pcbWritten != nullptr)
      *pcbWritten = written;
    return S_OK;
  }
  IFACEMETHOD(Seek)(
    LARGE_INTEGER dlibMove,
    DWORD dwOrigin,
    _Out_opt_ ULARGE_INTEGER* plibNewPosition) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(SetSize)(
    ULARGE_INTEGER libNewSize) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(CopyTo)(
    _In_ IStream* pstm,
    ULARGE_INTEGER cb,
    _Out_opt_ ULARGE_INTEGER* pcbRead,
    _Out_opt_ ULARGE_INTEGER* pcbWritten) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(Commit)(DWORD /*grfCommitFlags*/) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(Revert)() override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(LockRegion)(
    ULARGE_INTEGER /*libOffset*/,
    ULARGE_INTEGER /*cb*/,
    DWORD /*dwLockType*/) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(UnlockRegion)(
    ULARGE_INTEGER /*libOffset*/,
    ULARGE_INTEGER /*cb*/,
    DWORD /*dwLockType*/) override
  {
    return E_NOTIMPL;
  }
  IFACEMETHOD(Stat)(
    _Out_ STATSTG* pstatstg,
    DWORD grfStatFlag) override
  {
    if (pstatstg != nullptr)
      *pstatstg = {};
    return E_NOTIMPL;
  }
  IFACEMETHOD(Clone)(_COM_Outptr_ IStream** ppstm) override
  {
    if (ppstm != nullptr)
      *ppstm = {};
    return E_NOTIMPL;
  }
 
  HANDLE m_h = nullptr;
};

// cl /clr p.cpp
#define UNICODE
#define _UNICODE
#define WIN32_LEAN_AND_MEAN
#define _ATL_NO_AUTOMATIC_NAMESPACE
 
#include <iostream>
#include <windows.h>
#include "HandleStream.h"
 
using namespace System;
using namespace System::Runtime::InteropServices;
 
public ref class Hoge
{
public:
  // これが親プロセスから呼び出される関数
  [DispId(DISPID_VALUE)]
  void f()
  {
    MessageBox(nullptr, L"Hoge::f", L"c.exe", 0);
  }
};
 
[MTAThread]
int WINAPI WinMain(HINSTANCE, HINSTANCE, PSTR, int)
{
  auto obj = gcnew Hoge;
  ATL::CComPtr<IDispatch> disp;
  disp.Attach(static_cast<IDispatch*>(
    Marshal::GetIDispatchForObject(obj).ToPointer()));
 
  ATL::CComObjectStack<HandleStream> s;
  s.m_h = GetStdHandle(STD_OUTPUT_HANDLE);
  Marshal::ThrowExceptionForHR(CoMarshalInterface(
    &s, __uuidof(disp.p), disp, MSHCTX_LOCAL, nullptr, MSHLFLAGS_NORMAL));
 
  MessageBox(nullptr, L"OKを押すと終了します", L"c.exe", 0);
}

// cl p.cpp
#define UNICODE
#define _UNICODE
#define WIN32_LEAN_AND_MEAN
#define _ATL_NO_AUTOMATIC_NAMESPACE
 
#include <iostream>
#include <windows.h>
#include <atlbase.h>
#include <atlstr.h>
#include <atlutil.h>
#include "HandleStream.h"
 
HRESULT OutputErrorMessgae(_In_ PCWSTR functionName, HRESULT hr)
{
  std::wclog << functionName << '\n';
  std::wclog << std::showbase << std::hex << hr << '\n';
  std::wclog << ATL::AtlGetErrorDescription(hr).GetString() << std::endl;
  return hr;
}
 
HRESULT OutputLastError(_In_ PCWSTR functionName)
{
  auto hr = ATL::AtlHresultFromLastError();
  return OutputErrorMessgae(functionName, hr);
}
 
int main()
{
  std::wclog.imbue(
    std::locale(std::locale::classic(), "", std::locale::ctype));
  auto hrInit = CoInitializeEx(
    nullptr, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE);
  if (FAILED(hrInit))
  {
    return hrInit;
  }
 
  ATL::CHandle hOutputRead, hOutputWrite;
  if (!CreatePipe(&hOutputRead.m_h, &hOutputWrite.m_h, nullptr, 0))
  {
    return OutputLastError(L"CreatePipe");
  }
  if (!SetHandleInformation(
    hOutputWrite, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
  {
    return OutputLastError(L"SetHandleInformation");
  }
 
  STARTUPINFO si{sizeof si};
  si.dwFlags = STARTF_USESTDHANDLES;
  si.hStdOutput = hOutputWrite;
  PROCESS_INFORMATION pi{};
  if (!CreateProcess(L"c.exe", nullptr,
    nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi))
  {
    return OutputLastError(L"CreateProcess");
  }
  CloseHandle(pi.hProcess);
  CloseHandle(pi.hThread);
 
  ATL::CComObjectStack<HandleStream> s;
  s.m_h = hOutputRead;
 
  ATL::CComPtr<IDispatch> disp;
  auto hrUnmarshal = CoUnmarshalInterface(&s, IID_PPV_ARGS(&disp));
  if (FAILED(hrUnmarshal))
  {
    return OutputErrorMessgae(L"CoUnmarshalInterface", hrUnmarshal);
  }
 
  DISPID dispid = DISPID_VALUE;
  auto hr = disp.Invoke0(dispid); // Hoge::fの呼び出し
  if (FAILED(hr))
  {
    return OutputErrorMessgae(L"Hoge::f", hr);
  }
  disp.Release();
  std::cout << "完了" << std::endl;
 
  CoUninitialize();
}