static class ListExt<T>
    {
        public static string First(this List<T> list)
        {
            return list[0];
        }
        public static string Last(this List<T> list)
        {
            return list[list.Count-1];
        }
    }    
    ...
    var list = new List<string> {"aaa", "bbb", "ccc"};
        
    Console.WriteLine(list.First()); // А вот тут хочется extension-свойств!

    static class ListExt
    {
        public static object First(this IList list)
        {
            return list[0];
        }
        public static object Last(this IList list)
        {
            return list[list.Count-1];
        }
        public static bool Contains(this IList list, object item)
        {
            return list.Contains(item);
        }
    }
    ...
    var list = new List<string> {"aa", "bbbbb", "cccc", "dddd"};
    int[] ints = {1,2,3,4,5};

    Console.WriteLine(ints.Last());
    Console.WriteLine(list.Last());
    Console.WriteLine(list.Contains("cccc"));
    Console.WriteLine(ints.Contains(4));

    static class ListExt
    {
        public static T First<T>(this List<T> list)
        {
            return list[0];
        }
        public static T Last<T>(this List<T> list)
        {
            return list[list.Count-1];
        }
    }

if (Root.Config.User.Age > 16)
{
   //bla-bla
}

int? age = null;
var root = Root;
if (root != null)
{
   var config = root.Config;
   if (config != null) 
  {
      var user = config.User;
      if (user != null) 
        age = user.Age;
   }
}
if (age != null && age.Value > 10)
{
 //bla-bla
}

if (Root.?Config.?User.?Age > 16)
{
   //bla-bla
}

if (Root?.Config?.User?.Age > 16)
{
   //bla-bla
}

DG>if (Root.?Config.?User.?Age > 16)
DG>{
DG>   //bla-bla
DG>}
DG>

int  x = 0;  // Обыный int.
int% y = 0;  // Как я его назвал - undefinable int.

if (defined y) // Пройдет. Аналогия с SQL-ым IS NULL.
    ...;
    
y = undefined;
    
if (y == undefined) // Не пройдет. Так как undefined != undefined, как в SQL.
    ...;
    
x = (int)y; // Требуется явное приведение. В ран-тайм будет ошибка.

y = y + x; // Выполнится как y + (int%)x. Получится undefined.

class A
{
    public B% b;
}

class B
{
    public int x;
}

A% a = new A();
a.b  = undefined;

int% y = a.b.x; // y будет undefined. Так как a.b - undefined.
                // Несмотря на то, что поле x имеет тип int,
                // операция ((B%)somevar).x имеет тип int%.
                // но только на чтение.

a.b.x = 7;      // В ран-тайм будет ошибка. На запись a.b.x
                // имеет тип int.

if ( (Root == null || Root.Config == null || Root.Config.User == null ? default_value : Root.Config.User.Age) > 10 )
...

DG>>>if (Root.?Config.?User.?Age > 16)
DG>>>{
DG>>>   //bla-bla
DG>>>}
DG>>>

int x = Root.?Config.?User.?Age;

DG>>>>>if (Root.?Config.?User.?Age > 16)
DG>>>>>{
DG>>>>>   //bla-bla
DG>>>>>}
DG>>>>>

if (!(Root.?Config.?User.?Age > 16))
    ...;
    
if ((Root.?Config.?User.?Age > 16) || someBoolVar)
    ...;
    
bool x = (Root.?Config.?User.?Age > 16);

if (!(Root.?Config.?User.?Age > 16))
    ...;
    
if ((Root.?Config.?User.?Age > 16) || someBoolVar)
    ...;
    
bool x = (Root.?Config.?User.?Age > 16);

bool x = (Root.?Config.?User.?Age > 16);

int  age = Root.?Config.?User.?Age;
bool x   = (age > 16);

<EpressionType> retval;

if (Object1.Object2 != NULL) 
    retval = Object1.Object2; 
else 
    retval = false;
    
return retval;

if (Object1.?Object2.?Object3)
  DoSmth();

if (Object1 != null && Object1.Object2 != null)
{
  if (Object1.Object2.Object3)
    DoSmth();
}

if (Object1 != null)
    return Object1.Age;
else
    return (AgeType)default_value;

S>int x = Root.?Config.?User.?Age;
S>

int? x = Root.?Config.?User.?Age;

int? x;
if (Root != null && Root.Config != null && Root.Config.User != null)
    x = Root.Config.User.Age;
else
    x = null;

int? a;
a = null;
Console.WriteLine(a > 1);
a = 1;
Console.WriteLine(a > 1);
a = 2;
Console.WriteLine(a > 1);

False
False
True

int age;
try {  age = Root.Config.User.Age;} 
catch (NullReferenceException)  {age=0;}
if (age > 16)
{
  bla-bla
|

Кё>Нет, оператор не дожен возвращать никакой тип, иначе ничего не выйдет Именно это мне и показалось интересным — не простое вычисление выражения в операторе if по правилам языка, а какое-то более сложное поведение, в данном случае — считать само условие невыполненным в случае невозможности вычислить аргументы.

nil возвращаемый из методов в Objective-C /.../ в ответ на посылаемое ему сообщение nil не бросает исключение, а попросту игнорирует это сообщение. То есть, nil из Objective-C ведёт себя как "черная дыра". Это пустота. Это ничто. При посылке к nil-у любого сообщения, всё что вы получите назад — это nil. Не будет никаких исключений, никаких возвращенных значений. Ничего.
/.../
поведение ``поедающее'' сообщения позволяет создавать более элегантный код!
/.../
Предположим, что мы хотим найти последний телефонный номер, который вы набрали со своего офисного телефона, и сохранить этот номер в переменной, скажем, 'последнийНомер'. Далее предположим, что мы хотим сохранить этот номер как строку и затем отобразить его в виджете (или же использовать этот номер позже). Если вы -- это 'человек' в последовательности сообщений приведённой далее, то достаточно ли этой последовательности для получения работоспособной программы?

    последнийНомер := человек офис телефон последнийИсходящийНомер какСтрока.
    виджет строковоеЗначение: последнийНомер.

Возможно.

Но что, если у человека нет офиса? Или в офисе нет телефона? Или что если это новый телефон и по нему еще никто не звонил? В любом из этих случаев, при использовании ``исключенческого'' nil-а будет выброшено исключение, которое приведёт к остановке программы, если только не будет создан соответствующий обработчик исключения.

А что с nil-ом ``поедающим'' сообщения? В этом случае 'последнийНомер' может в качестве значения принять nil, но всё будет работать и в этом случае. Даже передача nil-а как аргумента для метода #строковоеЗначение:1будет работать, потому что ``поедающий'' nil может нормально работать с виджетами. Совершенно не важно, что аргумент это nil. Всё будет работать без бросания исключений и без заметных с первого взгляда побочных эффектов (на этом подробнее остановимся позже).

Для сравнения, ниже приведён код для работы с ``исключенческим'' nil-ом:

    | врем |
  врем := человек офис.
  врем неПусто еслиИстина: [врем := врем телефон].
    врем неПусто еслиИстина: [врем := врем последнийИсходящийНомер].
    врем неПусто еслиИстина: [врем := врем какСтрока].
    виджет строковоеЗначение: последнийНомер.

DG>if (Root.Config.User.Age > 16)
DG>{
DG>   //bla-bla
DG>}
DG>

class A
{
    public A(int i) { I = i; }
    public int I;
    public static readonly A Default = new A(-1);
}

class B
{
    public B() { A = A.Default; }
    public B(A a) { A = a; }
    public A A;
    public static readonly B Default = new B();
}

class Program
{
    static void Main()
    {
        B b = new B();

        int i = b.A.I;
    }
}

ANS>Врядли синтаксис тех лямб пойдёт в серию. Там же ни одной скобки нету. Ни круглой ни фигурной. Массы такого абстракционизма не поймут

(x, y) => x * y
(x)    => x * x

(int x, double y) => x * y
(int x) => { return x * x; }

delegate(int x, double y) {  return x * y; }
delegate(int x) { return x * x; }

(x, y) => x * y

delegate(int x, double y) {  return x * y; }

ANS>>Врядли синтаксис тех лямб пойдёт в серию. Там же ни одной скобки нету. Ни круглой ни фигурной. Массы такого абстракционизма не поймут

VD>(x, y) => x * y
VD>

VD>delegate(int x, double y) {  return x * y; }
VD>

delegate(x, y) {  return x * y; }

(x, y) => x * y

GZ> Это некоторый флаг Microsoft, чем удобнее пользовать коллекции, тем лучше С# .

int x = 2;
int y = 3;
int z = 3;

int res1 = (x + 123 + z * z) * y + (x + 321 + z * z) * y 
  + (x + 111 + z * z) * y + (x + 222 + z * z) * y;

int res2 = f1(x, y, z, 123) + f1(x, y, z, 321) 
  + f1(x, y, z, 111) + f1(x, y, z, 222);
...

private static int f1(int x, int y, int z, int a)
{
    return (x + a + z * z) * y;
}

Func<int, int> f2 = a => (x + a + z * z) * y;
var res3 = f2(123) + f2(321) + f2(111) + f2(222);

ANS>Занятно, что "длина" синтаксиса таки имеет значение

ANS> Я вроде как за краткость, но нужно же придерживаться некого стиля. Не нравится декларация типов (вот уж от тебя не ожидал

ANS>delegate(x, y) {  return x * y; }
ANS>

ANS>(x, y) => x * y
ANS>

list.Sort(delegate(KeyValuePair<string, int> x, KeyValuePair<string, int> y { return x.Value.CompareTo(y.Value); });

list.Sort((x, y) => x.Value.CompareTo(y.Value));

VD>Func<int, int> f2 = a => (x + a + z * z) * y;
VD>var res3 = f2(123) + f2(321) + f2(111) + f2(222);
VD>

Func<int, int> f2 = a => (f2(a) + 1);
var t=f2;

interface IA{}
interface IB:IA{}
class NullableIA:IA
{
  public static readonly IA Null = new NullableIA();
}
class NullableIB:IB
{
  public static readonly IB Null = new NullableIB();
}

class Program
{
  static void Main()
  {
     IA a = NullableIA.Null;
     CheckForNull(a); //print null
     
     IB b = NullableIB.Null;
     CheckForNull(b); //print null
 
     a = b;
     CheckForNull(a); //print not null     

     
  }
  public static void CheckForNull(IA a)
  {
     if (a == NullableIA.Null)
       Console.WriteLine("null");
     else
       Console.WriteLine("not null");  
  }
  public static void CheckForNull(IB b)
  {
     if (b == NullableIB.Null)
       Console.WriteLine("null");
     else
       Console.WriteLine("not null");  
  }
}

a.?Value = 5;

a.?Eval(5);

int? v = a.?Execute();

<res> = <primary> ".?" <field-name>

var q = <primary>;
if (q != null)
  <res> = q.<field-name>;
else
  <res> = null;

<primary>.?<field-name> = value;

var q = <primary>;
if (q != null)
  q = value;

<primary>.?<method-name>(<arg-1>, <arg-2>)

var q = <primary>;
if (q != null)
  q.<method-name>(<arg-1>, <arg-2>);

<res> = <primary> ".?" ?<method-name>(<arg-1>, <arg-2>)

var q = <primary>;
if (q != null)
  <res> = q.<method-name>(<arg-1>, <arg-2>);
else
  <res> = null;

GZ>Лисповцы наступают!!!

GZ>Грешен.

GZ>Func<int, int> f2 = a => (f2(a) + 1);
GZ>var t=f2;
GZ>

Func<int, int> f2 = null;
f2 = a => (f2(a) + 1);
var t = f2;

if (user.Age > 21)
{
  //bla-bla
}
if (user.Age < 16)
{
  //bla-bla
}

interface IUser
{
  int Age {get;}
}

class NullUser:
  IUser
{
  public int Age {get {return xxx;}}
}

S>int x = Root.?Config.?User.?Age;
S>

Root.?Config.?User.?Age

public class extension StringExtr : string
{
     // Модификатор доступа вообще говоря для расширений не нужен

     bool IsEmpty  // Это расширение свойством. 
     {
        get { return this != null || Length == 0; }
     }

     int ToInt32(int defaultValue) // Это расширение методом
     {...} 
}

Note
The PDC 2005 Technology Preview compiler does not support lambda expressions with a statement block body. In cases where a statement block body is needed, the C# 2.0 anonymous method syntax must be used.

VD>Я не смог уловить смысла этого абзаца.

GZ>>Грешен.

GZ>R# тебя спасет?

GZ>Напоминает слова проповедника.

GZ>

GZ>Ага. Правда при условии, если фукнции можно представить как лямбда-термы. Иначе возможности оптимизации существенно сужаются. А у нас тут в statement block body может твориться все что угодно.

List<int> list = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int i = 0;
var lazyList =
                from elem in list
                select ++i;

Console.WriteLine("i = " + i);

foreach (int x in lazyList)
     Console.WriteLine("x = " + x + " i = " + i);

Console.WriteLine();

foreach (int x in lazyList)
{
    if (x > 15)
        break;
    Console.WriteLine("x = " + x + " i = " + i);
}

Console.WriteLine();

foreach (int x in lazyList)
     Console.WriteLine("x = " + x + " i = " + i);

i = 0
x = 1 i = 1
x = 2 i = 2
x = 3 i = 3
x = 4 i = 4
x = 5 i = 5
x = 6 i = 6
x = 7 i = 7
x = 8 i = 8
x = 9 i = 9
x = 10 i = 10

x = 11 i = 11
x = 12 i = 12
x = 13 i = 13
x = 14 i = 14
x = 15 i = 15

x = 17 i = 17
x = 18 i = 18
x = 19 i = 19
x = 20 i = 20
x = 21 i = 21
x = 22 i = 22
x = 23 i = 23
x = 24 i = 24
x = 25 i = 25
x = 26 i = 26

GZ>Не-а. Я тоже послать могу. Мне нужна обзорная статья по оптимизации в функциональных языках. Чтобы прочел, и сразу просветленный. Сразу бы бросил пить и начал бы жрать горох. (а то мои знания ограничены "примерным" понимание graph rewrite ).

iT>Например, "засунуть" в DateTime статическое свойство TimeOfDinner Или расширить какой-то enum более дружественным, типизированным методом Parse.

static class EnumEx
{
    public static T Parse<T>(string str)
    {
        return (T)Enum.Parse(typeof(T), str, true);
    }
}

public string Name
{
   get
   {
      if (_Name == null)
         _Name = "Вася";
      else
         _Name = null;
      return _Name;
   }
}
string _Name;

if (user != null && user.Name != null && user.Name.Length > 10)

if (user.?Name.?Length > 10)

int? length = null;
if (user != null)
{
  string name = user.Name;
  if (name != null)
    length = name.Length;
}
if (length > 10)

DG>if (user.?Name.?Length > 10)
DG>

DG>int? length = null;
DG>if (user != null)
DG>{
DG>  string name = user.Name;
DG>  if (name != null)
DG>    length = name.Length;
DG>}
DG>if (length > 10)
DG>

foo[bar.getIndex()] += 7;

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

namespace ConsoleApplication1
{
    class RefTuple<T, U>
    {
        public T First;
        public U Second;

        public override string ToString()
        {
            return "{" + First.ToString() + ";" + Second.ToString() + "}";
        }

        public override bool Equals(object obj)
        {
            RefTuple<T, U> that = obj as RefTuple<T, U>;
            if (that == null)
                return false;
            return Equals(this, that);
        }

        public override int GetHashCode()
        {
            return First.GetHashCode() ^ Second.GetHashCode();
        }

        private static bool Equals(RefTuple<T, U> l, RefTuple<T, U> r)
        {
            return l.First.Equals(r.First) && l.Second.Equals(r.Second);
        }

        public static bool operator ==(RefTuple<T, U> l, RefTuple<T, U> r)
        {
            return Equals(l, r);
        }

        public static bool operator !=(RefTuple<T, U> l, RefTuple<T, U> r)
        {
            return !Equals(l, r);
        }
    }

    struct ValueTuple<T, U>
    {
        public T First;
        public U Second;

        public override int GetHashCode()
        {
            return First.GetHashCode() ^ Second.GetHashCode();
        }

        public override string ToString()
        {
            return First.ToString() + ";" + Second.ToString();
        }
    }

    class Program
    {
        static RefTuple<int, ValueTuple<float, ValueTuple<float, string>>> Test()
        {
            RefTuple<int, ValueTuple<float, ValueTuple<float, string>>> t = new RefTuple<int, ValueTuple<float, ValueTuple<float, string>>>();
            t.First = 1;
            t.Second.First = 1.1f;
            t.Second.Second.First = 123;
            t.Second.Second.Second = "asdf";
            return t;
        }

        static void Main()
        {
            RefTuple<int, ValueTuple<float, ValueTuple<float, string>>> t1 = Test();
            RefTuple<int, ValueTuple<float, ValueTuple<float, string>>> t2 = Test();
//            t1.Second.First = 1;
            Console.WriteLine(t1 == t2);
            Console.WriteLine(t1);
            Console.WriteLine(t2);
        }
    }
}

    class Program
    {
        static {int, float, float, string} Test()
        {
            return {1, 1.1f, 123f, "asdf"};
        }

        static void Main()
        {
            {int, float, float, string} t1 = Test();
            {int, float x, float, string} t2 = Test();
//            x = 1;
            Console.WriteLine(t1 == t2);
            Console.WriteLine(t1);
            Console.WriteLine(t2);
        }
    }