C#或.NET中最糟糕的问题是什么？

也许不是最糟糕的,但是.net框架的某些部分使用度,而其他部分使用弧度 (并且Intellisense出现的文档从不告诉您哪个,您必须访问MSDN才能找到)

所有这一切都可以通过一个Angle班来代替......

对于C/C++程序员来说,过渡到C#是很自然的.然而,我遇到的最大问题(并且已经与其他人进行了相同的转换)并没有完全理解C#中的类和结构之间的区别.

在C++中,类和结构是相同的; 它们仅在默认可见性方面有所不同,其中类默认为私有可见性,而结构默认为公共可见性.在C++中,这个类定义

    class A
    {
    public:
        int i;
    };

在功能上等同于此结构定义.

    struct A
    {
        int i;
    };

但是,在C#中,类是引用类型,而结构是值类型.这在(1)决定何时使用一个而不是另一个,(2)测试对象相等,(3)性能(例如,装箱/拆箱)等方面产生了巨大的差异.

网上有各种与两者之间的差异有关的信息(例如,这里).我强烈鼓励任何过渡到C#的人至少掌握差异及其含义的实际知识.

垃圾收集和Dispose().虽然您不必做任何事情来释放内存,但您仍然需要通过Dispose()释放资源.当您使用WinForms或以任何方式跟踪对象时,这是一个非常容易忘记的事情.

foreach循环变量范围!

var l = new List>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    l.Add(() => s);
}

foreach (var a in l)
    Console.WriteLine(a());

打印五个"amet",而以下示例工作正常

var l = new List>();
var strings = new[] { "Lorem" , "ipsum", "dolor", "sit", "amet" };
foreach (var s in strings)
{
    var t = s;
    l.Add(() => t);
}

foreach (var a in l)
    Console.WriteLine(a());

MS SQL Server无法处理1753年之前的日期.重要的是,这与.NET DateTime.MinDate常量(1/1/1 )不同步.因此,如果你试图保存一个思想,一个畸形的日期(最近发生在我的数据导入中)或者仅仅是征服者威廉的出生日期,你就会遇到麻烦.没有内置的解决方法; 如果您可能需要在1753年之前使用日期,则需要编写自己的解决方法.

令人讨厌的Linq Caching Gotcha

见我的问题,导致这一发现,并在博客谁发现了这个问题.

简而言之,DataContext保留了您加载的所有Linq-to-Sql对象的缓存.如果其他人对您之前加载的记录进行了任何更改,即使您明确重新加载记录,也无法获取最新数据!

这是因为ObjectTrackingEnabledDataContext上调用了一个属性,默认情况下为true.如果将该属性设置为false,则每次都会重新加载记录... 但是 ......您不能使用SubmitChanges()持久保存对该记录的任何更改.

GOTCHA!

数组实现 IList

但是不要实现它.当您调用Add时,它会告诉您它不起作用.那么为什么一个类在它不能支持时实现一个接口呢？

编译,但不起作用:

IList myList = new int[] { 1, 2, 4 };
myList.Add(5);

我们有很多这个问题,因为序列化程序(WCF)将所有IList转换为数组并且我们得到运行时错误.

关于Stream.Read的合同是我见过很多人的事情:

// Read 8 bytes and turn them into a ulong
byte[] data = new byte[8];
stream.Read(data, 0, 8); // <-- WRONG!
ulong data = BitConverter.ToUInt64(data);

这是错误的原因是,最多只Stream.Read读取指定的字节数,但完全可以自由读取1个字节,即使在流结束前有另外7个字节可用.

它看起来如此相似并没有帮助,如果它没有异常返回Stream.Write,则保证写入所有字节.上述代码几乎一直在工作也没有帮助.当然,没有现成的,方便的方法正确读取N个字节也无济于事.

因此,为了堵塞漏洞,并提高对此的认识,这里有一个正确的方法来做到这一点:

    /// 

    /// Attempts to fill the buffer with the specified number of bytes from the
    /// stream. If there are fewer bytes left in the stream than requested then
    /// all available bytes will be read into the buffer.
    /// 
    /// Stream to read from.
    /// Buffer to write the bytes to.
    /// Offset at which to write the first byte read from
    ///                      the stream.
    /// Number of bytes to read from the stream.
    /// Number of bytes read from the stream into buffer. This may be
    ///          less than requested, but only if the stream ended before the
    ///          required number of bytes were read.
    public static int FillBuffer(this Stream stream,
                                 byte[] buffer, int offset, int length)
    {
        int totalRead = 0;
        while (length > 0)
        {
            var read = stream.Read(buffer, offset, length);
            if (read == 0)
                return totalRead;
            offset += read;
            length -= read;
            totalRead += read;
        }
        return totalRead;
    }

    /// 

    /// Attempts to read the specified number of bytes from the stream. If
    /// there are fewer bytes left before the end of the stream, a shorter
    /// (possibly empty) array is returned.
    /// 
    /// Stream to read from.
    /// Number of bytes to read from the stream.
    public static byte[] Read(this Stream stream, int length)
    {
        byte[] buf = new byte[length];
        int read = stream.FillBuffer(buf, 0, length);
        if (read < length)
            Array.Resize(ref buf, read);
        return buf;
    }

今天我修了一个很长时间没收的错误.该错误位于多线程场景中使用的泛型类中,并且使用静态int字段使用Interlocked提供无锁同步.该错误是由于类型的泛型类的每个实例化都有自己的静态引起的.因此每个线程都有自己的静态字段,并没有按预期使用锁.

class SomeGeneric
{
    public static int i = 0;
}

class Test
{
    public static void main(string[] args)
    {
        SomeGeneric.i = 5;
        SomeGeneric.i = 10;
        Console.WriteLine(SomeGeneric.i);
        Console.WriteLine(SomeGeneric.i);
        Console.WriteLine(SomeGeneric.i);
    }
}

这打印5 10 5

活动

我从未理解为什么事件是一种语言特征.它们使用起来很复杂:你需要在调用之前检查null,你需要取消注册(你自己),你无法找到谁注册了(例如:我注册了吗？).为什么事件不是图书馆中的一个类？基本上是专业的List吗？

可以不止一次地评估枚举数

当你有一个懒惰枚举的可枚举并且你迭代它两次并得到不同的结果时它会咬你.(或者你得到相同的结果,但它不必要地执行两次)

例如,在编写某个测试时,我需要一些临时文件来测试逻辑:

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName());

foreach (var file in files)
    File.WriteAllText(file, "HELLO WORLD!");

/* ... many lines of codes later ... */

foreach (var file in files)
    File.Delete(file);

想象一下File.Delete(file)投掷时的惊喜FileNotFound!!

这里发生的是,files枚举得到重复两次(从第一次迭代的结果根本不记得),并在每个新的迭代你会被重新调用Path.GetTempFilename(),所以你会得到一组不同的临时文件名.

当然,解决方案是通过使用ToArray()或者急切枚举值ToList():

var files = Enumerable.Range(0, 5)
    .Select(i => Path.GetTempFileName())
    .ToArray();

当你做多线程的事情时,这甚至更可怕,例如:

foreach (var file in files)
    content = content + File.ReadAllText(file);

content.Length所有的写作后你发现仍然是0!然后你开始严格检查你没有竞争条件......在一个浪费时间之后......你发现它只是那个小小的可疑的东西你忘记了......

刚刚发现了一个让我陷入调试一段时间的奇怪的事情:

您可以为可空int添加null而不抛出异常,并且值保持为null.

int? i = null;
i++; // I would have expected an exception but runs fine and stays as null

TextInfo textInfo = Thread.CurrentThread.CurrentCulture.TextInfo;

textInfo.ToTitleCase("hello world!"); //Returns "Hello World!"
textInfo.ToTitleCase("hElLo WoRld!"); //Returns "Hello World!"
textInfo.ToTitleCase("Hello World!"); //Returns "Hello World!"
textInfo.ToTitleCase("HELLO WORLD!"); //Returns "HELLO WORLD!"

是的,记录了这种行为,但这肯定不是正确的.

有一本关于.NET Gotchas的书

我最喜欢的是你在C#中创建一个类,将它继承到VB,然后尝试重新继承回C#,它不起作用.ARGGH

字典<,>:"未定义项目的返回顺序".这太可怕了,因为它有时可能会咬你,但是工作别人,如果你只是盲目地认为词典会发挥得很好("为什么不应该呢？我想,List会这样做"),你真的需要在你最终开始质疑你的假设之前,请先了解它.

(这里有类似的问题.)

private void DumpError(Exception exception, Stack context)
{
    if (context.Any())
    {
        Trace.WriteLine(context.Pop());
        Trace.Indent();
        this.DumpError(exception, context);
        Trace.Unindent();
    }
    else
    {
        Trace.WriteLine(exception.Message);
    }
}

private void DumpError(Exception exception, Stack context)
{
    if (context.Any())
    {
        var popped = context.Pop();
        Trace.WriteLine(popped);
        Trace.Indent();
        this.DumpError(exception, context);
        Trace.Unindent();
    }
    else
    {
        Trace.WriteLine(exception.Message);
    }
}

using System.Threading;
class Blah
{
    static void Main() { /* Won’t run because the static constructor deadlocks. */ }

    static Blah()
    {
        Thread thread = new Thread(ThreadBody);
        thread.Start();
        thread.Join();
    }

    static void ThreadBody() { }
}

SPSite oSiteCollection = SPContext.Current.Site;

oSiteCollection.Dispose();

enum Seasons
{
    Spring = 1, Summer = 2, Automn = 3, Winter = 4
}

public string HowYouFeelAbout(Seasons season)
{
    switch (season)
    {
        case Seasons.Spring:
            return "Nice.";
        case Seasons.Summer:
            return "Hot.";
        case Seasons.Automn:
            return "Cool.";
        case Seasons.Winter:
            return "Chilly.";
    }
}

((MyObject)obj).Equals(this);

((MyObject)obj) == this;

return result = from o in table
                where o.column == null
                select o;
//Returns all rows where column is null

int? myNullInt = null;
return result = from o in table
                where o.column == myNullInt
                select o;
//Never returns anything!

class Program
{
    static void Main(string[] args)
    {
        var originalNumbers = new List { 1, 2, 3, 4, 5, 6 };

        var list = new List(originalNumbers);
        var collection = new Collection(originalNumbers);

        originalNumbers.RemoveAt(0);

        DisplayItems(list, "List items: ");
        DisplayItems(collection, "Collection items: ");

        Console.ReadLine();
    }

    private static void DisplayItems(IEnumerable items, string title)
    {
        Console.WriteLine(title);
        foreach (var item in items)
            Console.Write(item);
        Console.WriteLine();
    }
}

List items: 123456
Collection items: 23456