There are a few reasons you’d want to take them out. It’s pointless. They add no value. It’s confusing. What is being used from that namespace? If you don’t, then you’ll gradually accumulate pointless using statements as your code changes over time. Static analysis is slower. Code compilation is slower. On the other hand, there … Read more
Because of language design: Using static makes extension methods declared in the specified type available for extension method lookup. However, the names of the extension methods are not imported into scope for unqualified reference in code. using Directive
You can do this though: using (IDisposable cmd = new SqlCommand(), con = (cmd as SqlCommand).Connection) { var command = (cmd as SqlCommand); var connection = (con as SqlConnection); //code } Perhaps that would be satisfactory to you.
This mechanism is normally used in templated code, i.e. template <typename Value> class Foo. Now the question is which swap to use. std::swap<Value> will work, but it might not be ideal. There’s a good chance that there’s a better overload of swap for type Value, but in which namespace would that be? It’s almost certainly … Read more
Yes, it will; the implementation of DbConnection.Dispose() calls Close() (and so do its derived implementations).
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
If you want to selectively hide functions from B it does not make much sense to use public inheritance in the first place. Use private inheritance & selectively bring methods from B into the scope of A: struct B{ void method1(){}; void method2(){}; }; struct A : private B{ using B::method1; }; A a; a.method1(); … Read more
The following is how Microsoft recommends doing it. It is long and bulky, but safe: FileStream fs = null; try { fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); using (TextReader tr= new StreamReader(fs)) { fs = null; // Code here } } finally { if (fs != null) fs.Dispose(); } This method will always ensure … Read more
You don’t manually destroy .Net objects. That’s what being a managed environment is all about. In fact, if the object is actually reachable, meaning you have a reference you can use to tell the GC which object you want to destroy, collecting that object will be impossible. The GC will never collect any object that’s … Read more
The using syntax can(should) be used as a way of defining a scope for anything that implements IDisposable. The using statement ensures that Dispose is called if an exception occurs. //the compiler will create a local variable //which will go out of scope outside this context using (FileStream fs = new FileStream(file, FileMode.Open)) { //do … Read more