Hi Guys,

How would you go about this if you had an extra layer, such as a simple repository? So would you pass an IScope to the repository to initialise it?

Say it was like this very simplified example:

public class MyRepo
{
    private readonly IScope _scope;

    public MyRepo(IScope scope)
    {
        this._scope = scope;
    }

    public IEnumerable<string> GetUserNames()
    {
        return this._scope.Database.Fetch<string>("SELECT userName FROM umbracoUser ORDER BY userName");
    }

    public IEnumerable<int> GetIds()
    {
        return this._scope.Database.Fetch<int>("SELECT id FROM cmsContent");
    }
}

How would you initialise the repository once? Could you do it in the Controller's constructor like this, which doesn't seem right?

public class MyController : RenderMvcController
{
    private IScopeProvider _scopeProvider;
    private MyRepo _myRepo;

    public MyController(IScopeProvider scopeProvider)
    {
        this._scopeProvider = scopeProvider;

        using (var scope = _scopeProvider.CreateScope())
        {
            _myRepo = new MyRepo(scope);
        }
    }

    public ActionResult GetSomeUserNames(ContentModel model)
    {
        var names = _myRepo.GetUserNames();

        return CurrentTemplate(model);
    }

    public ActionResult GetSomeId(ContentModel model)
    {
        var ids = _myRepo.GetIds();

        return CurrentTemplate(model);
    }
}

Or would you need to initialise the scope in every call in the controller eg.

public ActionResult GetSomeUserNames(ContentModel model)
{
    using (var scope = _scopeProvider.CreateScope())
    {
        _myRepo = new MyRepo(scope);
        var names = _myRepo.GetUserNames();
        scope.Complete();
    }

    return CurrentTemplate(model);
}

Or is there some other better way? Can you access this AmbientScope you mentioned? Maybe someway of using DI to register the repo?

Hi Stephen,

OK, so I've created MyRespository like you suggested, so it takes a IScopeAccessor. I've then registered it as a singleton like this:

public class MyRepoComposer : IUserComposer
{
    public void Compose(Composition composition)
    {
        composition.RegisterUnique<IMyRepository, MyRepository>();
    }
}

I've then injected the IMyRepository into the constructor of a controller (just to test!).

However, in MyRepository the _scopeAccessor.AmbientScope is null.

The bit I don't quite get is how you create the ambient scope as in your example. You say "in order to user it you'll need to create an ambient scope" but I'm not clear where _scopeProvider is coming from in your example.

Assume I have a controller that injects my repo like this:

private readonly IMyRepository _myRepo;

public MyController(IMyRepository myRepo)
{
   this._myRepo = myRepo;
}

How do I then use that repository in controller methods so I have an ambient scope? eg. how would the following work?

 public ActionResult DoSomething()
 {
      _myRepo.DoSomething();
 }

PS. Sorry for all the questions!

You need an ambient scope:

public ActionResult DoSomething()
{
  using (var scope = _scopeProvider.CreateScope())
  {
    _myRepo.DoSomething();
  }
}

Thanks, but where does _scopeProvider come from? How does that get into the controller?

Inject!

public class MyController
{
  private readonly IScopeProvider _scopeProvider;

  public MyController(IScopeProvider scopeProvider)
  {
    _scopeProvider = scopeProvider;
  }
}

Hi Dan,

my copied from the core, and simplified a bit serivce / repo looks like this :

So my services are inheriting something like :

public class MyBaseService<TModel>
{
        protected readonly ILogger logger;
        protected IMyBaseRepoRepository<TModel> baseRepo;
        protected IScopeProvider scopeProvider;

        public TranslationServiceBase(
            IScopeProvider scopeProvider,
            IMyBaseRepoRepository<TModel> baseRepo,
            ILogger logger)
        {
            this.scopeProvider = scopeProvider;
            this.logger = logger;
            this.baseRepo = baseRepo;
        }

        public virtual TModel Get(int id)
        {
            using(scopeProvider.CreateScope(autoComplete: true))
            {
                return baseRepo.Get(id);
            }
        }
}

and my repositories are inheriting this (slightly more complex and this is where the ambient scope is created ... inside the repository class

protected MyRepositoryBase(
        IScopeAccessor scopeAccessor, 
        ILogger logger,
        string tableName)
    {
        this.scopeAccessor = scopeAccessor;
        this.logger = logger;
        this.tableName = tableName;
    }

    protected string tableName;

    protected readonly ILogger logger;
    protected readonly IScopeAccessor scopeAccessor;

    protected IScope AmbientScope
    {
        get
        {
            var scope = scopeAccessor.AmbientScope;
            if (scope == null)
                throw new InvalidOperationException("Cannot run repository without an Ambient scope");
            return scope;
        }
    }

    protected IUmbracoDatabase Database => AmbientScope.Database;

    protected ISqlContext SqlContext => AmbientScope.SqlContext;
    protected Sql<ISqlContext> Sql() => SqlContext.Sql();
    protected ISqlSyntaxProvider SqlSyntax => SqlContext.SqlSyntax;

    /// ... repository methods ...

then something like get looks like (using custom GetBaseQuery / GetBaseWhereClause functions)

 public virtual TModel Get(int id)
    {
        var sql = GetBaseQuery(false)
            .Where(GetBaseWhereClause(), new { Id = id });

        var dto = Database.FirstOrDefault<TDTOModel>(sql);

        if (dto == null) return default(TModel);

        return Mapper.Map<TModel>(dto);
    }

I think this is right (taking into consideration the autoclose stuff stephen mentioned)

Thanks, just after posting I did just that and it does work. So thanks for your help! :)

But.... but....

It doesn't seem quite right to me that you need to remember to wrap every call to the repo in a scope otherwise it fails. What if someone else injects it and doesn't do that?

So another developer comes along, injects IMyRepository and then calls _myRepo.DoSomething() and boom it blows up and they've no idea why. Isn't there a way you can just call MyRepo without needing to know or worry about scope?

You are also able to control how a database Connection behaves this way in .Net Framework, so it’s not unheard of.

But I agree it’s not very SOLID

The general pattern is that you don't expose your repository to "general other developers" - you expose services, which internally create scopes and invoke repositories.

Whoever uses the repository directly should know about the constraint.

At least that's how it works in Core.

OK, yeah, I get that to an extent. You might not make your repository layer public but only expose it internally via a service layer (I was trying to keep this example simple). But it still feels wrong to me that the consumer of a class needs to know to wrap it before calling it. Isn't this known as temporal coupling, which I thought should be avoided?

In my case I'm just looking at a small package that has a few database calls, and having multiple tiers seems a little OTT, as basically the service layer would just be calling each method in the repo, but having to wrap each call in a scope, which just seems like a lot of unnecessary code to me.

Is having a repo DI'd in this instance even a good idea? Maybe the service later should be, but maybe not the repo? I guess I'd just like some guidance on the best way for package makers to proceed with stuff like this.

Hello Kevin, I was just about to test this since I am extending my current Umbraco database.

I'm kinda stuck here because I can't get a grip of the whole scenario.

In your "MyRepositoryBase" - Why would you have repository methods there? (Why isn't the repository methods in each repository? example ProductRepository/ UserRepository?

Where is the "Public virtual TModel Get(int id) ? Where should this be run? in a controller or a handler/manager?

Is the only purpose of "MyRepositoryBase" to validate and set up the properties for instantiating the database?

Thanks!

Hi Alexander,

Yeah out of context i can see how that is confusing, the MyRepositoryBase class would be inherited by your ProductRepository or UserRepository, its just that the base get methods could then be shared between them.

i have a slightly more detailed version in a git hub repo : https://github.com/KevinJump/DoStuffWithUmbraco/tree/master/Src/DoStuff.Core/RepoPattern

that hopefully allows you to see it in context.

Hello Kevin!

Alright, now I see how they are connected. Thank you so much! :)

Regarding DI.. How would you inject the generic types?

BaseRepository<TModel> : IBaseRepository<TModel> where TModel : class

Right now I'm getting the "Make sure that the controller has a parameterless public constructor" Since I'm using the repository directly from my controller.

Do you have any ideas on how I set this up correctly in the compositons?

Just checking - is this OK.

using (var scope = _scopeProvider.CreateScope(autoComplete: true))
{
  _myRepository.DoSomething();
}

The autoComplete parameter makes it a bit neater - but i am sort of assuming it works

Thanks, Stephen, I could see that initialising the repo with the scope was wrong, just wasn't sure of the best alternative. I did try and look at some of the core stuff, but it was quite complex for my needs. I'll try your approach you mentioned.

No problem - following this thread, as it may turn into a blog post - lots of "obviously not obvious" things that you are discovering here.