for(int i = 0; i < 10000000; i++)
{
    string s = "123456789012345678901234567890";
    s += "1";
}

for(int i = 0; i < 100000000; i++)
{
    std::string s = "123456789012345678901234567890";
    s += "1";        
}

> D:\Users\Pavel\test\C++\sort\Release>sort.exe AdbeRdr60_enu_full.exe
> Delegate...
> Sort duration: 1109
> Index: 3059506
> CompareTo...
> Sort duration: 547
> Index: 3059506
>

> D:\Users\Pavel\test\C#\sort\sort\bin\Release>sort.exe
> AdbeRdr60_enu_full.exe 
> Delegate...
> Sort duration: 3265.625
> Index: 3059506
> CompareTo...
> Sort duration: 1093.75
> Index: 3059506
>

// мой код
Compare...                                  
Sort duration: 1331.8088                      
Index: 997046                                 
               
// твой код                               
Delegate...                                   
Sort duration: 3134.2568                      
Index: 997046                                 
CompareTo...                                  
Sort duration: 2783.7808                      
Index: 997046

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;


class ComparableTest<T, Comp> : Test<T>
    where Comp
        : IComparer< T >
        , new()
{
     public ComparableTest(CreateElement create_element)
         : base( create_element )
     {
         comparer_ = new Comp();
     }

     protected override void Sort(T[] array)
     {
         Sort(array, 0, array.Length - 1);
     }

     private void Sort(T[] array, int left, int right)
     {
         int i = left;
         int j = right;
         T center = array[(left + right) / 2];

         while (i <= j)
         {
             while (comparer_.Compare( array[i], center ) < 0)
                 i++;

             while (comparer_.Compare( array[j], center ) > 0)
                 j--;

             if (i <= j)
             {
                 T x = array[i];
                 array[i] = array[j];
                 array[j] = x;
                 i++;
                 j--;
             }
         }

         if (left < j)
             Sort(array, left, j);

         if (right > i)
             Sort(array, i, right);
     }

     protected override int Search(T[] array, T value)
     {
         return BinarySearch(array, 0, array.Length, value);
     }

     private int BinarySearch(T[] array, int lo, int hi, T value)
     {
         while (lo <= hi)
         {
             int i = (lo + hi) / 2;
             int cmpResult = comparer_.Compare( array[i], value );

             if (cmpResult == 0)
                 return i;
             else if (cmpResult < 0)
                 lo = i + 1;
             else
                 hi = i - 1;
         }

         return ~lo;
     }

     // private
     Comp comparer_;
};


abstract class Test<T>
{
     public delegate T CreateElement(int value);

     protected Test(CreateElement create_element)
     {
         create_element_ = create_element;
     }

     public void Run(string fileName)
     {
         T[] array = CreateArray(fileName);
         T value = array[0];

         Console.WriteLine("Sort duration: " + Measure( delegate() { Sort(array); } ) );

         int index = Search(array, value);
         Console.WriteLine("Index: " + index);
     }

     protected delegate void Action();

     private double Measure(Action action)
     {
         DateTime start = DateTime.Now;
         action();
         DateTime end = DateTime.Now;
         return (end - start).TotalMilliseconds;
     }

     protected abstract void Sort(T[] array);

     protected abstract int Search(T[] array, T element);

     private T[] CreateArray(string fileName)
     {
         ArrayList array = new ArrayList();

         BinaryReader reader =
             new BinaryReader(File.Open(fileName, FileMode.Open));
         try
         {
             while (true)
             {
                 int value = reader.ReadInt32();
                 array.Add(create_element_(value));
             }
         }
         catch (EndOfStreamException)
         {
             // ignore
         }
         finally
         {
             reader.Close();
         }

         return (T[])array.ToArray(typeof(T));
     }

     private CreateElement create_element_;
};
 

struct IntComparer : IComparer< int >
{
    public int Compare( int a, int b )
    {
        return a - b;  // watch for integer overflow!
    }

    public bool Equals( int a, int b )
    {
        return a == b;
    }

    public int GetHashCode( int obj )
    {
        return obj;
    }
}


class Program
{
     static void Main(string[] args)
     {
         Console.WriteLine("Compare...");
         TestComparable(args[0]);
     }

     private static void TestComparable(string fileName)
     {
         Test<int>.CreateElement create_element_delegate =
             delegate(int value) { return value; };

         ComparableTest<int, IntComparer> test =
             new ComparableTest<int, IntComparer>(create_element_delegate);

         test.Run(fileName);
     }
}

ПК>Не совсем понял... В сообщении по ссылке четыре варианта, и все относятся к записи

while (true)
             {
                 int value = reader.ReadInt32();
                 array.Add(create_element_(value));
             }

ПК>    public static IntWrapper operator -(IntWrapper l, IntWrapper r)
ПК>    {
ПК>        return new IntWrapper(l.value_ - r.value_);
ПК>    }

ПК>    public int CompareTo(IntWrapper r)
ПК>    {
ПК>        return this - r;
ПК>    }

ПК>         DelegateTest<IntWrapper>.CompareElement compare_element_delegate =
ПК>             delegate(IntWrapper x, IntWrapper y) { return x - y; };

public int CompareTo(IntWrapper r)
{
        return this - r;
}

public int CompareTo(IntWrapper r)
{
    return value_ - r.value_;
}

return _value > r._value ? 1 : _value == r._value ? 0 : -1;

> Прогаммисты хреновые...

> return _value > r._value ? 1 : _value == r._value ? 0 : -1;
>

D:\Users\Pavel\test\C#\sort\sort\bin\Release>sort.exe AdbeRdr60_enu_full.exe
Delegate...       Sort: 2218     (index: 2096905)
                         2296     (index: 2096905)
                         2296     (index: 2096905)
                         2437     (index: 2096905)
                         2296     (index: 2096905)
Comparer...       Sort: 1390     (index: 2096905)
                         1390     (index: 2096905)
                         1375     (index: 2096905)
                         1375     (index: 2096905)
                         1375     (index: 2096905)
Delegate (int)... Sort: 1968     (index: 2096905)
                         1968     (index: 2096905)
                         1953     (index: 2096905)
                         1968     (index: 2096905)
                         1984     (index: 2096905)
Comparer (int)... Sort: 1203     (index: 2096905)
                         1187     (index: 2096905)
                         1203     (index: 2096905)
                         1203     (index: 2096905)
                         1203     (index: 2096905)

D:\Users\Pavel\test\C++\sort\Release>sort.exe AdbeRdr60_enu_full.exe
Delegate...       Sort: 1157    (index: 2096905)
                         1188    (index: 2096905)
                         1141    (index: 2096905)
                         1125    (index: 2096905)
                         1125    (index: 2096905)
Comparer...       Sort: 657     (index: 2096905)
                         656     (index: 2096905)
                         656     (index: 2096905)
                         656     (index: 2096905)
                         657     (index: 2096905)
Delegate (int)... Sort: 1234    (index: 2096905)
                         1234    (index: 2096905)
                         1219    (index: 2096905)
                         1203    (index: 2096905)
                         1219    (index: 2096905)
Comparer (int)... Sort: 671     (index: 2096905)
                         657     (index: 2096905)
                         672     (index: 2096905)
                         656     (index: 2096905)
                         656     (index: 2096905)

using System;

struct IntWrapper : IComparable<IntWrapper>
{
     public IntWrapper(int value)
     {
         value_ = value;
     }

     public static bool operator <(IntWrapper l, IntWrapper r)
     {
         return l.value_ < r.value_;
     }

     public static bool operator >(IntWrapper l, IntWrapper r)
     {
         return l.value_ > r.value_;
     }

     public static bool operator ==(IntWrapper l, IntWrapper r)
     {
         return l.value_ == r.value_;
     }

     public int CompareTo(IntWrapper r)
     {
         return this > r ? 1 : this == r ? 0 : -1;
     }

     // Following are here just to keep the compiler silent.
     public static bool operator !=(IntWrapper l, IntWrapper r) { return l.value_ != r.value_; }
     public bool Equals(IntWrapper r) { return this == r; }
     public override bool Equals(Object r) { return this == (IntWrapper)r; }
     public override int GetHashCode() { return value_; }

     // private
     int value_;
};

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

interface IFactory<T>
{
     T Create(int value);
};

class Test<T, Comparer, Factory>
     where Comparer : IComparer<T>, new()
     where Factory : IFactory<T>, new()
{
     public Test(string name)
     {
         name_ = name;
         comparer_ = new Comparer();
     }

     public void Run(string fileName)
     {
         string prefix = name_ + "Sort: ";

         for (int i = 0; i < 5; ++i)
         {
             T[] array = CreateArray(fileName);
             T value = array[0];

             Console.Write(prefix + (int)Measure(delegate() { Sort(array); }));

             int index = Search(array, value);
             Console.WriteLine("\t (index: " + index + ")");

             if (i == 0)
                 prefix = new string(' ', prefix.Length);
         }
     }

     // private

     void Sort(T[] array)
     {
         Sort(array, 0, array.Length - 1);
     }

     void Sort(T[] array, int left, int right)
     {
         int i = left;
         int j = right;
         T center = array[(left + right) / 2];

         while (i <= j)
         {
             while (comparer_.Compare(array[i], center) < 0)
                 i++;

             while (comparer_.Compare(array[j], center) > 0)
                 j--;

             if (i <= j)
             {
                 T x = array[i];
                 array[i] = array[j];
                 array[j] = x;
                 i++;
                 j--;
             }
         }

         if (left < j)
             Sort(array, left, j);

         if (right > i)
             Sort(array, i, right);
     }

     int Search(T[] array, T value)
     {
         return BinarySearch(array, 0, array.Length, value);
     }

     int BinarySearch(T[] array, int lo, int hi, T value)
     {
         while (lo <= hi)
         {
             int i = (lo + hi) / 2;
             int cmpResult = comparer_.Compare(array[i], value);

             if (cmpResult == 0)
                 return i;
             else if (cmpResult < 0)
                 lo = i + 1;
             else
                 hi = i - 1;
         }

         return ~lo;
     }

     T[] CreateArray(string fileName)
     {
         Factory factory = new Factory();

         using (BinaryReader reader =
             new BinaryReader(File.Open(fileName, FileMode.Open)))
         {
             long len = reader.BaseStream.Length / 4;
             T[] array = new T[len];

             for (int i = 0; i < len; i++)
                 array[i] = factory.Create(reader.ReadInt32());

             return array;
         }
     }

     delegate void Action();
     double Measure(Action action)
     {
         DateTime start = DateTime.Now;
         action();
         DateTime end = DateTime.Now;
         return (end - start).TotalMilliseconds;
     }

     string name_;
     Comparer comparer_;
};

using System;
using System.Collections.Generic;
using System.Text;

struct DirectComparer<T> : IComparer<T>
     where T : IComparable<T>
{
     public int Compare(T l, T r) { return l.CompareTo(r); }
     public bool Equals(T l, T r) { return l.CompareTo(r) == 0; }
     public int GetHashCode(T obj){ return obj.GetHashCode(); }
}

struct DelegateComparer<T> : IComparer<T>
     where T : IComparable<T>
{
     public int Compare(T l, T r) { return compare_element_(l, r); }
     public bool Equals(T l, T r) { return compare_element_(l, r) == 0; }
     public int GetHashCode(T obj){ return obj.GetHashCode(); }

     // private
     delegate int CompareElement(T x, T y);
     static CompareElement compare_element_ = delegate(T x, T y) { return x.CompareTo(y); };
}

struct IntWrapperFactory : IFactory<IntWrapper>
{
     public IntWrapper Create(int value) { return new IntWrapper(value); }
}

struct IntFactory : IFactory<int>
{
     public int Create(int value) { return value; }
}

class Program
{
     static void Main(string[] args)
     {
         RunTest<IntWrapper, DelegateComparer<IntWrapper>, IntWrapperFactory>(
             args[0], "Delegate...       ");

         // RunTest<IntWrapper, ???, IntWrapperFactory>(args[0], "CompareTo...");

         RunTest<IntWrapper, DirectComparer<IntWrapper>, IntWrapperFactory>(
             args[0], "Comparer...       ");

         RunTest<int, DelegateComparer<int>, IntFactory>(
             args[0], "Delegate (int)... ");

         // RunTest<int, ???, IntFactory>(args[0], "CompareTo (int)...");

         RunTest<int, DirectComparer<int>, IntFactory>(
             args[0], "Comparer (int)... ");
     }

     private static void RunTest<T, Comparer, Factory>(string fname, string test_name)
         where T : IComparable<T>
         where Comparer : IComparer<T>, new()
         where Factory : IFactory<T>, new()
     {
         Test<T, Comparer, Factory> test = new Test<T, Comparer, Factory>(test_name);
         test.Run(fname);
     }
}

#pragma once

struct IntWrapper
{
public:
     IntWrapper(int value)
     : value_ (value)
     {
     }

     friend bool operator <(IntWrapper l, IntWrapper r)
     {
         return l.value_ < r.value_;
     }

     friend bool operator >(IntWrapper l, IntWrapper r)
     {
         return l.value_ > r.value_;
     }

     friend bool operator ==(IntWrapper l, IntWrapper r)
     {
         return l.value_ == r.value_;
     }

private:
     int value_;
};

template< class T >
int CompareTo( T l, T r )
{
     return l > r ? 1 : l == r ? 0 : -1;
}

#pragma once

#include <vector>

template< class T, template<class> class Comparer >
void Sort(std::vector<T>& v, std::size_t left, std::size_t right)
{
     std::size_t i = left;
     std::size_t j = right;
     T center = v[(left + right) / 2];

     while (i <= j)
     {
         while (Comparer<T>::compare(v[i], center) < 0)
             i++;

         while (Comparer<T>::compare(v[j], center) > 0)
             j--;

         if (i <= j)
         {
             T x = v[i];
             v[i] = v[j];
             v[j] = x;
             i++;
             j--;
         }
     }

     if (left < j)
         Sort<T, Comparer>(v, left, j);

     if (right > i)
         Sort<T, Comparer>(v, i, right);
}

template< class T, template<class> class Comparer >
void Sort(std::vector<T>& v)
{
     if (!v.empty())
         Sort<T, Comparer>(v, 0, v.size() - 1);
}

#pragma once

#include <vector>

template< class T, template<class> class Comparer >
std::size_t
BinarySearch(std::vector<T> const& v, std::size_t lo, std::size_t hi, T value)
{
     while (lo <= hi)
     {
         std::size_t i = (lo + hi) / 2;
         int cmpResult = Comparer<T>::compare(v[i], value);

         if (cmpResult == 0)
             return i;
         else if (cmpResult < 0)
             lo = i + 1;
         else
             hi = i - 1;
     }

     return ~lo;
}

template< class T, template<class> class Comparer >
std::size_t
Search(std::vector<T> const& v, T value)
{
     return BinarySearch<T, Comparer>(v, 0, v.size(), value);
}

#pragma once

#include <string>
#include <vector>
#include <fstream>

#include "Timer.h"
#include "Sort.h"
#include "Search.h"

template< class T >
void CreateArray(std::vector<T>& v, std::string const& fname)
{
     v.clear();

     std::filebuf reader;
     if (reader.open(fname.c_str(), std::ios::in | std::ios::binary))
     {
         int value;
         while (reader.sgetn(reinterpret_cast<char*>(&value), 4) == 4)
         v.push_back(T(value));
     }
}

template< class T, template<class> class Comparer >
void Test(std::string const& fname, std::string const& test_name)
{
     std::string prefix = test_name + "Sort: ";

     for (int i = 0; i < 5; ++i)
     {
         std::vector<T> v;
         CreateArray(v, fname);

         if ( !v.empty() )
         {
             T value = v[0];

             std::cout << prefix;

             Timer timer;
             Sort<T, Comparer>(v);
             std::cout << timer.time();

             std::cout
                 << "\t(index: "
                 << (unsigned)Search<T, Comparer>(v, value)
                 << ')'
                 << std::endl;

             if (i == 0)
                 prefix.assign(prefix.size(), ' ');
         }
     }
}

#pragma once

#include <ctime>

class Timer
{
public:
     Timer() { reset(); }

     void reset() { start_ = std::clock(); }

     std::clock_t time() const { return (std::clock() - start_) / ( CLOCKS_PER_SEC / 1000 ); }

private:
     std::clock_t start_;
};

#include <boost/function/function2.hpp>

#include "Test.h"
#include "IntWrapper.h"

template< class T >
struct DirectComparer
{
     static int compare( T l, T r ) { return CompareTo(l, r); }
};

template< class T >
struct DelegateComparer
{
     static int compare(T l, T r) { return delegate(l, r); }
     static boost::function2<int, T, T> delegate;
};

template< class T >
struct Functor
{
     int operator()(T l, T r) const { return CompareTo(l, r); }
};

template< class T >
boost::function2<int, T, T>
DelegateComparer<T>::delegate = Functor<T>();

int main(int argc, char** argv)
{
     if ( argc <= 1 )
     {
         std::cout << "usage: <program> <filename>" << std::endl;
     }
     else
     {
        Test<IntWrapper, DelegateComparer>(argv[1], "Delegate...       ");
        Test<IntWrapper, DirectComparer>(argv[1],   "Comparer...       ");
        Test<int, DelegateComparer>(argv[1],        "Delegate (int)... ");
        Test<int, DirectComparer>(argv[1],          "Comparer (int)... ");
     }
}

D:\Users\Pavel\test\C++\sort\Release>sort.exe AdbeRdr60_enu_full.exe
Delegate...
Sort duration: 1109
Index: 3059506
CompareTo...
Sort duration: 547
Index: 3059506

D:\Users\Pavel\test\C#\sort\sort\bin\Release>sort.exe AdbeRdr60_enu_full.exe
Delegate...
Sort duration: 3265.625
Index: 3059506
CompareTo...
Sort duration: 1093.75
Index: 3059506

struct IntWrapper : IComparable<IntWrapper>
{
    public IntWrapper(int value)
    {
        value_ = value;
    }

    public static implicit operator int(IntWrapper w)
    {
        return w.value_;
    }

    public static IntWrapper operator -(IntWrapper l, IntWrapper r)
    {
        return new IntWrapper(l.value_ - r.value_);
    }

    public int CompareTo(IntWrapper r)
    {
        return this - r;
    }

    public bool Equals(IntWrapper r)
    {
        return CompareTo(r) == 0;
    }

    private int value_;
};

class ComparableTest<T> : Test<T> where T : IComparable<T>
{
     public ComparableTest(CreateElement create_element)
     : base( create_element )
     {
     }

     protected override void Sort(T[] array)
     {
         Sort(array, 0, array.Length - 1);
     }

     private static void Sort(T[] array, int left, int right)
     {
         int i = left;
         int j = right;
         T center = array[(left + right) / 2];

         while (i <= j)
         {
             while (array[i].CompareTo(center) < 0)
                 i++;

             while (array[j].CompareTo(center) > 0)
                 j--;

             if (i <= j)
             {
                 T x = array[i];
                 array[i] = array[j];
                 array[j] = x;
                 i++;
                 j--;
             }
         }

         if (left < j)
             Sort(array, left, j);

         if (right > i)
             Sort(array, i, right);
     }

     protected override int Search(T[] array, T value)
     {
         return BinarySearch(array, 0, array.Length, value);
     }

     private static int BinarySearch(T[] array, int lo, int hi, T value)
     {
         while (lo <= hi)
         {
             int i = (lo + hi) / 2;
             int cmpResult = array[i].CompareTo(value);

             if (cmpResult == 0)
                 return i;
             else if (cmpResult < 0)
                 lo = i + 1;
             else
                 hi = i - 1;
         }

         return ~lo;
     }
};

class DelegateTest<T> : Test<T>
{
     public delegate int CompareElement(T x, T y);

     public DelegateTest(CreateElement create_element, CompareElement compare_element)
     : base( create_element )
     {
         compare_element_ = compare_element;
     }

     protected override void Sort(T[] array)
     {
         Sort(array, 0, array.Length - 1, compare_element_);
     }

     private static void Sort(T[] array, int left, int right, CompareElement compare)
     {
         int i = left;
         int j = right;
         T center = array[(left + right) / 2];

         while (i <= j)
         {
             while (compare(array[i], center) < 0)
                 i++;

             while (compare(array[j], center) > 0)
                 j--;

             if (i <= j)
             {
                 T x = array[i];
                 array[i] = array[j];
                 array[j] = x;
                 i++;
                 j--;
             }
         }

         if (left < j)
             Sort(array, left, j, compare);

         if (right > i)
             Sort(array, i, right, compare);
     }

     protected override int Search(T[] array, T value)
     {
         return BinarySearch(array, 0, array.Length, value, compare_element_);
     }

     private static int BinarySearch(T[] array, int lo, int hi, T value, CompareElement compare)
     {
         while (lo <= hi)
         {
             int i = (lo + hi) / 2;
             int cmpResult = compare(array[i], value);

             if (cmpResult == 0)
                 return i;
             else if (cmpResult < 0)
                 lo = i + 1;
             else
                 hi = i - 1;
         }

         return ~lo;
     }

     CompareElement compare_element_;
};

abstract class Test<T>
{
     public delegate T CreateElement(int value);

     protected Test(CreateElement create_element)
     {
         create_element_ = create_element;
     }

     public void Run(string fileName)
     {
         T[] array = CreateArray(fileName);
         T value = array[0];

         Console.WriteLine("Sort duration: " + Measure( delegate() { Sort(array); } ) );

         int index = Search(array, value);
         Console.WriteLine("Index: " + index);
     }

     protected delegate void Action();

     private double Measure(Action action)
     {
         DateTime start = DateTime.Now;
         action();
         DateTime end = DateTime.Now;
         return (end - start).TotalMilliseconds;
     }

     protected abstract void Sort(T[] array);

     protected abstract int Search(T[] array, T element);

     private T[] CreateArray(string fileName)
     {
         ArrayList array = new ArrayList();

         BinaryReader reader =
             new BinaryReader(File.Open(fileName, FileMode.Open));
         try
         {
             while (true)
             {
                 int value = reader.ReadInt32();
                 array.Add(create_element_(value));
             }
         }
         catch (EndOfStreamException)
         {
             // ignore
         }
         finally
         {
             reader.Close();
         }

         return (T[])array.ToArray(typeof(T));
     }

     private CreateElement create_element_;
};

class Program
{
     static void Main(string[] args)
     {
         Console.WriteLine("Delegate...");
         TestDelegate(args[0]);

         Console.WriteLine("CompareTo...");
         TestComparable(args[0]);
     }

     private static void TestDelegate(string fileName)
     {
         Test<IntWrapper>.CreateElement create_element_delegate =
             delegate(int value) { return new IntWrapper(value); };

         DelegateTest<IntWrapper>.CompareElement compare_element_delegate =
             delegate(IntWrapper x, IntWrapper y) { return x - y; };

         DelegateTest<IntWrapper> test =
             new DelegateTest<IntWrapper>(
                 create_element_delegate,
                 compare_element_delegate
                 );

         test.Run(fileName);
     }

     private static void TestComparable(string fileName)
     {
         Test<IntWrapper>.CreateElement create_element_delegate =
             delegate(int value) { return new IntWrapper(value); };

         ComparableTest<IntWrapper> test =
             new ComparableTest<IntWrapper>(create_element_delegate);

         test.Run(fileName);
     }
}

D:\Users\Pavel\test\C#\sort\sort\bin\Release>sort.exe AdbeRdr60_enu_full.exe
Delegate...
Sort duration: 2953.125
Index: 3059506
CompareTo...
Sort duration: 1171.875
Index: 3059506
Comparator...
Sort duration: 1250
Index: 3059506
Delegate (int)...
Sort duration: 1093.75
Index: 3059506
CompareTo (int)...
Sort duration: 937.5
Index: 2096905
Comparator (int)...
Sort duration: 578.125
Index: 3059506

struct IntWrapperComparer : IComparer<IntWrapper>
{
     public int Compare(IntWrapper a, IntWrapper b)
     {
         return a - b;  // watch for integer overflow!
     }

     public bool Equals(IntWrapper a, IntWrapper b)
     {
         return a == b;
     }

     public int GetHashCode(IntWrapper obj)
     {
         return obj;
     }
};

class Program
{
     static void Main(string[] args)
     {
         Console.WriteLine("Delegate...");
         TestDelegate(args[0]);

         Console.WriteLine("CompareTo...");
         TestComparable(args[0]);

         Console.WriteLine("Comparator...");
         TestComparator(args[0]);

         Console.WriteLine("Delegate (int)...");
         TestIntDelegate(args[0]);

         Console.WriteLine("CompareTo (int)...");
         TestIntComparable(args[0]);

         Console.WriteLine("Comparator (int)...");
         TestIntComparator(args[0]);
     }

     private static void TestDelegate(string fileName)
     {
         Test<IntWrapper>.CreateElement create_element_delegate =
             delegate(int value) { return new IntWrapper(value); };

         DelegateTest<IntWrapper>.CompareElement compare_element_delegate =
             delegate(IntWrapper x, IntWrapper y) { return x - y; };

         DelegateTest<IntWrapper> test =
             new DelegateTest<IntWrapper>(
                 create_element_delegate,
                 compare_element_delegate
                 );

         test.Run(fileName);
     }

     private static void TestComparable(string fileName)
     {
         Test<IntWrapper>.CreateElement create_element_delegate =
             delegate(int value) { return new IntWrapper(value); };

         ComparableTest<IntWrapper> test =
             new ComparableTest<IntWrapper>(create_element_delegate);

         test.Run(fileName);
     }

     private static void TestComparator(string fileName)
     {
         Test<IntWrapper>.CreateElement create_element_delegate =
             delegate(int value) { return new IntWrapper(value); };

         ComparatorTest<IntWrapper, IntWrapperComparer> test =
             new ComparatorTest<IntWrapper, IntWrapperComparer>(create_element_delegate);

         test.Run(fileName);
     }

     private static void TestIntDelegate(string fileName)
     {
         Test<int>.CreateElement create_element_delegate =
             delegate(int value) { return value; };

         DelegateTest<int>.CompareElement compare_element_delegate =
             delegate(int x, int y) { return x - y; };

         DelegateTest<int> test =
             new DelegateTest<int>(
                 create_element_delegate,
                 compare_element_delegate
                 );

         test.Run(fileName);
     }

     private static void TestIntComparable(string fileName)
     {
         Test<int>.CreateElement create_element_delegate =
             delegate(int value) { return value; };

         ComparableTest<int> test =
             new ComparableTest<int>(create_element_delegate);

         test.Run(fileName);
     }

     private static void TestIntComparator(string fileName)
     {
         Test<int>.CreateElement create_element_delegate =
              delegate(int value) { return value; };

         ComparatorTest<int, IntComparer> test =
             new ComparatorTest<int, IntComparer>(create_element_delegate);

         test.Run(fileName);
     }
}

// для примера данные инициализируются только на стеке
IntWrapper* array = stackalloc IntWrapper[arraySize];
Marshal.Copy(streamAsByteArray/*данные из потока*/, 0, new IntPtr(array), sizeof(int));

>> Вопрос, будет ли запись корректной? В данном случае это, конечно, побоку, но тем не менее? Как-то не нравится "выжимать" такты за счет использования конструкций, корректность работы которых не гарантирована

> Тут есть некоторая двойственность. Думаю, что сама запись корректна, но вот то, что операция sizeof является unsafe это смущает

For all other types < не из перечисленного чуть выше набора >, the result of the sizeof operator is implementation-defined and is classified as a value, not a constant.

<...>

The order in which members are packed into a struct is unspecified.

For alignment purposes, there can be unnamed padding at the beginning of a struct, within a struct, and at the end of the struct. The contents of the bits used as padding are indeterminate.

When applied to an operand that has struct type, the result is the total number of bytes in a variable of that type, including any padding.

    private T[] CreateArray(string fileName)
    {
        using (BinaryReader reader =
            new BinaryReader(File.Open(fileName, FileMode.Open)))
        {
            long len = reader.BaseStream.Length / 4;
            T[] array = new T[len];

            for (int i = 0; i < len; i++)
                array[i] = CreateElement(reader.ReadInt32());

            return array;
        }
    }

private T[] CreateArray(string fileName)
{
    using (BinaryReader reader =
        new BinaryReader(File.Open(fileName, FileMode.Open)))
    {
        long len = reader.BaseStream.Length / 4;
        T[] array = new T[len];

        for (int i = 0; i < len; i++)
            array[i] = CreateElement(reader.ReadInt32());

        return array;
    }
}

// Объявления констант для функции CreateFile
enum DESIRED_ACCESS : ulong
{
    GENERIC_READ = 0x80000000L,
    GENERIC_WRITE = 0x40000000L,
    GENERIC_EXECUTE = 0x20000000L,
    GENERIC_ALL = 0x10000000L,
};
enum SHARE_MODE : ulong
{
    FILE_SHARE_READ = 0x00000001,
    FILE_SHARE_WRITE = 0x00000002,
    FILE_SHARE_DELETE = 0x00000004
};
enum FLAGSANDATTRIBUTES : ulong
{
    FILE_ATTRIBUTE_READONLY = 0x00000001,
    FILE_ATTRIBUTE_HIDDEN = 0x00000002,
    FILE_ATTRIBUTE_SYSTEM = 0x00000004,
    FILE_ATTRIBUTE_DIRECTORY = 0x00000010,
    FILE_ATTRIBUTE_ARCHIVE = 0x00000020,
    FILE_ATTRIBUTE_ENCRYPTED = 0x00000040,
    FILE_ATTRIBUTE_NORMAL = 0x00000080,
    FILE_ATTRIBUTE_TEMPORARY = 0x00000100,
    FILE_ATTRIBUTE_SPARSE_FILE = 0x00000200,
    FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400,
    FILE_ATTRIBUTE_COMPRESSED = 0x00000800,
    FILE_ATTRIBUTE_OFFLINE = 0x00001000,
    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 0x00002000,
};
enum CREATION_DISPOSITION : ulong
{
    CREATE_NEW = 1, CREATE_ALWAYS, OPEN_EXISTING,
    OPEN_ALWAYS, TRUNCATE_EXISTING
};

const int INVALID_HANDLE_VALUE = -1;
const uint INVALID_FILE_SIZE = 0xFFFFFFFF;

// Объявление Win32 API-функции CreateFile
[DllImport("Kernel32.dll")]
private extern static int CreateFile(
    string lpFileName,                            // LPCTSTR - file name
    uint daDesiredAccess,                        // DWORD - access mode
    uint smShareMode,                            // DWORD - share mode
    int lpSecurityAttributes,                    // LPSECURITY_ATTRIBUTES - SD
    CREATION_DISPOSITION dwCreationDisposition,    // DWORD - how to create
    uint dwFlagsAndAttributes,                    // DWORD - file attributes
    int hTemplateFile                            // HANDLE - handle to template file
    );

[DllImport("Kernel32.dll")]
private extern static bool ReadFile(
    int hFile,                        // handle to file
    int[] IntWrapper,                    // data buffer
    uint nNumberOfBytesToRead,        // number of bytes to read
    ref uint lpNumberOfBytesRead,    // number of bytes read
    int lpOverlapped                // overlapped buffer
    );

uint len = (uint)new FileInfo(fileName).Length;
ReadFile(hInputFile, arrayOfIntWrapper, len, ref dwNumberOfBytesRead, 0);

>> Прогаммисты хреновые...

ПК> Кста, данный казус лишний раз демонстрирует, что ни язык, ни среда исполнения не могут в достаточной степени ловить проявления небрежности

ПК>Твое наблюдение о переполнении верно. Интересно только, почему для IntWrapper и int была такая разница в быстродействии при том, что по идее работа делалась та же самая...

ПК>Единственное, просто поправить не получилось: увлекся обобщением и упрощением, пытаясь и в C# уменьшить дублирование кода

ПК> Но и тесты, в общем-то несколько изменились... Также можно заметить, что теперь в C# и int тормозит почти так же, как IntWrapper. Ниже привожу новые результаты и код, по просьбам телезрителей включая C++

C:\MyProjects\Tests\PerfPK\PerfPK\bin\Release>PerfPK.exe
Framework version: 2.0.40607.16

Start DelegateTest`1 test  ...
        Load time: 0.265829
        Unsorted array check sum: 192090977768567
        value: 67324752
                                                Sort duration:    0.83459
        Index: 1320102
        array[index]: 67324752
        Sorted array check sum: 192090977768567

Start ComparableTest`1 test  ...
        Load time: 0.2612564
        Unsorted array check sum: 192090977768567
        value: 67324752
                                                Sort duration:    0.59322
        Index: 1320102
        array[index]: 67324752
        Sorted array check sum: 192090977768567

Start AbstractClassComparerTest`1 test  ...
        Load time: 0.2588181
        Unsorted array check sum: 192090977768567
        value: 67324752
                                                Sort duration:    0.71454
        Index: 1320102
        array[index]: 67324752
        Sorted array check sum: 192090977768567

Start InterfaceComparerTest`1 test with IntWrapperItfOnClassComparer ...
        Load time: 0.2576783
        Unsorted array check sum: 192090977768567
        value: 67324752
                                                Sort duration:    0.70451
        Index: 1320102
        array[index]: 67324752
        Sorted array check sum: 192090977768567

Start InterfaceComparerTest`1 test with IntWrapperItfOnStructComparer ...
        Load time: 0.2605197
        Unsorted array check sum: 192090977768567
        value: 67324752
                                                Sort duration:    1.07454
        Index: 1320102
        array[index]: 67324752
        Sorted array check sum: 192090977768567