Menu
Consider following code:
public class Test { public async Task Do() { await Task.Delay(200); using (var disposable = new Disposable()) { disposable.Do(); } } } public class Disposable : IDisposable { public void Do() { } public void Dispose() { } } When I run a code analysis in Visual studio I get a warning:
Warning CA1001 Implement IDisposable on Test.< Do>d__0 because it creates members of the following IDisposable types: 'Disposable'.
Why do I get this message? Disposable class is disposed correctly and I don't store it anywhere.
Furthermore this seems to be OK for analyzer:
public class Test { public void Do() { using (var disposable = new Disposable()) { disposable.Do(); } } } 
402
DisposeAsync() method when you need to perform resource cleanup, just as you would when implementing a Dispose method. One of the key differences, however, is that this implementation allows for asynchronous cleanup operations. The DisposeAsync() returns a ValueTask that represents the asynchronous disposal operation.
The async keyword turns a method into an async method, which allows you to use the await keyword in its body. When the await keyword is applied, it suspends the calling method and yields control back to its caller until the awaited task is complete.
A class that declares an IDisposable field indirectly owns an unmanaged resource. The class should implement the IDisposable interface to dispose of the unmanaged resource that it owns once the resource is no longer in use.
IAsyncDisposable isn’t a replacement for IDisposable, it’s an additional way to dispose. Basically, if you implement IAsyncDisposable in your class, you should probably implement IDisposable too and perform the synchronous equivalent of your disposal operation. myResource. Dispose (); await myResource. DisposeAsync ();
The IDisposable interface is defined as: In order to use the IDisposable interface, you would declare a class like this: public class MyClass : IDisposable { public void Dispose () { // Perform any object clean up here.
If any of the base classes in your inheritance chain implements the IDisposable interface, overrides void Dispose(), or overrides Finalize, you should simply override Dispose(bool disposing), adding your cleanup logic and making sure to call base.Dispose(disposing) as the last statement.
While the language implementations for asynchronous disposal are only available in netstandard2.1, there is a package from Microsoft that provides the IAsyncDisposable interface and related types for netstandard2.0 and .NET 4.6.1, Microsoft.Bcl.AsyncInterfaces (as David Fowler kindly pointed out to me in the Autofac PR).
That's because compiler generates state machine from your async method, and that state machine class (named <Do>d__0 in this case) contains field of type Disposable but does not itself implements IDisposable interface. It doesn't make much sense for analyzer to analyze compiler generated code (and this <Do>d__0 class is marked with CompilerGenerated attribute). Fortunately, there is a setting for code analyzer to avoid compiler generated code: go to project properties, "Code Analysis" tab and check "Suppress results from generated code", and this warning will go away.
105
If you look at the IL, you'll find that a class <Do>d__0 is created to handle the async stuff:
// Nested Types .class nested private auto ansi sealed beforefieldinit '<Do>d__0' extends [mscorlib]System.Object implements [mscorlib]System.Runtime.CompilerServices.IAsyncStateMachine { Later on, this class creates an instance of Disposable:
IL_0074: newobj instance void ConsoleApp1.Disposable::.ctor() That's the class that triggers CA1001 because CA1001 checks the IL, and the generated class does not implement IDisposable. You can safely disregard the CA1001 warning on this particular class.
44
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
