3D Client Programmer

지난 글에 이어서.

[in, out] 배열을 C#에서 C/C++로 넘기는 방법
; http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&detail=1&wid=810

마이크로소프트가 원래 의도한 바는 아니었겠지만, tlbimp.exe 의 기능을 보정할 수 있는 방법을 별도로 제공하고 있습니다.

.NET Framework Developer's Guide
- Customizing Runtime Callable Wrappers
; http://msdn.microsoft.com/en-us/library/e753eftz.aspx

위의 글에 포함된 그림이 재미있습니다. ^^

[그림 1: RCW DLL 생성 방법]


RCW를 생성하는 3가지 방법 중에서 중간 그림이 의미가 있는데, 일단 한번 tlbimp.exe에 의해서 생성된 DLL 을 역어셈블한 뒤, 원하는 데로 마샬링 정보를 바꾸고 다시 ilasm을 이용해서 DLL을 생성하고 있습니다. 오호... 이 정도면 훌륭한 대안이죠. ^^

이것을 이용해서 지난 번 예제를 개선해 보겠습니다.

IDL 은 원래 정의된 그대로 사용하고,

[
	object,
	uuid(1A38076B-3D6D-4F20-8B4D-C72EF6AE1204),
	dual,
	nonextensible,
	helpstring("IMyTest Interface"),
	pointer_default(unique)
]
interface IMyTest : IDispatch
{
	[id(0x3003), helpstring("method PrepareBuf")] 
	HRESULT PrepareBuf([in, out, size_is(bufLength)] __int64 buffer [], [in] int bufLength);
};

마샬링 정보가 올바르진 않겠지만 일단 tlbimp.exe (또는 Visual Studio의 DLL 참조)를 이용하여 interop DLL을 생성합니다.

tlbimp testatl.dll /out:interop.testatl.dll

ildasm 으로 DLL을 역어셈블하면 해당 메서드가 다음과 같이 선언된 것을 볼 수 있습니다.

ildasm interop.testatl.dll /out:interop.testatl.il

.method public hidebysig newslot virtual 
      instance void  PrepareBuf([in][out] int64& buffer,
                                 [in] int32 bufLength) runtime managed internalcall
{
.custom instance void [mscorlib]System.Runtime.InteropServices.DispIdAttribute::.ctor(int32) = ( 01 00 03 30 00 00 00 00 )   // ...0....
.override interop.testatl.IMyTest::PrepareBuf
} // end of method MyTestClass::PrepareBuf

여기에서 "[in][out] int64& buffer" 구문을 "[in][out] int64[] marshal([]) buffer" 과 같이 바꿔줍니다. (또 한군데 더 정의되어 있기 때문에 그 부분도 마저 바꿔줍니다.) 이렇게 변경하고 다시 ilasm으로 어셈블해주면, C# 에서 정상적으로 long [] 으로 사용할 수 있습니다.

ilasm interop.testatl.il /dll

public virtual void PrepareBuf(long[] buffer, int bufLength);

우와~~~ ^^ 깔끔하죠! (첨부된 파일은 위의 예제와 지난 번 글의 예제를 함께 테스트한 프로젝트입니다.)

그러고 보니, 이걸 하면서 예전에 쓴 글이 하나 생각났습니다.

COM 개체의 이벤트를 구독하는 코드 제작
; http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&detail=1&wid=589

위의 방법 역시 interop DLL 코드가 잘못 생성된 경우인데, ildasm/ilasm 조합으로 해결할 수도 있었지 않았을까 싶네요. ^^

출처 : http://www.sysnet.pe.kr/2/0/811

가령, long 형 배열을 C/C++에 넘겨주고, C/C++ 측에서 해당 배열의 내용을 채운 후 반환해 주는 메서드라면 다음과 같이 IDL 정의를 해줄 수 있습니다.

[
	object,
	uuid(1A38076B-3D6D-4F20-8B4D-C72EF6AE1204),
	dual,
	nonextensible,
	helpstring("IMyTest Interface"),
	pointer_default(unique)
]
interface IMyTest : IDispatch
{
	[id(0x3003), helpstring("method PrepareBuf1")] 
	HRESULT PrepareBuf([in, out, size_is(bufLength)] __int64 buffer [], [in] int bufLength);
};

그런데, tlbimp.exe (또는 Visual Studio의 DLL 참조)를 이용하여 interop DLL을 생성해 보면, PrepareBuf 의 함수 형식이 다음과 같이 정의되는 것을 볼 수 있습니다.

tlbimp testatl.dll /out:interop.testatl.dll

public virtual void PrepareBuf(ref long buffer, int bufLength);

오호... tlbimp.exe로써는, 감당이 안되는 IDL 구문이라는 것인데요. 그렇다면 이를 해결하기 위해서 생각해 볼 수 있는 것이 배열 자체를 포인터로 넘겨보는 정도일텐데, 약간 찜찜하긴 해도 4byte(혹은 8byte) 값으로 넘기는 것은 ^^ 너무 잘 동작합니다.

그래서 C# 측에서, 배열 자체를 IntPtr로 변경하고,

[STAThread]
static void Main(string[] args)
{
    interop.testatl.MyTestClass mtc = new interop.testatl.MyTestClass();
    
    long [] test = new long[5];
    IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(test, 0);
    mtc.PrepareBuf(ptr.ToInt64(), 5);
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine(test[i]);
    }
}

C/C++ 에서는 넘겨받은 정수값을 간단하게 포인터로 형변환해서 처리해 주면 됩니다.

STDMETHOD(PrepareBuf2)(__int64 buffer, int bufLength)
{
	__int64 *pBuffer = (__int64 *)buffer;

	for (int i = 0; i < bufLength; i ++ )
	{
		pBuffer[i] = i;
	}

	return S_OK;
}

물론, 이 방법은 out-of-process COM 개체로 만들면 프로세스 주소 공간이 달라지기 때문에 동작하지 않습니다. 하지만, In-proc COM 개체만으로 사용하실 분들이라면 이 방법이 나쁘다고 볼 수는 없습니다.

출처 : http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&pageno=0&detail=1&wid=810

저의 경우, VC++ 8.0 의 C++/CLI 에 대한 매력을 느끼게 된 것은 문맥 구문이니... 뭐 그런 것들이 아니었습니다. 바로 명시적인 delete 구문의 지원이었습니다. 어떻게 그것이 가능할까... 뭔가 Interop 간에 대단한 비밀이 있지 않나 싶었는데요. 역시 파고들어 보니... 결국 ^^; IL 코드내에서 해결할 수 있을 뿐이더군요. (이제와서는, 명시적인 종료자보다 IJW 를 구현한 것에 대해 더 칭찬을 해주고 싶습니다.)

우선, 본격적으로 들어가기에 앞서 미리 다음의 토픽을 먼저 봐주시기 바랍니다.

.NET IDisposable 처리 정리 
; http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&pageno=0&detail=1&wid=347

사실, 도움말에도 나타난 위의 토픽을 굳이 한번 더 언급한 것은 이번 토픽을 위해서였습니다.

그럼, 하나씩 한번 알아볼까요? ^^

우선 예제 코드가 하나 있어야 할테니, 다음과 같은 클래스를 만들어서 예로 들어보겠습니다.

public ref class MyClass 
{
public:

	MyClass()
	{
	}
};

아래는 위의 코드를 사용하느 main 함수입니다.

int main(array ^args)
{
	MyClass ^myClass = gcnew MyClass();
    return 0;
}

일단, 여기 까지는 크게 일반 C#/VB.NET 클래스와 다른 점이 없습니다. 그런데, 여러분이 (또는 과거의 제가) 어렴풋이 들었던 것 중에, C++/CLI 에서는 delete 구문으로 개체를 명시적으로 해제하는 것을 지원한다고 했지요. 그래서 다음과 같이 delete 를 추가해 보겠습니다.

int main(array ^args)
{
	MyClass ^myClass = gcnew MyClass();
	delete myClass;
    return 0;
}

과연 정말 그럴까요? 위와 같이 하면 CLR Heap 에 할당된 개체가 즉시 삭제되어 메모리 관리 효율이 C++ 과 같아질 수 있을까요? 물론... 대답은 "아니오" 입니다. 실제로, 위의 코드 부분에 대해서 ".NET Reflector" 로 보면 다음과 같이 delete 코드가 확장되어 나오는 것을 확인할 수 있습니다.

internal static int main(string[] args)
{
      MyClass class1 = null;
      class1 = new MyClass();
      IDisposable disposable1 = class1 as IDisposable;
      if (disposable1 != null)
      {
            disposable1.Dispose();
      }

      return 0;
}

위의 코드를 보시고, ^^; 쓴 웃음을 짓는 분도 계실 텐데요. 그렇습니다. "delete myClass;" 구문은 실제로는 해당 개체의 IDisposable 인터페이스 구현여부를 알아내서 그것의 Dispose 메서드를 호출해주는 코드로 대체되어 삽입되는 것 뿐입니다. 이건 사실 기술이라고 부를 수도 없지요. 단지 언어적인 확장에 기인한 것 뿐이니까요. 마치 C# 의 경우 using 예약어를 지원하지만, 결국 생성된 코드는 try / finally 에 Dispose 메서드를 불러주는 코드로 확장되는 것과 다를 바 없습니다. 실제로, 우리가 기대했던 CLR Heap 의 메모리 정리 상황은 발생하지 않는 다는 것이 중요할 것입니다. 위의 방식을 아셨으니, 이제 쓰게 될 나머지 부분은 다 그러한 부분의 확장으로 받아들이시면 이해가 금방 되실 텐데요.

가만 있자... 그럼 또 뭐가 있을까요? 그렇군요. 우리가 알고 있던 얘기 중에, C++/CLI 는 파괴자를 구현하면 scope 을 벗어나는 경우 자동으로 호출된다고 들었지요. 그럼 그 부분도 한번 살펴볼까요? 예를 위해 위의 코드를 다음과 같이 수정해 보겠습니다.

public ref class MyClass 
{
	char *m_pBuf;
public:

	MyClass()
	{
		m_pBuf = new char[ 4096 ];
	}

	~MyClass()
	{
		delete [] m_pBuf;
	}
};

scope 을 벗어나는 것을 테스트 하기 위해서 MyClass 에 대한 명시적인 delete 없이 다음과 같은 스택 방식으로 수정을 하겠습니다.

int main(array ^args)
{
	MyClass myClass;
	return 0;
}

역시 이번에도 생성된 IL 코드를 ".NET Reflector" 로 확인해 보겠습니다.

internal static int main(string[] args)
{
      int num2;
      MyClass class1 = null;
      MyClass modopt(IsConst) local1 = (MyClass modopt(IsConst)) new MyClass();
      try
      {
            class1 = local1;
            num2 = 0;
      }
      fault
      {
            class1.Dispose();
      }
      class1.Dispose();
      
      return num2;
}

오... 이런... ^^; 역시 이번에도 실제로는 Managed 클래스를 스택상에 생성하지 않고 CLR Heap 에 할당하고는 fault 처리기에서 Dispose 가 명시적으로 불릴 수 있도록 하는 IL 코드로 확장이 되었습니다. 
재미있는 것은, MyClass 를 IL 코드로 열어보면 C++ 구문의 파괴자를 구현한 것이 실제로는 다음과 같이 IDisposable 패턴으로 확장된 것을 볼 수 있습니다.

public class MyClass : IDisposable
{
      public MyClass();
      private void ~MyClass();
      public sealed override void Dispose();
      protected virtual void Dispose([MarshalAs(UnmanagedType.U1)] bool);

      private unsafe sbyte modopt(IsSignUnspecifiedByte)* m_pBuf;
}

패턴은 이전 토픽에서 살펴봤던 C# 과 동일한 구조를 따르고 있습니다.

정리해 보면, C++/CLI 의 자원해제 기능은 결국 C++ 과 유사한 구문을 그대로 유지하되 내부적으로는 IDisposable 구문으로 확장해주는 것에 불과하다는 것입니다.

즉, C++/CLI 에서 다음과 같이 코딩을 한 것은,

	MyClass ^myClass = gcnew MyClass();
	delete myClass;
	
	또는,
	
	MyClass myClass;

C# 으로 다음과 같이 코딩을 해줄 수가 있습니다.

  using ( MyClass myClass = new MyClass() )
  {
  }  

C++/CLI 에서는 단지 구문을 단순하게 해준다는 장점만 있을 뿐, 그 이외의 어떠한 장점도 없다는 것입니다.

이미 앞에서 다뤘던 .NET IDisposable 처리 정리의 토픽과 비교해 보시면 아직 얘기하지 않은 이야기가 하나 있음을 아시게 될 텐데요. 바로 Managed 자원 해제와 Unmanaged 자원해제를 구분지어 해제하는 방법이 과연 무엇이냐는 것입니다. C# 의 경우, IDisposable 인터페이스를 구현하고 내부적으로 Dispose(bool disposing) 메서드를 호출하는데, C++/CLI 에서는 IDisposable 인터페이스를 자동으로 구현하기 때문에 bool disposing 에 대한 처리를 하는 부분이 모호해 지기 때문입니다. 이를 위해, C++/CLI 에서는 다음과 같은 특별한 구문의 파괴자를 하나 더 지원합니다.

public ref class MyClass 
{
	char *m_pBuf;
public:

	MyClass()
	{
		m_pBuf = new char[ 4096 ];
	}

	~MyClass()
	{
		// Managed 자원과 Unmanaged 자원을 모두 해제
		delete [] m_pBuf;
	}

	!MyClass()
	{
		// Unmanaged 자원을 해제
		delete [] m_pBuf;
	}
};

이 부분에서 약간 재미난 현상을 만나게 되는데요. Unmanaged 자원에 대한 해제 코드를 중복시키지 않기 위해 ~MyClass 에서 !MyClass 를 아래와 같이 호출하게 되면 컴파일 오류가 발생하게 됩니다.

	~MyClass()
	{
		!MyClass(); // error C2088: '!' : illegal for class	d:\...\Test.h
	}

	!MyClass()
	{
		delete [] m_pBuf;
	}

대신에 다음과 같이 포인터 구문을 쓰게 되면 정상적으로 호출이 됩니다.

	~MyClass()
	{
		this->!MyClass(); // 또는 MyClass::!MyClass();
	}

	!MyClass()
	{
		delete [] m_pBuf;
	}

이로써, C++/CLI 의 명시적인 종료자에 대해서 왠만큼 살펴본 것 같은데요. 
결론을 내려보면. C++/CLI 가 자원 해제 면에서 결코 우수한 언어가 아님을 알게 됩니다. 그저 Interop 만 우수한 언어일 뿐.

출처 : http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&pageno=1&title=%25c%2B%2B%25&wid=349&detail=1

Native Cpp 개발자를 위한 Cpp-CLI.pdf