using Autofac;

using System;

using System.Linq;

using System.Linq.Expressions;

using NDatabase;

using NDatabase.Api;

​

public class Program {

    private static IContainer Container;

    public static void Main() {

        SetupDIContainer();

        // Com um DI container, o código diminui muito. =)

        var service = Container.Resolve<IUserService>();

        var userName = Guid.NewGuid().ToString("N") + "@userName";

        service.SaveUser(new User {

            UserName = userName,

            Email = userName + "@domain.com"

        });

        var user = service.GetUserByUserName(userName);

        // Dump é um método do DotNetFiddle que cria um gráfico do objeto.

        user.Dump();

    }

    private static void SetupDIContainer() {

        // Meu "Container Of Choice" - Autofac!

        var builder = new ContainerBuilder();

        builder

            .Register(context => OdbFactory.OpenInMemory())

            .As<IOdb>()

            .SingleInstance();

        builder

            .RegisterType<NDatabaseRepository>()

            .As<IRepository>()

            .SingleInstance();

        builder

            .RegisterType<UserService>()

            .As<IUserService>()

            .InstancePerDependency();

        Container = builder.Build();

    }

}

​

public interface IRepository {

    void Store<T>(T obj) where T : Entity;

    void Delete<T>(T obj) where T : Entity;

    T Get<T>(Expression<Func<T, bool>> expression) where T : Entity;

    IQueryable<T> List<T>() where T : Entity;

}

​

public class NDatabaseRepository : IRepository, IDisposable {

    private bool _disposed;

​

    // Fazemos o campo "readonly" para evitar que ele seja

    // atribuído novamente.

    private readonly IOdb _odb;

​

    public NDatabaseRepository(IOdb odb) {

        if (odb == null) {

            throw new ArgumentNullException("odb");

        }

        // Nos não iremos criar uma instância do container

        // mas iremos esperar que o que nos chamar indique

        // uma instância a ser utilizada.

        _odb = odb;

    }

    ~NDatabaseRepository() {

        Dispose(false);

    }

​

    public void Store<T>(T obj) where T : Entity {

        if (obj == null) {

            throw new ArgumentNullException("obj");

        }

        if (obj.ID == Guid.Empty) {

            obj.ID = Guid.NewGuid();

        }

        _odb.Store(obj);

    }

    public void Delete<T>(T obj) where T : Entity {

        if (obj == null) {

            throw new ArgumentNullException("obj");

        }

        var existingObj = List<T>().SingleOrDefault(_ => _.ID.Equals(obj.ID));

        if (existingObj == null) {

            return;

        }

        _odb.Delete(existingObj);

    }

    public T Get<T>(Expression<Func<T, bool>> expression) where T : Entity {

        if (expression == null) {

            throw new ArgumentNullException("expression");

        }

        return _odb.AsQueryable<T>().SingleOrDefault(expression);

    }

    public IQueryable<T> List<T>() where T : Entity {

        return _odb.AsQueryable<T>();

    }

    public void Dispose() {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

    protected virtual void Dispose(bool disposing) {

        if (_disposed) { return; }

        if (disposing) {

            if (!_odb.IsClosed()) {

                _odb.Close();

            }

        }

        _disposed = true;

    }

}

​

public interface IUserService {

    void SaveUser(User user);

    User GetUserByUserName(string userName);

}

​

public class UserService : IUserService {

    private readonly IRepository _repository;

    public UserService(IRepository repository) {

        if (repository == null) {

            throw new ArgumentNullException("repository");

        }

        _repository = repository;

    }

    public void SaveUser(User user) {

        if (user == null) {

            throw new ArgumentNullException("user");

        }

        _repository.Store(user);

    }

    public User GetUserByUserName(string userName) {

        if (string.IsNullOrWhiteSpace(userName)) {

            throw new ArgumentException("Parameter cannot be null, empty or white spaces.", "userName");

        }

        return _repository.Get<User>(_ => _.UserName.Equals(userName));

    }

}

​

public abstract class Entity {

    public Guid ID { get; set; }

}

​

public class User : Entity {

    public string UserName { get; set; }

    public string Email { get; set; }

}