在using namespace不使用命名空间限定符的情况下,我可以直接看到该命名空间的全部内容.如果using namespace在广泛使用的头文件中发生这可能会导致问题- 我们可能无意中使两个具有相同类名称的名称空间可见,并且编译器将拒绝编译,除非类名称前缀为名称空间限定符.
我可以撤消,using namespace以便编译器忘记它之前看到它吗？
我已经定义了'使用'功能如下:
def using[A, B <: {def close(): Unit}] (closeable: B) (f: B => A): A =
try { f(closeable) } finally { closeable.close() }
我可以这样使用它:
using(new PrintWriter("sample.txt")){ out =>
out.println("hellow world!")
}
现在我很好奇如何定义'使用'函数来获取任意数量的参数,并且能够单独访问它们:
using(new BufferedReader(new FileReader("in.txt")), new PrintWriter("out.txt")){ (in, out) =>
out.println(in.readLIne)
}
我正在迭代一个ManageObjectCollection.(这是WMI接口的一部分).
但重要的是,以下代码行.:
foreach (ManagementObject result in results)
{
//code here
}
关键是ManageObject也实现了IDisposable,所以我想把"result"变量放在using块中.关于如何做到这一点的任何想法,而不是太奇怪或复杂？
我正在使用此代码:
public void InsertMember(Member member)
{
string INSERT = "INSERT INTO Members (Name, Surname, EntryDate) VALUES (@Name, @Surname, @EntryDate)";
using (sqlConnection = new SqlConnection(sqlConnectionString_WORK))
{
sqlConnection.Open();
using (SqlCommand sqlCommand = new SqlCommand(INSERT, sqlConnection))
{
sqlCommand.Parameters.Add("@Name", SqlDbType.VarChar).Value = member.Name;
sqlCommand.Parameters.Add("@Surname", SqlDbType.VarChar).Value = member.Surname;
sqlCommand.Parameters.Add("@EntryDate", SqlDbType.Date).Value = member.EntryDate;
sqlCommand.ExecuteNonQuery();
}
}
}
如果我sqlConnection.Close();在处理它之前不添加它是错误的吗？我的意思是.它没有显示任何错误,也没有任何问题.首先关闭它会更好吗？如果是,为什么？
using ::std::...;
VS
using std::...;
有差异吗？如果是的话,哪一个？
我看到了这个:
using ::std::nullptr_t;
这让我很好奇.
因为C#using语句只是try/finally {dispose}的语法糖,为什么它只接受多个对象,如果它们属于同一类型？
我不明白,因为他们需要的只是IDisposable.如果所有这些都实现了IDisposable,它应该没问题,但事实并非如此.
具体来说,我习惯写作
using (var cmd = new SqlCommand())
{
using (cmd.Connection)
{
// code
}
}
我压缩成:
using (var cmd = new SqlCommand())
using (cmd.Connection)
{
// code
}
我想进一步说明:
using(var cmd = new SqlCommand(), var con = cmd.Connection)
{
// code
}
但我不能.有人会说,我可能写道:
using((var cmd = new SqlCommand()).Connection)
{
// code
}
因为我需要处理的只是连接而不是命令,但除此之外.
我只是看着使用声明,我一直都知道它的作用,但直到现在还没有尝试使用它,我已经提出了以下代码:
using (SqlCommand cmd =
new SqlCommand(reportDataSource,
new SqlConnection(Settings.Default.qlsdat_extensionsConnectionString)))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@Year", SqlDbType.Char, 4).Value = year;
cmd.Parameters.Add("@startDate", SqlDbType.DateTime).Value = start;
cmd.Parameters.Add("@endDate", SqlDbType.DateTime).Value = end;
cmd.Connection.Open();
DataSet dset = new DataSet();
new SqlDataAdapter(cmd).Fill(dset);
this.gridDataSource.DataSource = dset.Tables[0];
}
这似乎是工作,但有没有因为就在这个任何一点我可以告诉我还需要附上这在try catch块捕捉不可预见的错误,例如SQL服务器停机.我错过了什么吗？
据我目前所知,它只是阻止我关闭和处理cmd,但由于仍需要try catch,因此会有更多行代码.
我跑ildasm发现这个:
using(Simple simp = new Simple())
{
Console.WriteLine("here");
}
生成与此等效的IL代码:
Simple simp = new Simple();
try
{
Console.WriteLine("here");
}
finally
{
if(simp != null)
{
simp.Dispose();
}
}
而问题是为什么它会在最后检查null？只有在执行try块时才会执行finally块,并且只有在Simple构造函数成功时才会执行try块(即不抛出异常),在这种情况下simp将为非null.(如果担心在Simple构造函数和try块的开头之间可能会出现一些干预步骤,那么这确实是一个问题,因为可能会抛出一个异常,阻止finally块执行.)那么,为什么地狱？
暂且不谈(请)使用声明是否比try-finally更好的论点,我将try-finally块写成:
Simple simp = new Simple();
try
{
Console.WriteLine("here");
}
finally
{
simp.Dispose();
simp = null; // sanity-check in case I touch simp again
// because I don't rely on all classes
// necessarily throwing
// ObjectDisposedException
}
在一些c ++实践中,我试图学习并采用复制交换习语,对这个问题进行彻底的解释:复制交换习语.
但我发现了一些我从未见过的代码:using std::swap; // allow ADL在这个例子中
class dumb_array
{
public:
// ...
void swap(dumb_array& pOther) // nothrow
{
using std::swap; // allow ADL /* <===== THE LINE I DONT UNDERSTAND */
swap(mSize, pOther.mSize); // with the internal members swapped,
swap(mArray, pOther.mArray); // *this and pOther are effectively swapped
}
};
using std::swap;在函数实现的主体内部意味着什么？有时我需要在函数中使用几个一次性对象.最常见的情况是使用StreamReader和StreamWriter,但有时它甚至比这更多.
嵌套使用语句快速加起来并且看起来很难看.为了解决这个问题,我创建了一个小类,它收集IDisposable对象并在它本身被处置时处理它们.
public class MultiDispose : HashSet<IDisposable>, IDisposable
{
public MultiDispose(params IDisposable[] objectsToDispose)
{
foreach (IDisposable d in objectsToDispose)
{
this.Add(d);
}
}
public T Add<T>(T obj) where T : IDisposable
{
base.Add(obj);
return obj;
}
public void DisposeObject(IDisposable obj)
{
obj.Dispose();
base.Remove(obj);
}
#region IDisposable Members
public void Dispose()
{
foreach (IDisposable d in this)
{
d.Dispose();
}
}
#endregion
}
所以我的代码现在看起来像这样:
using (MultiDispose md = new MultiDispose())
{
StreamReader rdr = md.Add(new StreamReader(args[0]));
StreamWriter wrt = md.Add(new StreamWriter(args[1])); …