Portage (non géré) C ++ à C # vs. Utilisation de la C ++ comme DLL dans une application C #

Une chose que j'ai trouvée utile est de plonger dans C ++ / CLI < / a> lorsque vous traitez avec des bibliothèques C ++ non gérés. Créez une enveloppe gérée à l'aide de C ++ / CLI et appelez-le de votre code C #. L'enveloppe gérée peut inclure la bibliothèque (je suppose qu'il est lié statilement) dans sa DLL et une référence de projet est tout ce dont vous avez besoin pour votre code C #.

http://msdn.microsoft.com/en-us/library/aa288468%28vs.71%29.aspx p>

Edit: Si vous le faites à l'aide de C ++ / CLI, vous Besoin d'apporter des appels de chargement et de créer des pointeurs de la fonction. Ceci est nettement plus facile dans C #. Cela vient du didacticiel MSDN lié ci-dessus, mais avec mes propres commentaires ajoutés: p> xxx pré>

EDIT: Les types complexes peuvent également être mis au rebut, bien qu'il soit nécessaire de définir les structures. Cet exemple tiré de mon propre code qui invoque GDI +. Je l'ai coupé un peu. P>

private static int SRCCOPY = 0x00CC0020;
private static uint BI_RGB = 0;
private static uint DIB_RGB_COLORS = 0;


[DllImport("gdi32.dll")]
private static extern bool DeleteObject(IntPtr hObject);

[StructLayout(LayoutKind.Sequential)]
private struct BITMAPINFO
{
    public uint biSize;
    public int biWidth;
    public int biHeight;
    public short biPlanes;
    public short biBitCount;
    public uint biCompression;
    public uint biSizeImage;
    public int biXPelsPerMeter;
    public int biYPelsPerMeter;
    public uint biClrUsed;
    public uint biClrImportant;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
    public uint[] cols;
}

public static Bitmap Downsample(Bitmap input, int bpp)
{
    Bitmap retval = null;

    // We will call into this GDI functionality from C#. Our plan:
    // (1) Convert our Bitmap into a GDI hbitmap (ie. copy unmanaged->managed)
    // (2) Create a GDI monochrome hbitmap
    // (3) Use GDI "BitBlt" function to copy from hbitmap into monochrome (as above)
    // (4) Convert the monochrone hbitmap into a Bitmap (ie. copy unmanaged->managed)

    IntPtr inputHandle = input.GetHbitmap();

    //
    // Step (2): create the monochrome bitmap.
    //
    BITMAPINFO bmi = new BITMAPINFO();
    bmi.biSize = 40;  // the size of the BITMAPHEADERINFO struct
    bmi.biWidth = input.Width;
    bmi.biHeight = input.Height;
    bmi.biPlanes = 1;
    bmi.biBitCount = (short)bpp; // 1bpp or 8bpp
    bmi.biCompression = BI_RGB;
    bmi.biSizeImage = (uint)(((input.Width + 7) & 0xFFFFFFF8) * input.Height / 8);
    bmi.biXPelsPerMeter = 0; // not really important
    bmi.biYPelsPerMeter = 0; // not really important

    //
    // Create the color palette.
    //
    uint numColors = (uint)1 << bpp; // 2 colors for 1bpp; 256 colors for 8bpp
    bmi.biClrUsed = numColors;
    bmi.biClrImportant = numColors;
    bmi.cols = new uint[256];

    if (bpp == 1)
    {
        bmi.cols[0] = MAKERGB(0, 0, 0);
        bmi.cols[1] = MAKERGB(255, 255, 255);
    }
    else
    {
        for (int i = 0; i < numColors; i++)
        {
            bmi.cols[i] = MAKERGB(i, i, i);
        }
    }

    // 
    // Now create the indexed bitmap
    //
    IntPtr bits0;
    IntPtr indexedBitmapHandle = CreateDIBSection(IntPtr.Zero, ref bmi, DIB_RGB_COLORS, out bits0, IntPtr.Zero, 0);
    IntPtr sourceDC = GetDC(IntPtr.Zero);
    IntPtr hdc = CreateCompatibleDC(sourceDC);
    IntPtr hdc0 = CreateCompatibleDC(sourceDC);

    SelectObject(hdc, inputHandle);
    SelectObject(hdc0, indexedBitmapHandle);

    BitBlt(hdc0, 0, 0, input.Width, input.Height, hdc, 0, 0, SRCCOPY);

    retval = Bitmap.FromHbitmap(indexedBitmapHandle);

    //
    // Dispose of the crud
    //
    DeleteDC(hdc);
    DeleteDC(hdc0);
    ReleaseDC(IntPtr.Zero, sourceDC);
    DeleteObject(inputHandle);
    DeleteObject(indexedBitmapHandle);

    return retval;
}