We have had to determine if C# was comparable to C++ in performance and I wrote some test programs for that (using Visual Studio 2005 for both languages). It turned out that without garbage collection and only considering the language (not the framework) C# has basically the same performance as C++. Memory allocation is way faster in C# than in C++ and C# has a slight edge in determinism when data sizes are increased beyond cache line boundaries. However, all of this had eventually to be paid for and there is a huge cost in the form of non-deterministic performance hits for C# due to garbage collection.

我在c++ vs c#中插入代码的一个领域是创建到SQL Server的数据库连接并返回结果集。我比较了c++ (ODBC上的薄层)和c# (ADO。NET SqlClient)，并发现c++比c#代码快50%左右。ADO。NET被认为是处理数据库的低级接口。你可能会发现更大的差异是内存消耗而不是原始速度。

使c++代码更快的另一件事是，你可以在粒度级别上调优编译器选项，以一种在c#中无法做到的方式进行优化。

. net语言可以像c++代码一样快，甚至更快，但是c++代码将拥有更恒定的吞吐量，因为. net运行时必须暂停进行GC，即使它非常巧妙地处理了暂停。

因此，如果您有一些代码必须持续快速运行而不需要任何暂停，. net在某些时候会引入延迟，即使您非常小心地使用运行时GC。

I suppose there are applications written in C# running fast, as well as there are more C++ written apps running fast (well C++ just older... and take UNIX too...) - the question indeed is - what is that thing, users and developers are complaining about ... Well, IMHO, in case of C# we have very comfort UI, very nice hierarchy of libraries, and whole interface system of CLI. In case of C++ we have templates, ATL, COM, MFC and whole shebang of alreadyc written and running code like OpenGL, DirectX and so on... Developers complains of indeterminably risen GC calls in case of C# (means program runs fast, and in one second - bang! it's stuck). To write code in C# very simple and fast (not to forget that also increase chance of errors. In case of C++, developers complains of memory leaks, - means crushes, calls between DLLs, as well as of "DLL hell" - problem with support and replacement libraries by newer ones... I think more skill you'll have in the programming language, the more quality (and speed) will characterize your software.

In theory, for long running server-type application, a JIT-compiled language can become much faster than a natively compiled counterpart. Since the JIT compiled language is generally first compiled to a fairly low-level intermediate language, you can do a lot of the high-level optimizations right at compile time anyway. The big advantage comes in that the JIT can continue to recompile sections of code on the fly as it gets more and more data on how the application is being used. It can arrange the most common code-paths to allow branch prediction to succeed as often as possible. It can re-arrange separate code blocks that are often called together to keep them both in the cache. It can spend more effort optimizing inner loops.

我怀疑。net或任何jre都能做到这一点，但早在我上大学的时候就有人在研究这一点，所以认为这类东西很快就会在现实世界中找到自己的方式也不是不合理的。

我已经在c++和c#等效中测试了vector - List和简单的2d数组。

我使用Visual c# / c++ 2010 Express版本。这两个项目都是简单的控制台应用程序，我在标准(没有自定义设置)发布和调试模式下对它们进行了测试。 c#列表在我的电脑上运行得更快，c#中的数组初始化也更快，数学运算更慢。

我使用英特尔Core2Duo P8600@2.4GHz, c# - . net 4.0。

我知道向量实现不同于c#列表，但我只是想测试我将用于存储我的对象的集合(并能够使用索引访问器)。

当然，您需要清除内存(比如每次使用new时)，但我希望保持代码简单。

c++矢量测试:

static void TestVector()
{
    clock_t start,finish;
    start=clock();
    vector<vector<double>> myList=vector<vector<double>>();
    int i=0;
    for( i=0; i<500; i++)
    {
        myList.push_back(vector<double>());
        for(int j=0;j<50000;j++)
            myList[i].push_back(j+i);
    }
    finish=clock();
    cout<<(finish-start)<<endl;
    cout<<(double(finish - start)/CLOCKS_PER_SEC);
}

c#列表测试:

private static void TestVector()
{

    DateTime t1 = System.DateTime.Now;
    List<List<double>> myList = new List<List<double>>();
    int i = 0;
    for (i = 0; i < 500; i++)
    {
        myList.Add(new List<double>());
        for (int j = 0; j < 50000; j++)
            myList[i].Add(j *i);
    }
    DateTime t2 = System.DateTime.Now;
    Console.WriteLine(t2 - t1);
}

c++ -数组：

static void TestArray()
{
    cout << "Normal array test:" << endl;
    const int rows = 5000;
    const int columns = 9000;
    clock_t start, finish;

    start = clock();
    double** arr = new double*[rows];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    finish = clock();

    cout << (finish - start) << endl;

    start = clock();
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i * j;
    finish = clock();

    cout << (finish - start) << endl;
}

c# -数组:

private static void TestArray()
{
    const int rows = 5000;
    const int columns = 9000;
    DateTime t1 = System.DateTime.Now;
    double[][] arr = new double[rows][];
    for (int i = 0; i < rows; i++)
        arr[i] = new double[columns];
    DateTime t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

    t1 = System.DateTime.Now;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < columns; j++)
            arr[i][j] = i * j;
    t2 = System.DateTime.Now;

    Console.WriteLine(t2 - t1);

}

时间:(发布/调试)

C++

600 / 606 ms array init 200 / 270毫秒阵列填充， 1秒/13秒矢量初始化和填充。

(是的，13秒，我总是在调试模式下遇到列表/向量的问题。)

C#:

20 / 20 ms数组初始化 403 / 440毫秒阵列填充， 710 / 742 ms列表初始化和填充。