首先,对标题感到抱歉 – 我无法弄清楚那个短而清晰的标题.

这是问题：我有一个列表List< MyClass>我总是添加新创建的MyClass实例的列表,如下所示：list.Add(new MyClass()).我不以任何其他方式添加元素.

然而,然后我用foreach迭代列表并发现有一些空条目.也就是说,以下代码：

foreach (MyClass entry in list)
    if (entry == null)
         throw new Exception("null entry!");

有时会抛出异常.
我应该指出list.Add(new MyClass())是从并发运行的不同线程执行的.我能想到的唯一考虑空条目的是并发访问.列表与LT;>毕竟,这不是线程安全的.虽然我仍然觉得奇怪的是它最终包含空条目,而不仅仅是在订购时没有提供任何保证.

你能想到其他任何原因吗？

此外,我不关心添加项目的顺序,我不希望调用线程阻止等待添加其项目.如果同步确实是问题,你能推荐一种简单的方法来异步调用Add方法,即创建一个委托,在我的线程继续运行其代码时处理它吗？我知道我可以为Add创建一个委托并在其上调用BeginInvoke.这看起来合适吗？

谢谢.

编辑：一个基于凯文的建议的简单解决方案：

public class AsynchronousList<T> : List<T> {

    private AddDelegate addDelegate;
    public delegate void AddDelegate(T item);

    public AsynchronousList() {
        addDelegate = new AddDelegate(this.AddBlocking);
    }

    public void AddAsynchronous(T item) {
        addDelegate.BeginInvoke(item,null,null);
    }

    private void AddBlocking(T item) {
        lock (this) {
            Add(item);
        }
    }
}

我只需要控制Add操作,我只需要这个用于调试(它不会在最终产品中),所以我只想快速修复.

谢谢大家的回答.

列表与LT; T>只能同时支持多个读者.如果要使用多个线程添加到列表中,则需要先锁定对象.实际上没有办法解决这个问题,因为如果没有锁定,你仍然可以让某人从列表中读取而另一个线程更新它(或者多个对象同时尝试更新它).

http://msdn.microsoft.com/en-us/library/6sh2ey19.aspx

您最好的选择可能是将列表封装在另一个对象中,并使该对象处理内部列表上的锁定和解锁操作.这样你就可以使你的新对象的“添加”方法异步,让调用对象以他们的快乐方式运行.任何时候你读它虽然你很可能仍然需要等待任何其他对象完成他们的更新.

我看到一些非常奇怪的东西,我无法解释.我猜测我不熟悉的C#的一些边缘情况,还是运行时/发射器的错误？

我有以下方法：

public static bool HistoryMessageExists(DBContext context,string id)
{
    return null != context.Getobject<HistoryMessage>(id);
}

在测试我的应用程序时,我看到它是不正常的 – 它为我知道的不存在于我的数据库的对象返回true.所以我停止了在方法和立即,我跑了以下：

context.Getobject<HistoryMessage>(id)
null
null == context.Getobject<HistoryMessage>(id)
true
null != context.Getobject<HistoryMessage>(id)
true

Getobject的定义如下：

public T Getobject<T>(object pk) where T : DBObject,new()
{
    T rv = Connection.Get<T>(pk);

    if (rv != null)
    {
        rv.AttachToContext(this);
        rv.IsInserted = true;
    }

    return rv;
}

有趣的是,当将表达式转换为对象时,正确评估比较：

null == (object)context.Getobject<HistoryMessage>(id)
true
null != (object)context.Getobject<HistoryMessage>(id)
false

没有平等的运算符覆盖.

编辑：事实证明有一个操作符超载,这是不正确的.但是,为什么在内部方法通用Getobject中正确评估这个方法,在这种情况下,rv的类型为HistoryMessage.

public class HistoryMessage : EquatableIdentifiableObject
{
    public static bool HistoryMessageExists(DBContext context,string id)
    {
        var rv = context.Getobject<HistoryMessage>(id);
        bool b = rv != null;
        return b;
    }

    public static void AddHistoryMessage(DBContext context,string id)
    {
        context.InsertObject(new HistoryMessage { Id = id });
    }
}

public abstract partial class EquatableIdentifiableObject : DBObject,IObservableObject
{
    public event PropertyChangedEventHandler PropertyChanged;

    [PrimaryKey]
    public string Id { get; set; }

    //...
}

public abstract partial class EquatableIdentifiableObject
{
    //...

    public static bool operator ==(EquatableIdentifiableObject self,EquatableIdentifiableObject other)
    {
        if (ReferenceEquals(self,null))
        {
            return ReferenceEquals(other,null);
        }

        return self.Equals(other);
    }

    public static bool operator !=(EquatableIdentifiableObject self,null))
        {
            return !ReferenceEquals(other,null);
        }

        return !self.Equals(other);
    }
}

public abstract class DBObject
{
    [Ignore]
    protected DBContext Context { get; set; }

    [Ignore]
    internal bool IsInserted { get; set; }

    //...
}

这里发生了什么？

>如你已经澄清的那样,==操作符失败,因为您的重载不正确.
>当转换为对象时,==操作符正常工作,因为它是被使用的对象的==的实现,而不是EquatableIdentifiableObject.
>在方法Getobject中,操作符正确地求值,因为它不是EquatableIdentifiableObject的正在使用的==的实现.在C#泛型中,运行时解析(至少在这里是相关的),而不是在编译时解决.注意==是静态而不是虚拟的.所以类型T在运行时被解析,但是调用==必须在编译时解决.在编译时,当编译器解析==它不会知道使用EquatableIdentifiableObject的==的实现.因为类型T有这个约束：其中T：DBObject,new(),DBObject的实现(如果有的话)将被使用.如果DBObject没有定义==,那么将使用第一个基类的实现(直到对象).

有关EquatableIdentifiableObject的实现的更多评论==：

>您可以替换此部分：

if (ReferenceEquals(self,null))
{
     return ReferenceEquals(other,null);
}

有：

// If both are null,or both are the same instance,return true.
if (object.ReferenceEquals(h1,h2))
{
    return true;
}

>更换更有力

public static bool operator !=(EquatableIdentifiableObject self,EquatableIdentifiableObject other)
{
    ...
}

有：

public static bool operator !=(EquatableIdentifiableObject self,EquatableIdentifiableObject other)
{
    return !(self == other);
}

>为==定义签名的方法略有误导.第一个参数命名为self,第二个命名为other.如果==是一个实例方法就可以了.由于它是一种静态方法,所以名字自身有点误导.更好的名称将是o1和o2或沿着这条线的东西,以便两个操作数在更平等的基础上对待.