小编Tra*_*rap的帖子

作为一名程序员,我在键盘上花了很多时间,而且在过去的12年里,我或多或少都在做.如果有一些我从未习惯过的东西,那么由于一些最常见的代码编辑任务,我在编码过程中会遇到这些烦人且几乎无意识的持续微中断.像从不同的行(或甚至同一行)进行简单的复制和粘贴,或者从当前位置向上或向下移动1或2行所需要的东西需要太多的输入或涉及使用箭头键......它会得到当我想进一步移动时更糟糕 - 我最终使用了鼠标.现在想象一下这个场景,但在笔记本电脑上.

我一直都在考虑学习VIM,但掌握它所需的时间总是让我想退后一步.

我想听听那些已经学会了它的人,以及它最终成为你不能没有的东西之一.

在工作中,我使用VS2008,C#和R#,它们使编辑代码比以往更快更容易,但即便如此,我认为我可以享受不必使用鼠标.

甚至没有箭头键.

或者它现在反过来了？

从我所听到的有些领域,C#证明比C++更快,但我从来没有勇气自己测试它.

你们中的任何一个人都可以详细解释这些差异,或者将我指向正确的地方以获取相关信息.

虽然我确实理解玩这个功能的严重影响(或者至少是我的想法),但我不明白为什么它会成为那些受人尊敬的程序员不会使用的东西之一,即使是那些甚至不知道的人也是如此它是什么.

假设我正在开发一个应用程序,其中内存使用量根据用户的行为而变化很大.应用程序生命周期可分为两个主要阶段:编辑和实时处理.在编辑阶段,假设创建了数十亿甚至数万亿的对象; 其中一些是小的,一些不是,有些可能有终结器,有些可能没有,并且假设它们的寿命从几毫秒到长时间不等.接下来,用户决定切换到实时阶段.在这一点上,假设性能起着根本性的作用,程序流程中的最轻微改动可能会带来灾难性的后果.然后,通过使用对象池等将对象创建减少到最小可能,然后,GC意外地进行编辑并将其全部抛弃,并且有人死亡.

问题:在这种情况下,在进入第二阶段之前调用GC.Collect()不是明智的吗？

毕竟,这两个阶段永远不会在时间上相互重叠,GC可能收集的所有优化和统计数据在这里几乎没用......

注意:正如你们中的一些人所指出的那样,.NET可能不是这样的应用程序的最佳平台,但这超出了这个问题的范围.目的是澄清GC.Collect()调用是否可以改善应用程序的整体行为/性能.我们都同意你在这种情况下做这种事情的情况非常罕见,但话说再次,GC试图猜测并且在大多数情况下做得非常好,但它仍然是猜测.

谢谢.

我正在展示一棵非常大的树,里面有很多物品.这些项目中的每一项都通过其关联的UserControl控件向用户显示信息,并且此信息必须每250毫秒更新一次,这可能是一项非常昂贵的任务,因为我还使用反射来访问其某些值.我的第一种方法是使用IsVisible属性,但它不能像我预期的那样工作.

有什么方法可以确定控件是否对用户"可见"？

注意:我已经使用IsExpanded属性来跳过更新折叠节点,但是一些节点有100多个元素,并且找不到跳过网格视口之外的节点的方法.

我正在编写一个应用程序,它读取大型浮点数并使用它们执行一些简单的操作.我正在使用花车,因为我认为它比双打快,但经过一些研究后我发现这个主题有些混乱.任何人都可以详细说明这个吗？

我从来都不是匈牙利表示法的粉丝,除非你做了一些非常低级的编程,否则我总是觉得它很无用,但在每个C++项目中,我都采用了某种匈牙利符号政策,并且使用一些"非真正匈牙利"的前缀作为m_表示字段,s_表示静态,g_表示全局变量等等.

很快我意识到它在C#中有多么无用,并逐渐开始放弃我所有的旧习惯......但是'm_'的事情.我仍然在私有字段上使用m_前缀,因为我真的觉得能够区分参数,本地和字段非常有用.

MSDN上字段页面的命名约定说我不应该,但它没有说明原因(例如Google的惯例通常倾向于合理化他们的处方).

有没有理由我不应该或只是风格问题.如果是后者,前缀通常被认为是一种不好的风格,我是否可以期待其他人在代码库上做出负面反应？

我今天早些时候试过这个:

public interface IFoo
{
    IEnumerable<int> GetItems_A( ref int somethingElse );
    IEnumerable<int> GetItems_B( ref int somethingElse );
}


public class Bar : IFoo
{
    public IEnumerable<int> GetItems_A( ref int somethingElse )
    {
        // Ok...
    }

    public IEnumerable<int> GetItems_B( ref int somethingElse )
    {
        yield return 7; // CS1623: Iterators cannot have ref or out parameters            

    }
}

这背后的理由是什么？

我一直在使用FFT的Exocortex实现,但我遇到了一些问题.

每当我在调用iFFT之前修改频率区间的幅度时,结果信号包含一些咔嗒声和砰砰声,特别是当信号中存在低频时(如鼓或低音).但是,如果我用相同的因子衰减所有的箱子,就不会发生这种情况.

让我举一个4样本FFT输出缓冲区的例子:

// Bin 0 (DC)
FFTOut[0] = 0.0000610351563
FFTOut[1] = 0.0

// Bin 1
FFTOut[2] = 0.000331878662
FFTOut[3] = 0.000629425049

// Bin 2
FFTOut[4] = -0.0000381469727
FFTOut[5] =  0.0

// Bin 3, this is the first and only negative frequency bin.
FFTOut[6] =  0.000331878662
FFTOut[7] = -0.000629425049

输出由成对的浮点组成,每个浮点数代表单个bin的实部和虚部.因此,bin 0(数组索引0,1)将代表DC频率的实部和虚部.正如你所看到的,第1和第3个箱子都有相同的值(除了Im部分的符号),所以我猜bin 3是第一个负频率,最后索引(4,5)将是最后的正值频率仓.

然后,为了衰减频率仓1,这就是我所做的:

// Attenuate the 'positive' bin
FFTOut[2] *= 0.5;
FFTOut[3] *= 0.5;

// Attenuate its corresponding negative bin.
FFTOut[6] *= 0.5;
FFTOut[7] *= 0.5;

对于实际测试,我使用1024长度的FFT,我总是提供所有样本,因此不需要0填充.

// Attenuate
var …

我正在用C#编写一个DSP应用程序(基本上是一个多轨编辑器).我已经在不同的机器上进行了很长一段时间的分析,并且我注意到了一些"好奇"的东西.

在我的家用机器上,回放循环的第一次运行占用了可用时间的大约50%-60%,(我认为这是由于JIT完成其工作),然后对于后续循环,它会下降到稳定的5 % 消费.问题是,如果我在较慢的计算机上运行应用程序,第一次运行占用的时间超过可用时间,导致播放中断并弄乱输出音频,这是不可接受的.之后,它降至8%-10%的消费量.

即使在第一次运行之后,应用程序仍然不时地调用一些耗时的例程(每2秒或多或少),这导致稳定的5%消耗经历非常短的20%-25%的峰值.我注意到,如果我让应用程序运行一段时间,这些峰值也会下降到7%-10%.(我不确定这是否是由于JIT重新编译这些代码部分).

所以,我对JIT有一个严重的问题.虽然应用程序即使在非常慢的机器中也能很好地运行,但这些"编译风暴"将成为一个大问题.我正在试图弄清楚如何解决这个问题,我想出了一个想法,即用一个属性来标记所有"明智的"例程,该属性将告诉应用程序在启动时预先"挤压"它们因此,当他们真正需要时,他们将完全优化.但这只是一个想法(我也不太喜欢它),我想知道是否有更好的解决方案来解决整个问题.

我想听听你们的想法.

(NGEN应用程序不是一个选项,我喜欢并希望我能获得所有JIT优化.)

编辑:

内存消耗和垃圾收集没有问题,我正在使用对象池,播放期间的最大内存峰值为304 Kb.

这个问题长期困扰着我.我来自一个沉重而长期的C++背景,自从我开始使用C#进行编程并处理垃圾收集时,我总觉得这样的"魔术"会付出代价.

我最近开始在一个用Java(服务器端)编写的大型MMO项目中工作.我的主要任务是优化内存消耗和CPU使用率.每秒发送数十万条消息,同时创建相同数量的对象.经过大量的分析后,我们发现VM垃圾收集器占用了大量的CPU时间(由于常量收集),并决定尝试最小化对象创建,在适用的情况下使用池并重用我们可以做的一切.到目前为止,这被证明是一个非常好的优化.

所以,从我所学到的,拥有一个垃圾收集器很棒,但你不能只是假装它不存在,你仍然需要关注对象创建及其含义(至少在Java和一个大的像这样的应用程序).

那么,.NET也是如此吗？如果是,到什么程度？

我经常写这样的函数:

// Combines two envelopes and the result is stored in a new envelope.
public static Envelope Combine( Envelope a, Envelope b )
{
    var envelope = new Envelope( _a.Length, 0, 1, 1 );
    Combine( _a, _b, _operation, envelope );
    return envelope;
}

// Combines two envelopes and the result is 'written' to the specified envelope
public static void Combine( Envelope a, Envelope b, Envelope result )
{
    result.Clear();
    ...
}

提供第二个功能,以防有人有一个已经制作的信封可以重复使用来存储结果,但我发现这有点奇怪.

当我更喜欢使用类时,我有时会编写结构,因为我知道会有成千上万的实例不断被创建和处理,这对我来说真的很奇怪.

我知道作为.NET开发人员,我不应该担心这类问题,但我对Java和常识的经验告诉我,我应该这样做.

任何有关此事的亮点和想法都会受到赞赏.提前致谢.