使用块与 function 块

Question

I want to know which is better way regarding memory management from both cause

With using using

 public void AddUser(User user)
        {
            using (var myentities = new MyEntities())
            {
                myentities .AddTotblUsers(user);
                myentities .SaveChanges();
            }
        }

Without using using

public void AddUser(User user)
            {
                var myentities = new MyEntities();

                myentities .AddTotblUsers(user);
                myentities .SaveChanges();

            }

which one remove first object from memory? first, second or both same?

Answer 1

The first one using dispose the object resources and should free the resources healed by the object.

Where in the second method, you are relying on the garbage collector to do that for you, However the garbage collector will do it at some not deterministic point while your application is executing.

It worth to mentioned here that the using statement is converted to something like:

{
    Entities myentities = new MyEntities();
    try
    {
        myentities.AddTotblUsers(user);
        myentities.SaveChanges();
    }
    finally
    {
        if (myentities != null)
            ((IDisposable)myEntities).Dispose();
    }
}

So it wrap the whole object at try/finally block and when finish using it, it alwyes calls dispose to free the resource, even if exception is thrown at the process inside the using we are sure that our resource is disposed probably.

Answer 2

using statement is useful only for objects implementing IDisposable , usually where the underlying resource is unmanaged.

See this: http://msdn.microsoft.com/en-us/library/yh598w02.aspx

For other scenarios, it is advisable to let automatic garbage collector do its job.

See this: http://msdn.microsoft.com/en-us/library/aa691138(v=vs.71).aspx

Answer 3

Using of using is the better way.

The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object. You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; in fact, this is how the using statement is translated by the compiler.

Answer 4

the first is better - at least for cases where MyEntities implements IDisposable... but it is better esp. if any exception occurs...

see http://msdn.microsoft.com/en-us/library/yh598w02.aspx

Answer 5

The using block is typically used for an object that contains references to un-managed objects or other things that won't get garbage collected. Using block can only be used with objects that support the IDisposible interface. It has no effect on when the value gets garbage collected.