在jQuery中，要选择节点的第n个兄弟节点，是.next（）链接n次还是.nextAll（'：eq（n-1）'）更快？(In jQuery, to select the nth sibling of a node, is .next() chained n times or .nextAll(':eq(n-1)') faster?)

 直接从C＃使用本机C ++类在技术上是可行的，但它并不是微不足道的，而且它甚至都不是一个好主意。 对于初学者，您必须知道用于从DLL导入的名称，这将是C ++名称修改后的名称。 您也无法直接访问C＃中的vector等内容。 
 
 基本上有两个不错的选择： 
 
 第一种是使用C接口编写DLL，该接口仅使用可以编组为CLR类型的类型。 您可以将指针与IntPtr类型一起使用，但是您无法真正取消引用这些指针。 您几乎可以将它们存储在C＃代码中，然后在需要时将它们传递回本机DLL。 只要您不需要深层复制来处理它们，您也可以使用简单的struct类型。 此选项涉及使用P / Invoke。 
 
 第二个选项是编写混合模式C ++ / CLI程序集，该程序集实现了访问本机代码所需的所有逻辑。 这个程序集可以直接访问C＃代码中的类和数据，也可以直接访问您的本机代码，尽管您应该预先警告，有些烦人的中断，您不能将它们混合在一起。 例如，C ++ / CLI中的ref class不能具有shared_ptr成员。 但是，它可以将原始C ++指针作为成员。 （混合模式）本机类也可以访问CLR句柄类型，并通过它调用C＃代码。 此选项涉及使用C ++ Interop。 
 
 值得注意的是，你也可以采用C ++ Interop的另一种方式。 您可以让C＃代码访问混合模式C ++ / CLI程序集，该程序集为某些本机代码提供.NET接口。 但是，在这种情况下，您仍然需要进行一些翻译，因此它并不比第一个选项好很多。 
 
 关于C ++ Interop的完整教程将会相当冗长。 我建议你在这里阅读并对Google上的C ++ Interop做进一步的调查。 

In order to make a C wrapper for a C++ class to be used in for example a C# application you can do the following.
 
In Visual Studio choose Win32 Console Application and Enter a name, Then click next and on the next pane choose DLL and click finish. When you are done you are represented with a DLL project including 3 files.
 
testdll.h 
testdll.cpp
dllmain
 
Delete everything that exists inside your testdll.h and testdll.cpp files and copy the following contents to each respectively. Add these lines to your testdll.h
 
// Our C wrapper for creating a dll to be used in C# apps

// The following ifdef block is the standard way of creating macros which make exporting 
// from a DLL simpler. All files within this DLL are compiled with the TESTDLL_EXPORTS
// symbol defined on the command line. This symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see 
// TESTDLL_API functions as being imported from a DLL, whereas this DLL sees symbols
// defined with this macro as being exported.
#ifdef  TESTDLL_EXPORTS
#define  TESTDLL_API __declspec(dllexport)
#else
#define  TESTDLL_API __declspec(dllimport)
#endif

extern "C"
{
     TESTDLL_API int OurTestFunction(int x, int y);                         
}
 
It is inside this extern "C" block where you define your interface, functions to access your class member functions.Note the TESTDLL before the function prototype. All of your functions must be proceeded by that.
 
Add these to your testdll.cpp file: 
 
#include "testdll.h"
#include "ourClass.h"

#define DLL_EXPORT

extern "C"
{
    OurClass ourObject;
    TESTDLL_API int OurTestFunction(int x, int y)
    {
        return ourObject.Add(x,y);
    }
}
 
You compile this and get a C based dll which can be used in a C# application.
 There are couple of things to notice though, The more important ones are: 
 
 
 
You need to understand that the code you use as a proxy- i mean function definition inside your testdll.h, must only use C compatible types, it is C after all not C++.
 
 
is that you would want to be able to allocate new objects of your class instead of just using one global object to access all methods.
 
 
For this, if you need to pass your class objects between member functions, you need to first convert it to a void* which C can understand and then pass it and use it to access your member functions of whatever. 
 
For example I would have something like this inside my testdll.h in order to make user capable of managing the objects indirectly:
 
#ifdef TESTDLL_EXPORTS
#define TESTDLL_API __declspec(dllexport)
#else
#define TESTDLL_API __declspec(dllimport)
#endif

extern "C"
{
    TESTDLL_API int OurTestFunction(int x, int y);                      

    TESTDLL_API void*  CreateHandle();
    TESTDLL_API void*  GetCurrentHandle();
    TESTDLL_API void   DisposeCurrentHandle();
    TESTDLL_API void   SetCurrentHandle(void* handle);
    TESTDLL_API void*  GetHandle();
    TESTDLL_API void   DisposeHandle(void*);
    TESTDLL_API void   DisposeArrayBuffers(void);
}
 
And inside my testdll.cpp I would define them as : 
 
#include "testdll.h"
#include "ourClass.h"

#define DLL_EXPORT

extern "C"
{
    OurClass *ourObject;

    TESTDLL_API int OurTestFunction(int x, int y)
    {
        //return ourObject.Add(x,y); -- not any more !!
        ourObject = reinterpret_cast<OurClass *>(GetHandle());
    }

    //Handle operations
    TESTDLL_API void* CreateHandle()
    {
        if (ourObject == nullptr)
        {
            ourObject = new OurClass ;
        }
        else
        {
            delete ourObject ;
            ourObject = new OurClass ;
        }
        return reinterpret_cast<void*>(ourObject);
    }

    TESTDLL_API void* GetCurrentHandle()
    {
        return reinterpret_cast<void*>(ourObject );
    }

    TESTDLL_API void  DisposeCurrentHandle()
    {
        delete ourObject ;
        ourObject = nullptr;
    }

    TESTDLL_API void  SetCurrentHandle(void* handle)
    {
        if (handle != nullptr)
        {
            ourObject = reinterpret_cast<OurClass *>(handle);
        }
        else
        {
            ourObject = new OurClass ;
        }

    }

    //factory utility function
    TESTDLL_API void* GetHandle()
    {
        void* handle = GetCurrentHandle();
        if (handle != nullptr)
        {
            return handle;
        }
        else
        {
            ourObject = new OurClass ;
            handle = reinterpret_cast <void*>(ourObject );
        }
        return handle;
    }

    CDLL_API void  DisposeHandle(void* handle)
    {
        OurClass * tmp = reinterpret_cast<OurClass *>(handle);
        delete tmp;
    }

    TESTDLL_API void DisposeArrayBuffers(void)
    {
        ourObject = reinterpret_cast<OurClass *>(GetHandle());
        return ourObject ->DisposeBuffers();//This is a member function defined solely for this purpose of being used inside this wrapper to delete any allocated resources by our class object.
    }
}
 
And when we compile this Dll, we can easily work with it inside our C# application. Before being able to use our functions defined in this dll we need to use appropriate [ImportDll()]. So for our TestDll we would write:
 
[DllImport(@"TestDll.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int OurTestFunction(int firstNumber,int secondNumber); 
 
And finally use it like:
 
private void btnReadBigram_Click(object sender, EventArgs e)
{
    int x = OurTestFunction(10,50);
    MessageBox.Show(x.ToString());
}
 
This is all I did to make my C++ class member functions accessible inside a C# application without any hassle.
 
Note:
 When compiling your C# application make sure you have chosen the x86 Platform for compiling your project not AnyCpu.You can change your platform through properties. 
 
Note 2:
 For knowing how to create a C++/CLI wrapper for your native C++ class read this: C++/CLI wrapper for your native C++ class.