Dispose() will not be called automatically. If there is a finalizer it will be called automatically. Implementing IDisposable provides a way for users of your class to release resources early, instead of waiting for the garbage collector. The preferable way for a client is to use the using statement which handles automatic calling of Dispose() … Read more
Following the Inteface Segregation Principle of SOLID if you add the IDisposable to the interface you are giving methods to clients that are not interested in so you should add it to A. Apart from that, an interface is never disposable because disposability is something related with the concrete implementation of the interface, never with … Read more
There are different valid uses for IDisposable. A simple example is holding an open file, which you need to be closed at certain moment, as soon as you don’t need it any more. Of course, you could provide a method Close, but having it in Dispose and using pattern like using (var f = new … Read more
There’s nothing special about IDisposable here – but there is something special about iterators. Before C# 2, using this duck type on foreach was the only way you could implement a strongly-typed iterator, and also the only way of iterating over value types without boxing. I suspect that if C# and .NET had had generics … Read more
In fact this is two questions in one: When should I Dispose() of a context? What should be the lifespan of my context? Answers: Never 1. using is an implicit Dispose() in a try-finally block. A separate Dispose statement can be missed when an exception occurs earlier. Also, in most common cases, not calling Dispose … Read more
Calling the Dispose method is not required but you can still call it if you need for some reasons. Proof: HttpClient and lifetime management Disposal of the client isn’t required. Disposal cancels outgoing requests and guarantees the given HttpClient instance can’t be used after calling Dispose. IHttpClientFactory tracks and disposes resources used by HttpClient instances. … Read more
Dispose is called after the view is rendered, always. The view is rendered in the call to ActionResult.ExecuteResult. That’s called (indirectly) by ControllerActionInvoker.InvokeAction, which is in turn called by ControllerBase.ExecuteCore. Since the controller is in the call stack when the view is rendered, it cannot be disposed then.
The resolved objects have the same life-time/dispose cycle as their container, that’s unless you manually dispose the transient services in code using using statement or .Dispose() method. In ASP.NET Core you get a scoped container that’s instantiated per request and gets disposed at the end of the request. At this time, scoped and transient dependencies … Read more
No – default implementation of IDisposable pattern does not support it
Yes, Dispose will be called. It’s called as soon as the execution leaves the scope of the using block, regardless of what means it took to leave the block, be it the end of execution of the block, a return statement, or an exception. As @Noldorin correctly points out, using a using block in code … Read more