小编maf*_*afu的帖子

我有几个这种模式的单元测试:

[TestMethod ()]
[ExpectedException (typeof (ArgumentNullException))]
public void DoStuffTest_Exception ()
{
    var foo = new Foo ();
    Foo.DoStuff (null);
}

事实证明,代码覆盖率将抛出线标记为半运行,因此每次我得到1块未覆盖的代码.

在考虑了这个问题一段时间后,我能想出的最佳解决方案是添加一个try/catch.由于这是一个重复的模式,我将创建一个帮助方法

public static void ExpectException<_T> (Action action) where _T: Exception
{
    try { action(); }
    catch (_T) { return; }
    Assert.Fail ("Expected " + _T);
}

这将有很好的附带好处,我可以将所有异常测试添加到非投掷测试.

这是一个有效的设计,还是我错过了什么？

编辑: Ugs ...看起来像上面的ExpectException方法也留下了1个未覆盖的块.

我看到一些程序员添加的代码毕竟没有做任何有用的事情.例如(C#):

[Serializable]
class Foo {
    // ...
    string SerializeMe() {
        return new XmlSerializer(typeof(this)).Serialize(this).ToString(); // serialize to xml (syntax wrong, not important here)
    }
}

该类被标记为Serializable,但它被序列化的唯一方法是通过XmlSerialization,它根本不需要class属性.

我个人讨厌这种无用的代码,但我经常看到它,我很好奇其他人对它的看法.毕竟这不是一个严重的缺陷吗？这是行业中的常见做法吗？或者这只是简单的坏事,无论如何应该删除？

我想像这样使用XML序列化:

class Foo {
    public Foo (string name) {
        Name1 = name;
        Name2 = name;
    }

    [XmlInclude]
    public string Name1 { get; private set; }

    [XmlInclude]
    private string Name2;
}

StreamWriter wr = new StreamWriter("path.xml");
new XmlSerializer<Foo>().Serialize (wr, new Foo ("me"));

编辑:我知道这段代码错了.这只是为了展示我想如何使用它.

但这根本不起作用:

• XmlSerializer不是通用的.我必须对(de)序列化进行转换.
• 每个房产都必须完全公开.为什么我们不只是使用Reflection来访问私人设置者？
• 私有字段无法序列化.我想用属性装饰私有字段让XmlSerializer包含它们.

我错过了什么,XmlSerializer实际上提供了所描述的可能性吗？是否有替代的XML序列化程序可以更复杂地处理这些情况？

如果不是:我们毕竟是在2010年,.NET已存在多年.通常使用XML序列化,完全标准化,并且应该非常容易执行.或者我的理解可能是错误的,XML序列化不应该有充分的理由暴露所描述的功能？

编辑:遗产不是一个很好的理由imo.List起初也是非通用的.

(随意调整标题或标签.如果这应该是CW,请只需删除一个注释.)

我想在文件系统中轮询任何已更改,添加或删除的文件或子目录.应尽快检测所有更改,但不要对机器施加压力.操作系统是Windows> = Vista,观察到的部分是本地目录.

通常情况下,我会使用FileSystemWatcher,但这会导致其他程序试图查看相同位置的问题(突出显示,Windows资源管理器).另外,我听说FSW即使对于本地文件夹和大缓冲区也不是很可靠.

我遇到的主要问题是文件和目录的数量可能非常大(猜数为7位).只需每秒检查一次所有文件就会对我的机器造成明显影响.

我的下一个想法是每秒检查整棵树的不同部分以减少整体影响,并可能添加一种启发式方法,例如检查经常更快地更改的文件.

我想知道是否有这种问题的模式,或者是否有人有这种情况的经验.

我有一个与XML序列化兼容的基类和一个实现IXmlSerializable的派生类.

在此示例中,基类确实实现了IXmlSerializable:

using System.Diagnostics;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace XmlSerializationDerived
{
    public class Foo
    {
        public int fooProp;

        public XmlSchema GetSchema()
        {
            return null;
        }

        public void ReadXml(XmlReader reader)
        {
            fooProp = int.Parse (reader.ReadElementString ("fooProp"));
        }

        public void WriteXml(XmlWriter writer)
        {
            writer.WriteElementString ("fooProp", fooProp.ToString ());
        }
    }

    public class Bar : Foo, IXmlSerializable
    {
        public new void ReadXml(XmlReader reader)
        {
            base.ReadXml (reader);
        }

        public new void WriteXml(XmlWriter writer)
        {
            base.WriteXml (writer);
        }

        static void Main(string[] args) …

我有一个树状的结构.此结构中的每个元素都应该能够返回它所属的所有元素的Enumerable.我们称之为这种方法IEnumerable<Foo> GetAll().所以,如果我们有

      A <-- topmost root
    /   \
   B     C
  / \   / \
  D  E  F  G

GetAll对元素C返回的调用{C, F, G}(元素的固定顺序很好,但不需要).我想每个人都已经知道了.

目前的实现GetAll看起来像这样:

public IEnumerable<Foo> GetAll ()
{
    yield return this;

    foreach (Foo foo in MyChildren) {
        foreach (Foo f in foo.GetAll ()) {
            yield return f;
        }
    }
}

在早期的实现中,我返回了一个List并添加了child-foos List.AddRange().

我的问题是,是否正确实施了使用产量的版本,或者是否应该改进(特别是在性能方面).或者这只是坏事我应该坚持Lists(或ReadOnlyCollections)而不是？

在家里,我正在开发一个用Java编写的大型个人项目.我最近找到了C#开发人员的工作.

经过8个小时的工作日阅读C#代码后,我发现很难在家里切换回Java.实际上,自从我受雇以来,我的家庭项目几乎完全停滞不前.

起初我以为我必须等待休假才能真正切换回Java,但即使在大脑上没有C#一周之后,我也无法再次进入Java风格.我不想承认我的家庭项目已经死亡,但我无法真正看到克服这个问题的方法.

Math.Pi根据反射器和MSDN,常数等于3.14159265358979323846.在Visual Studio 2010中查看Math类时,该值显示为3.14159.截断宝贵的常数我可以归咎于谁？

可能重复:
如何使用反射调用静态构造函数？

我在各种类的静态构造函数中有一些初始化代码.我不能创建实例,也不提前知道类型.我想确保加载类.

我试过这个:

fooType.TypeInitializer.Invoke (new object[0]);

但得到一个MemberAccessException:类型初始化程序不可调用.

我假设这是因为cctor是私有的？有没有办法在不改变架构的情况下解决这个问题？

编辑:我找到了一个解决方法使用RuntimeHelpers.RunClassConstructor,但这种方式似乎几乎没有在MSDN中记录,我不确定它是一个黑客或一个合理的,prod系统的方式.

我目前正在尝试编写一个线程安全的记录器类.我对这方面的正确设计和最佳实践不是很熟悉.我的代码有缺陷吗？

public class WriteStuff
{
    private readonly StreamWriter m_Writer;
    private readonly object m_WriteLock = new object ();

    public WriteStuff(String path)
    {
        m_Writer = File.CreateText (path);

        m_Writer.WriteLine ("x");
        m_Writer.Flush ();
    }

    public void ListenTo(Foo foo)
    {
        foo.SomeEvent += new EventHandler<SomeArgs> (Foo_Update);
    }

    private void Foo_Update(object sender, SomeArgs args)
    {
        lock (m_WriteLock) {
            m_Writer.WriteLine (args);
            m_Writer.Flush ();
        }
    }
}