var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary<int,Order>();

var x;                    // Error, no initializer to infer type from
var y = {1, 2, 3};    // Error, collection initializer not permitted
var z = null;            // Error, null type not permitted

int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);

namespace Acme.Utilities
{
    public static class Extensions
    {
        public static int ToInt32(this string s) {
            return Int32.Parse(s);
        }
        public static T[] Slice<T>(this T[] source, int index, int count) {
            if (index < 0 || count < 0 || source.Length – index < count)
                throw new ArgumentException();
            T[] result = new T[count];
            Array.Copy(source, index, result, 0, count);
            return result;
        }
    }
}

using Acme.Utilities;

...

string s = "1234";
int i = s.ToInt32();                    // Same as Extensions.ToInt32(s)
int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3);        // Same as Extensions.Slice(digits, 4, 3)

delegate R Func<A,R>(A arg);

...

Func<int,int> f1 = x => x + 1;            // Ok
Func<int,double> f2 = x => x + 1;        // Ok
Func<double,int> f3 = x => x + 1;        // Error

var a = new Point { X = 0, Y = 1 };
// which has the same effect as
// var a = new Point();
// a.X = 0;
// a.Y = 1;

var r = new Rectangle {
    P1 = new Point { X = 0, Y = 1 },
    P2 = new Point { X = 2, Y = 3 }
};
// which has the same effect as
// var r = new Rectangle();
// var __p1 = new Point();
// __p1.X = 0;
// __p1.Y = 1;
// r.P1 = __p1;
// var __p2 = new Point();
// __p2.X = 2;
// __p2.Y = 3;
// r.P2 = __p2;

var contacts = new List<Contact> {
    new Contact {
        Name = "Chris Smith",
        PhoneNumbers = { "206-555-0101", "425-882-8080" }
    },
    new Contact {
        Name = "Bob Harris",
        PhoneNumbers = { "650-555-0199" }
    }
};
// which has the same effect as
// var contacts = new List<Contact>();
// var __c1 = new Contact();
// __c1.Name = "Chris Smith";
// __c1.PhoneNumbers.Add("206-555-0101");
// __c1.PhoneNumbers.Add("425-882-8080");
// contacts.Add(__c1);
// var __c2 = new Contact();
// __c2.Name = "Bob Harris";
// __c2.PhoneNumbers.Add("650-555-0199");
// contacts.Add(__c2);

var dict = new Dictionary<string, int> {
    new KeyValuePair<string, int>("one", 1),
    new KeyValuePair<string, int>("two", 2),
    new KeyValuePair<string, int>("three", 3)
}

var p1 = new { Name = "Lawnmower", Price = 495.00 };
var p2 = new { Name = "Shovel", Price = 26.95 };
p1 = p2;
// Компилятор неявно создает следующий класс:
// class __Anonymous1
{
    private string _name;
    private double _price;
    
    public string Name { get {return _name;} set {_name = value;}}
    public double Price { get {return _price;} set {_price = value;}}
}

var a = new[] { 1, 10, 100, 1000 };                // int[]
var b = new[] { 1, 1.5, 2, 2.5 };                // double[]
var c = new[] { "hello", null, "world” };        // string[]
var d = new[] { 1, "one", 2, "two" };            // Error

from c in customers
where c.City == "London"
from o in c.Orders
where o.OrderDate.Year == 2005
select new { c.Name, o.OrderID, o.Total }

customers.
Where(c => c.City == "London").
SelectMany(c =>
    c.Orders.
    Where(o => o.OrderDate.Year == 2005).
    Select(o => new { c.Name, o.OrderID, o.Total })
)

delegate R Func<A,R>(A arg);
class C<T>
{
    public C<T> Where(Func<T,bool> predicate);
    public C<S> Select<S>(Func<T,S> selector);
    public C<S> SelectMany<S>(Func<T,C<S>> selector);
    public O<T> OrderBy<K>(Func<T,K> keyExpr);
    public O<T> OrderByDescending<K>(Func<T,K> keyExpr);
    public C<G<K,T>> GroupBy<K>(Func<T,K> keyExpr);
    public C<G<K,E>> GroupBy<K,E>(Func<T,K> keyExpr, Func<T,E> elemExpr);
}
class O<T> : C<T>
{
    public O<T> ThenBy<K>(Func<T,K> keySelector);
    public O<T> ThenByDescending<K>(Func<T,K> keySelector);
}
class G<K,T>
{
    public K Key { get; }
    public C<T> Group { get; }
}

Func<int,int> f = x => x + 1;                        // Code
Expression<Func<int,int>> e = x => x + 1;        // Data

Expression trees are efficient in-memory data representations of lambda expressions and make the structure of the expression transparent and explicit.

//я написал
public MyCryptoClass
{
public Crypt(){CryptForSecure();};
}
//доброжелатель ответил
public static class Extensions
{
public static Crypt(this MyCryptoClass class){SaveForUnsecure();};
}

The Standard Query Operators (described in a separate specification) provide an implementation of the query operator pattern for any type that implements the System.Collections.Generic.IEnumerable<T> interface.

AVK>Вот так — прозрачные и явные. Попой чую, что для каких то особо хитрых извратств в рантайме (скорее всего связанных с п.7), но чего то вечером пример придумать не могу. Ну разве что такую лямбду можно будет сериализовать (к примеру, чтобы сохранить в БД или передать по сети).

struct A
{
    public A(int value) { Value = value; }
    
    public int Value;
}
...
A[] array = { 1, 2, 3 };

AVK>delegate R Func<A,R>(A arg);

AVK>...

AVK>Func<int,int> f1 = x => x + 1;            // Ok
AVK>Func<int,double> f2 = x => x + 1;        // Ok
AVK>Func<double,int> f3 = x => x + 1;        // Error
AVK>

AVK>var a = new Point { X = 0, Y = 1 };
AVK>// which has the same effect as
AVK>// var a = new Point();
AVK>// a.X = 0;
AVK>// a.Y = 1;

Ё! И об этом говорили большивеки в "Философии". Эх если бы они нас читали, то все это могло бы появиться еще в двушке. :(


AVK>Не уверен, но по идее должно работать и так:
AVK>[c#]
AVK>var dict = new Dictionary<string, int> {
AVK>    new KeyValuePair<string, int>("one", 1),
AVK>    new KeyValuePair<string, int>("two", 2),
AVK>    new KeyValuePair<string, int>("three", 3)
AVK>}
AVK>

var dict = new Dictionary<string, int>
{
    ("one", 1), ("two", 2), ("three", 3)
};

var dict = new Dictionary<string, int>
{
  new { "one", 1 }, new { "two", 2 }, new { "three", 3 }
};

AVK>var p1 = new { Name = "Lawnmower", Price = 495.00 };
AVK>var p2 = new { Name = "Shovel", Price = 26.95 };
AVK>p1 = p2;
AVK>// Компилятор неявно создает следующий класс:
AVK>// class __Anonymous1
AVK>{
AVK>    private string _name;
AVK>    private double _price;
    
AVK>    public string Name { get {return _name;} set {_name = value;}}
AVK>    public double Price { get {return _price;} set {_price = value;}}
AVK>}
AVK>

AVK>var a = new[] { 1, 10, 100, 1000 };                // int[]
AVK>var b = new[] { 1, 1.5, 2, 2.5 };                // double[]
AVK>var c = new[] { "hello", null, "world” };        // string[]
AVK>var d = new[] { 1, "one", 2, "two" };            // Error
AVK>

AVK>from c in customers
AVK>where c.City == "London"
AVK>from o in c.Orders
AVK>where o.OrderDate.Year == 2005
AVK>select new { c.Name, o.OrderID, o.Total }
AVK>

AVK>Func<int,int> f = x => x + 1;                        // Code
AVK>Expression<Func<int,int>> e = x => x + 1;        // Data
AVK>

AVK>Вот так — прозрачные и явные. Попой чую, что для каких то особо хитрых извратств в рантайме (скорее всего связанных с п.7), но чего то вечером пример придумать не могу. Ну разве что такую лямбду можно будет сериализовать (к примеру, чтобы сохранить в БД или передать по сети).

c => c.Name = "MyName"

VD>Вот и ответ на все несоотвестия. Таки теперь мы будет иметь нормальный ОО-синтаксис вызова методов расширения. В общем, объект все что качается, если не качается, то раскачивается и признается объектом.

public static string Concat(this IEnumerable self, string separator)
{
  StringBuilder sb = new StringBuilder();
  foreach(object o in self)
    {
      sb.Append(o); 
        sb.Append(separator); 
    }
    if (sb.Length > 0)
      sb.Length -= separator.Length;
}

VD>var dict = new Dictionary<string, int>
VD>{
VD>    ("one", 1), ("two", 2), ("three", 3)
VD>};
VD>

string a;
int b;

a,b = ("one, 1 );