void SomeFunction()
{
StreamWriter someFile = new StreamWriter(somePath);
DisposableThing someDisposableThing1 = null;
DisposableThing someDisposableThing2 = null;
try
{
lock (someCriticalSection)
{
someDisposableThing1 = new DisposableThing();
DoSomething();
someDisposableThing2 = new DisposableThing();
lock (someOtherCriticalSection)
{
DoSomethingMore();
}
}
}
catch (Exception e)
{
Log(e);
}
finally
{
// requires SafeDispose extension method
someFile.SafeDispose();
someDisposableThing1.SafeDispose();
someDisposableThing2.SafeDispose();
}
}
public async Task RequestServicesAreDisposedAsynOnCompleted()
{
var serviceProvider = new AsyncDisposableServiceProvider(new ServiceCollection()
.AddTransient <DisposableThing>()
.BuildServiceProvider());
var scopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
DisposableThing instance = null;
var context = new DefaultHttpContext();
context.ServiceScopeFactory = scopeFactory;
var responseFeature = new TestHttpResponseFeature();
context.Features.Set <IHttpResponseFeature>(responseFeature);
Assert.NotNull(context.RequestServices);
Assert.Single(responseFeature.CompletedCallbacks);
instance = context.RequestServices.GetRequiredService <DisposableThing>();
var callback = responseFeature.CompletedCallbacks[0];
await callback.callback(callback.state);
Assert.Null(context.RequestServices);
Assert.True(instance.Disposed);
var scope = Assert.Single(serviceProvider.Scopes);
Assert.True(scope.DisposeAsyncCalled);
Assert.False(scope.DisposeCalled);
}
void SomeFunction()
{
StreamWriter someFile;
try
{
someFile = new StreamWriter(somePath);
lock (someCriticalSection)
{
using (var someDisposableThing1 = new DisposableThing())
{
DoSomething();
using (var someDisposableThing2 = new DisposableThing())
{
lock (someOtherCriticalSection)
{
DoSomethingMore();
}
}
}
}
}
catch (Exception e)
{
Log(e);
}
finally
{
if (someFile != null)
{
someFile.Dispose();
}
}
}
public static void UseDisposableThing()
{
using (var foo = new DisposableThing())
{
foo.DoSomething();
}
}
public async Task RequestServicesAreDisposedOnCompleted()
{
var serviceProvider = new ServiceCollection()
.AddTransient <DisposableThing>()
.BuildServiceProvider();
var scopeFactory = serviceProvider.GetRequiredService <IServiceScopeFactory>();
DisposableThing instance = null;
var middleware = new RequestServicesContainerMiddleware(
ctx =>
{
instance = ctx.RequestServices.GetRequiredService <DisposableThing>();
return(Task.CompletedTask);
},
scopeFactory);
var context = new DefaultHttpContext();
var responseFeature = new TestHttpResponseFeature();
context.Features.Set <IHttpResponseFeature>(responseFeature);
await middleware.Invoke(context);
Assert.NotNull(context.RequestServices);
Assert.Single(responseFeature.CompletedCallbacks);
var callback = responseFeature.CompletedCallbacks[0];
await callback.callback(callback.state);
Assert.Null(context.RequestServices);
Assert.True(instance.Disposed);
}
void ExecuteCriticalSection()
{
using (var someDisposableThing1 = new DisposableThing())
{
DoSomething();
ExecuteFinalCriticalSection();
}
}
void ExecuteFinalCriticalSection()
{
using (var someDisposableThing2 = new DisposableThing())
{
lock (someOtherCriticalSection)
{
DoSomethingMore();
}
}
}
public static IEnumerable <int> GetRandomNumbers()
{
var rand = new Random();
// can use "using" with yield
using (var dt = new DisposableThing())
{
while (true)
{
yield return(rand.Next());
}
}
}
public Task Send()
{
return(Task.Run(() =>
{
using (DisposableThing client = new DisposableThing())
{
using (DisposableThing message = DoAsync().Result)
{
DisposableThing resultAsString = DoTask().Result;
}
}
}));
}
void SomeFunction()
{
using (var someFile = new StreamWriter(somePath)) {
try {
lock (someCriticalSection) {
using (var someDisposableThing1 = new DisposableThing()) {
DoSomething();
}
}
} catch (Exception e) {
Log(e);
}
}
}
public static void UseDisposableThing()
{
try
{
using (Foo = new DisposableThing())
{
Foo.DoSomething();
}
}
finally
{
Foo = null;
}
}
