Calling C++ Dll from C#

Why I Use Dynamic Invoke Instead of Static Invoke?

Sometimes when I want to write and call some unmanaged function (C++ DLL function), I do the following:
In the *.cpp file...
int __declspec(dllexport) a(int b)
{
      return b;
}
... compile the *.cpp file to a *.dll file and in the C# file:
class Program
{
   [DllImport(@"c:\a.dll")]
   private static extern int a(int b);
   static void Main(string[] args)
   {
       Console.WriteLine(a(3));
   }
}
In this method, you see that I have to declare a static DLL filename, and when I compile to an excutable file (*.exe), I cannot change the DLL filename.
The second case is, I want to write some C++ DLL function for an ASP.NET/IIS (Internet Information Services) Web site. If I static invoke unmanaged, when I want to update the DLL file, I stop the Web site in IIS and replace the old file with the new file, but .. IIS still keeps the old DLL file. It does not release the file, and I have to stop the entire Web site, all services running in IIS for replacing the file.
So, I want to dynamically invoke an unmanaged file. I can load, invoke and free unmanaged DLL function initiatively.

How to Dynamic Invoke Unmanaged DLL Function?

The first way is by referring to dynamicinvokedll.aspx.
The second way that I want to introduce is how to use the WindowAPI function. We use three functions in kernel32.dll (this is a kernel DLL file and appears in [WindowRoot]\System32) LoadLibrary, GetProcess, and FreeLibrary. You can find the C++ declare type functions on MSDN (msdn.com). I only show the declare in C#:
class Program
{
        [DllImport("kernel32.dll", EntryPoint = "LoadLibrary")]
        static extern int LoadLibrary(
            [MarshalAs(UnmanagedType.LPStr)] string lpLibFileName);

        [DllImport("kernel32.dll", EntryPoint = "GetProcAddress")]
        static extern IntPtr GetProcAddress( int hModule,
            [MarshalAs(UnmanagedType.LPStr)] string lpProcName);

                [DllImport("kernel32.dll", EntryPoint = "FreeLibrary")]
        static extern bool FreeLibrary(int hModule);
}
The LoadLibrary function loads an unmanaged file, the GetProcAddress function gets the function pointer of an unmanaged file and the FreeLibrary function frees the unmanaged file. Now I can get the function pointer in a.dll very easily:
int hModule = LoadLibrary(@"c:\a.dll");
if (hModule == 0) return false;
IntPtr intPtr = GetProcAddress(hModule, "a");
And when I want to free the a.dll file, I can call:
FreeLibrary(hModule);
But C# doesn’t suport C++ function pointer, so we cannot invoke a C++ function pointer here. C# only has Delegate objects and we have to convert the function pointer to Delegate by Marshal.GetDelegateForFunctionPointer. It is declared in System.Runtime.InteropServices as follows:
public static Delegate GetDelegateForFunctionPointer (
      IntPtr ptr,
      Type t
)
(You can find more support for this function in MSDN.)
We first declare the Delegate for a function:
delegate int A(int b);
And get the delegate object as follows:
A a = (A)Marshal.GetDelegateForFunctionPointer(intPtr, typeof(A));
Now we can invoke a function as follows:
static void Main(string[] args)
{
    Console.WriteLine(a(3));
}



//Program.cs File


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace DLLCall
{
    class Program
    {
        // NativeMethods
        [DllImport("kernel32.dll")]
        static extern int LoadLibrary(
            [MarshalAs(UnmanagedType.LPStr)] string strLibfilName);

        [DllImport("kernel32.dll")]
        static extern IntPtr GetProcAddress(int hModule,
            [MarshalAs(UnmanagedType.LPStr)] string ProcName);

        [DllImport("kernel32.dll")]
        static extern void FreeLibrary(int hModule);

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int myfunc(int number1, int number2);

        [DllImport(@"E:\CPPDLL.dll",CallingConvention=CallingConvention.StdCall)]
        static extern int Add(int a , int b);

        static void Main(string[] args)
        {
           int b=   Add(50, 600);  // Direct Dll Import bby calling convention... 
            // Enable Unmanged Code Debugging in C# Project Properties for debuging in Cpp.


            // Using LoadLibrary function Call
            int hModule = LoadLibrary(@"E:\CPPDLL.dll");
            IntPtr intptr;
            if (hModule == 0)
                return;
            else
                intptr = GetProcAddress(hModule, "Add");

            myfunc cppfuntion = (myfunc)Marshal.GetDelegateForFunctionPointer(intptr,typeof(myfunc));

            int c = cppfuntion(60, 80);

            FreeLibrary(hModule);
        }
    }
}




// C++ Dll Project File


// CPPDLL.cpp : Defines the exported functions for the DLL application.
//

#include "stdafx.h"
#include <Windows.h>
#include <iostream>

extern "C"
{
__declspec(dllexport) int Add(int a , int b)
{
return a+b;
}
}

Comments

Post a Comment

Popular posts from this blog

Smart Pointers in C++ and How to Use Them

Image
  Smart Pointers in C++ and How to Use Them In this article, we will be discussing smart pointers in C++. What are Smart Pointers, why, and how to use them properly? Pointers are used for accessing the resources which are external to the program – like heap memory. So, for accessing the heap memory (if anything is created inside heap memory), pointers are used. When accessing any external resource we just use a copy of the resource. If we make any change to it, we just change it in the copied version. But, if we use a pointer to the resource, we’ll be able to change the original resource. Play Video Click here for the Complete Course! Problems with Normal Pointers Take a look at the code below. C++ #include <iostream> using namespace std;   class Rectangle { private :      int length;      int breadth; };   void fun() {      // By taking a pointer p and      // dynamically creating object      // of class rectangle      Rectangle* p = new Rectangle(); }   int main() {    
Read more

Operator Overloading in C++

Operator Overloading in C++ In C++, we can make operators to work for user defined classes. For example, we can overload an operator ‘+’ in a class like String so that we can concatenate two strings by just using +. Other example classes where arithmetic operators may be overloaded are Complex Number, Fractional Number, Big Integer, etc. A simple and complete example #include<iostream> using namespace std;   class Complex { private :      int real, imag; public :      Complex( int r = 0, int i =0)  {real = r;   imag = i;}             // This is automatically called when '+' is used with      // between two Complex objects      Complex operator + (Complex const &obj) {           Complex res;           res.real = real + obj.real;           res.imag = imag + obj.imag;           return res;      }      void print() { cout << real << " + i" << imag << endl; } };   int main()
Read more

How would you read in a string of unknown length without risking buffer overflow

How would you read in a string of unknown length without risking buffer overflow #include <stdio.h> #include <stdlib.h> char * inputString ( FILE * fp , size_t size ){ //The size is extended by the input with the value of the provisional char * str ; int ch ; size_t len = 0 ; str = realloc ( NULL , sizeof ( char )* size ); //size is start size if (! str ) return str ; while ( EOF !=( ch = fgetc ( fp )) && ch != '\n' ){ str [ len ++]= ch ; if ( len == size ){ str = realloc ( str , sizeof ( char )*( size += 16 )); if (! str ) return str ; } } str [ len ++]= '\0' ; return realloc ( str , sizeof ( char )* len ); } int main ( void ){ char * m ; printf ( "input string : " ); m = inputString ( stdin , 10 ); printf ( "%s\n" , m ); free ( m ); return 0 ; }
Read more