Transacciones con Entity Framework

Un ejemplo de uso podría ser:

using (ModelContextContainer context= new ModelContextContainer()) {
      context.Connection.Open();
      DbTransaction tx = context.Connection.BeginTransaction();
      
      //Operacion 1
      //.......

      context.SaveChanges();

      //Operacion 2
      //.......

      context.SaveChanges();


      tx.Commit();//aqui se salvan todas las operaciones
      context.Connection.Close();
}

Más información: Administrar conexiones y transacciones (Entity Framework)

Usar SQL en Entity Framework

Hay distintas posibilidades, a continuación se expondrán algunas de ellas:

1 – Se puede utilizar el método ExecuteStoreQuery para lanzar queries contra el origen de datos:

using (SchoolEntities context = new SchoolEntities())
{
    // Use the parameter substitution pattern.
    foreach (string name in context.ExecuteStoreQuery< string >
        ("Select Name from Department where DepartmentID < {0}", 5)) {
        Console.WriteLine(name);
    }

    // Use parameter syntax with object values.
    foreach (string name in context.ExecuteStoreQuery< string >
        ("Select Name from Department where DepartmentID < @p0", 5)) {
        Console.WriteLine(name);
    }
    // Use an explicit SqlParameter.
    foreach (string name in context.ExecuteStoreQuery< string >
        ("Select Name from Department where DepartmentID < @p0",
            new SqlParameter { ParameterName = "p0", Value = 5 })) {
        Console.WriteLine(name);
    }
}

2 - Otra forma sería usar el método translate para convertir un DbDataReader en (siguiente el ejemplo anterior) objetos del tipo Department.

3 - También tenemos el método ExecuteStoreCommand, que permite ejecutar comandos directamente contra el origen de datos: insert, update,...

4 - Otra posibilidad que nos permite Entity Framework consiste en crear una EntityConnection para usar un EntityCommand

NorthwindEntities context = new NorthwindEntities();
EntityConnection conn = new EntityConnection(context.Connection.ConnectionString);
conn.Open();
var sql = "SELECT VALUE emp FROM NorthwindEntities.Employees AS emp";
EntityCommand cmd = new EntityCommand(sql, conn);
DbDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess);
while (reader.Read()) {
  Console.WriteLine("{0} {1} {2} {3}", reader["EmployeeID"], reader["LastName"],
    reader["FirstName"], reader["Country"]);
}

Fuentes:
Cómo: Ejecutar directamente comandos contra el origen de datos en .Net Framework 4

Cómo ejecutar una consulta de Entity SQL parametrizada con EntityCommand

LINQ to Objects

Gracias a «LINQ to Objects» podemos hacer consultas LINQ directamente sobre cualquier colección IEnumerable o IEnumerable sin utilizar ninguna API o proveedor LINQ intermedio, como LINQ to SQL o LINQ to XML. Más Info

Un ejemplo de uso podría ser el que muestro a continuación:

  IEnumerable< Persona > persona = from p in personas.AsEnumerable()
                     where p.Name.StartsWith("S")
                     orderby p.Name
                     select p; 

Se realiza una consulta sobre una lista de personas que me devuelve todas aquellas personas cuyo nombre comienza por la letra S. Además, realiza una ordenación por nombre.
Persona: sería una clase con p.e. las propiedades Name, Apellidos, Edad.
List: podría ser la lista personas sobre la que hacemos la consulta.

Además, si se quiere se podría hacer algo mas amigable la consulta. Para por ejemplo no tener que escribir consultas muy grandes.

  Func< Persona, bool > func = delegate(Persona person){
         return person.Name.StartsWith("S");
  }
  IEnumerable< Persona > persona = (from p in personas.AsEnumerable() select p)
         .Where(func)
         .OrderBy< Persona, string >(per => per.Name); 

Aquí se realiza exactamente lo mismo que antes, con la diferencia de que he creado una función para evaluar las condiciones del Where (está función debe tener como mínimo un objeto de entrada y debe devolver bool).

En el ejemplo he utilizado un Where sobre una IEnumerable pero también se podría hacer lo mismo para IQueryable, usando Exressions en este caso.

public static IQueryable< TSource > Where< TSource >(
    this IQueryable< TSource > source,
    Expression< Func < TSource, bool > > predicate
)

public static IEnumerable< TSource > Where< TSource >(
    this IEnumerable< TSource > source,
    Func< TSource, bool > predicate
)