if (true)
      {
        LightSynchronizer<int> sync = new LightSynchronizer<int>(this,
          delegate
          {
            return modifyDeviceGridSynch.VisibleDataRegion.Height;
          },
          delegate (int visibleHeight)
          {
            int rowHeight = modifyDeviceGridSynch.RowHeight;
            modifyDevicePanel.Height = modifyDevicePanel.Height + (rowHeight - visibleHeight);
          },
          TimeSpan.FromMilliseconds(100));
      }

      if (true)
      {
        LightSynchronizer<string> sync = new LightSynchronizer<string>(this,
          delegate
          {
            return Passport2.Model.GetValue(modifyDevice);
          },
          delegate(string model)
          {
            foreach (string dataType in modelBox.GetNewDataTypes(model))
              Passport2.StoragePeriod.SetProperty(modifyDevice, 14, dataType);
          });
      }

      CreateHeightModifyPanelSynchronizer();
      CreateDeviceDataTypeSynchronizer();

      inline("HeightModifyPanelSynchronizer")
      {
        ...
      }

      inline("DeviceDataTypeSynchronizer")
      {
        ...
      }

U>      if (true)
U>      {
U>        LightSynchronizer<int> sync = new LightSynchronizer<int>(this,
U>          delegate
U>          {
U>            return modifyDeviceGridSynch.VisibleDataRegion.Height;
U>          },
U>          delegate (int visibleHeight)
U>          {
U>            int rowHeight = modifyDeviceGridSynch.RowHeight;
U>            modifyDevicePanel.Height = modifyDevicePanel.Height + (rowHeight - visibleHeight);
U>          },
U>          TimeSpan.FromMilliseconds(100));
U>      }

U>      if (true)
U>      {
U>        LightSynchronizer<string> sync = new LightSynchronizer<string>(this,
U>          delegate
U>          {
U>            return Passport2.Model.GetValue(modifyDevice);
U>          },
U>          delegate(string model)
U>          {
U>            foreach (string dataType in modelBox.GetNewDataTypes(model))
U>              Passport2.StoragePeriod.SetProperty(modifyDevice, 14, dataType);
U>          });
U>      }
U>

delegate
{
    return modifyDeviceGridSynch.VisibleDataRegion.Height;
}
delegate
{
    return Passport2.Model.GetValue(modifyDevice);
}

delegate
{
     int result = modifyDeviceGridSynch.VisibleDataRegion.Height;
     return result;
}
delegate
{
     int result = Passport2.Model.GetValue(modifyDevice);
     return result;
}

var result = array1.Aggregate((first, second) => first + ", " + second);

CRA>>delegate
CRA>>{
CRA>>     int result = modifyDeviceGridSynch.VisibleDataRegion.Height;
CRA>>     return result;
CRA>>}
CRA>>

delegate
{
  t1 x1 = modifyDeviceGridSynch;
  t2 x2 = x1.VisibleDataRegion;
  int result = x2.Height;
  return result;
}

Функциональное вычисление – функция (или если быть точнее – «чистая функция», pure function) – должна принимать некоторые аргументы (входящие данные) на входе, производить вычисление и возвращать некоторый результат. При этом функция не должна создавать никаких побочных эффектов... В общем, функция не имеет право делать ничего, что могло бы изменить состояние чего бы то ни было. Все, что может сделать функция – это произвести вычисления и выдать результат.

У такого подхода есть одна замечательная особенность. Функция всегда должна возвращать один и тот же результат для одних и тех же аргументов.

ФЯ развивают эту идею, возводя ее в принцип – функция является в программе таким же полноценным объектом, как и экземпляр любого другого типа (например, экземпляр строки).

Скажем, в С мы можем передать указатель на функцию другой функции, но составить из двух функций третью мы не в силах.

typedef int (*func)(int);
int compose(func a, func b, int x)
{
    return a(b(x));
}

Первое, что требуется для манипуляции функциями – это иметь возможность описать их тип.

arg1 => arg2.ToString()

СПИСОК_ПОЛЕ_ПЕРЕЧИСЛЕННЫХ_ЧЕРЕЗ_ЗАПЯТУЮ

H>Я, наверное, еще очень молодой, но ИМХО этот код не читается вообще .

      void CreateHeightModifyPanelSynchronizer()
      {
        LightSynchronizer<int> sync = new LightSynchronizer<int>(this,
          delegate
          {
            return modifyDeviceGridSynch.VisibleDataRegion.Height;
          },
          delegate (int visibleHeight)
          {
            int rowHeight = modifyDeviceGridSynch.RowHeight;
            modifyDevicePanel.Height = modifyDevicePanel.Height + (rowHeight - visibleHeight);
          },
          TimeSpan.FromMilliseconds(100));
      }
...
      CreateHeightModifyPanelSynchronizer();

      if (true)
      {
        LightSynchronizer<int> heightModifyPanelSync = new LightSynchronizer<int>(this,
          delegate
          {
            return modifyDeviceGridSynch.VisibleDataRegion.Height;
          },
          delegate (int visibleHeight)
          {
            int rowHeight = modifyDeviceGridSynch.RowHeight;
            modifyDevicePanel.Height = modifyDevicePanel.Height + (rowHeight - visibleHeight);
          },
          TimeSpan.FromMilliseconds(100));
      }

var result = array1.Aggregate((first, second) => first + ", " + second);

array1.Aggregate("", (first, second) => first + ", " + second);