var size = keyToValMap["size"];
var sizeDiv2 = size / 2;
Console.WriteLine(Math.Sqrt(sizeDiv2));

var customers = GetCustomers()

D>Dictionary<string, EntityData> nameToEntityData = new Dictionary<string, EntityData>();
D>

D>var nameToEntityData = new Dictionary<string, EntityData>();
D>

Dictionary<string, EntityData> nameToEntityData = new Dictionary<string, EntityData>();

var nameToEntityData = new Dictionary<string, EntityData>();

            bool isAnySpace = false;
            foreach (var s in "qeqweqweqwe")
            {
                if (s == ' ')
                {
                    isAnySpace = true;
                    break;
                }
            }

bool isSpace = "qeqweqweqwe".Any(s => s == ' ');

var customer = GetCustomers().FirstOrDefault();

if (customer != null)
    Console.WriteLine(customer.Name);

def keyToValMap = Dectionary();
...
keyToValMap["key1"] = 123;
...
keyToValMap["key2"] = 65;
...
when (keyToValMap.Contains("key2"))
  doSomeWork();

[CompilerGenerated]
private sealed class <Values>d__0 : IEnumerable<int>, IEnumerable, IEnumerator<int>, IEnumerator, IDisposable
{
    // Fields
    private int <>1__state;
    private int <>2__current;
    public Program.Node <>3__root;
    public IEnumerator<int> <>7__wrap3;
    private int <>l__initialThreadId;
    public IEnumerable<int> <childValues>5__1;
    public int <value>5__2;
    public Program.Node root;

    // Methods
    [DebuggerHidden]
    public <Values>d__0(int <>1__state)
    {
        this.<>1__state = <>1__state;
        this.<>l__initialThreadId = Thread.CurrentThread.ManagedThreadId;
    }

    private void <>m__Finally4()
    {
        this.<>1__state = -1;
        if (this.<>7__wrap3 != null)
        {
            this.<>7__wrap3.Dispose();
        }
    }

    private bool MoveNext()
    {
        try
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    if (object.ReferenceEquals(this.root, null))
                    {
                        break;
                    }
                    this.<>2__current = this.root.Value;
                    this.<>1__state = 1;
                    return true;

                case 1:
                    this.<>1__state = -1;
                    this.<childValues>5__1 = Program.Values(this.root.Left).Concat<int>(Program.Values(this.root.Right));
                    this.<>7__wrap3 = this.<childValues>5__1.GetEnumerator();
                    this.<>1__state = 2;
                    while (this.<>7__wrap3.MoveNext())
                    {
                        this.<value>5__2 = this.<>7__wrap3.Current;
                        this.<>2__current = this.<value>5__2;
                        this.<>1__state = 3;
                        return true;
                    Label_00DE:
                        this.<>1__state = 2;
                    }
                    this.<>m__Finally4();
                    break;

                case 3:
                    goto Label_00DE;
            }
            return false;
        }
        fault
        {
            this.System.IDisposable.Dispose();
        }
    }

    [DebuggerHidden]
    IEnumerator<int> IEnumerable<int>.GetEnumerator()
    {
        Program.<Values>d__0 d__;
        if ((Thread.CurrentThread.ManagedThreadId == this.<>l__initialThreadId) && (this.<>1__state == -2))
        {
            this.<>1__state = 0;
            d__ = this;
        }
        else
        {
            d__ = new Program.<Values>d__0(0);
        }
        d__.root = this.<>3__root;
        return d__;
    }

    [DebuggerHidden]
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator();
    }

    [DebuggerHidden]
    void IEnumerator.Reset()
    {
        throw new NotSupportedException();
    }

    void IDisposable.Dispose()
    {
        switch (this.<>1__state)
        {
            case 2:
            case 3:
                break;

            default:
                break;
                try
                {
                }
                finally
                {
                    this.<>m__Finally4();
                }
                break;
        }
    }

    // Properties
    int IEnumerator<int>.Current
    {
        [DebuggerHidden]
        get
        {
            return this.<>2__current;
        }
    }

    object IEnumerator.Current
    {
        [DebuggerHidden]
        get
        {
            return this.<>2__current;
        }
    }
}

IT>Сам по ссылке ходил?

IT>Он ещё буквально вчера закомитил самый быстрый в мире ObjectMapper

string ReadLastRow(File file) {
  int pos = file.Size;  

  while(pos != 0) {
    pos -= PAGE_SIZE; // resonable max row size, for ex. 4k
    if(pos<0)
      pos = 0;

    file.Seek(pos);
    string page = file.read(pos, PAGE_SIZE);
    int pagePos = page.findLastOf('\n');
  
    if(pagePos != -1)
      return file.ReadToEnd(pos+pagePos+1);
  }

  return file.Read(0, file.Size);
}

IT>Вот! Типичный пример того, о чём я говорил. Люди рассуждают о том, о чём имеют весьма смутное и отдалённое понятие. 0x7be, иди и попробуй теперь это удачно подать

using System;
using System.Collections;
using System.Linq;

namespace NonGenericLINQ
{
    public class Student
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public int[] Scores { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            ArrayList arrList = new ArrayList();
            arrList.Add(
                new Student
                    {
                        FirstName = "Svetlana", LastName = "Omelchenko", Scores = new int[] { 98, 92, 81, 60 }
                    });
            arrList.Add(
                new Student
                    {
                        FirstName = "Claire", LastName = "O’Donnell", Scores = new int[] { 75, 84, 91, 39 }
                    });
            arrList.Add(
                new Student
                    {
                        FirstName = "Sven", LastName = "Mortensen", Scores = new int[] { 88, 94, 65, 91 }
                    });
            arrList.Add(
                new Student
                    {
                        FirstName = "Cesar", LastName = "Garcia", Scores = new int[] { 97, 89, 85, 82 }
                    });

            var query = from Student student in arrList
                        where student.Scores[0] > 95
                        select student;

            foreach (Student s in query)
                Console.WriteLine(s.LastName + ": " + s.Scores[0]);

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

using System;

namespace LinqOperation
{
    internal class Program
    {
        private static void Main()
        {
            var serviceOne = new ServiceOne();
            var serviceTwo = new ServiceTwo();

            var op = from str in serviceOne.Load(42)
                     from ent in serviceTwo.Load("test")
                     select ent.Name + str;

            // this could be transaction scope, for example
            using (var context = new OperationContext())
            {
                Console.WriteLine(op.Execute(context));
            }
        }
    }

    public class OperationContext : IDisposable
    {
        public void Dispose()
        {
        }
    }

    public class NamedEntity
    {
        public string Name { get; set; }
    }

    public class ServiceOne
    {
        public Operation<string> Load(int id)
        {
            return Operation.Create(() => id.ToString());
        }
    }

    public class ServiceTwo
    {
        public Operation<NamedEntity> Load(string name)
        {
            return Operation.Create(() => new NamedEntity { Name = name });
        }
    }

    /// <summary>
    /// Deffered operation.
    /// </summary>
    public class Operation<T>
    {
        internal Func<T> Process { get; set; }

        public T Execute(OperationContext context)
        {
            return Process();
        }
    }

    public static class Operation
    {
        public static Operation<T> Create<T>(Func<T> process)
        {
            return new Operation<T> {Process = process};
        }

        public static Operation<TResult> Select<TSource, TResult>(
            this Operation<TSource> source, Func<TSource, TResult> result)
        {
            return new Operation<TResult>
                   {
                       Process = () => result(source.Process())
                   };
        }

        public static Operation<TResult> SelectMany<TSource, TInner, TResult>(
            this Operation<TSource> source,
            Func<TSource, Operation<TInner>> selecor,
            Func<TSource, TInner, TResult> result)
        {
            return new Operation<TResult>
                   {
                       Process =
                           () =>
                           {
                               var src = source.Process();

                               return result(src, selecor(src).Process());
                           }
                   };
        }
    }
}

if (customers.Any()) {
  grid.DataSource = customers;
  grid.DataBind();
} else {
  // ....
}

L>var customers = GetCustomers();
L>if (customers.Any()) {
L>  Console.WriteLine(customers.First().Name);
L>}
L>

var customer = GetCustomers().FirstOrDefault();
if (customer != null)
  Console.WriteLine(customer.Name);

def keyToValMap = Dectionary();
...
keyToValMap[Foo()] = Bar();

public class Student
{
    public int    StudentID { get; set; }
    public string FirstName { get; set; }
    public string LastName  { get; set; }

    [Association(ThisKey = "StudentID", OtherKey = "StudentID")]
    public Score[] Scores { get; set; }
}

public class Score
{
    public int StudentID { get; set; }
    public int Value     { get; set; }
}

public class StudentDB : DbManager
{
    public Table<Student> Student { get { return GetTable<Student>(); } }
}

static void Test()
{
    using (var db = new StudentDB())
    {
        var query =
            from Student student in db.Student
            where student.Scores.FirstOrDefault().Value > 95
            select student;

        foreach (Student s in query)
            Console.WriteLine(s.LastName + ": " + s.Scores[0]);
    }
}