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

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

SELECT
    [student].[StudentID],
    [student].[FirstName],
    [student].[LastName]
FROM
    [Student] [student]
WHERE
    (
        SELECT
            [t1].[Value]
        FROM
            [Score] [t1]
        WHERE
            [student].[StudentID] = [t1].[StudentID]
    ) > 95

var query =
    from Student student in db.Student
    where student.Scores.Max(s => s.Value) > 95
    select student;

SELECT
    [student].[StudentID],
    [student].[FirstName],
    [student].[LastName]
FROM
    [Student] [student]
WHERE
    (
        SELECT
            Max([t1].[Value])
        FROM
            [Score] [t1]
        WHERE
            [student].[StudentID] = [t1].[StudentID]
    ) > 95

оттуда их можно спокойно выдернуть SQL запросом, который отработает на сервере, который всё соптимизирует, закэширует и т. д. Зачем мне самому держать коллекции, к которым потом обращаться через заново изобретенный SQL и не забывать синхронизировать с базой?

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

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

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

var customers = GetCustomers()

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

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

L>>Почему не Customer[], Collection<Customer>, HashSet<Customer> или List<Customer>?

for(int i=0; i < customers.Count(); i++) {
  Consolw.WriteLine("{0}: {1}", i, customers.ElementAt(i).Name);
}

L>>>Если customers — IEnumerable, полученный из linq-овского запроса, то на 1000 customer-ах получили 2000 запросов в базу. Если просто лист — то ни одного.

var arr  = new[] { new { String = "", Int = 1 } };
var list = arr.ToList();

List<T> GetCustomers<T>(T[] arr)
{
    return arr.ToList();
}

var arr  = new[] { new { String = "", Int = 1 } };
var list = GetCustomers(arr);

IT>> Всякие пишем. Я не вижу никаких проблем в написании методов с таким поведением.

IEnumerable<T> ValidateAndConvert<T>(this IEnumerable<string[]>, Func<string[]>,T>);

var customers = GetCustomers();
foreach (var customer in customers)
{
  Output(customer.Name);
}

var customers = GetCustomers();
for (int i = 0; i < customers.Length; ++i)
{
  Output(customers[i].Name);
}

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

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

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

class Quaternion
{
    // ...
    public EulerAngles Angles
    {
        get
        {
            var zDirection = this.Rotate(new Vector3(0, 0, 1));    // Vector3, т.к. операция, это поворот вектора кватернионом
            var projectedZDirection = new Vector3(zDirection.X, 0, zDirection.Z);    // Vector3, очевидно

            if (projectedZDirection.Length > 0.0001)
            {
                var normalizedProjectedZDirection = projectedZDirection.Normalized;    // Vector3, т.к. нормализованный проецированный вектор
                var yaw = CalculateAngle(normalizedProjectedZDirection.Z, normalizedProjectedZDirection.X);    // float, т.к. Yaq это угол Эйлера.

                var rotationWithoutYaw = Quaternion.RotationY(-yaw) * this;    // Quaternion, т.к. произведение кватернионов, это кватернион
                var zDirectionWithoutYaw = rotationWithoutYaw.Rotate(new Vector3(0, 0, 1));    // И т.д.
                var pitch = CalculateAngle(zDirectionWithoutYaw.Z, -zDirectionWithoutYaw.Y);

                var xDirectionWithoutYaw = rotationWithoutYaw.Rotate(new Vector3(1, 0, 0));
                var roll = CalculateAngle(xDirectionWithoutYaw.X, xDirectionWithoutYaw.Y);

                return new EulerAngles(yaw, pitch, roll);
            }
            else
            {
                var pitch = zDirection.Y > 0 ? -90 : 90;

                var xDirection = this.Rotate(new Vector3(1, 0, 0));
                var normalizedProjectedXDirection = new Vector3(xDirection.X, 0, xDirection.Z).Normalized;
                var yaw = CalculateAngle(normalizedProjectedXDirection.X, normalizedProjectedXDirection.Z);

                var rotationWithoutYawPitch = Quaternion.RotationX(-pitch) * Quaternion.RotationY(-yaw) * this;
                var xDirectionWithoutYawPitch = rotationWithoutYawPitch.Rotate(new Vector3(1, 0, 0));
                var roll = CalculateAngle(xDirectionWithoutYawPitch.X, xDirectionWithoutYawPitch.Y);

                return new EulerAngles(yaw, pitch, roll);
            }
        }
    }
    // ...
}

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

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

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

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