Develop Reference

How to ger method of class from a loaded C# dl-library in C++? [duplicate]

How to call managed c# functions from unmanaged c++

Or use a project of mine that allows C# to create unmanaged exports. Those can be consumed as if they were written in a native language.

I used COM interop first, but by now I switched to IJW (it just works), as it is a lot simpler. I have a wrapper C++/CLR DLL (compile with /clr).
A simple example (using statics to make the calls easier):
namespace MyClasses
{
public class MyClass
{
public static void DoSomething()
{
MessageBox.Show("Hello World");
}
}
}
In the DLL I can reference namespaces as follows:
using namespace MyClasses;
And call it:
__declspec(dllexport) void CallManagedCode()
{
MyClass::DoSomething();
}
Now you have an unmanaged DLL export "CallManagedCode" which calls into the managed code.
Of course, you also have to convert data between the managed/unmanaged boundary. Starting with VS2008, Microsoft includes a marshal-helper for converting between unmanaged and managed types. See http://msdn.microsoft.com/en-us/library/bb384865.aspx

I used C++/CLI wrapper classes described here and it was relatively easy to implement.

RE: How to call managed C# code from an unmanaged C++ application?
http://www.tech-archive.net/Archive/DotNet/microsoft.public.dotnet.framework.interop/2005-05/msg00030.html
Calling Managed .NET C# COM Objects from Unmanaged C++ Code ...
http://www.codeproject.com/KB/cs/ManagedCOM.aspx
Wrapping a managed C# DLL in a unmanaged C++ project : dll .
http://www.experts-exchange.com/Programming/Languages/.NET/Q_22006727.html

How can I call a function of a C++ DLL that accepts a parameter of type stringstream from C#?

I want to import an unmanaged C++ DLL and call a function that takes stringstream as a parameter. In C#, there is no stringstream class, so can anyone tell me how to call such a function from a C# program?

You should not expose templated objects via a DLL, period.
Templated objects (e.g. almost everything in std::) become inlined. So in this way, your DLL gets its own private copy of the implementation. The module calling your DLL will also get its own private implementation of stringstream. Passing between them means you are inadvertently weaving two unrelated implementations together. For many projects, if you are using the exact same build settings, it's probably no problem.
But even if you use the same compiler, and mix a release DLL with a debug EXE, you will find stack / heap corruption and other harder-to-find problems.
And that's only using your DLL from another unmanaged C++ exe/dll. Crossing then the lines to .NET is even more of a problem.
The solution is to change your DLL's interface to something that plays friendly across DLL bounds. Either COM (you could use IStream for example), or just a C-style interface like the winapi.

If you can modify the C++ dll, export a plain string version. Otherwise you have to build a managed C++ wrapper project, import the other C++ dll, export it as a managed function, and call that from your C# code. C++ interop really sucks.

I'm afraid that you're going to have to create your own StringStream class in C# in order to be able to consume the functions exported from that DLL. As you mentioned, the .NET Framework doesn't provide any similar class out of the box.
The easiest way is probably to wrap the StringBuilder class provided by the .NET Framework such that it can function as a stream. See this blog post for a further explanation and some sample code.
A similar question was also answered in MSDN Magazine: http://msdn.microsoft.com/en-us/magazine/cc163768.aspx. You might find some of the hints and/or sample code given there useful.

You are trying to bind native C++ code to managed code in C#. Best way of doing that in general is to introduce middle layer in managed C++ that will provide interface to calls from C#.

Create an Wrapper dll in c, or c++ that exposes an friendly call to that function. It's the better way.
for example an
BOOL getString(TCHAR * myreturnString, DWORD *size);

Call c++ library from c#

This question might seem a repeat of previous ones. I have read through a series of posts, but not completely clear for my situation.
I have a c++ library which is created using momentics IDE. I have to be able to use this library into a c# project.
Someone had been working on this project before being handed over to me. Currently, there are 2 layers for making this possible. First, a c++ project includes the complete library with a c++ wrapper. This project creates a dll as the output. This c++ dll is then fed to a c# project, which has dllimport calls to the c++ dll. This c# project again creates a dll. Finally, in order to use the library in c# application, I have to include a reference to both of these dlls.
Is this the correct way to get it working? I was thinking probably there should be a way to simplify the process.
Can someone please help me with this question?

Given that you're using a C++ library, I'm assuming it takes advantage of C++ semantics like classes, rather than just exposing procedures. If this is the case, then the way this is typically done is via a manually-created managed C++ interop library.
Basically, you create a managed C++ library in Visual Studio, reference your existing C++ library, and create a managed wrapper around your existing C++ classes. You then reference this (managed) C++ assembly in your C# project and include the original (unmanaged) C++ library in your C# assembly just as a file that gets placed in the build directory.
This is required because there is no way to reference things like C++ classes via P/Invoke (DllImport) calls.
If your base library is just a series of functions, then you can reference that directly in the C# project via P/Invoke functions.
Either way, all of the libraries mentioned above (for the first, the unmanaged C++ library, the managed C++ assembly, and the C# project, or, for the second, the unmanaced C++ library and the C# project) must be included in any project that references them. You cannot statically link the unmanaged library into the managed assembly.

Seems like you have one wrapper too many but perhaps someone is implementing some sort of facade or adding properties or something. The basic connection between managed and unmanaged will be either DllImport of "flat" function calls - not member functions - or C++/CLI code calling member functions. If the wrapper is C++/CLI it's easiest to write (just include the header for the C++ library) and easiest to call (C# code just adds a .NET reference to it and carries on as normal) so it would be my first choice if there's C++ expertise on the project.
It sounds like whoever you were taking over from is doing it the hard way. If there are less than 20 methods, I would suggest starting over.

You can use:
DllImport
class Example
{
// Use DllImport to import the Win32 MessageBox function.
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);
static void Main()
{
// Call the MessageBox function using platform invoke.
MessageBox(new IntPtr(0), "Hello World!", "Hello Dialog", 0);
}
}

How to create a .dll in Visual Studio 2008 for use in a C# App?

I have a C++ class I'd like to access from a C# application. I'll need to access the constructor and a single member function. Currently the app accepts data in the form of stl::vectors but I can do some conversion if that's not likely to work?
I've found a few articles online which describe how to call C++ DLLs and some others which describe how to make .dll projects for other purposes. I'm struggling to find a guide to creating them in Visual Studio 2008 for use in a C# app though (there seem to be a few for VS 6.0 but the majority of the options they specify don't seem to appear in the 2008 version).
If anyone has a step-by-step guide or a fairly basic example to get going from, I'd be very grateful.

The easiest way to interoperate between C++ and C# is by using managed C++, or C++/CLI as it is called. In VisualStudio, create a new C++ project of type "CLR Class Library". There is some new syntax for the parts that you want to make available to C#, but you can use regular C++ as usual.
In this example, I'm using std::vector<int> just to show that you can use standard types - however, in an actual application, I'd prefer to use the .NET types where possible (in this case a System::Collections::Generic::List<int>).
#pragma unmanaged
#include <vector>
#pragma managed
public ref class CppClass
{
public:
CppClass() : vectorOfInts_(new std::vector<int>)
{}
// This is a finalizer, run when GC collects the managed object
!CppClass()
{ delete vectorOfInts_; }
void Add(int n)
{ vectorOfInts_->push_back(n); }
private:
std::vector<int>* vectorOfInts_;
};
EDIT: Changed the class to hold the vector by pointer instead of by value.

If such DLL is unmanaged. You will have to use P/invoke. A p/invoke function definition looks like this:
[DllImport("Library_Name.dll", EntryPoint = "function")]
public static extern void function();
If, on the other hand, is a managed (C++/CLI) DLL (or assembly). You can access it by adding a reference to it on your .NET project.
EDIT:
I think I didn't answer your question at all. But to create a managed C++ DLL to be accessed from .NET, create a new project an choose:
Visual C++/CLR/Class Library. And then, just add its output DLL to your C# project.
That'd do it. :)

Do you have an existing C++ exe that you want to re-build as a dll? Or is all you have the C++ class?
If all you have is the C++ class, you might think about building a .Net dll. While you couldn't pass stl types from C# to C++, I am pretty sure you can pass managed .Net types.
If you must use the stl types in the class, you could convert the data in the C++ class, or the calling app.

I've found a tutorial which works. A quick note though, you have to be careful to copy the .dll into the same directory as the executable. I messed around with trying to tell the executable where the DLL was but gave up in the end.

Use of unmanaged C++ Dlls can be very tedious in C#.
An "easier" route is to place it in a COM wrapper.

Marshalling reference-types from C++ to C#

I want to invoke the following C++ function (exported by a DLL) from C#:
void createVm(
const jace::VmLoader& loader,
const jace::OptionList& options,
bool ignoreUnrecognized = true );
I've found documentation for marshaling primitives from C++ to C# but I'm not sure how to handle reference-types or non-pritmive types such as VmLoader or OptionList (both of which are classes). I'm trying to wrap a C++ API with a C# layer, delegating to the underlying C++ code for the actual method implementation.
Any ideas?

AFAIK, PInvoking into a function with C++ constructs is not a supported operation. You could probably get it to work but I think you'll find problems.
What is supported is writing a simple C wrapper function which calls into your C++ function. PInvoke into the wrapper function instead and that will do the trick.

Assuming the c++ DLL correctly exports the types being passed by reference, you could right a light weight managed C++ wrapper that calls the dll. With managed c++ you can call native C/C++ libs and dlls directly while still exporting a managed interface from the resulting assemblies. Other .Net languages can call the managed interface just like they would any other assembly. It's a bit of extra overhead, but's is can be the quickest way to get it done.