Q:

DbContext prematurely disposing when passed into another `using` block

I have one function that requires an active dbContext that is used in multiple places.  In some places the DbContext already exists so I pass it in and use it if it does:
public void DoStuff(){
     using (var db = new dbContext()){
         DoThings(db);
         db.SaveChanges(); // breaks, context was disposed
     }
  }

public void DoThings(DbContext optionalContext = null){
     using (var db = optionalContext ?? new dbContext()){
         DoInternalThings(db);
     }
  }

Is there any way to make this pattern work, or should I just make the optionalContext required and spin up the contexts from the calling functions?  Because then I end up with a bunch of this:
public void DoStuff(){
     using (var db = new dbContext()){
         DoThings(db);
         db.SaveChanges(); // breaks
     }
 }

 public void DoThings(){ // version without dbContext passed in - solely a wrapper - yuck!
     using (var db = new dbContext()){
         DoThings(db);
     }
 }

  public void DoThings(DbContext db){
       DoInternalThings(db);
  }

A:

You should not dispose an object that is passed into a function, because you do not own it and don't control its lifetime. Yes, spin up a context in a calling function and makes the context required, and it's up to you how to design that in a beautiful and convenient to use way.

