// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.MongoDbProvider.Repository(
                                                      new RepositoryOptions 
                                                      { 
                                                         ConnectionString = ConfigurationManager.AppSettings["MongoConnection"] 
                                                      }));

// Resolve IRepository (this may happen anywhere within application)
// Let's assume we have defined entity Category
var repo = ObjectContainer.Current.Resolve<IRepository>();
var category = repo.GetById<Category, int>(1000);
var categories = repo.GetByIdList<Category, int>(new[] { 1000, 1100 });

// Yarn provides a simple IoC container implementation
// One can easily override it with any DI framework 
// of choice by implementing IContainer
// The following code should be called on application startup
// in order to override IoC container
ObjectContainer.Initialize(() => new Any_IoC_Implementation_Based_On_IContainer());

// IRepository is instantiated using default constructor of Yarn.Data.EntityFrameworkProvider.Repository
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// IRepository is instantiated using parametrized constructor of Yarn.Data.EntityFrameworkProvider.Repository
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.EntityFrameworkProvider.Repository(
                                                      ObjectContainer.Current.Resolve<IDataContext<DbContext>>()));
  
// IRepository is instantiated unders a specific instance name
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.EntityFrameworkProvider.Repository(
                                                      ObjectContainer.Current.Resolve<IDataContext<DbContext>>()), "Lazy");

// IRepository is instantiated as a singleton
ObjectContainer.Current.Register<IRepository>(new Yarn.Data.EntityFrameworkProvider.Repository(
                                                      ObjectContainer.Current.Resolve<IDataContext<DbContext>>()));

// Resolved IRepository implementation
var repo = ObjectContainer.Current.Resolve<IRepository>();
// IRepository is resolved by instance name
var repo = ObjectContainer.Current.Resolve<IRepository>("Lazy");

// Bind IRepository to specific implementation (this should happen during application startup)
// For this example one must provide "EF.Default.Model" application setting and "EF.Default.Connection" connection string setting
// ("EF.Default.Model" points to an assembly which contains model class definition)
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.MongoDbProvider.Repository(
                                                      new RepositoryOptions 
                                                      { 
                                                         ConnectionString = ConfigurationManager.AppSettings["MongoConnection"] 
                                                      }), "mongo");
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.EntityFrameworkProvider.Repository(
                                                      ObjectContainer.Current.Resolve<IDataContext<DbContext>>()), "ef");

// Resolve IRepository (this may happen anywhere within application)
// "mongo" will resolve to MongoDB implementation, while "ef" will resolve to EF implementation
var repo = ObjectContainer.Current.Resolve<IRepository>("ef");
//var repo = ObjectContainer.Current.Resolve<IRepository>("mongo");
var category = repo.GetById<Category, int>(1000);

// With NHibernate one must specify implementation of the data context to be used with repository
// For this example one must provide "NHibernate.MySqlClient.Model" application setting 
// and "NHibernate.MySqlClient.Connection" connection string setting
ObjectContainer.Current.Register<IRepository>(() => new Yarn.Data.NHibernateProvider.Repository(
                                                  ObjectContainer.Current.Resolve<IDataContext<ISession>>("nh_uow_mysql")), "nh");
ObjectContainer.Current.Register<IDataContext<ISession>>(
  () => new Yarn.Data.NHibernateProvider.MySqlClient.MySqlDataContext(), "nh_uow_mysql");

// In order to use NHibernate with SQL Server one has to bind IDataContext to the SQL Server implementation
// Similarly to the MySQL example "NHibernate.SqlClient.Model" application setting 
// and "NHibernate.SqlClient.Connection" connection string setting should be defined
// ObjectContainer.Current.Register<IDataContext<ISession>>(() =>
                                                  new Yarn.Data.NHibernateProvider.SqlClient.Sql2012DataContext(), "nh_uow_sql");

var repo = ObjectContainer.Current.Resolve<IRepository>("nh");
var categories = repo.FindAll<Category>(c => c.Name.Contains("cat"), offset: 50, limit: 10);

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// Resolve IRepository (this may happen anywhere within application)
var repo = ObjectContainer.Current.Resolve<IRepository>();

// Create a specification to abstract search criteria
var spec = new Specification<Category>(c => c.Name.Contains("hello")).Or(c => c.Name.Contains("world"));
var categories = repo.FindAll<Category>(spec);

// Implement a cache provider to support caching of your choice
public class SimpleCache : ICacheProvider
{
  // Implementation goes here
}

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// Resolve IRepository (this may happen anywhere within application)
var repo = ObjectContainer.Current.Resolve<IRepository>();

// Initialize cache repository adapter
// Note: Cache adapter implements write-through cache for entity-related 
// operations and generational caching for queries
var cachedRepo = repo.WithCache<SimpleCache>();

// Create a specification to abstract search criteria
var spec = new Specification<Category>(c => c.Name.Contains("hello")).Or(c => c.Name.Contains("world"));

// This call produces a cache miss, hence the database is hit
var categories1 = cachedRepo.FindAll<Category>(spec);

// This call produces a cache hit, hence there will be no trip to the database
var categories2 = cachedRepo.FindAll<Category>(spec);

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// Resolve IRepository (this may happen anywhere within application)
var repo = ObjectContainer.Current.Resolve<IRepository>();

// Load customer with orders and order details
var customer = repo.As<ILoadServiceProvider>()
                  .Load<Customer>()
                  .Include(c => c.Orders)
                  .Include(c => c.Orders.Select(o => o.Order_Details))
                  .Find(c => c.CustomerID == "ALFKI");

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// Resolve IRepository (this may happen anywhere within application)
var repo = ObjectContainer.Current.Resolve<IRepository>();

// Merge customer changes with customer data from the database
// Yarn will attempt to merge only the changes specified by the navigation paths
// Note: currently only EF, NHibernate and Nemo providers implement this functionality
var mergedCustomer = repo.As<ILoadServiceProvider>()
                  .Load<Customer>()
                  .Include(c => c.Orders)
                  .Include(c => c.Orders.Select(o => o.Order_Details))
                  .Update(customer);

// Auditable adapter will automatically populate audit information 
// when calling Add/Update for all entities which implement IAuditable interface
var repo = ObjectContainer.Current.Resolve<IRepository>().WithAudit(Thread.CurrentPrincipal);

// Soft-delete adapter will automatically re-write Remove as Update 
// and will filter all deleted records out on retrieve for all entities
// which implement ISoftDelete interface
var repo = ObjectContainer.Current.Resolve<IRepository>().WithSoftDelete(Thread.CurrentPrincipal);

// Multi-tenancy adapter will automatically filter tenant related data as well 
// as check tenant ownership when calling Add, Update and Remove for all entities 
// which implement ITenant interface
// Note: the following example assumes Thread.CurrentPrincipal implements ITenant interface
var repo = ObjectContainer.Current.Resolve<IRepository>().WithMultiTenancy((ITenant)Thread.CurrentPrincipal);

// Fail-over adapter can use an alternative repository if one becomes unavailable
// Once the fail-over happens, the repo adapter will stick to that one until it becomes unavailable
// Updates however are sent to both repositories
// Note: one can use it with more than two repository implementations by chaining
var repo = ObjectContainer.Current.Resolve<IRepository>().WithFailover(ObjectContainer.Current.Resolve<IRepository>("no-sql"));

// It is also possible to chain the adapters
// Note: IPrincipal parameter is optional for soft-delete and auditable adapters
var repo = ObjectContainer.Current.Resolve<IRepository>().WithSoftDelete().WihAudit();

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();

// Resolve IRepository (this may happen anywhere within application)
var repo = ObjectContainer.Current.Resolve<IRepository>();

// As of now bulk operations are implemented by EF and Mongo providers only
var bulk = repo.As<IBulkOperationsProvider>();

// Bulk retrieve
var customers = bulk.GetById<Customer, string>(new[] { "ALFKI", "ANTON"  });

// Bulk delete by id
bulk.Delete<Customer, string>(new[] { "ALFKI", "ANTON"  });

// Bulk delete
bulk.Delete<Customer>(c => c.City == "London");

// Bulk update
bulk.Update<Customer>(c => c.City == "New York", c => new Customer { City = c.City + " City" });

public class LogInterceptor : IDisposable
{
  private readonly ILog logger = LogManager.GetLogger("my-log");
  private readonly Stopwatch sw;
  
  public LogIntercetor(InterceptorContext ctx)
  {
    sw = Stopwatch.StartNew();
    logger.Info("Begin " + ctx.Method.Name);
    ctx.Execute();
  }
  
  public void Dispose()
  {
    sw.Stop();
    logger.Info("End " + ctx.Method.Name + ", " + sw.Elapsed.TotalMilliseconds + " ms");  
  }
}

// Interceptor will automatically intercept all methods
var repo = ObjectContainer.Current.Resolve<IRepository>().WithInterceptor(ctx => new LogInterceptor(ctx));

// Bind IRepository to specific implementation (this should happen during application startup)
ObjectContainer.Current.Register<IRepository, Yarn.Data.EntityFrameworkProvider.Repository>();
ObjectContainer.Current.Register<ICustomerRepository, CustomerRepository>();

public interface ICustomerRepository : IEntityRepository<Customer, string>
{
    IQueryResult<Order> GetOrders(string id);
}

public class CustomerRepository : ICustomerRepository
{
    private readonly IRepository _repo;

    public CustomerRepository(IRepository repo)
    {
        _repo = repo;
    }

    public IQueryResult<Customer> Find(ISpecification<Customer> criteria)
    {
        var customer = _repo.Find(criteria);
        var items = customer != null ? new[] { _repo.Find(criteria) } : new Customer[] { };
        return new QueryResult<Customer>(items, customer != null ? 1 : 0 );
    }

    public IQueryResult<Customer> GetAll()
    {
        return new QueryResult<Customer>(_repo.FindAll(new Specification<Customer>(c => true)), 
                                          _repo.Count<Customer>());
    }

    public Customer GetById(string id)
    {
        return _repo.GetById<Customer, string>(id);
    }

    public IQueryResult<Order> GetOrders(string id)
    {
        return new QueryResult<Order>(_repo.FindAll<Order>(o => o.CustomerID == id), 
                                      _repo.Count<Order>(o => o.CustomerID == id));
    }

    public void Remove(Customer entity)
    {
        _repo.Remove(entity);
    }

    public Customer Remove(string id)
    {
        return _repo.Remove<Customer, string>(id);
    }

    public bool Save(Customer entity)
    {
        return _repo.As<ILoadServiceProvider>().Load<Customer>().Update(entity) != null;
    }
}