Develop Reference

Creating C++ DLL called from C#

I'm trying to find a tutorial on creating a C++ class in a DLL that can be called from C#. I've found a few tutorials but they either do not compile in VS 2013 Community or are not on point. The C++ object has only a few exported functions (i.e., that are called from the consuming C# app like ptr->StartAction()). It has about 70 procedures that are not exposed, in assembly language which is why I need to use C++. Currently I expose some functions in the DLL via dllimport etc. But C# requires using fixed(...) (to prevent garbage collection) which slows everything down quite a bit (and they are called 1,000,000s of times). Hence the need to move all that into the DLL. So I need a class that I can instantiate in the C# calling program and then call the public methods in the dll. I'm using .NET 4.0. The DLL will only be used by this one C# app.

You can achieve it through the help of COM component and IDL with an output of Interoperability dll where you can use in your c# project. For more details follow this link.

You can use the DllImport attribute of C#. Here is a sample signature:
[DllImport("path to dll", CallingConvention = CallingConvention.Cdecl)]
[return: MarshalAs(UnmanagedType.BStr)]
public static extern string methodName(string parameterName);
C# will call the method with the same name in the DLL.
Its impossible to say what you really need, because we don't have your method declarations.

How to call C# code in C++

I have a small C# class (Gram.cs) and it is working with a 3rd party dll to operate a device. Now, I need to call some functions in this C# class using C++.
How can I do it?
I am using MS Visual Studio 2010 professional edition.

If C# class is small, and it deals with native dll, it might by simpler rewrite that class in C++, rather then integrate .Net into your application. In addition, integrating .Net will force whole .Net virtual machine to start just for processing your simple class.
Otherwise,
You could use COM interop: build an assembly based on your C# class and make it COM visible. Then you could use class as a COM-object.
You can use Managed C++ to make a wrapper between managed and unmanaged code.
You can reverse control flow, so C# code will call unmanaged functions. In this case you can export it from your binary and import from C# code with DllImport attribute.

Normally you should make your c# code as COM visible from your c# project settings and use c# IJW regasm tool.
Look into http://msdn.microsoft.com/en-IN/library/ms173185.aspx
I had integrated c# into c++ using this approach few years ago.
You will be able to load your c# assembly as a COM component in your c++ code.

This might be what you're looking for (I've answered similiar question here before: how to : use c++ projects for windows phone (C#))
a) Load symbols directly from C library, for example:
using System;
using System.Runtime.InteropServices;
static class win32
{
[DllImport("kernel32.dll")]
public static extern IntPtr LoadLibrary(string dllToLoad);
[DllImport("kernel32.dll")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
[DllImport("kernel32.dll")]
public static extern bool FreeLibrary(IntPtr hModule);
}
(this is taken from: http://www.andyrushton.co.uk/csharp-dynamic-loading-of-a-c-dll-at-run-time/ after brief googling)
You need to export the C++ interface methods as "C" for that, e.g.:
extern "C" __declspec( dllexport ) int MyFunc(long parm1);
(from MSDN: http://msdn.microsoft.com/en-us/library/wf2w9f6x.aspx)
b) Use a wrapper in C++/CLI to connect unmanaged C++ to managed C#:
here's a good example: http://www.codeproject.com/Articles/19354/Quick-C-CLI-Learn-C-CLI-in-less-than-10-minutes
Do note that the syntax is somewhat weird at first look, and not eveything can be used. However, what you gain is ability to use the C++ classes - something that exporting "C" prohibits you from doing.

P/Invoke C++ Class in C#

I want to use rasterbar libtorrent in a C# application. It's written in unmanaged C++.
I'm new at using DLLs and found this article online: How to Marshal a C++ Class
It describes that it's not possible to marshal/invoke a C++ class directly and you have to write a bridge in C (or managed C++) in order to use the library in managed C# code.
The article is from 2007 and I wonder if there is a better solution to use C++ DLLs by now. I'm looking for solutions that also work on the Mono platform. libtorrent is cross plattform so it should be possible.

First you should have the libtorrent dll built for windows. This link here can help you. Then for calling the un-managed code (C++ in this case) from the managed code (C# in this case) you can use Platform Invocation Services (PInvoke). It allows managed code to call unmanaged functions that are implemented in a DLL. For example have a look on this MSDN code
// PInvokeTest.cs
using System;
using System.Runtime.InteropServices;
class PlatformInvokeTest
{
[DllImport("msvcrt.dll")]
public static extern int puts(string c);
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
public static void Main()
{
puts("Test");
_flushall();
}
}
The better approach will be to write a wrapper class in C# for libtorrent dll, wrap it's methods using PInvoke and use the wrapper throughout your project.

How to access a C++ Class in a C# code?

I have following problem statement.
Export a C++ class in the dll (un-managed).
Create and use an object of this class in C# code.
For the first part I have the classDLL.h as follows
``
#include <iostream>
__declspec(dllexport)
class pABC{
private:
int x;
public:
void func();
};
The respective cpp is also there. On compiling I get the dll.For thesecond part of the problem I am not getting how to proceed.
Thanks.

You can't access an unmanaged class directly from C# code. You can write a small wrapper .DLL in C++/CLI, which wraps the unmanaged class in a managed class which is visible to C#.

Convert the C++ class and DLL to be COM. If you don't have access to the unmanaged code source or can't modify, you can implement a COM wrapper class in a different DLL that consumes the original DLL and proxies the functionality of the original class through a COM class.
Define an interface in an IDL file to represent your C++ class (along with a coclass declaration). Use only basic COM types in all methods (BSTR for strings, HRESULT for return codes). Complicated structs passed as params should be refactored into their own interface.
Build your COM DLL such that it outputs a type library (tlb file).
Implement the interface (including IUnknown methods) in your C++ class. Build the COM DLL and register it.
Import the type library into your C# project. Or use the type library importer. You should now be able to instantiate your C++ class (through COM) via "new".
By the way, ATL is a great framework to get going on this quickly.

Google P/Invoke or see www.pinvoke.net

[DllImport("pABC.dll", SetLastError = true, CharSet = CharSet.Auto)]
private static extern void func();

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);
}
}