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);
}

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;
}

        // 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;