Unmanaged-вариант: 751
Managed-вариант:   811

#include "stdafx.h"
#include "atlstr.h"
#include <time.h>
#include <stdlib.h>

int _tmain()
{
    double elapsedTime;
    clock_t stopTime;
    clock_t startTime = clock();

    int i;
    CStringW buf1;
    CStringW buf2;

    for (i = 0; i < 10000000; i++ )
    {
        if((i & 1) == 0)
            buf1.Append(L"hello", 5);
        else
            buf2.Append(L"hello!", 6);
    }
    stopTime = clock();
    elapsedTime = (stopTime - startTime) /  (CLOCKS_PER_SEC / (double) 1000.0);
    printf("String Concat. Elapsed time: %1.0f\n", elapsedTime);//, strbuf);

    return 0;
}

Routine Name                                         Time           Time with Children  Shared Time          Hit Count

DatasetStorageEngine::Load                           0.00665421125  18.7413820525       0.0355054458169608      36
ProductLibraryManager::LoadProdLibWorker             0              17.78354583875      0                        1
ProductLibDataSetPersist::DsLoad                     0.00084167625  16.797909685        0.00501060111515893      1
DataSetLoader::Load                                  0.00016143625  16.3967278325       0.000984563820593623     1
TabInfo::Load                                        1.44434606875  16.38647400125      8.81425783630952        77
<Garbage Collector>                                 11.63491199375  11.63491199375    100                      308
<JIT Compiler>                                      11.48328216     11.485244375       99.9829153395789      13864
ZipStorageEngine::Load                               3.43084997875   8.962737435       38.2790414606182      5
PersistManager::Load                                 6.76625E-6      8.9577977525       7.55347484610448E-5  4
PropInfo::Load                                       1.00993600125   8.8353232525      11.430662720396       59387
DocumentManager::GetNetworkObject                    3.855E-6        8.7928121725       4.38426287787282E-5  2
ValidatableEventSource::SetValidatableProperty       0.32878773      7.88257587         4.1710696531488      43581
EventSourceObject::GetPropertyDescriptionInternal    0.10383751375   7.5208579025       1.3806604924085      87539
EventSourceObject::BuildPropertyDescriptionMap       6.34245147625   7.469254285       84.9141190572012      15229
EventSourceObject::GetPropertyDescriptionMapInternal 0.0282405075    7.4341745525       0.379874151468547    88041
IndexableNamedObject::set_Name                       0.1251015475    7.386138655        1.69373407870313     12125
EventSourceObject::GetPropertyDescription            0.0155469175    6.36041299         0.244432516008681    62998
AppController::RunWizard                             0.00045296125   6.18196760125      0.00732713723553664      1
ScriptManager::ExecuteFile                           0.00122776      6.17574920875      0.0198803409675456       1
ScriptManager::ExecuteString                         3.77125E-5      6.16964905875      0.00061125843043722      1
SAXEngine::VPI.NC.Scripting.IScriptEngine.Execute    1.365692915     6.1415065075      22.2370995346535          1
DocumentManager::SaveDocument                        6.206E-5        5.70805727375      0.00108723506131235      1
DocumentManager::Save                                0.00057522625   5.69897192         0.0100935091113767       1
ZipStorageEngine::Store                              2.32114413375   4.8816617725      47.548237504404           6
PersistManager::Store                                3.919625E-5     4.881230335        0.00080299939379935      4
DocumentManager::OpenDocument                        0.05199691375   3.13453559625      1.65883947249495         1
DocumentManager::OpenDoc                             0.00052821      2.9891938675       0.017670650463423        1
BaseCollection::.ctor                                0.000103765     2.0311321375       0.00510872720116172   7892
ReadOnlyBaseCollection::.ctor                        0.011396135     2.027203835        0.56216029208528      7892

template <class T>
struct arg_info {
     enum { marshal_type = value };
};

template <class T>
struct arg_info<T&> {
     enum { marshal_type = ref };
};

template <class T>
struct arg_info<T*> {
     enum { marshal_type = ptr };
};
// намек понятен?

for (int i=0; i<N; i++) 
{
  if((i & 1) == 0)
     StringBuffer1.Append("hello");
  else
     StringBuffer2.Append("hello!");
}

using System;
using System.Collections;
using System.Text;
using System.IO;

namespace Benchmark_CSharp
{
    class BenchmarkCSharp
    {
        static DateTime startTime;
        static DateTime stopTime;
        static TimeSpan elapsedTime;
        
        [STAThread]
        static void Main(string[] args)
        {
            Console.WriteLine("Start C# benchmark");
            long scTime = (long)sc2( 10000000 );
            Console.WriteLine("End C# benchmark");
        }


         public static long sc2(int N)
        {
            long elapsedMilliseconds;
            startTime = DateTime.Now;

            if(N < 1) N = 1;

            StringBuilder sb1 = new StringBuilder();
                        StringBuilder sb2 = new StringBuilder();

            for (int i=0; i<N; i++) 
            {
                            if((i & 1) == 0)
                      sb1.Append("hello");
                else
                              sb2.Append("hello!");
            }

            stopTime = DateTime.Now;
            elapsedTime = stopTime.Subtract(startTime);
            elapsedMilliseconds = (int)elapsedTime.TotalMilliseconds;            
            Console.WriteLine("String Concat. (fixed) elapsed time: " + elapsedMilliseconds + " ms");

            return elapsedMilliseconds;
        }        
    }
}

#include <time.h>
#include <stdlib.h>

namespace aux {

// wchar_t_buffer class - in-memory dynamic buffer.
  class wchar_t_buffer 
  {
    wchar_t*        _body;
    size_t          _allocated;
    size_t          _size;

    wchar_t *reserve(size_t size)
    {
      if((_size + size) > _allocated) 
      {
        // not bad, huh?
        _allocated *= 2;
        wchar_t *newbody = new wchar_t[_allocated];
        memcpy(newbody,_body,_size * sizeof(wchar_t));
        delete[] _body;
        _body = newbody;
      }
      return _body + _size;
    }

  public:

    wchar_t_buffer():_size(0)     { _body = new wchar_t[_allocated = 256]; }
    ~wchar_t_buffer()             { delete[] _body;  }

    const wchar_t * data()  {  
             if(_size == _allocated) reserve(1); 
             _body[_size] = 0; return _body; }

    size_t length() const         { return _size; }

    void push(wchar_t c)    { *reserve(1) = c; ++_size; }
    void push(const wchar_t *pc, size_t sz) 
    { 
      memcpy(reserve(sz),pc,sz*sizeof(wchar_t)); 
      _size += sz; 
    }
  };
}

int  main() 
{
    double elapsedTime;
    clock_t stopTime;
    clock_t startTime = clock();

    int i;
  aux::wchar_t_buffer buf1;
  aux::wchar_t_buffer buf2;
    
    for (i=0; i < 10000000; i++ )
    {
    if((i & 1) == 0)
      buf1.push(L"hello",5);
    else
      buf2.push(L"hello!",6);
    }
    stopTime = clock();
    elapsedTime = (stopTime - startTime) /  (CLOCKS_PER_SEC / (double) 1000.0);
    printf("String Concat. Elapsed time: %1.0f\n", elapsedTime);//, strbuf);

  return 0;
}

            StringBuilder sb1 = new StringBuilder(50000000);
            StringBuilder sb2 = new StringBuilder(50000000);

DM>            StringBuilder sb1 = new StringBuilder(50000000);
DM>            StringBuilder sb2 = new StringBuilder(50000000);
DM>

StringBuilder sb1 = new StringBuilder(50000000);
StringBuilder sb2 = new StringBuilder(60000000);

int i;
aux::wchar_t_buffer buf1(50000000);
aux::wchar_t_buffer buf2(60000000);
    
for (i=0; i < 10000000; i++ )
{
  if((i & 1) == 0)
    buf1.push(L"hello",5);
  else
    buf2.push(L"hello!",6);
}

        // Appends a copy of this string at the end of this string builder.
        /// <include file='doc\StringBuilder.uex' path='docs/doc[@for="StringBuilder.Append2"]/*' />
        public StringBuilder Append(String value) {
            //If the value being added is null, eat the null
            //and return.
            if (value==null) {
                return this;
            }

            int tid;
            // hand inlining of GetThreadSafeString
            String currentString = m_StringValue;
            tid = InternalGetCurrentThread();
            if (m_currentThread != tid) 
                currentString = String.GetStringForStringBuilder(currentString, currentString.Capacity);

            int currentLength = currentString.Length;
          
            int requiredLength = currentLength + value.Length;
            
            if (NeedsAllocation(currentString,requiredLength)) {
                String newString = GetNewString(currentString,requiredLength);
                newString.AppendInPlace(value,currentLength);
                ReplaceString(tid,newString);
            } else {
                currentString.AppendInPlace(value,currentLength);
                ReplaceString(tid,currentString);
            }

            return this;
        }

        private String GetNewString(String currentString, int requiredLength) {
            int newCapacity;

            requiredLength++; //Include the terminating null.

            if (requiredLength >  m_MaxCapacity) {
                throw new ArgumentOutOfRangeException(Environment.GetResourceString("ArgumentOutOfRange_NegativeCapacity"),
                                                      "requiredLength");
            }
          
            newCapacity = ( currentString.Capacity)*2; // To force a predicatable growth of 160,320 etc. for testing purposes

            if (newCapacity<requiredLength) {
                newCapacity = requiredLength;
            }

            if (newCapacity> m_MaxCapacity) {
                newCapacity =  m_MaxCapacity;
            }

            if (newCapacity<=0) {
                throw new ArgumentOutOfRangeException(Environment.GetResourceString("ArgumentOutOfRange_NegativeCapacity"));
            }

            return String.GetStringForStringBuilder( currentString, newCapacity);
        }

std::string s3 = s2 + s1;