Wrappers related to Reuse

[jods4]

Other DIs have wrappers that affect Reuse, which are esp. useful combined with Func wrapper, for example:

• Scoped<T>: IDisposable will create a new scope, provide T Value in this scope, and dispose the whole scope when it's disposed itself.
• Owned<T> contains a transient T Value of a type that might be registered with Reuse other than transient. Because it's transient you're responsible for disposing it if required.

They make more sense when you think of them as Func<Scoped<T>> and Func<Owned<T>> or similar.

I have read the docs about Reuse and my understanding is that Func<T> actually works partly like Owned: its return value is never tracked for disposal; but it still reuses instances (multiple calls for a singleton per scope would always return the same instance), am I correct?

First wrapper is probably easy to create as:

class Scoped<T> : IDisposable
{
  private IResolverContext scope;

  public Scoped<T>(IResolverContext context)
  {
    scope = context.OpenScope();
    Value = scope.Resolve<T>();
  }

  public T Value { get; } 
  public void Dispose() => scope.Dispose();
}

Although I'm not sure how to write Owned.

PS: does [ServiceKey] work on RegisterDelegate the same way it does in ctor parameters?

[jods4]

I did more research and testing.

The Scoped wrapper can be created as above, or alternatively it can be registered with openResolutionScope: true and inject IResolverContext just for disposal.

I still haven't found a solution to create something like Func<Owned<T>>, and would love some advice.

The use case is this:

• You register as Scoped a commonly used service such as an EF DbContext, or an open SqlConnection, so that all components have easy access to it during a request execution and they're disposed automatically at the end.
• For some advanced use cases, you'd like to be able to create and control additional instances in the same scope. For example maybe you want a second SqlConnection to perform actions in a different transaction.

Ideally you'd inject Func<SqlConnection> for this purpose, but DryIoc will still return the same scoped instance.
This is where other DI containers sometimes provide Func<Owned<SqlConnection>> for this purpose.

Things that almost work:

• I thought New<T>() might be it, but it actually respects existing registrations (what's the difference with Resolve when T is registered then?)
• Rule WithIgnoringReuseForFuncWithArgs almost does Func<Owned<T>> by default on Func<T> but only when there are arguments!

[dadhi]

Hi @jods4

You probably need this one: https://github.com/dadhi/DryIoc/blob/master/docs/DryIoc.Docs/ReuseAndScopes.md#own-the-resolution-scope-disposal

Here how could you write your Owned

DryIoc/src/DryIoc.Syntax.Autofac/AutofacSyntax.cs

Line 494 in 1e4228c

public class Owned<T> : IDisposable

And register it like this:

DryIoc/src/DryIoc.Syntax.Autofac/AutofacSyntax.cs

Line 69 in 1e4228c

Container.Register(typeof(Owned<>),

For more info, you may look into https://github.com/dadhi/DryIoc/blob/1e4228c3d984e2b64aecd89d8c998ab0fb7b15a4/docs/DryIoc.Docs/FaqAutofacMigration.md
and maybe even use https://www.nuget.org/packages/DryIoc.Syntax.Autofac.dll/2.0.0-preview-02 which code for Owned
I've referenced above.

[jods4]

Not quite, I'm more interested in Grace Owned than AutoFac.
What you suggest is basically Scoped<T> in Grace: it creates a new scope to resolve T.
Owned<T> creates new, untracked instances inside the current scope.
The difference is subtle but it could have consequences on dependencies of T?

I am not too attached to re-creating Owned and maybe you have other ideas. My main use-case is not to track a disposable myself, but to be able to create additional instances of a service that is registered as scoped in the container.

[jods4]

Just for added context, I found another common use-case for Owned in our codebase (I'm making a transition toward a dedicated Factory singleton type as a replacement).

We also sometimes inject Owned<T> into Singletons when they need a T to perform an operation during construction but don't hold on to it.
With default DryIoC configuration it wouldn't work (injecting Scoped T without an open scope), and rightly so as the Scoped instance would be kept alive forever by root container.

[dadhi]

@jods4

I thought New() might be it, but it actually respects existing registrations (what's the difference with Resolve when T is registered then?)

New creates the service using the dependencies registered in container, without polluting the container of any information about the service itself.

Rule WithIgnoringReuseForFuncWithArgs almost does Func<Owned> by default on Func but only when there are arguments!

Interesting observation, I will test it and get back to you.

[jods4]

Interesting observation, I will test it and get back to you.

I'm on the fence about using it, but maybe it makes sense.
If something is a singleton or even scoped, why would you inject a Func<T> when you can inject T directly, Considering there's Lazy<T> as well?

The two conflicting use-cases that I see are using Func<T, ...> to create the singleton with specific arguments and using Scope Context, so Func<T> can be used to create scoped singletons in nested scopes.

[jods4]

Just FYI, I replaced my Owned<T> uses with dedicated factory classes, like IHttpClientFactory can be used to create extra HttpClient that are not tracked by DI. I didn't have too many types T so it wasn't a big deal.