javascript

java

python

c#

android

node.js

c++

reactjs

php

html

jquery

css

.net

ios

git

ruby-on-rails

sql

c

string

ruby

c#-using(){}块中的yield return语句在执行之前进行处置

我已经编写了自己的自定义数据层以保留到特定文件,并使用自定义DataContext模式对其进行了抽象。

这全部基于.NET 2.0框架(对目标服务器有限制),因此即使其中一些看起来像LINQ-to-SQL,但事实并非如此! 我刚刚实现了类似的数据模式。

请参阅以下示例,以了解我无法解释的情况。

要获取Animal的所有实例,我可以这样做,并且效果很好

public static IEnumerable<Animal> GetAllAnimals() {
        AnimalDataContext dataContext = new AnimalDataContext();
            return dataContext.GetAllAnimals();
}

以及下面的AnimalDataContext()中的GetAllAnimals()方法的实现

public IEnumerable<Animal> GetAllAnimals() {
        foreach (var animalName in AnimalXmlReader.GetNames())
        {
            yield return GetAnimal(animalName);
        }
}

AnimalDataContext()实现IDisposable,因为我在那里有一个XmlTextReader,我想确保它能快速清理。

现在,如果我将第一个调用包装在using语句中,如下所示

public static IEnumerable<Animal> GetAllAnimals() {
        using(AnimalDataContext dataContext = new AnimalDataContext()) {
            return dataContext.GetAllAnimals();
        }
}

并在AnimalDataContext.GetAllAnimals()方法的第一行放置一个断点,并在AnimalDataContext.Dispose()方法的第一行放置另一个断点,然后执行...

Dispose()方法被称为FIRST,因此AnimalXmlReader.GetNames()给出“对象引用未设置为对象实例”的异常,因为在Dispose()中将AnimalXmlReader设置为null。

有任何想法吗? 我有一种预感,不允许在try-catch块中调用与收益率相关的收益,该收益在编译后使用有效表示...

trans by 2020-02-14T09:40:43Z

CodeGo.net>使用语句与IDisposable.Dispose()

据我了解,一旦代码退出代码块,.NET中的Dispose()语句就会调用Dispose()对象的using方法。

Dispose()语句是否还有其他作用? 如果没有,似乎以下两个代码示例可以实现完全相同的效果:

Using Con as New Connection()
    Con.Open()
    'do whatever '
End Using

Dim Con as New Connection()
Con.Open()
'do whatever '
Con.Dispose()

无论确认我是对的人还是指出我错了并解释原因的人,我都会给最好的答案。 请记住,我知道某些类在其Dispose()方法中可以做不同的事情。 这个问题是关于using语句是否达到与调用对象的Dispose()方法完全相同的结果。

trans by 2020-02-10T09:20:44Z

.net-流作为WCF中的返回值-谁处理它?

假设我有以下WCF实现:

public Stream Download(string path)
{
    FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read);
    return stream;
}

谁负责处理返回的值? 毕竟,可能会发生网络故障,因此使用者可能无法处理它。

trans by 2020-01-08T18:15:44Z

CodeGo.net>你应该实现IDisposable.Dispose(),使其永远不会抛出?

对于C ++中的等效机制(析构函数),建议是通常不应抛出任何异常。 这主要是因为这样做可能会终止您的过程,但这很少是一个好的策略。

在.NET中的等效方案中...

  1. 引发第一个异常
  2. 由于第一个异常而执行了finally块
  3. 最后的块调用Dispose()方法
  4. Dispose()方法引发第二个异常

...您的过程不会立即终止。 但是,您丢失了信息,因为.NET意外地将第二个异常替换为第一个异常。 因此,调用堆栈上方某个地方的catch块将永远不会看到第一个异常。 但是,通常对第一个异常更感兴趣,因为通常可以提供更好的线索来说明为什么事情开始出错。

由于.NET缺少一种机制,可以在异常未决期间检测代码是否正在执行,因此似乎只有两种选择可以实现IDisposable:

  • 始终吞并Dispose()内部发生的所有异常。 不好,因为您可能最终还会吞下OutOfMemoryException,ExecutionEngineException等。通常,我宁愿在它们发生而又没有其他异常发生时关闭进程。
  • 让所有异常传播到Dispose()中。 不好,因为您可能会丢失有关问题根本原因的信息,请参见上文。

那么,这两种罪恶中哪一个较小? 有没有更好的办法?

编辑:为澄清起见,我不是在谈论是否主动从Dispose()抛出异常,而是在谈论让Dispose()调用的方法抛出的异常是否传播到Dispose()外,例如:

using System;
using System.Net.Sockets;

public sealed class NntpClient : IDisposable
{
    private TcpClient tcpClient;

    public NntpClient(string hostname, int port)
    {
        this.tcpClient = new TcpClient(hostname, port);
    }

    public void Dispose()
    {
        // Should we implement like this or leave away the try-catch?
        try
        {
            this.tcpClient.Close(); // Let's assume that this might throw
        }
        catch
        {
        }
    }
}
trans by 2020-01-04T03:18:04Z

IDisposable.Dispose()是否自动调用?

可能重复:
垃圾收集器会打给IDisposable.Dispose给我吗?

我有一个包含一些非托管资源的类。 我的类实现267815008413470007000接口,并以Dispose()方法释放非托管资源。 我必须调用267815008413470007000方法,还是会以某种方式自动调用它? 垃圾收集器会打电话吗?

trans by 2019-12-28T21:18:18Z

CodeGo.net> foreach是否自动调用Dispose?

在C#中,foreach是否在实现IDisposable的任何对象上自动调用Dispose?

[http://msdn.microsoft.com/zh-cn/library/aa664754(v=vs.71).aspx]似乎表明它确实存在:

*否则,集合表达式是实现System.IEnumerable的类型,并且foreach语句的扩展是:复制

IEnumerator enumerator = 
        ((System.Collections.IEnumerable)(collection)).GetEnumerator();
try {
   while (enumerator.MoveNext()) {
      ElementType element = (ElementType)enumerator.Current;
      statement;
   }
}
finally {
   IDisposable disposable = enumerator as System.IDisposable;
   if (disposable != null) disposable.Dispose();
}
trans by 2019-10-14T19:19:32Z

CodeGo.net>应该“处置”仅用于包含非托管资源的类型?

我最近与一位同事讨论了IDisposable的值和实现using new MyThingWithAConnection()的类型。

我认为为IDisposable实现应尽快清除的类型是有价值的,即使没有任何非托管资源需要清除也是如此。

我的同事有不同的看法。 如果您没有任何非托管资源,则无需实施IDisposable,因为您的类型最终将被垃圾回收。

我的观点是,如果您希望尽快关闭ADO.NET连接,则实现IDisposableusing new MyThingWithAConnection()是有意义的。 我的同事回答说,在幕后,ADO.NET连接是不受管的资源。 我对他的答复是,所有事情最终都是不受管理的资源。

我知道建议使用的一次性模式,在这种模式下,如果调用了IDisposable,则可以释放托管和非托管资源,但是如果通过终结器/析构函数调用,则只能释放非托管资源。

因此,我的问题是,如果您的类型不包含非托管资源,是否值得实施IDisposable

trans by 2019-10-02T00:11:11Z

c# - 如何判断是否配置了IDisposable对象引用?

是否有方法或其他轻量级方法来检查引用是否属于被处置对象?

附: - 这只是一种好奇心(睡得好,不在生产代码中)。 是的,我知道在尝试访问该对象的成员时我可以捕获ObjectDisposedException

trans by 2019-09-19T03:26:15Z

c# - 如果我在使用语句结束之前返回会发生什么? 处理是否会被召唤?

我有以下代码

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

dispose()方法在using语句的末尾调用}对吗? 由于我在using语句结束前return,是否将MemoryStream对象妥善处理? 这里发生了什么?

trans by 2019-07-24T02:11:00Z

c# - 我应该为流对象调用Close()还是Dispose()?

诸如using(),Close(),Close()等类实现了IDisposable接口。 这意味着,我们可以在这些类的对象上调用Dispose()方法。 他们还定义了一个名为publicpublic方法。现在让我困惑的是,一旦我完成了对象,我应该调用什么? 如果我同时打电话怎么办?

我目前的代码是这样的:

using (Stream responseStream = response.GetResponseStream())
{
   using (StreamReader reader = new StreamReader(responseStream))
   {
      using (StreamWriter writer = new StreamWriter(filename))
      {
         int chunkSize = 1024;
         while (!reader.EndOfStream)
         {
            char[] buffer = new char[chunkSize];
            int count = reader.Read(buffer, 0, chunkSize);
            if (count != 0)
            {
               writer.Write(buffer, 0, count);
            }
         }
         writer.Close();
      }
      reader.Close();
   }
}

如您所见,我编写了using()构造,它自动在每个对象上调用Close()方法。 但我也称之为Close()方法。 这样对吗?

请告诉我使用流对象时的最佳做法。:-)

MSDN示例不使用using()构造,并调用Close()方法:

  • 如何:使用FTP下载文件

好吗?

trans by 2019-05-31T04:18:30Z

c# - 使用带有null obj的语句

在(可能)null对象上使用using语句是否安全?
请考虑以下示例:

class Test {
    IDisposable GetObject(string name) {
        // returns null if not found
    }

    void DoSomething() {
        using (IDisposable x = GetObject("invalid name")) {
            if (x != null) {
                 // etc...
            }
        }
    }
}

是否保证仅当对象不为空时才会调用Dispose,并且我不会得到NullReferenceException

trans by 2019-05-10T13:30:11Z

c# - 如何判断是否配置了IDisposable对象引用?

是否有方法或其他轻量级方法来检查引用是否属于被处置对象?

附: - 这只是一种好奇心(睡得好,不在生产代码中)。 是的,我知道我可以在尝试访问该对象的成员时捕获ObjectDisposedException

trans by 2019-04-24T19:42:22Z

asp.net mvc - ASP MVC:什么时候IController Dispose()被调用?

我正在对我的一个较大的MVC应用程序进行重大的重构/速度调整。 它已经部署到生产几个月了,我开始等待连接池中的连接超时。 我已将问题跟踪到未正确处理的连接。

鉴于此,我已经对我的基本控制器进行了此更改:

public class MyBaseController : Controller
{
    private ConfigurationManager configManager;  // Manages the data context.

    public MyBaseController()
    {
         configManager = new ConfigurationManager();
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (this.configManager != null)
            {
                this.configManager.Dispose();
                this.configManager = null;
            }
        }

        base.Dispose(disposing);
    }
}

现在,我有两个问题:

  1. 我是否介绍了竞争条件? 由于Dispose()管理DataContext,因此公开IQueryable<>参数意见,我需要确保不会调用Dispose()在视图完成渲染之前在控制器上。
  2. 在呈现视图之前或之后,MVC框架是否在Controller上调用Dispose()? 或者,MVC框架是否会离开GarbageCollector?
trans by 2019-04-21T17:28:42Z

c# - 在使用b的中间返回

就像是:

using (IDisposable disposable = GetSomeDisposable())
{
    //.....
    //......
    return Stg();
}

我相信这不是回报声明的合适地方,是吗?

trans by 2019-04-19T07:28:04Z

我应该Dispose()DataSet和DataTable吗?

DataSet和DataTable都实现了IDisposable,因此,通过传统的最佳实践,我应该调用它们的Dispose()方法。

但是,从我到目前为止所读到的,DataSet和DataTable实际上并没有任何非托管资源,因此Dispose()实际上并没有做太多。

另外,我不能只使用using,因为DataSet有一组DataTables。

所以,为了安全起见,我需要遍历myDataSet.Tables,处理每个DataTable,然后处理DataSet。

那么,在我的所有DataSet和DataTables上调用Dispose()是否值得麻烦?

附录:

对于那些认为应该处理DataSet的人:通常,处理模式是使用usingtry..finally,因为您要保证将调用Dispose()。

然而,这对于一个集合来说真的很快。 例如,如果对Dispose()的一个调用抛出异常,你会怎么做? 你吞下它(这是“坏”),以便你可以继续处理下一个元素?

或者,你是否建议我只调用myDataSet.Dispose(),而忘记在myDataSet.Tables中处理DataTables?

trans by 2019-03-18T13:58:20Z

c# - 必须处理HttpClient和HttpClientHandler吗?

.NET Framework 4.5中的System.Net.Http.HttpClient和System.Net.Http.HttpClientHandler实现了IDisposable(通过System.Net.Http.HttpMessageInvoker)。

Dispose()声明文档说:

通常,当您使用IDisposable对象时,您应该声明和   在using语句中实例化它。

这个答案使用了这种模式:

var baseAddress = new Uri("http://example.com");
var cookieContainer = new CookieContainer();
using (var handler = new HttpClientHandler() { CookieContainer = cookieContainer })
using (var client = new HttpClient(handler) { BaseAddress = baseAddress })
{
    var content = new FormUrlEncodedContent(new[]
    {
        new KeyValuePair<string, string>("foo", "bar"),
        new KeyValuePair<string, string>("baz", "bazinga"),
    });
    cookieContainer.Add(baseAddress, new Cookie("CookieName", "cookie_value"));
    var result = client.PostAsync("/test", content).Result;
    result.EnsureSuccessStatusCode();
}

但是微软最明显的例子并没有明确地或隐含地调用Dispose()。 例如:

  • 最初的博客文章宣布了HttpClient的发布。
  • HttpClient的实际MSDN文档。
  • BingTranslateSample
  • GoogleMapsSample
  • WorldBankSample

在公告的评论中,有人问微软员工:

检查你的样品后,我看到你没有进行处理   对HttpClient实例的操作。 我已经使用了HttpClient的所有实例   在我的应用程序上使用声明,我认为这是正确的方式   因为HttpClient实现了IDisposable接口。 我是谁   正确的道路?

他的回答是:

一般来说,这是正确的,但你必须要小心   “使用”和异步,因为他们不真正混合.Net 4,在.Net 4.5你   可以在“using”语句中使用“await”。

顺便说一下,你可以重复使用相同的HttpClient,因为你喜欢这么多次   通常你不会一直创建/处置它们。

第二段对于这个问题是多余的,它不关心你可以使用HttpClient实例多少次,而是关注是否有必要在你不再需要它之后处理它。

(更新:事实上,第二段是答案的关键,如下面的@DPeden所示。)

所以我的问题是:

  1. 鉴于当前的实现(.NET Framework 4.5),是否有必要在HttpClient和HttpClientHandler实例上调用Dispose()? 澄清:“必要”是指如果不处置会产生任何负面影响,例如资源泄漏或数据腐败风险。

  2. 如果没有必要,那么它是否是一个“好的做法”,因为它们实现了IDisposable?

  3. 如果有必要(或推荐),上面提到的代码是否安全地实现了它(对于.NET Framework 4.5)?

  4. 如果这些类不需要调用Dispose(),为什么它们被实现为IDisposable?

  5. 如果他们需要,或者如果是推荐的做法,微软的例子是误导性的还是不安全的?

trans by 2019-02-16T23:29:15Z

c# - 我什么时候应该使用GC.SuppressFinalize()?

在.NET中,我应该在哪种情况下使用GC.SuppressFinalize()

使用这种方法有什么好处?

trans by 2019-02-08T04:08:32Z

.net - 在C#中完成/处理模式

C#2008

我一直在研究这个问题,我仍然对一些问题感到困惑。 我的问题如下

  1. 我知道如果你处理非托管资源,你只需要一个终结器。 但是,如果您使用托管资源来调用非托管资源,您是否仍需要实现终结器?

  2. 但是,如果您开发的类直接或间接不使用任何非托管资源,您是否可以实现IDisposable,以便您的类的客户端可以使用'using statement'?

    是否可以接受实现IDisposable,以便您的类的客户端可以使用using语句?

    NoGateway
  3. 我在下面开发了这个简单的代码来演示Finalize / dispose模式:

    NoGateway

关于源代码的问题:

  1. 这里我没有添加终结器,通常GC将调用终结器,终结器将调用Dispose。 由于我没有终结器,何时调用Dispose方法? 这个类的客户端是否需要调用它?

    所以我的示例中的类叫做NoGateway,客户端可以像这样使用和处理类:

    NoGateway

    当执行到达using块的末尾时,是否会自动调用Dispose方法,或者客户端是否必须手动调用dispose方法?即

    NoGateway
  2. 我正在使用NoGateway类中的webclient类。 因为webclient实现了IDisposable接口,这是否意味着webclient间接使用非托管资源? 是否有一个严格的规则可以遵循这个? 我怎么知道一个类使用非托管资源?

trans by 2019-01-09T16:09:09Z

c# - 正确使用IDisposable

我从阅读MSDN文档中了解到,_theList接口的“主要”用途是清理非托管资源。

对我来说,“非托管”意味着像数据库连接,套接字,窗口句柄等等。但是,我已经看到实现_theList方法以释放托管资源的代码,这对我来说似乎是多余的,因为垃圾收集器应该小心 这对你来说。

例如:

public class MyCollection : IDisposable
{
    private List<String> _theList = new List<String>();
    private Dictionary<String, Point> _theDict = new Dictionary<String, Point>();

    // Die, clear it up! (free unmanaged resources)
    public void Dispose()
    {
        _theList.clear();
        _theDict.clear();
        _theList = null;
        _theDict = null;
    }

我的问题是,这是否使_theList使用的垃圾收集器可用内存比通常更快?

编辑:到目前为止,人们已经发布了一些使用IDisposable清理非托管资源(例如数据库连接和位图)的好例子。 但是假设_theList在上面的代码中包含了一百万个字符串,并且你想现在释放那个内存,而不是等待垃圾收集器。 上面的代码会实现吗?

trans by 2018-11-27T06:27:15Z

1 共1页