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.

_FR>Гхм. Если не сложно, а что за история?

int? i = null;
Console.WriteLine(i == null); // Выводится True, что нормально.
object o = i;
Console.WriteLine(o == null); // Выводится False, что, мягко говоря, не очень логично.

using System;
using System.Collections.Generic;

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

public static class Extensions
{
    public static Dictionary<K,T> ToDictionary<T,K>(this IEnumerable<T> collection, Func<T,K> func)
    {
        var dict = new Dictionary<K,T>();
        foreach (T elem in collection)
            dict.Add(func(elem), elem);
        return dict;
    }
}

public static class Program
{
    public static void Main(string[] args)
    {
        var dict = (new [] {"aaa", "b", "cccc", "dd"}).ToDictionary(s => s.Length);
        Console.WriteLine(dict[3]);
    }
}

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

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>>

VD>Гы. Это же они и есть — tuple-ы.

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

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

TupleDic.cs(15,9): error CS0029: Cannot implicitly convert type 'Test.<Projection>f__0' to 'System.Collections.Generic.KeyValuePair<string,int>'

TupleDic.cs(7,42): error CS1501: No overload for method 'Add' takes '1' arguments

26.7.2 The query expression pattern
The Query Expression Pattern establishes a pattern of methods that types can implement to support query expressions. Because query expressions are translated to method invocations by means of a syntactic mapping, types have considerable flexibility in how they implement the query expression pattern. For example, the methods of the pattern can be implemented as instance methods or as extension methods because the two have the same invocation syntax, and the methods can request delegates or expression trees because lambda expressions are convertible to both.
The recommended shape of a generic type C<T> that supports the query expression pattern is shown below. A generic type is used in order to illustrate the proper relationships between parameter and result types, but it is possible to implement the pattern for non-generic types as well.
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; }
}

26.7.2 The query expression pattern
The Query Expression Pattern establishes a pattern of methods that types can implement to support query expressions. Because query expressions are translated to method invocations by means of a syntactic mapping, types have considerable flexibility in how they implement the query expression pattern. For example, the methods of the pattern can be implemented as instance methods or as extension methods because the two have the same invocation syntax, and the methods can request delegates or expression trees because lambda expressions are convertible to both.
The recommended shape of a generic type C<T> that supports the query expression pattern is shown below. A generic type is used in order to illustrate the proper relationships between parameter and result types, but it is possible to implement the pattern for non-generic types as well.

_FR>>Вот, блин, дают Кто-нибудь бывает на таких мероприятиях?

Table of Contents

26. Overview of C# 3.0
  26.1 Implicitly typed local variables
  26.2 Extension methods
    26.2.1 Declaring extension methods
    26.2.2 Importing extension methods
    26.2.3 Extension method invocations
  26.3 Lambda expressions
    26.3.1 Lambda expression conversions
    26.3.2 Type inference
    26.3.3 Overload resolution
  26.4 Object and collection initializers
    26.4.1 Object initializers
    26.4.2 Collection initializers
  26.5 Anonymous types
  26.6 Implicitly typed arrays
  26.7 Query expressions
    26.7.1 Query expression translation
      26.7.1.1 where clauses
      26.7.1.2 select clauses
      26.7.1.3 group clauses
      26.7.1.4 orderby clauses
      26.7.1.5 Multiple generators
      26.7.1.6 into clauses
    26.7.2 The query expression pattern
    26.7.3 Formal translation rules
  26.8 Expression trees

//я написал
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), но чего то вечером пример придумать не могу. Ну разве что такую лямбду можно будет сериализовать (к примеру, чтобы сохранить в БД или передать по сети).

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 );

string a;
int b;

(a, b) = ("one", 1 );

(string a; int b) = ("one", 1 );

(var a; var b) = ("one", 1 );

Exercise 4 – Using Lambda Expressions to Create Expression Trees
In addition to treating data as objects, LINQ provides the ability to treat expressions as data at runtime. LINQ defines a new type, Expression<T>, that represents an expression tree, an in-memory representation of a lambda expression. Expression trees allow developers to treat lambda expressions as data, allowing for inspection and modification of lambda expressions in code. This feature will be used to enable an ecosystem of third-party libraries that leverage the base query abstractions that are part of LINQ. For example, a database access implementation might leverage this facility to translate expression trees into suitable query statements for a particular kind of database.

static void Main(string[] args)
{
     Expression<Func<int, bool>> filter = n => (n * 3) < 5;

     BinaryExpression lt = (BinaryExpression) filter.Body;
     BinaryExpression mult = (BinaryExpression) lt.Left;            
     ParameterExpression en = (ParameterExpression) mult.Left;            
     ConstantExpression three = (ConstantExpression) mult.Right;
     ConstantExpression five = (ConstantExpression) lt.Right;
                        
     Console.WriteLine("({0} ({1} {2} {3}) {4})", lt.NodeType, 
              mult.NodeType, en.Name, three.Value, five.Value); 
}

var x = new { X = 0, yield = 1 };
var y = new { Z = 0, yield = 1 };

Console.WriteLine(x == y);

error CS0019: Operator '==' cannot be applied to operands of type 'LINQConsoleApplication1.Program.<Projection>f__0' and 'LINQConsoleApplication1.Program.<Projection>f__1'

var x = new { X = 0, yield = 1 };
var y = new { X = 0, yield = 1 };

Console.WriteLine(x == y);

M>string a;
M>int b;

M>a,b = ("one, 1 );
M>

var x = new { A = "one", B = 1 };
string a = x.A;
int b    = x.B;

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

AVK>Не факт . В нем тоже может многое из этого появится. Надо глядеть. Да и потом — для любителей извратов есть С++/CLI

AVK>var dict2 = new Dictionary<string, int>
AVK>{
AVK>    new { Key = "one", Value = 1 },
AVK>    new { Key = "two", Value = 2 },
AVK>    new { Key = "three", Value = 3 }
AVK>};
AVK>

AVK>TupleDic.cs(15,9): error CS0029: Cannot implicitly convert type 'Test.<Projection>f__0' to 'System.Collections.Generic.KeyValuePair<string,int>'
AVK>

var x = new { X = 0, yield = 1 };
var y = new { X = 0, yield = 1 };

Console.WriteLine(x == y);

c => c.Name = "MyName"

System.Data.DLinq.QueryExtensions.Sum<T>(Query<T> seq, Expression<Func<T, Nullable<double>>> expr)

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

customers.
SelectMany(c =>
    c.Orders.
    Where(o => o.OrderDate.Year == 2005).
    Select(o => new { k1 = o.Total, v = new { c.Name, o.OrderID, o.Total } })
).
OrderByDescending(x => x.k1).
Select(x => x.v)

using System;
using System.Expressions;
using System.Query;

class Program
{
    static void Main()
    {
        // просто лямбда
        Func<int, int> lambda = x => x * x;
        Console.WriteLine(lambda); // выводит System.Query.Func`2[System.Int32,System.Int32]
        Console.WriteLine(lambda(2)); // выводит 4

        // лямбда преобразуемая в дерево выражений. 
        Expression<Func<int, int>> lambdaExpression = x => x * x;
        Console.WriteLine(lambdaExpression); // выводит |x| Multiply(x, x)
    }
}

iT>>Но, конечно, открывается простор для багов, если ПОЗЖЕ в класс добавили метод, ранее введенный extension'ом, но с чуть-чуть другим поведением.

    static class StringExt
    {
        public static string[] Split(this string s)
        {
            return new string[] {};
        }
    }
    ...
    Console.WriteLine("1 2 3 4 5 6 7 8 9 10".Split().Length); // Выведет 10

AVK>var dict2 = new Dictionary<string, int>
AVK>{
AVK>    new { Key = "one", Value = 1 },
AVK>    new { Key = "two", Value = 2 },
AVK>    new { Key = "three", Value = 3 }
AVK>};
AVK>

var scoreRecords = new [] { new {Name = "Alice", Score = 50},
                                                        new {Name = "Bob"  , Score = 40},
                                                        new {Name = "Cathy", Score = 45}
                                                };

var scoreRecordsDict = scoreRecords.ToDictionary(sr => sr.Name);

Console.WriteLine("Bob's score: {0}", scoreRecordsDict["Bob"]);

static class TestExtensions
{
      public static string ToString(this string str){return "Переопределено";}
}
static void Main(string[] args)
{
    string sss="sss";
    Console.WriteLine(TestExtensions.ToString(sss));//явно вызываем метод расширения
    Console.WriteLine(sss.ToString()); //тут вызов родного метода
}

Переопределено
sss

public interface IMyObject
{
    String MyMethod();
}
public class MyObject:IMyObject
{
    String IMyObject.MyMethod()
    {
        return "Real My Method";
    }
}

static class TestExtensions
{
    public static String MyMethod(this MyObject myObject){return "Extension";}
}
class Program
{
    static void Main(string[] args)
    {
        MyObject obj=new MyObject();
        Console.WriteLine(obj.MyMethod());
        IMyObject iface=new MyObject();
        Console.WriteLine(iface.MyMethod());
    }
}

Extension
My Real Method

public class MyObject
{
    static public string MyMethod()
    {
        return "My Static Method";
    }
}
static class TestExtensions
{
    public static String MyMethod(this MyObject myObject){return "Extension";}
}
class Program
{
    static void Main(string[] args)
    {
        MyObject obj=new MyObject();
        Console.WriteLine(obj.MyMethod());//Error Static member 
            //'LINQConsoleApplication1.MyObject.MyMethod()' cannot be accessed 
            //with an instance reference; qualify it with a type name instead
        Console.WriteLine(MyObject.MyMethod());
    }
}

public class MyObject
{
    private string MyMethod()
    {
        return "My Static Method";
    }
}
static class TestExtensions
{
    public static String MyMethod(this MyObject myObject){return "Extension";}
}
class Program
{
    static void Main(string[] args)
    {
        MyObject obj=new MyObject();
        Console.WriteLine(obj.MyMethod());//Error Static member 
            //'LINQConsoleApplication1.MyObject.MyMethod()' cannot be accessed 
            //with an instance reference; qualify it with a type name instead
        Console.WriteLine(MyObject.MyMethod());
    }
}

Extension methods are less discoverable and more limited in functionality than instance methods. For those reasons, it is recommended that extension methods be used sparingly and only in situations where instance methods are not feasible or possible.

AVK>delegate R Func<A,R>(A arg);
AVK>...
AVK>Func<int,int> f1 = x => x + 1;            // Ok
[...]