是否存在不依赖 IDisposable 的 Using 模式？

Question

我想创建一个内部消息传递系统，它可以告诉我某些代码被调用的持续时间。我在考虑易于使用，使 SystemMessage 类实现 IDisposable。

我会在 SystemMessage 的构造函数期间设置一个时间戳，如果调用了 Dispose，我可以计算出持续时间。

问题是我不想让对象 GC'ed。我希望它作为 MessageCollection 的一部分保留。

C# 中是否有另一种结构可以让我使用 Using 语句，而无需踩到 IDisposable 的预期功能。

Using (message = Collection.CreateNewMessage("FileDownlading"))
{
    // I wonder how long it is taking me to download this file in production?
    // Lets log it in a message and store for later pondering.
    WebClass.DownloadAFile("You Know This File Is Great.XML");
}
// we fell out of the using statement, message will figure out how long
// it actually took to run.
// This was clean and easy to implement, but so wrong?

Answer 1

问题是我不想让对象 GC'ed。我希望它作为 MessageCollection 的一部分保留。

调用 Dispose 不会导致对象被 GC'ed - 当 GC 进行扫描并且没有任何对象引用它时会发生这种情况。如果您仍然通过 MessageCollection 引用该对象，它会一直存在。

Dispose 可以防止它被 Finalized，但是由于您没有使用 Dispose 来清理资源，因此您将没有 Finalizer，您也不会关心。

所以，真正唯一的问题是让你的 calss 实现 IDisposable 的语义令人困惑，即使没有可处置的资源。

就个人而言，我不认为这是一个问题。如果消费者调用 Dispose，那么很好 - 他们得到时间记录。如果他们不这样做，那么他们就不会获得 itme 印章，最糟糕的是他们会违反 FxCop。

然而，这有点不直观 - 所以如果这是供公众使用，我建议提供一个更容易发现的替代方案，例如：

// C# 3+ lambda syntax
Collection.CreateNewMessage("FileDownlading", () => {
    // I wonder how long it is taking me to download this file in production?    
    // Lets log it in a message and store for later pondering.    
    WebClass.DownloadAFile("You Know This File Is Great.XML");
});

// C# 2 anonymous delegate syntax
Collection.CreateNewMessage("FileDownlading", delegate() {
    // I wonder how long it is taking me to download this file in production?    
    // Lets log it in a message and store for later pondering.    
    WebClass.DownloadAFile("You Know This File Is Great.XML");
});

// Method
void CreateNewMessage(string name, Action action) {
   StopWatch sw = StopWatch.StartNew();
   try {
      action();
   } finally {
      Log("{0} took {1}ms", name, sw.ElapsedMilliseconds);
   }
}

这将运行一个 Action 委托并为其计时。

Answer 2

你在寻找类似于闭包的东西吗？

http://en.wikipedia.org/wiki/Closure_(computer_science)

你可以伪造一些东西......像这样......

private TimeSpan GetDuration(Action a)
        {
            var start = DateTime.Now;
            a.Invoke();
            var end = DateTime.Now;
            return end.Subtract(start);
        }

        public void something()
        {
            string message;
            var timeSpan = GetDuration(() => { message = "Hello"; } );
        }

Answer 3

我不认为 using 是你想要的。为什么不让构造函数记录时间，然后在调用 DownloadAFile 时记录时间增量？在您的示例中，如果有异常，它将记录异常的时间，就好像当时下载了文件一样。

如果您真的希望行为像您的示例一样，只需使用 try / finally 块，然后在 finally 中进行日志记录。 using 只是 try / finally 块和调用 Dispose 的语法糖。

与您的示例等效的代码如下所示：

try 
{
    var message = Collection.CreateNewMessage("FileDownlading"); 
    //...
    WebClass.DownloadAFile("You Know This File Is Great.XML");
}
finally 
{
    //You can change this to do logging instead.
    message.Dispose(); 
}

Answer 4

您可以在 DownloadAFile() 中使用 System.Diagnostics.Stopwatch 来在每次调用时进行计时。

或者，只需在对 DownloadAFile() 的调用周围添加秒表代码（取决于您希望它如何工作）。

在这种情况下使用 IDisposable 不是一个好主意。

Answer 5

我最近一直在看这个，也许 PostSharp 可以帮助你。它允许您使用属性装饰方法，该属性将在您的方法启动和停止时调用。

http://www.postsharp.org/

我不确定它会做你喜欢的事，但它值得研究，它有你渴望的“语法糖”！

克里斯

Answer 6

嗯，这是一个老歌，但似乎没有其他人发布我认为是最佳风格的答案（根据我对您的要求的理解）：

using (MessageTimer timer = Collection.CreateNewTimedMessage("blabla"))
{
   // ...
}

重要的一点是CreateNewTimedMessage 可能会作为副作用创建并存储一个半永久性的Message 对象，但它返回一个临时计时对象（使用StopWatch，或一些类似的机制）在using 块的范围内不存在。 （MessageTimer 可以引用Message，但不能反过来。）

因此，处理MessageTimer 对象可能会产生在某处记录最后时间的副作用，但该对象本身不会存活或复活；这不是滥用using 构造，因为您确实是在处理一个对象。

（MessageTimer 的实际实现可能与 Joe 的回答类似。）

Answer 7

不是真的。你能找到的最接近的是这样的（无论如何，这就是 using() 语句的底层发生的事情:)

var message = Collection.CreateNewMessage("FileDownloading")

try
{
    WebClass.DownloadAFile("You Know This File Is Great.XML");
}
finally
{
    message.HowLongHaveIBeenAlive();
}

Answer 8

using 语句旨在在您完成对象后处理它们。在一个对象被丢弃后抓住它的想法并不完全是有意的。你可以尝试做一些简单的事情：

message = Collection.CreateNewMessage("FileDownlading");
DateTime dtStart = DateTime.Now;
WebClass.DownloadAFile("You Know This File Is Great.XML");
DateTime dtEnd = DateTime.Now;

// perform comparison here to see how long it took.

// dispose of DateTimes
dtStart = dtEnd = null;

Answer 9

可以说这是对 using 构造的滥用，因此我可能不会在以这种方式使用 IDisposable 的共享类库中实现公共类。

但是我已经看到了这种事情，并且认为如果它保留在您的应用程序内部是可以的。

问题是我不想 有对象GC'ed。我想要它 留在周围 消息集合。

我完全不明白。 IDisposable 与 GC 无关，如果将其作为 MessageCollection 的元素引用，您的消息将保持活动状态。

您的消息类可能类似于下面的示例。调用 Dispose 后，它仍然存在并且运行良好。大多数实现 IDisposable 的类在调用 Dispose 后不可用，因此如果在调用 Dispose 后访问成员，它们的实现将引发 ObjectDisposedException。但这绝不是强制性的。

class Message : IDisposable
{
    private Stopwatch _stopwatch = Stopwatch.StartNew();
    private long _elapsedTicks;
    private string _message;

    public Message(string message)
    {
        _message = message;
    }

    public void Dispose()
    {
       _elapsedTicks = _stopwatch.ElapsedTicks;
       ... anything else including logging the message ...
    }

    ...
}

Answer 10

“using”语句实际上编译为 Try/Finally，它期望对象实现 IDisposable——“using”只是语言提供的快捷方式。

出于您的目的，特别是因为您想回收对象，我会考虑编写您自己的界面。当您调用方法开始计时时，只需获取 datetime.now 的值；当你停止计时器时再次。然后从 stoptime 中减去 starttime，就得到了持续时间。

避免在每个类实例上使用真正的 Timer 对象。 Timer 使用 ThreadPool 线程，这意味着每条消息将消耗至少一个线程——如果系统中的消息过多，您的应用程序将因线程切换而变慢。此外，如果计时器没有正确处理，它们可能不会释放它们的 ThreadPool 线程，并且您基本上会有线程泄漏。

Answer 11

最初 IDisposable 旨在作为在 C# 中引入确定性清理的一种方式，但我已经看到 authors 和 implementations 使用 using/Dispose 功能来实现与您的内容类似的东西正在谈论。

就我个人而言，我对此不太满意，因为它破坏了IDisposable 背后的概念，但由于没有其他选择，它归结为你想成为多正统的问题。我当然可以理解您为什么要这样做，但是这样做会使您更难解释IDisposable 接口的目的和重要性。

Answer 12

再次查看您的问题后，我看不出所讨论的对象实际上是消息，除非它更像是跟踪消息（用于调试帮助）。

如果您正在寻找更多类似这些方面的东西，那么这里是一个非常使用委托的粗略方法。本质上，您为要调用的每个方法和时间创建一个委托，然后将委托和方法参数传递给负责实际调用方法并计时其持续时间的助手。

我的示例中明显的缺点是我牺牲了类型安全的参数，因为我不确定它是否正是您正在寻找的。另一个问题是，每次您想要调用具有您还没有委托的方法签名的方法时，您都需要添加一个新委托：

using System;

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {

            SomeCaller callerOne;
            YetAnotherCaller callerTwo;

            callerOne = new SomeCaller(SomeMethod);
            LogCallDuration(callerOne, new object[] { 15 });

            callerOne = new SomeCaller(SomeOtherMethod);
            LogCallDuration(callerOne, new object[] { 22 });

            callerTwo = new YetAnotherCaller(YetAnotherMethod);
            LogCallDuration(callerTwo, null);

            Console.ReadKey();
        }

        #region "Supporting Methods/Delegates"

        delegate void SomeCaller(int someArg);
        delegate void YetAnotherCaller();

        static void LogCallDuration(Delegate targetMethod, object[] args)
        {
            DateTime start = DateTime.UtcNow;
            targetMethod.DynamicInvoke(args);
            DateTime stop = DateTime.UtcNow;

            TimeSpan duration = stop - start;

            Console.WriteLine(string.Format("Method '{0}' took {1}ms to complete", targetMethod.Method.Name, duration.Milliseconds));

        }

        #endregion "Supporting Methods/Delegates"

        #region "Target methods, these don't have to be in your code"
        static void SomeMethod(int someArg)
        {
            // Do something that takes a little time
            System.Threading.Thread.Sleep(1 + someArg);
        }

        static void SomeOtherMethod(int someArg)
        {
            // Do something that takes a little time
            System.Threading.Thread.Sleep(320 - someArg);
        }

        static void YetAnotherMethod()
        {
            // Do something that takes a little time
            System.Threading.Thread.Sleep(150);
        }
        #endregion "Target methods"
    }
}