Question

I have separate repository classes for each entity. Now I would like to implement few static methods on domain object which uses repository instance, but the drawback of this approach is that, I have to hold repository instance on the static variable(which not works well on web application) or I have to create new instance on each static method. Is there any better approach for this(i.e. to implement static method on domain class with repository instance)? please share your ideas.

Base repository:

public abstract class AbstractRepository<TEntity> : IabstractRepository<TEntity>
    where TEntity : EntityObject
{
    protected CivilRegistryEntities civilContext;

    public AbstractRepository()
    {
        civilContext = CivilRegistryEntities.Instance; // Per HTTP request singletone.
    }

    // Other method implementation goes here.
}

Per entity repository:

public class BirthReportRepository : AbstractRepository<BirthReport>
{

}

Domain/Entity/Model object:

public partial class BirthReport
{
    //Not works well in web application.
    private static BirthReportRepository repository = new BirthReportRepository();

    public static BirthReport Method1()
    {
        return repository.SomeMethod();
    }

    public static BirthReport Method2()
    {
        return repository.SomeOtherMethod();
    }

    // Other methods(both static and instance) goes here.
}

Answer 1

Static mutable state is horrible. Period. The repository contains a context and a context contains tons of mutable states. Besides that, contexts are supposed to have a short life cycle. And: I think that your domain classes should have nothing to do with repositories. This is pseudo encapsulation. Instead, let domain services handle Method1, method2.

You may consider using an IoC container to inject a context into your repositories and a repository into your domain services. The IoC container could also handle the life cycles of contexts and repositories. For web, an instance per request is common.