标签: using-statement

在下面的示例中,如果在using语句中引发异常,则连接是否会关闭并处理？

using (var conn = new SqlConnection("..."))
{
    conn.Open();
    // stuff happens here and exception is thrown...
}

我知道下面这段代码会确保它确实如此,但我很好奇使用声明是如何做到的.

var conn;
try
{
    conn = new SqlConnection("...");
    conn.Open();
    // stuff happens here and exception is thrown...
}
// catch it or let it bubble up
finally
{
    conn.Dispose();
}

有关:

我在using语句中有一个IDbTransaction,但我不确定如果在using语句中抛出异常,它是否会被回滚.我知道using语句会强制调用Dispose()......但是有人知道Rollback()是否也是如此？

更新:此外,我是否需要显式调用Commit(),如下所示,还是由using语句处理吗？

我的代码看起来像这样:

using Microsoft.Practices.EnterpriseLibrary.Data;

...

using(IDbConnection connection = DatabaseInstance.CreateConnection())
{
    connection.Open();

    using(IDbTransaction transaction = connection.BeginTransaction())
    {
       //Attempt to do stuff in the database
       //potentially throw an exception
       transaction.Commit();
    }
}

我有一堆属性,我将使用读/写锁.我可以使用a try finally或a using子句来实现它们.

在try finally我之前try,我将获得锁定,然后释放finally.在该using子句中,我将创建一个在其构造函数中获取锁的类,并在其Dispose方法中释放.

我在很多地方使用读/写锁,所以我一直在寻找可能更简洁的方法try finally.我有兴趣听听一些关于为什么不推荐一种方式的想法,或者为什么一种方式可能比另一方更好.

方法1(try finally):

static ReaderWriterLock rwlMyLock_m  = new ReaderWriterLock();
private DateTime dtMyDateTime_m
public DateTime MyDateTime
{
    get
    {
        rwlMyLock_m .AcquireReaderLock(0);
        try
        {
            return dtMyDateTime_m
        }
        finally
        {
            rwlMyLock_m .ReleaseReaderLock();
        }
    }
    set
    {
        rwlMyLock_m .AcquireWriterLock(0);
        try
        {
            dtMyDateTime_m = value;
        }
        finally
        {
            rwlMyLock_m .ReleaseWriterLock();
        }
    }
}

方法2:

static ReaderWriterLock rwlMyLock_m  = new ReaderWriterLock();
private DateTime dtMyDateTime_m
public …

我正在计算两点之间的距离.我用C++中的向量存储的两点:(0,0)和(1,1).

我应该得到结果

0
1.4
1.4
0

但我得到的实际结果是

0
1
-1
0

我认为在向量中使用迭代器的方式有问题.我该如何解决这个问题？

我发布了以下代码.

typedef struct point {
    float x;
    float y;
} point;

float distance(point *p1, point *p2)
{
    return sqrt((p1->x - p2->x)*(p1->x - p2->x) +
                (p1->y - p2->y)*(p1->y - p2->y));
}

int main()
{
    vector <point> po;
    point p1; p1.x = 0; p1.y = 0;
    point p2; p2.x = 1; p2.y = 1;
    po.push_back(p1);
    po.push_back(p2);

    vector <point>::iterator ii;
    vector <point>::iterator jj;
    for (ii = po.begin(); ii != po.end(); ii++) …

我试图在SO上扩展这个答案,使WCF客户端在瞬态网络故障时重试,并处理需要重试的其他情况,例如身份验证到期.

题:

什么是需要处理的WCF异常,以及处理它们的正确方法是什么？

以下是一些我希望看到的示例技术,而不是proxy.abort():

• 延迟重试前X秒
• 关闭并重新创建New()WCF客户端.处理旧的.
• 不要重试并重新抛出此错误
• 重试N次,然后扔掉

由于一个人不太可能知道解决它们的所有例外或方法,因此请分享您所知道的内容.我将在下面的代码示例中汇总答案和方法.

    // USAGE SAMPLE
    //int newOrderId = 0; // need a value for definite assignment
    //Service<IOrderService>.Use(orderService=>
    //{
    //  newOrderId = orderService.PlaceOrder(request);
    //}




    /// <summary>
    /// A safe WCF Proxy suitable when sessionmode=false
    /// </summary>
    /// <param name="codeBlock"></param>
    public static void Use(UseServiceDelegateVoid<T> codeBlock)
    {
        IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel();
        bool success = false;
        try
        {
            codeBlock((T)proxy);
            proxy.Close();
            success = true;
        }
        catch (CommunicationObjectAbortedException e)
        {
                // Object …

我一直在遇到一些与我在我的代码中使用的SqlTransaction有关的问题.在我的谷歌搜索期间,我看到许多人使用带有SqlTransaction的using语句.

使用SqlTransaction这种类型的语句有什么好处和/或区别？

using (SqlConnection cn = new SqlConnection())
{
     using (SqlTransaction tr = cn.BeginTransaction())
     {
      //some code
      tr.Commit();
     }
}

目前我的代码如下所示:

SqlConnection cn = new SqlConnection(ConfigurationManager.AppSettings["T3"]);
cn.Open();
SqlTransaction tr = cn.BeginTransaction();

try
{
     //some code
     tr.Commit();
     cn.Close();
}
catch(Exception ex)
{
      tr.Rollback();
      cn.Close();
      throw ex;
}

一种方式优于另一种方式的优势是什么？

use会捕获异常还是抛出异常？即

using (StreamReader rdr = File.OpenText("file.txt"))
{
 //do stuff
}

如果streamreader抛出异常是通过使用或抛出来捕获的,那么调用函数可以处理它吗？

我今天正在浏览同事c#代码并发现以下内容:

    using (MemoryStream data1 = new MemoryStream())
    using (MemoryStream data2 = new MemoryStream())
    {
        // Lots of code..........
     }

我一直看到using声明后跟一对花括号,它们定义了对象生命的范围.我编写代码的同事说,data1 using语句的大括号不需要,代码做的就像它们存在并嵌套data2 using语句一样.那么,当花括号被省略时会发生什么？

我在C#工作,并且我一直非常松懈地使用using块来声明实现的对象IDisposable,这显然是你应该做的.但是,我没有看到一种简单的方法来了解我何时滑倒.Visual Studio似乎没有以任何方式表明这一点(我只是错过了什么？).我每次申报任何东西时都应该检查帮助,然后逐渐建立一个百科全书式的记忆,对象是哪些,哪些不是一次性的？似乎没有必要,痛苦和容易出错.

如何你处理这个问题？

编辑:

看一下相关问题的侧边栏,我发现了另一个问题,它明确表示Dispose()应该被对象的终结器调用.因此,即使你自己也没有自己调用它,它最终会发生,这意味着如果你不使用它就不会有内存泄漏using(这是我认为我一直非常担心的).唯一需要注意的是,垃圾收集器不知道对象作为非托管内容持有多少额外内存,因此无法准确了解通过收集对象将释放多少内存.这将导致垃圾收集器的性能低于平常.

简而言之,如果我错过了,那就不是世界末日了using.我只是希望有些东西会产生至少一个警告.

(偏离主题:为什么链接到另一个问题没有特殊的降价？)

编辑:

好的,好的,别叫吵了.这是超级决斗所有激烈的戏剧性 - 花栗鼠级别的重要打电话Dispose()或我们都会死.

现在.鉴于此,为什么这么容易 - 地狱,为什么甚至允许 - 做错了？你必须尽力去做正确的事.像其他一切一样做它会导致世界末日(显然).封装这么多,是吧？

[偷偷摸摸,反感]

在using语句中使用内存流时,是否需要调用close？例如这里需要ms.Close()吗？

  using (MemoryStream ms = new MemoryStream(byteArray)) 
    {  
      // stuff 

      ms.Close(); 
    }