小编And*_*nov的帖子

有关新4.0中的新功能和类的信息很多,但是也存在可能影响现有应用程序的更改

1. Timespan现在实现了IFormattable,而带有无效选项的旧string.Format()将抛出异常,而不是调用简单的ToString().但是,CLR团队提供了一个很好的功能,可以通过配置设置启用以前版本的行为 - TimeSpan_LegacyFormatMode.

   CLR Inside Out

2. 访问使用+ =或 - =声明它们的类中的事件将导致调用添加/删除生成的返回void的访问器.有些代码甚至不会在4.0中编译.

   克里斯伯罗斯博客

3. CAS已弃用,要启用它,仍需要在配置中使用特殊设置 - NetFx40_LegacySecurityPolicy

所以我想知道其他更改是什么,是否有可能找到至少初步的更改列表,这些更改将会或可能会破坏.NET 4.0发布的现有功能？

我正在使用Disruptor框架及其.NET平台端口,并发现了一个有趣的案例.可能是我完全错过了一些东西所以我正在寻找全能社区的帮助.

        long iterations = 500*1000*1000;
        long testValue = 1;

        //.NET 4.0. Release build. Mean time - 26 secs;
        object lockObject = new object();
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            lock (lockObject)
            {
                testValue++;    
            }
        }
        sw.Stop();

        //Java 6.25. Default JVM params. Mean time - 17 secs.
        Object lock = new Object();
        long start = System.currentTimeMillis();
        for (int i = 0; i < iterations; i++)
        {
                synchronized (lock)
                { …

MSDN声明以下SortedSet(T).Add方法:

如果Count小于内部阵列的容量,则此方法是O(1)操作.

有人可以解释"怎么样"？我的意思是在添加新值时,我们需要找到一个正确的位置来添加一个值(将其与另一个值进行比较),内部实现看起来像一个具有O(log N)插入复杂度的"红黑树".

有人可以向我解释为什么下面显示的代码在C#中有效并执行调用Console.WriteLine？

using (null) 
{
   Console.WriteLine ("something is here")
}

它编译成(最后显示块).如您所见,编译器决定不执行该Dispose()方法并跳转到该endfinally指令.

IL_0013:  ldnull
IL_0014:  ceq
IL_0016:  stloc.1
IL_0017:  ldloc.1
IL_0018:  brtrue.s   IL_0021 // branches here and decide not to execute Dispose()
IL_001a:  ldnull
IL_001b:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
IL_0020:  nop
IL_0021:  endfinally

但是,如果我运行以下代码,它将失败a NullReferenceException(预期):

((IDisposable)null).Dispose();
IL_0023:  ldnull
IL_0024:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()

为什么第一个版本编译？为什么编译器决定不执行Dispose()？是否有任何其他情况下,当编译器可以决定不叫Dispose()的using块？

今天我和Lazy一起玩,<T>发现了一个有趣的案例(在我看来).

http://msdn.microsoft.com/en-us/library/system.threading.lazythreadsafetymode.aspx

• PublicationOnly:

  当多个线程尝试同时初始化Lazy实例时,允许所有线程运行初始化方法...将丢弃由竞争线程创建的任何T实例.

  如果我们查看Lazy <T>.LazyInitValue()的代码,我们会发现没有检查IDisposable实现,并且这里的resoruces可能会泄漏:

   case LazyThreadSafetyMode.PublicationOnly:
          boxed = this.CreateValue();
          if (Interlocked.CompareExchange(ref this.m_boxed, boxed, null) != null)
          {  
             //* boxed.Dispose(); -> see below.
             boxed = (Boxed<T>) this.m_boxed;
          }
          break;
  

  Run Code Online (Sandbox Code Playgroud)

截至目前,确保仅创建实例的唯一方法是使用LazyThreadSafetyMode.ExceptionAndPublication.

所以我有两个问题:

• 我是否会遗漏某些内容,或者我们可以看到在这种情况下可以创建很少的漏洞并且资源可能会泄漏？

• 如果正确的假设为什么不在这种情况下检查IDisposable并在Boxed上实现Dispose(),<T>以便它将处理委托给Boxed实例,T如果它实现IDisposable或以某种不同的方式:

     class Boxed<T>
     {
          internal T m_value;
          void Dispose()
          {
              if (m_value is IDisposable)
              {     ((IDisposable) m_value).Dispose();  }
          }
     }
  

  Run Code Online (Sandbox Code Playgroud)

今天我正在阅读Julienne Walker关于排序的一篇很棒的文章 - Eternal Confuzzled - 排序艺术,有一件事引起了我的注意.我不太了解作者证明通过比较进行排序的部分我们受到Ω(N ·log N)下限的限制

下限不是那么明显.大多数排序算法的最低可能范围是Ω(N ·log N).这是因为大多数排序算法使用项目比较来确定项目的相对顺序.通过比较排序的任何算法将具有Ω的最小下界(N ·log N),因为比较树用于选择已排序的排列.可以很容易地构建三个数字1,2和3的比较树:

                         1 < 2

           1 < 3                       1 < 3

   2 < 3           3,1,2       2,1,3           2 < 3

1,2,3   1,3,2                            2,3,1     3,2,1

Run Code Online (Sandbox Code Playgroud)

注意每个项目如何与每个其他项目进行比较,并且每个路径都会导致三个项目的有效排列.树的高度决定了排序算法的下限.因为有排列的算法是正确的,必须有尽可能多的叶子,比较树的最小可能高度登录ñ!,这相当于Ω(ñ ·日志ñ).

它似乎是一个非常合理的,直到最后一部分(粗体),我不太明白 - 如何记录N!等于Ω(N ·log N).我必须从我的CopmSci课程中遗漏一些东西,无法完成最后的过渡.如果我们通过比较使用排序,我期待着对此的帮助或者与我们有限的其他证据的链接Ω(N ·log N).