I like instantiating my WCF service clients within a `using` block as it&#39;s pretty much the standard way to use resources that implement `IDisposable`:

    using (var client = new SomeWCFServiceClient()) 
    {
        //Do something with the client 
    }

But, as noted in [this MSDN article][1], wrapping a WCF client in a `using` block could mask any errors that result in the client being left in a faulted state (like a timeout or communication problem). Long story short, when `Dispose()` is called, the client&#39;s `Close()` method fires, but throws an error because it&#39;s in a faulted state. The original exception is then masked by the second exception. Not good.

The suggested workaround in the MSDN article is to completely avoid using a `using` block, and to instead instantiate your clients and use them something like this:

    try
    {
        ...
        client.Close();
    }
    catch (CommunicationException e)
    {
        ...
        client.Abort();
    }
    catch (TimeoutException e)
    {
        ...
        client.Abort();
    }
    catch (Exception e)
    {
        ...
        client.Abort();
        throw;
    }

Compared to the `using` block, I think that&#39;s ugly. And a lot of code to write each time you need a client.

Luckily, I found a few other workarounds, such as this one on the (now defunct) IServiceOriented blog. You start with:

    public delegate void UseServiceDelegate&lt;T&gt;(T proxy); 
    
    public static class Service&lt;T&gt; 
    { 
        public static ChannelFactory&lt;T&gt; _channelFactory = new ChannelFactory&lt;T&gt;(&quot;&quot;); 
        
        public static void Use(UseServiceDelegate&lt;T&gt; codeBlock) 
        { 
            IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel(); 
            bool success = false; 
            try 
            { 
                codeBlock((T)proxy); 
                proxy.Close(); 
                success = true; 
            } 
            finally 
            { 
                if (!success) 
                { 
                    proxy.Abort(); 
                } 
            } 
         } 
    } 

Which then allows:

    Service&lt;IOrderService&gt;.Use(orderService =&gt; 
    { 
        orderService.PlaceOrder(request); 
    }); 

That&#39;s not bad, but I don&#39;t think it&#39;s as expressive and easily understandable as the `using` block.

The workaround I&#39;m currently trying to use I first read about on [blog.davidbarret.net][2]. Basically, you override the client&#39;s `Dispose()` method wherever you use it. Something like:

    public partial class SomeWCFServiceClient : IDisposable
    {
        void IDisposable.Dispose() 
        {
            if (this.State == CommunicationState.Faulted) 
            {
                this.Abort();
            } 
            else 
            {
                this.Close();
            }
        }
    }

This appears to be able to allow the `using` block again without the danger of masking a faulted state exception. 

So, are there any other gotchas I have to look out for using these workarounds? Has anybody come up with anything better?


  [1]: http://msdn.microsoft.com/en-us/library/aa355056.aspx
  [2]: http://blog.davidbarrett.net/archive/2007/11.aspx

What is the best workaround for the WCF client `using` block issue?

[System.Net.Http.HttpClient](http://msdn.microsoft.com/en-us/library/hh193681.aspx) and [System.Net.Http.HttpClientHandler](http://msdn.microsoft.com/en-us/library/system.net.http.httpclienthandler.aspx) in .NET Framework 4.5 implement IDisposable (via [System.Net.Http.HttpMessageInvoker](http://msdn.microsoft.com/en-us/library/system.net.http.httpmessageinvoker.aspx)).

The [`using` statement documentation]((http://msdn.microsoft.com/en-us/library/yh598w02.aspx)) says:

&gt; As a rule, when you use an IDisposable object, you should declare and
&gt; instantiate it in a using statement.

[This answer](https://stackoverflow.com/a/12374486/376366) uses this pattern:

    var baseAddress = new Uri(&quot;http://example.com&quot;);
    var cookieContainer = new CookieContainer();
    using (var handler = new HttpClientHandler() { CookieContainer = cookieContainer })
    using (var client = new HttpClient(handler) { BaseAddress = baseAddress })
    {
        var content = new FormUrlEncodedContent(new[]
        {
            new KeyValuePair&lt;string, string&gt;(&quot;foo&quot;, &quot;bar&quot;),
            new KeyValuePair&lt;string, string&gt;(&quot;baz&quot;, &quot;bazinga&quot;),
        });
        cookieContainer.Add(baseAddress, new Cookie(&quot;CookieName&quot;, &quot;cookie_value&quot;));
        var result = client.PostAsync(&quot;/test&quot;, content).Result;
        result.EnsureSuccessStatusCode();
    }

But the most visible examples from Microsoft don&#39;t call `Dispose()` either explicitly or implicitly. For instance:

* The [original blog article](http://blogs.msdn.com/b/henrikn/archive/2012/02/16/httpclient-is-here.aspx) announcing the relase of HttpClient.
* The actual [MSDN documentation](http://msdn.microsoft.com/en-us/library/system.net.http.httpclient.aspx) for HttpClient.
* [BingTranslateSample](http://aspnet.codeplex.com/SourceControl/changeset/view/9cb7243bd9fe3b2df484bf2409af943f39533588#Samples/HttpClient/BingTranslateSample/Program.cs)
* [GoogleMapsSample](http://aspnet.codeplex.com/SourceControl/changeset/view/9cb7243bd9fe3b2df484bf2409af943f39533588#Samples/HttpClient/GoogleMapsSample/Program.cs)
* [WorldBankSample](http://aspnet.codeplex.com/SourceControl/changeset/view/9cb7243bd9fe3b2df484bf2409af943f39533588#Samples/HttpClient/WorldBankSample/Net45/Program.cs)

In the [announcement](http://blogs.msdn.com/b/henrikn/archive/2012/02/16/httpclient-is-here.aspx)&#39;s comments, someone asked the Microsoft employee:

&gt; After checking your samples, I saw that you didn&#39;t perform the dispose
&gt; action on HttpClient instance. I have used all instances of HttpClient
&gt; with using statement on my app and I thought that it is the right way
&gt; since HttpClient  implements the IDisposable interface. Am I on the
&gt; right path?

His answer was:

&gt; In general that is correct although you have to be careful with
&gt; &quot;using&quot; and async as they dont&#39; really mix in .Net 4, In .Net 4.5 you
&gt; can use &quot;await&quot; inside a &quot;using&quot; statement.
&gt; 
&gt; Btw, you can reuse the same HttpClient as many times are [as] you like so
&gt; typically you won&#39;t create/dispose them all the time.

The second paragraph is superfluous to this question, which is not concerned about how many times you can use an HttpClient instance, but about if it is necessary to dispose it after you no longer need it.

(Update: in fact that second paragraph is the key to the answer, as provided below by @DPeden.)

So my questions are:

1. Is it necessary, given the current implementation (.NET Framework 4.5), to call Dispose() on HttpClient and HttpClientHandler instances? Clarification: by &quot;necessary&quot; I mean if there are any negative consequences for not disposing, such as resource leakage or data corruption risks.

2. If it&#39;s not necessary, would it be a &quot;good practice&quot; anyway, since they implement IDisposable?

3. If it&#39;s necessary (or recommended), is [this code](https://stackoverflow.com/a/12374486/376366) mentioned above implementing it safely (for .NET Framework 4.5)?

4. If these classes don&#39;t require calling Dispose(), why were they implemented as IDisposable?

5. If they require, or if it&#39;s a recommended practice, are the Microsoft examples misleading or unsafe?

Do HttpClient and HttpClientHandler have to be disposed between requests?

I am working on a project. I have to compare the contents of two files and see if they match each other precisely.

Before a lot of error-checking and validation, my first draft is:

      DirectoryInfo di = new DirectoryInfo(Environment.CurrentDirectory + &quot;\\TestArea\\&quot;);
      FileInfo[] files = di.GetFiles(filename + &quot;.*&quot;);

      FileInfo outputFile = files.Where(f =&gt; f.Extension == &quot;.out&quot;).Single&lt;FileInfo&gt;();
      FileInfo expectedFile = files.Where(f =&gt; f.Extension == &quot;.exp&quot;).Single &lt;FileInfo&gt;();

      using (StreamReader outFile = new StreamReader(outputFile.OpenRead()))
      {
        using (StreamReader expFile = new StreamReader(expectedFile.OpenRead()))
        {
          while (!(outFile.EndOfStream || expFile.EndOfStream))
          {
            if (outFile.ReadLine() != expFile.ReadLine())
            {
              return false;
            }
          }
          return (outFile.EndOfStream &amp;&amp; expFile.EndOfStream);
        }
      }


It seems a little odd to have nested `using` statements.

Is there a better way to do this?

Nested using statements in C#

User [kokos][1] answered the wonderful *[Hidden Features of C#][2]* question by mentioning the `using` keyword. Can you elaborate on that? What are the uses of `using`?

  [1]: https://stackoverflow.com/users/1065/kokos
  [2]: https://stackoverflow.com/questions/9033/hidden-features-of-c


What are the uses of &quot;using&quot; in C#?

In a MySQL `JOIN`, what is the difference between `ON` and `USING()`? As far as I can tell, `USING()` is just more convenient syntax, whereas `ON` allows a little more flexibility when the column names are not identical. However, that difference is so minor, you&#39;d think they&#39;d just do away with `USING()`.

Is there more to this than meets the eye? If yes, which should I use in a given situation?

MySQL JOIN ON vs USING?

What is the purpose of the `Using` block in C#? How is it different from a local variable?

What is the C# Using block and why should I use it?

For example, I rarely need:

    using System.Text;

but it&#39;s always there by default. I assume the application will use more memory if your code contains unnecessary [using directives][1]. But is there anything else I should be aware of?

Also, does it make any difference whatsoever if the same using directive is used in only one file vs. most/all files?

&lt;hr&gt;

*Edit: Note that this question is not about the unrelated concept called a [using statement][2], designed to help one manage resources by ensuring that when an object goes out of scope, its [IDisposable.Dispose][3] method is called. See [Uses of &quot;using&quot; in C#][4].*


  [1]: http://msdn.microsoft.com/en-us/library/aa664764(VS.71).aspx
  [2]: http://msdn.microsoft.com/en-us/library/yh598w02.aspx
  [3]: http://msdn.microsoft.com/en-us/library/system.idisposable.dispose.aspx
  [4]: https://stackoverflow.com/questions/75401/uses-of-using-in-c

Why should you remove unnecessary C# using directives?

DataSet and DataTable both implement IDisposable, so, by conventional best practices, I should call their Dispose() methods.

However, from what I&#39;ve read so far, DataSet and DataTable don&#39;t actually have any unmanaged resources, so Dispose() doesn&#39;t actually do much.

Plus, I can&#39;t just use `using(DataSet myDataSet...)` because DataSet has a collection of DataTables.

So, to be safe, I&#39;d need to iterate through myDataSet.Tables, dispose of each of the DataTables, then dispose of the DataSet.

So, is it worth the hassle to call Dispose() on all of my DataSets and DataTables?

**Addendum:**

For those of you who think that DataSet should be disposed:
In general, the pattern for disposing is to use `using` or `try..finally`, because you want to guarantee that Dispose() will be called.

However, this gets ugly real fast for a collection.  For example, what do you do if one of the calls to Dispose() thrown an exception?  Do you swallow it (which is &quot;bad&quot;) so that you can continue on to dispose the next element?

Or, do you suggest that I just call myDataSet.Dispose(), and forget about disposing the DataTables in myDataSet.Tables? 

Should I Dispose() DataSet and DataTable?

Is it safe to use the `using` statement on a (potentially) null object?  
Consider the following example:

    class Test {
        IDisposable GetObject(string name) {
            // returns null if not found
        }
        
        void DoSomething() {
            using (IDisposable x = GetObject(&quot;invalid name&quot;)) {
                if (x != null) {
                     // etc...
                }
            }
        }
    }

Is it guaranteed that `Dispose` will be called only if the object is not null, and I will not get a `NullReferenceException`?


Will Dispose() be called in a using statement with a null object?

I&#39;m having a look at a couple of the [new features in][1] C# 6, specifically, 
_&quot;using static&quot;_.

&gt; _**using static** is a new kind of using clause that lets you import static members of types directly into scope._  
&gt; &lt;sub&gt;(Bottom of the blog post)&lt;/sub&gt;

The idea is as follows, according to a couple of tutorials I found,  
Instead of:

    using System;

    class Program 
    { 
        static void Main() 
        { 
            Console.WriteLine(&quot;Hello world!&quot;); 
            Console.WriteLine(&quot;Another message&quot;); 
        } 
    }

You can omit the repeated `Console` statement, using the new C# 6 feature of using static classes:

    using System.Console;
    //           ^ `.Console` added.
    class Program 
    { 
        static void Main() 
        { 
            WriteLine(&quot;Hello world!&quot;); 
            WriteLine(&quot;Another message&quot;); 
        } // ^ `Console.` removed.
    }

However, this doesn&#39;t appear to be working for me. I&#39;m getting an error on the `using` statement, saying:

&gt; _&quot;A &#39;`using namespace`&#39; directive can only be applied to namespaces; &#39;`Console`&#39; is a type not a namespace. Consider a &#39;`using static`&#39; directive instead&quot;_

I&#39;m using visual studio 2015, and I have the build language version set to _&quot;C# 6.0&quot;_

What gives? Is the msdn blog&#39;s example incorrect? Why doesn&#39;t this work?

---

The blog post has now been updated to reflect the latest updates, but here&#39;s a screenshot in case the blog goes down:

&gt;[![blog][3]][2]


  [1]: http://blogs.msdn.com/b/csharpfaq/archive/2014/11/20/new-features-in-c-6.aspx
  [2]: https://i.stack.imgur.com/by29I.png
  [3]: https://i.stack.imgur.com/by29Im.png

How do I use the C#6 &quot;Using static&quot; feature?

**First question:**  
Say I have 

    using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();

        string storedProc = &quot;GetData&quot;;
        SqlCommand command = new SqlCommand(storedProc, connection);
        command.CommandType = CommandType.StoredProcedure;
        command.Parameters.Add(new SqlParameter(&quot;@EmployeeID&quot;, employeeID));

        return (byte[])command.ExecuteScalar();
    }

Does the connection get closed? Because technically we never get to the last `}` as we `return` before it.


**Second question:**  
This time I have:

    try
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            int employeeID = findEmployeeID();

            connection.Open();
            SqlCommand command = new SqlCommand(&quot;UpdateEmployeeTable&quot;, connection);
            command.CommandType = CommandType.StoredProcedure;
            command.Parameters.Add(new SqlParameter(&quot;@EmployeeID&quot;, employeeID));
            command.CommandTimeout = 5;

            command.ExecuteNonQuery();
        }
    }
    catch (Exception) { /*Handle error*/ }

Now, say somewhere in the `try` we get an error and it gets caught. Does the connection still get closed? Because again, we skip the rest of the code in the `try` and go directly to the `catch` statement.


Am I thinking too linearly in how `using` works? ie Does `Dispose()` simply get called when we leave the `using` scope?



in a &quot;using&quot; block is a SqlConnection closed on return or exception?

Returning a method value from **inside** a using statement that gets a DataContext seems to always work **fine**, like this:

    public static Transaction GetMostRecentTransaction(int singleId)
    {
        using (var db = new DataClasses1DataContext())
        {
            var transaction = (from t in db.Transactions
                                  orderby t.WhenCreated descending
                                  where t.Id == singleId
                                  select t).SingleOrDefault();
            return transaction;
        }
    }

But I always feel like I should be **closing something** before I break out of the using brackets, e.g. by defining transaction **before** the using statement, get it&#39;s value **inside** the brackets, and then returning **after** the brackets. 

**Would defining and returning the variable outside the using brackets be better practice or conserve resources in any way?**




Are there any side effects of returning from inside a using() statement?

I&#39;m wondering if there are any reasons (apart from tidying up source code) why developers use the &quot;Remove Unused `Usings`&quot; feature in Visual Studio 2008?


Why remove unused using directives in C#?

Visual Studio will automatically create using statements for you whenever you create a new page or project. Some of these you will never use.

Visual Studio has the useful feature to &quot;remove unused usings&quot;.

I wonder if there is any negative effect on program performance if the using statements which are never accessed, remain mentioned at the top of the file.

How is performance affected by an unused using directive?

Per my other [question here about Disposable objects][1], should we call Close() before the end of a using block?

    using (SqlConnection connection = new SqlConnection())
    using (SqlCommand command = new SqlCommand())
    {
    	command.CommandText = &quot;INSERT INTO YourMom (Amount) VALUES (1)&quot;;
    	command.CommandType = System.Data.CommandType.Text;
    
    	connection.Open();
    	command.ExecuteNonQuery();
    
    	// Is this call necessary?
    	connection.Close();
    }


  [1]: https://stackoverflow.com/questions/1033334/is-there-a-list-of-common-object-that-implement-idisposable-for-the-using-stateme

Do I have to Close() a SQLConnection before it gets disposed?

I just want to know is it safe/ good approach to call `return` inside a `using` block.

For ex.

    using(var scope = new TransactionScope())
    {
      // my core logic
      return true; // if condition met else
      return false;
      scope.Complete();
    }

We know the at the last most curly brace  `dispose()` will get called off. But what will be in the above case, since `return` jumps the control out of the given scope (AFAIK)...

1. Is my `scope.Complete()` get called?
2. And so for the scope&#39;s `dispose()` method.

Is it a good approach to call return inside using {} statement?

C# lets me do the following (example from MSDN):

    using (Font font3 = new Font(&quot;Arial&quot;, 10.0f),
                font4 = new Font(&quot;Arial&quot;, 10.0f))
    {
        // Use font3 and font4.
    }

What happens if `font4 = new Font` throws? From what I understand font3 will leak resources and won&#39;t be disposed of.

 - Is this true? (font4 won&#39;t be disposed of)
 - Does this mean `using(... , ...)` should be avoided altogether in favor of nested using?

Can &quot;using&quot; with more than one resource cause a resource leak?

    class C {
      using namespace std;  // error
    };
    namespace N {
      using namespace std; // ok
    }
    int main () {
      using namespace std; // ok
    }

I want to know the motivation behind it.


Why is &quot;using namespace X;&quot; not allowed at class/struct level?

I have next method:

    public async Task&lt;IEnumerable&lt;Quote&gt;&gt; GetQuotesAsync()
    {
        using var connection = new SqlConnection(_connectionString);

        var allQuotes = await connection.QueryAsync&lt;Quote&gt;(@&quot;SELECT [Symbol], [Bid], [Ask], [Digits] FROM [QuoteEngine].[RealtimeData]&quot;);

        return allQuotes;
    }

Everything fine and clear, connection will be disposed at the end of scope.

But resharper suggests to change it to:

    public async Task&lt;IEnumerable&lt;Quote&gt;&gt; GetQuotesAsync()
    {
        await using var connection = new SqlConnection(_connectionString);

        var allQuotes = await connection.QueryAsync&lt;Quote&gt;(@&quot;SELECT [Symbol], [Bid], [Ask], [Digits] FROM [QuoteEngine].[RealtimeData]&quot;);

        return allQuotes;
    }

It adds await before using and code is compiled successfully. What does it mean and when do we need to do that?

C# 8 understanding await using syntax

I wrote the below code in order to explain my issue. If I comment the line 11 (with the keyword &quot;using&quot;), the compiler does not compile the file and displays this error: `invalid conversion from &#39;char&#39; to &#39;const char*&#39;`. It seems to not see the method `void action(char)` of the `Parent` class in the `Son` class. 
 
Why the compiler behave this way? Or have I done something wrong?

    class Parent
    {
    	public:
    		virtual void action( const char how ){ this-&gt;action( &amp;how ); }
    		virtual void action( const char * how ) = 0;
    };
    
    class Son : public Parent
    {
    	public:
    		using Parent::action; // Why should i write this line?
    		void action( const char * how ){ printf( &quot;Action: %c\n&quot;, *how ); }
    };
    
    int main( int argc, char** argv )
    {
    	Son s = Son();
    	s.action( &#39;a&#39; );
    	return 0;
    }

Why should I use the &quot;using&quot; keyword to access my base class method?

Are there particular instances where I should (or shouldn&#39;t?) be using &quot;using&quot; blocks:

    using(SomeType t = new SomeType()){
        ...
    }




When should I use &quot;using&quot; blocks in C#?

This was a telephone interview question I had: Is there a time when Dispose will not be called on an object whose scope is declared by a using block?

My answer was no - even if an exception happens during the using block, Dispose will still be called.

The interviewer disagreed and said if `using` is wrapped in a `try`-`catch` block then Dispose will not be called by the time you enter the catch block.

This goes contrary to my understanding of the construct, and I haven&#39;t been able to find anything that backs up the interviewers point of view. Is he correct or might I have misunderstood the question?


Is there a situation in which Dispose won&#39;t be called for a &#39;using&#39; block?

If I have the following situation:

    StreamWriter MySW = null;
    try
    {
       Stream MyStream = new FileStream(&quot;asdf.txt&quot;);
       MySW = new StreamWriter(MyStream);
       MySW.Write(&quot;blah&quot;);
    }
    finally
    {
       if (MySW != null)
       {
          MySW.Flush();
          MySW.Close();
          MySW.Dispose();
       }
    }

Can I just call &lt;code&gt;MySW.Dispose()&lt;/code&gt; and skip the Close even though it is provided?  Are there any Stream implimentations that don&#39;t work as expected (Like CryptoStream)?

If not, then is the following just bad code:

    using (StreamWriter MySW = new StreamWriter(MyStream))
    {
       MySW.Write(&quot;Blah&quot;);
    }

Does Stream.Dispose always call Stream.Close (and Stream.Flush)

What is the use of `using namespace std`? 

I&#39;d like to see explanation in Layman terms.

What is the use of &quot;using namespace std&quot;?

In Java is there an equivalent to the [C# &quot;using&quot; statement][1] allowing to define a scope for an object:

    using (AwesomeClass hooray = new AwesomeClass())
    {
       // Great code
    }


  [1]: http://msdn.microsoft.com/en-us/library/yh598w02(VS.80).aspx

&quot;using&quot; keyword in java

If an Exception happens within a using statement does the object still get disposed?

The reason why I&#39;m asking is because I&#39;m trying to decide on whether to put a try caught around the whole code block or within the inner using statement. Bearing in mind certain exceptions are being re-thrown by design within the catch block.

    using (SPSite spSite = new SPSite(url))
    {
       // Get the Web
       using (SPWeb spWeb = spSite.OpenWeb())
       {
           // Exception occurs here
       }
    }

If an Exception happens within a using statement does the object still get disposed?

It has been my understanding that the [`using` statement][1] in .NET calls an `IDisposable` object&#39;s `Dispose()` method once the code exits the block.

Does the `using` statement do anything else? If not, it would seem that the following two code samples achieve the exact same thing:

	Using Con as New Connection()
		Con.Open()
		&#39;do whatever &#39;
	End Using

	Dim Con as New Connection()
	Con.Open()
	&#39;do whatever &#39;
	Con.Dispose()

I will give the best answer to whoever confirms that I am correct or points out that I am wrong and explains why. Keep in mind that I am aware that certain classes *can do different things* in their `Dispose()` methods. This question is about whether or not the `using` statement achieves the exact same result as calling an object&#39;s `Dispose()` method.

  [1]: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/using-statement

Using statement vs. IDisposable.Dispose()

Is it safe (and correct) in a C++ header file to use the using declaration within a namespace as follows:

    #include &lt;boost/numeric/ublas/vector.hpp&gt;
    namespace MyNamespace {
        using boost::numeric::ublas::vector;
        vector MyFunc(vector in);
    }

I.e. is the &quot;using boost::numeric::ublas::vector&quot; properly contained within the MyNamespace block, or will this pollute the namespace of any file that includes this header?

scope of using declaration within a namespace

I&#39;ve written my own custom data layer to persist to a specific file and I&#39;ve abstracted it with a custom DataContext pattern.

This is all based on the .NET 2.0 Framework (given constraints for the target server), so even though some of it might look like LINQ-to-SQL, its not! I&#39;ve just implemented a similar data pattern.


See example below for example of a situation that I cannot yet explain.

To get all instances of `Animal` - I do this and it works fine
    
    public static IEnumerable&lt;Animal&gt; GetAllAnimals() {
            AnimalDataContext dataContext = new AnimalDataContext();
                return dataContext.GetAllAnimals();
    }

And the implementation of the `GetAllAnimals()` method in the `AnimalDataContext` below

    public IEnumerable&lt;Animal&gt; GetAllAnimals() {
            foreach (var animalName in AnimalXmlReader.GetNames())
            {
                yield return GetAnimal(animalName);
            }
    }

The `AnimalDataContext` implements `IDisposable` because I&#39;ve got an `XmlTextReader` in there and I want to make sure it gets cleaned up quickly.  

Now if I wrap the first call inside a using statement like so

    public static IEnumerable&lt;Animal&gt; GetAllAnimals() {
            using(AnimalDataContext dataContext = new AnimalDataContext()) {
                return dataContext.GetAllAnimals();
            }
    }

and put a break-point at the first line of the `AnimalDataContext.GetAllAnimals()` method and another break-point at the first line in the `AnimalDataContext.Dispose()` method, and execute...

**the `Dispose()` method is called FIRST so that `AnimalXmlReader.GetNames()` gives *&quot;object reference not set to instance of object&quot;* exception because `AnimalXmlReader` has been set to `null` in the `Dispose()` ???**

Any ideas? I have a hunch that its related to `yield return` not being allowed to be called inside a try-catch block, which `using` effectively represents, once compiled... 



yield return statement inside a using() { } block Disposes before executing

I am not sure whether I need to call `Flush()` on the used objects if I write something like this:

    using (FileStream...)
    using (CryptoStream...)
    using (BinaryWriter...)
    {
        // do something
    }

Are they always automatically flushed? When does the `using` statement flush them and when it doesn’t (if that can happen)?

All Using Solutions on Gang of Coders

Total of 30 Using Solutions

What is the best workaround for the WCF client `using` block issue?

Do HttpClient and HttpClientHandler have to be disposed between requests?

Nested using statements in C#

What are the uses of "using" in C#?

MySQL JOIN ON vs USING?

What is the C# Using block and why should I use it?

Why should you remove unnecessary C# using directives?

Should I Dispose() DataSet and DataTable?

Will Dispose() be called in a using statement with a null object?

How do I use the C#6 "Using static" feature?

in a "using" block is a SqlConnection closed on return or exception?

Are there any side effects of returning from inside a using() statement?

Why remove unused using directives in C#?

How is performance affected by an unused using directive?

Do I have to Close() a SQLConnection before it gets disposed?

Is it a good approach to call return inside using {} statement?

Can "using" with more than one resource cause a resource leak?

Why is "using namespace X;" not allowed at class/struct level?

C# 8 understanding await using syntax

Why should I use the "using" keyword to access my base class method?

When should I use "using" blocks in C#?

Is there a situation in which Dispose won't be called for a 'using' block?

Does Stream.Dispose always call Stream.Close (and Stream.Flush)

What is the use of "using namespace std"?

"using" keyword in java

If an Exception happens within a using statement does the object still get disposed?

Using statement vs. IDisposable.Dispose()

scope of using declaration within a namespace

yield return statement inside a using() { } block Disposes before executing

Do you need to call Flush() on a stream or writer if you are using the “using” statement?