C#

George_George wrote:

What is the benefit?

George_George wrote:

when the Http Service stops (process stops or terminations), all resources like native handle wrapped by StreamReader could be released automatically.

What is the benefit of using "using" statement?

using(Stream str = new FileStream(..))
{
   // Use str here
}

Stream str = null;
try
{
   str = new FileStream(..);
}
finally
{
   if(str != null)
     ((IDisposable)str).Dispose();
}

George_George wrote:

In the C# compiler expanded code, no catch block? Just a finally block?

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Xml;

class Test
{

    class MyException : ApplicationException
    {
        public MyException (string message)
            : base(message)
        {

        }
    }

    class MyObject : IDisposable
    {
        public virtual void Dispose()
        {
            Console.WriteLine("Disposed ");
            throw new MyException("Disposed exception. ");
        }

    }

    public static void Main()
    {
        try
        {
            using (MyObject myobj = new MyObject())
            {
                throw new MyException("Hello World");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }
}

try
        {
            MyObject myobj = new MyObject();
            try
            {
                throw new MyException("Hello World");
            }
            finally
            {
                myobj.Dispose();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

George_George wrote:

It is in theory that the information of MyException("Hello World") is missing when there is exception in Dispose, right?

George_George wrote:

when there is exception and we are in finally block because of the exception

George_George wrote:

How can you write a common finally block, to handle exception at first, then Dispose?

public static void Main()
    {
        try
        {
            using (MyObject myobj = new MyObject())
            {
                try{
                   throw new MyException("Hello World");
                }
                catch(MyException)
                {
                     
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }
    }

John Simmons / outlaw programmer wrote:

So which is it - a good thing, or a bad thing?

John Simmons / outlaw programmer wrote:

automatic-ness of memory handling

John Simmons / outlaw programmer wrote:

Personally, I avoid "using" statements because I think they obfuscate the intent of code.

S. Senthil Kumar wrote:

Really? How else do you close DB connections or file streams?