Provide a new object instance in every method of a class?

Question

Lets say I want to use, for example, a new DbContext object whenever a method is called in a class but without getting it by a parameter. Like so

class MyClass {
    public virtual void MethodOne() {
        // Having automatically a new instance of DbContext
    }

    public virtual void MethodTwo() {
        // Also having automatically a new instance of DbContext
    }
}

What I was really hoping for was a DI way of doing this. Like public void Method(IMyWayOfContext context).

class MyClass {
    public virtual void MethodOne(IMyWayOfContext context)) {
    }

    public virtual void MethodTwo(IMyWayOfContext context) {
    }
}

Other classes inheriting from this class must be provided with a new instance of dbcontext. That's why I don't want to create a new instance inside of the function

If you dont want it as a parameter, just make it the first line of each method.. — BugFinder, Mar 03 '17 at 10:28
http://stackoverflow.com/questions/18740421/default-parameter-for-value-must-be-a-compile-time-constant — iPhantomGuy, Mar 03 '17 at 10:30
I've updated the question. I'm looking for a DI -type of answer — Rikard Olsson, Mar 03 '17 at 10:33

Baldrick · Accepted Answer · 2017-03-03T11:59:39.067

You could do something like this (generic interface, plus a wrapper with multiple constraints):

class DBContext{ }

interface IDoesMethods<TContext> where TContext : new()
{
    void MethodOne(TContext context = default(TContext));
    void MethodTwo(TContext context = default(TContext));
}


class MyClass : IDoesMethods<DBContext>
{
    public void MethodOne(DBContext context)
    {            
    }

    public void MethodTwo(DBContext context)
    {            
    }
}

class MyContextWrapper<TClass, TContext> : IDoesMethods<TContext> where TContext : new() where TClass : IDoesMethods<TContext>, new()
{
    public void MethodOne(TContext context = default(TContext))
    {
        instance.MethodOne(new TContext());        
    }

    public void MethodTwo(TContext context = default(TContext))
    {
        instance.MethodTwo(new TContext());
    }

    private TClass instance = new TClass();
}

class Program
{
    static void Main(string[] args)
    {
        var wrapper = new MyContextWrapper<MyClass, DBContext>();
        wrapper.MethodOne();
        wrapper.MethodTwo();
    }
}

You're welcome. Note I've updated it to not need the `class` constraint, and use `default(T)` instead of `null`. This is cleaner, and means the wrapper will work for value as well as reference types. — Baldrick, Mar 03 '17 at 12:00

Simeon Vanov · Answer 2 · 2017-03-03T10:41:39.783

Make a property with only getter that will return new instance every time

   protected DbContext MyDBContext 
   {
       get 
       { 
         return new DbContext(); 
       }
   }

EDIT: If you want some kind of dependency injection you can make your class generic and pass to instance of the class what type of context you want

class MyClass<T> {

    protected DbContext MyDBContext 
    {
       get 
       { 
          return Activator.CreateInstance<T>();
       }
    }

    public void MethodOne() {
        // Having automatically a new instance of DbContext
    }

    public void MethodTwo() {
        // Also having automatically a new instance of DbContext
    }
}

score 0 · Answer 3 · answered Mar 03 '17 at 10:57

Your simple solution can work this way:

class MyClass {
    protected DbContext InternalContext {
        return new DbContext();
    }

    public virtual void MethodOne(DbContext dc = null) {
        if(dc == null)
            dc = InternalContext;
        // do your work
    }

    public virtual void MethodTwo(DbContext dc = nnull) {
        if(dc == null)
            dc = InternalContext;
        // do your work
    }
}

In that case, you have to take care of disposing InternalContext

score 0 · Answer 4 · answered Mar 03 '17 at 18:19

While answer here looks valid, they don't seem to fulfill perfectly your requirement of having a solution that rely on DI.

DI in it's simplest expression is most of the time achieve with Constructor Injection.

Your design was already good and DI ready. Indeed, asking for dependencies via the constructor is good. It is at the composition root of your application that you need to decide what implementation you need to pass.

Using a DI library can help (but it is not required to enable DI).

With your actual class design:

class MyClass {
   public virtual void MethodOne(IMyWayOfContextFactory contextFactory)) {
      using(var context = contextFactory.Create()){
          //play with context
      }
   }
   public virtual void MethodTwo(IMyWayOfContextFactory contextFactory) {
      using(var context = contextFactory.Create()){
          //play with context
      }
   }
}

public ContextFactory : IMyWayOfContextFactory {
     IMyWayOfContext Create(){
        return new MyWayOfContext();
     }
}

Without a factory and with a DI container like SimpleInjector, you could have:

class MyClass {
   public virtual void MethodOne(IMyWayOfContext context)) {
          //play with context
   }
   public virtual void MethodTwo(IMyWayOfContext context) {
          //play with context       
   }
}

And register your component once at the composition root with configurable Lifestyle management:

container.Register<IMyWayOfContext, MyWayOfContext>(Lifestyle.Transient);

The latter approach is simpler if you want to configure when to inject what instance of your context. Indeed, such configuration is built in an DI Container library. For instance, see: Lifestyle of component with SimpleInjector

Nice! If I'm trying to implement this in a custom library, what is considering being the root? — Rikard Olsson, Mar 04 '17 at 12:29
A library does not have a composition root. Only application do. Check this article on the subject: http://blog.ploeh.dk/2011/07/28/CompositionRoot/ — plog17, Mar 04 '17 at 13:03
In your library you definetly want to have DI in place. Different type of application will have different configuration needed but your librairie should not have to change for that. — plog17, Mar 04 '17 at 13:08
Okey, great! Thanx for your answer as well, it made me rethink. I'll probably look into SimpleInjector lib and will try to implement with that — Rikard Olsson, Mar 04 '17 at 13:11
I've got right now three projects. Two of em are .net libs and the third is an asp.net core app. One of the libs has a custom DbContext class that I would like to use in a DI way and that's why the question. Im already using DI between the core app and the second lib, injecting repository classes — Rikard Olsson, Mar 04 '17 at 13:41

Provide a new object instance in every method of a class?

4 Answers4

With your actual class design:

Without a factory and with a DI container like SimpleInjector, you could have: