#!c#
// using IQueryableDataFacade (this assignment is trivial, here It must be used the custom implementation)
IQueryableDataFacade facade = new MyQueryableDataFacade(); 

// Get entity by Id (id is an object, the underlying implementation must be know how come use this parameter as entity identifier)
User user = facade.Get<User>(user.Id);

// Exists logic applying an expression which returns a boolean
bool match = facade.Exists<User>(us => us.Name == "name parameter");

// Tries to find an unique instance from source, if there are many matches results throws an exception
User user = facade.UniqueResult<User>(us => us.CF == "CF parameter");

// Tries to find instances from source with the given criteria
IEnumerable<User> users = facade.ApplyWhere<User>(us => us.Name == "name parameter");

// Tries to find instances using IQueryable<User> function, you can apply some custom / complex logic on filtering
IEnumerable<User> users = facade.ExecuteExpression<User>(usr => usr.Where(us => us.Name == "name parameter"));

// Tries to find instances using like previous IQueryable<User> function, but using a custom output transformation
// in output I will have an List<dynamic>
var users = facade.ExecuteExpression<User, List<dynamic>>(usr => usr
                      .Where(us => us.Name == "name parameter")
                      .Select(ss => new { ss.Name, ss.Surname })
                      .ToList());

// Tries to find instances using like previous IQueryable<User> function, but in this case using anonymous result, 
// Note how the function is built inline on method.
var users = facade.ExecuteExpression((IQueryable<User> usr) => usr
                      .Where(us => us.Name == "name parameter")
                      .Select(ss => new { ss.Name, ss.Surname, ss.Birthdate })
                      .ToList());

With this approach, It's possible to read anonymous data, and take advantage of intellisense.

#!c#
IQueryableDataFacade facade = ...;

var isolation = IsolationLevel.ReadCommitted;

// create an instance
using (var tran = facade.BeginTransaction(new TransactionDescriptor { Name = "create-instance", Isolation = isolation }))
{
    facade.MakePersistent<User>(new User());

    // Commit must be called in order to persist isntance, otherwise the given transaction rollbacks implicitly.
    tran.Commit();
}

// create many instances
IEnumerable<User> users = GetUsersToPersist();

using (var transaction = facade.BeginTransaction(new TransactionDescriptor { Isolation = IsolationLevel.ReadCommitted }))
{
    facade.MakePersistent<User>(users);
    transaction.Commit();
}

// delete instance
using (var tran = facade.BeginTransaction(new TransactionDescriptor { Name = "delete-instance", Isolation = isolation }))
{
    facade.MakeTransient<User>(user.Id);
    tran.Commit();
}

// you can use transaction Scopes in order to create a transaction root 
using (
    var rootTran = new TransactionScope(TransactionScopeOption.Required,
        new TransactionOptions {IsolationLevel = isolation, Timeout = TimeSpan.FromSeconds(240)}))
{
    using (var tran1 = facade.BeginTransaction(new TransactionDescriptor { Name = "delete-instance", Isolation = isolation }))
    {
        facade.MakePersistent(instance);
        tran1.Commit();
    }

    using (var tran2 = new TransactionScope())
    {
        // all another kinds of unit of works
        // if this transaction is not Completed correctly, root transaction cannot be commitable.
    }

    // needed in order to render atomic all inner transactions
    rootTran.Complete();
}

#!c#
// a default usage to create a transaction from facade.
using (var tran2 = facade.BeginTransaction())
{
    // all another kinds of unit of works
    // if this transaction is not Completed correctly, root transaction cannot be commitable.
}

// you can specify a transaction descriptor
User instance = GetUserToPersist();
var isolation = IsolationLevel.ReadCommitted;

using (var tran1 = facade.BeginTransaction(new TransactionDescriptor { Name = "create-or-update-instance", Isolation = isolation }))
{
    facade.MakePersistent(instance);
    tran1.Commit();
}