This has got nothing to do with managed vs unmanaged code or UINT16.
Apparently NewNetwork is a non-static member function, and VC7.1 is not
only allowing the illegal syntax for referring to it in your
SetNewNetworkCallBack call, it's emitting a misleading error message which
implies it's a static member. IIRC, VC8 fixes the syntax problem, so the
bare "NewNetwork" reference will be disallowed; instead, you'll have to use
&CCommApp::NewNetwork to form a pointer to member. In any case, the
solution is to make NewNetwork static.

P.S. It would be useful in the future to include the complete text of the
error message, including error number, and to abstract the problem into a
simple console program. For example (removing all the managed stuff doesn't
affect the error message):

#using <mscorlib.dll>
using namespace System;

#pragma unmanaged

void f(void (*)(unsigned short))
{
}

#pragma managed

struct X
{
  void g(unsigned short)
  {
  }

  void h()
  {
     f(g);
  }
};

int main()
{
}

C>ccr k.cpp
Microsoft (R) C/C++ Optimizing Compiler Version 13.10.3077 for .NET
Framework
Copyright (C) Microsoft Corporation 1984-2002. All rights reserved.

k.cpp
k.cpp(20) : error C2664: 'f' : cannot convert parameter 1 from 'void
(unsigned short)' to 'void (__cdecl *)(unsigned short)'
       None of the functions with this name in scope match the target type

Is CCommApp::NewNetwork static? The NewNetworkCallBack prototype
requires that the function is non-member or at least static. Just move
the NewNetwork function outside of the CComApp class, it doesn't belong
there.

Also check that UInt16 is exactly the same type as unsigned short
(better to rename Uint16 to unsigned short), and the calling conventions
must match too (both __stdcall or __cdecl, better to specify it explicitly).

Tom

If I see it correctly, you're passing a managed method as an unmanaged
pointer. That's not going to work. You have to write a global unmanaged
function (in MC++ or C++/CLI) that calls back to the managed code, and
pass this intermediate function to the unmanaged API. There's no way you
can pass a managed callback to an unmanaged library without this
intermediate layer.

Also, you can't pass a managed void* to the unmanaged part either, at
least not without pinning it.

Tom

I was curious how to do this, and worked out two very simple examples.
This is how I would implement a C-callback in managed C++ code. I
couldn't find anything that allowed a managed function to be passed
directly to an unmanaged call (first I couldn't convert between void*
and the managed type, second I couldn't convert between __clrcall and
__cdecl functions). So I had to introduced the intermediate class
"Bridge". gcroot<> is a wrapper for GCHandle, which allows us to store a
managed handle in a native class. It also ensures that the managed class
is pinned, so the garbage collector doesn't move around the "c" object
while the native code is running. After the native "Process" is done,
the bridge goes out of scope, so the pin gets released.

//////////////////////////////////////////////////////////////////
// For MC++:
#include "stdafx.h"
#include <vcclr.h>

#using <mscorlib.dll>

using namespace System;

typedef void (*Callback)(void* param);

void Process(Callback callback, void* param)
{
   if(callback) callback(param);
}

__gc class C
{
public:
   void ProcessMe();
   void OnProcess() // the callback implementation
   {
      Console::WriteLine(S"OnProcess");
   }
};

class Bridge
{
public:
   Bridge(C* in) : c(in) { }
   static void ForwardOnProcess(void* param)
   { static_cast<Bridge*>(param)->c->OnProcess(); }
private:
   gcroot<C*> c;
};

void C::ProcessMe()
{
   Bridge b(this);
   ::Process(&Bridge::ForwardOnProcess, &b);
}

int _tmain()
{
   C* c = new C;
   c->ProcessMe();
   return 0;
}

//////////////////////////////////////////////////////////////////
// For C++/CLI:
#include "stdafx.h"
#include <vcclr.h>

using namespace System;

typedef void (*Callback)(void* param);

void Process(Callback callback, void* param)
{
   if(callback) callback(param);
}

ref class C
{
public:
   void ProcessMe();
   void OnProcess() // the callback implementation
   {
      Console::WriteLine(L"OnProcess");
   }
};

class Bridge
{
public:
   Bridge(C^ in) : c(in) { }
   static void ForwardOnProcess(void* param)
   { static_cast<Bridge*>(param)->c->OnProcess(); }
private:
   gcroot<C^> c;
};

void C::ProcessMe()
{
   Bridge b(this);
   ::Process(&Bridge::ForwardOnProcess, &b);
}

int main(array<System::String^>^ args)
{
   C^ c = gcnew C;
   c->ProcessMe();
   return 0;
}

Tom