When you call GetAllAnimals it doesn’t actually execute any code until you enumerate the returned IEnumerable in a foreach loop. The dataContext is being disposed as soon as the wrapper method returns, before you enumerate the IEnumerable. The simplest solution would be to make the wrapper method an iterator as well, like this: public static … Read more
No, it is not safe – it won’t pollute another namespace, but it is dangerous for other reasons: A using directive will import anything that is currently visible by the name you specify into the namespace where you use it. While your using will only be visible to users of MyNamespace, other things from “outside” … Read more
using: You are going to use it. namespace: To use what? A namespace. std: The std namespace (where features of the C++ Standard Library, such as string or vector, are declared). After you write this instruction, if the compiler sees string it will know that you may be referring to std::string, and if it sees … Read more
using is basically the equivalent of: try { // code } finally { obj.Dispose(); } So it also has the benefit of calling Dispose() even if an unhandled exception is thrown in the code within the block.
Yes, they will. using(SPWeb spWeb = spSite.OpenWeb()) { // Some Code } is equivalent to { SPWeb spWeb = spSite.OpenWeb(); try { // Some Code } finally { if (spWeb != null) { spWeb.Dispose(); } } } Edit After answering this question, I wrote a more in depth post about the IDisposable and Using construct … Read more
Can I just call MySW.Dispose() and skip the Close even though it is provided? Yes, that’s what it’s for. Are there any Stream implementations that don’t work as expected (Like CryptoStream)? It is safe to assume that if an object implements IDisposable, it will dispose of itself properly. If it doesn’t, then that would be … Read more
Four things that will cause Dispose to not be called in a using block: A power failure on your machine when inside the using block. Your machine getting melted by an atomic bomb while in the inside of the using block. Uncatchable exceptions like StackOverflowException, AccessViolationException and possibly others. Environment.FailFast
Some objects need some action to be taken when you have finished with them. Usually this is because the object uses some kind of resource that needs to be disposed of. For example, if you have a file object of class File, and this object opens a file from the file system, the file in … Read more
The action declared in the derived class hides the action declared in the base class. If you use action on a Son object the compiler will search in the methods declared in Son, find one called action, and use that. It won’t go on to search in the base class’s methods, since it already found … Read more
I don’t know exactly, but my guess is that allowing this at class scope could cause confusion: namespace Hello { typedef int World; } class Blah { using namespace Hello; public: World DoSomething(); } //Should this be just World or Hello::World ? World Blah::DoSomething() { //Is the using namespace valid in here? } Since there … Read more