using System;
using System.Collections.Generic;

class Program
{
    delegate T Adder<T>(T x, T y);

    static T Sum<T>(Adder<T> adder, IEnumerable<T> list)
    {
        return Sum<T>(adder, list, default(T));
    }

    static T Sum<T>(Adder<T> adder, IEnumerable<T> list, T init)
    {
        T value = default(T);
        foreach (T elem in list)
            value = adder(value, elem);

        return value;
    }

    // Реализация абстрактных операций для целых и временных
    // отрезков. Для строк ничего писать не нужно, так как можно воспользоваться
    // функцией string.Concat. Заметь! Статической. :)
    static int IntAdd(int x, int y) { return x + y; }
    static TimeSpan TimeSpanAdd(TimeSpan x, TimeSpan y) { return x + y; }

    static void Main()
    {
        // Сумируем целые.
        int intValue = Sum<int>(IntAdd, new int[] { 1, 3, 5, 7, 8, 9 });
        Console.WriteLine("intValue is " + intValue);

        // Сумируем временные промежутки.
        TimeSpan timeSpanValue = Sum<TimeSpan>(
            TimeSpanAdd,
            new TimeSpan[]
            {
                new TimeSpan(10, 0, 0), new TimeSpan(10000),
                new TimeSpan(1, 12, 10), new TimeSpan(20000)
            });
        Console.WriteLine("timeSpanValue is " + timeSpanValue);

        // Сумируем строки. Кстати, функция уже есть, так что писать ее не нужно.
        string strValue = Sum<string>(
            string.Concat, 
            new string[] { "the ", "power ", "of ", "generic ", "programing! :)" }
            );
        Console.WriteLine("strValue is " + strValue);
    }
}

delegate T ClassMethod<T, X>(int i, string s, X x);

template<class ValueT, class Order, int Shift> class pixel_formats_rgba
{
   enum { Shift2 = Shift * 2 };
   . . .
            do
            {
               p[Order::R] = (ValueT)((((c.r - r) * alpha) + (r << Shift2)) >> Shift2);
               p[Order::G] = (ValueT)((((c.g - g) * alpha) + (g << Shift2)) >> Shift2);
               p[Order::B] = (ValueT)((((c.b - b) * alpha) + (b << Shift2)) >> Shift2);
               p[Order::A] = (ValueT)(((alpha + (a << Shift)) - ((alpha * Shift) >> 8)) >> 8);
               p += 4;
            }
            while(--len);
   . . .
};

>     static int IntAdd(int x, int y) { return x + y; }
>     static TimeSpan TimeSpanAdd(TimeSpan x, TimeSpan y) { return x + y; }
>

template<class T>
static T Add(T x, T y) { return x + y; }

> delegate T ClassMethod<T, X>(int i, string s, X x);
>

> О как? А я сверху не то же самое сотварил? Нет?

> Ты случаем не обратил внимания на две мелочи? Нет? Такие незаметнинькие...

But in Java (and apparently C#), you can't seem to say "any type."

C# also doesn't support latent typing, and although it has a better generics model than Java (since they went ahead and changed the underlying IL so that, for example, a static field in a class will be different between class and class). So if you want latent typing you'll have to use C++ or D (or Python, Smalltalk, Ruby, etc.).

> 2. Они забыл разобраться в дэенериках.

ПК>template<class T>
ПК>static T Add(T x, T y) { return x + y; }
ПК>

    static Adder<T> GetAdditionOperator<T>()
    {
        return (Adder<T>)Delegate.CreateDelegate(
            typeof(Adder<T>), typeof(T), "op_Addition");
    }
    ...
    TimeSpan timeSpanValue = Accumulate<TimeSpan>(
    GetAdditionOperator<TimeSpan>(),
    new TimeSpan[]
    {
        new TimeSpan(10, 0, 0), new TimeSpan(10000),
        new TimeSpan(1, 12, 10), new TimeSpan(20000)
    });
    Console.WriteLine("timeSpanValue is " + timeSpanValue);

Xxx(delegate(int i) { return new Yyy(i) });

apparently нареч.
1) очевидно, несомненно Syn: evidently
2) вероятно, видимо, по-видимому, предположительно Syn: to all appearance

>> 2. Они забыл разобраться в дэенериках.

>> ПК>template<class T>
>> ПК>static T Add(T x, T y) { return x + y; }
>> ПК>

>> Ну, да ради искуства... напишу тебе универсальную функцию :

>>     static Adder<T> GetAdditionOperator<T>()
>>     {
>>         return (Adder<T>)Delegate.CreateDelegate(
>>             typeof(Adder<T>), typeof(T), "op_Addition");
>>     }
>>     ...
>>     TimeSpan timeSpanValue = Accumulate<TimeSpan>(
>>     GetAdditionOperator<TimeSpan>(),
>>     new TimeSpan[]
>>     {
>>         new TimeSpan(10, 0, 0), new TimeSpan(10000),
>>         new TimeSpan(1, 12, 10), new TimeSpan(20000)
>>     });
>>     Console.WriteLine("timeSpanValue is " + timeSpanValue);
>>

// Процедура универсального получения делегата метода сложения.
// Если у типа реализован оператор сложения, то он обязательно
// содержит статический метод op_Addition.
// Таким образом мы создаем делегат для этого метода/типа.
static Adder<T> GetAdditionOperator<T>()
{
        return (Adder<T>)Delegate.CreateDelegate(
                typeof(Adder<T>), typeof(T), "op_Addition");
}
...
TimeSpan timeSpanValue = Accumulate<TimeSpan>(
// Применяем универсальный метод. Вместо TimeSpan
// можно подставить любой тип реализующих оператор сложения.
GetAdditionOperator<TimeSpan>(),
new TimeSpan[]
{
        new TimeSpan(10, 0, 0), new TimeSpan(10000),
        new TimeSpan(1, 12, 10), new TimeSpan(20000)
});
Console.WriteLine("timeSpanValue is " + timeSpanValue);

ПК>Ага. Например, создание таким макаром результата функции получения ряда матрицы... Представляю