Небольшая справка. PI – это давняя идея, о которой я впервые услышал при знакомстве с CORBA-ой. Ее суть заключается в том, что программист должен работать с «чистой» объектной моделью, а слой персистентности (это изобретение человеческой мысли даже назвать, то по русски трудно) «прозрачно» для программиста хранит данные в БД. При этом программист думает об объекте как о долгоживущей сущности. Объект (в мыслях программиста) живет дольше чем какое либо приложение им манипулирующее, будь то Web-страница или сервер приложений. В общем, программист манипулирует объектом (или их коллекциями), а подсистема персистентности сама когда надо сохраняет его состояние в персистентом хранилище (которым обычно выступает СУБД, но с точки зрения чисто идеологии может выступать все что угодно). Иногда на эту идею смотрят как на «объектизацию» БД, в том смысле, что программист думает, что в БД хранятся объекты (в полном понимании ООП).

update StoreItem set Available = Available - OrderItem.Amount, Reserved = Reserved + OrderItem.Amount
from StoreItem inner join OrderItem on StoreItem.ProductID = OrderItem.ProductId
where OrderItem.OrderID = @OrderId and StoreItem.Available >= OrderItem.Amount;

update set c.Name = "Новое имя" from c in customers where c.id = 123;

var cutomer1 = ...;
update set c.Name = "Новое имя" set c.Bonus = c.Bonus + 1; 
   from c in customers 
   where c is cutomer1;

var cutomer1 = ...;
var oldName = cutomer1.SelectedData_Name; // данные когда-то полученные с сервера для свойства Name
update set c.Name = "Новое имя" set c.Bonus = c.Bonus + 1; 
   from c in customers 
   where c is cutomer1
     and c.Name == oldName; // старое

var cutomer1 = ...;
var oldName = cutomer1.SelectedData_Name; // данные когда-то полученные с сервера для свойства Name
update set c.Bonus = c.Bonus + 1; 
   from c in customers 
   where (from o in orders where c.Total > 1000m select o.CustomerId)
   .Distinct().Contains(c.id)

//Нахождение "компонент связности" графа. Принимает список ребер графа.
// Возвращает список компонент, в компоненте список вершин.
//если ребра(связи) повторяются то тоже будет работать правильно.
public static List<List<TVertex>> FindConnectivityComponents<TVertex>(IEnumerable<Pair<TVertex, TVertex>> Links) 
    where TVertex: class
{
    Links = Links.Concat(    //добавляем обратные связи
        Links.Select(l => new Pair<TVertex, TVertex> { First = l.Second, Second= l.First })   
        ); 
    Dictionary<TVertex, Pair<TVertex, int>> markedVertexDict =   //ключ-вершина, значение-маркированая вершина
        Links.Select(l => l.First).Distinct()
        .Select(vertex => new Pair<TVertex, int> { First = vertex, Second = 0 })    //превращаем в маркированую
        .ToDictionary(markedVertex => markedVertex.First)
        ;
    var adjucentLists =   //ключ-маркированая вершина, значение-список примыкающих маркированых вершин 
        Links.ToLookup(l => markedVertexDict[l.First], l => markedVertexDict[l.Second]);

    int componentNum = 1;
    foreach (var vertex in markedVertexDict.Values)
        MarkConnectedVertexesRecursive(vertex, componentNum++, adjucentLists);
    return
        markedVertexDict.Values
        .GroupBy(v => v.Second, v => v.First) //(ключ-номер компоненты, значение-вершина)
        .Select(grouping => grouping.ToList())
        .ToList();
}
//Маркирует числом markWithNumber вершины начиная с startVertex, рекурсивно все связаные с ней.
private static void MarkConnectedVertexesRecursive<TVertex>(
    Pair<TVertex, int> startVertex,
    int markWithNumber,
    ILookup<Pair<TVertex, int>, Pair<TVertex, int>> graphAsAdjacentLists)
{
    if (startVertex.Second != 0) //уже прошлись по этой вершине
        return;
    startVertex.Second = markWithNumber;
    foreach (Pair<TVertex, int> linked in graphAsAdjacentLists[startVertex])
        MarkConnectedVertexesRecursive(linked, markWithNumber, graphAsAdjacentLists);
}

string GenerateSetClauseFromExpression<T>(Expression<Func<T, T>> expr)
{
    var parameter = expr.Parameters[0];
    var memberInit = expr.Body as MemberInitExpression;

    return String.Join(", ",
               memberInit.Bindings
               .OfType<MemberAssignment>()
               .Select(a => a.Member.Name + " = " + ExpressionToSql(a.Expression))
               .ToArray()
           );
}

Dictionary<ExpressionType, string> binaryOps = new Dictionary<ExpressionType, string>()
{
    {ExpressionType.Add, "+"},
    {ExpressionType.Subtract, "-"},
    {ExpressionType.Multiply, "*"},
    {ExpressionType.Divide, "/"},
};


string ExpressionToSql(Expression e)
{

    var constantExpression = e as ConstantExpression;
    if (constantExpression != null)
    {
        return ToSqlString(constantExpression.Value);
    }

    try
    {
        Expression<Func<object>> lambda = Expression.Lambda<Func<object>>(Expression.Convert(e, typeof(object)), new ParameterExpression[0]);
        return ToSqlString(lambda.Compile()());
    }
    catch (Exception)
    {

        var member = e as MemberExpression;
        if (member != null)
        {
            var param = member.Expression as ParameterExpression;
            if (param != null)
            {
                return (member.Member as System.Reflection.PropertyInfo).Name;
            }
        }

        var binary = e as BinaryExpression;
        return ExpressionToSql(binary.Left) + binaryOps[binary.NodeType] + ExpressionToSql(binary.Right);
    }

}

string ToSqlString(object o)
{
    if (o is string)
    {
        return "'" + o + "'";
    }
    else
    {
        return o.ToString();
    }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

static void Main(string[] args)
{
    var setClause = GenerateSetClauseFromExpression<Person>(p => new Person() { Name = "aaa", Age = p.Age + 1 });
    Console.WriteLine("update Persons set {0}", setClause);
}

using(context.Batch()) //extension-метод Batch() вполне можно сделать как для Linq to SQL, так и для EF
{
    var q = from c in context.Customers where c.Id == 1;
    foreach(var customer in q)
    {
      c.Name = "aaa";
    }
}

using(context.Batch())
{
    update c in context.Customers where c.Id == 1 set c.Name = "aaa"; //Предположим что так можно написать
}

T>А ты не молчи, ты расскажи.

Код должен быть поменян, а данные — нет.
(с) IB

T>>>Ну тогда еще проще — уменьшаем кол-во проходов цикла до минимума и комплексити падает.

T>код поскипан
T>

if (condition1())
  action1();
else if (condition2())
  action2();
...
else if (conditionN())
  actionN();

var q = from Customers c select c;

if (minRegistrationDate.HasValue)
  q = from q c where c.RegistrationDate >= RegistrationDate.Value
      select c;

VD>>Microsoft сделала неправильный O/R Mapper (по-русски это будет звучать вроде объектно-реляционные отображальники ). С точки зрения поклонников Hibernate, Microsoft сделал не полноценный O/R Mapper, так как он не предоставляет мощной и законченной подсистемы Persistence Ignorance (PI),

using (myDb.BeginTran())
{
  insert into myDb.TableA values(1, 2, "test");
  delete from myDb.TableA where Col1 = 2;
}

VD>>Единственное, что меня радует – это то, что Microsoft-таки показала, как интегрировать ER-подход с современными объектно-ориентированными языками с функциональным уклоном, и кто-то из посторонних сможет реализовать, казалось бы, такие напрашивающиеся для LINQ insert, update и delete. Жаль, что, в отличие от Nemerle, такие языки, как C# и VB, не позволяют расширить свой синтаксис чтобы бесшовно ввести эти операторы в язык. Но хотя бы в виде процедур, принимающих условия в виде деревьев выражений, их можно добавить в любой язык. Продаю идею .

T>Viva la Nemerle!

Не согласен. Есть походы вредные и не нужные. Вот императивная обработка объектов отображаемых на БД — это идея вредная и не нужная. К сожалению, с легкой руки тех самых Корба и EJB она проела плеш очень многим и эти многие уже и представить себе не могут альтернативный подход.

T>>>Не забывай добавлять "в простых (а потому нежизненных) сценарих". Все равно нужно будет делать валидацию/проверку прав/аудит, тут-то объект у вас в память и заползет.

var someQuery = from el in collection where ... select c;//такое уже есть
delete from c in collection where ... //Сложно?
update c in collection where ... set c.Prop1 = val1, c.Prop2 = val2 //Тоже не очень мудрено
insert into collection2 (someQuery) //любое выражение типа IEnumerable<T> в скобках

T>>>Ну приплыли.

G>>var someQuery = from el in collection where ... select c;//такое уже есть
G>>delete from c in collection where ... //Сложно?
G>>update c in collection where ... set c.Prop1 = val1, c.Prop2 = val2 //Тоже не очень мудрено
G>>insert into collection2 (someQuery) //любое выражение типа IEnumerable<T> в скобках
G>>

T>Ничего сложного, но где здесь security, валидация, аудит?

//Предположим что здесь запрос, выполняющий резервирование
//Выборка кастомера, материализация не требуется
var cust = from c in context.Customers 
           where c.Id == customerId
           where c.Category.Name == "VIP"
           select c;

//Теперь валидационный запрос, выполняется в тойже транзакции что и предыдущие
from ..... //Выборка зарезервированных позиций
where (условие остатки < 0) && !cust.Any()
select context.ThrowError() //context.ThrowError - функция в БД, которая кидает ошибку и откатывает транзакцию.