Question

我正在开发一个WFP应用程序，它包含一个动态网格，具体取决于相关的订单类型。因此我将网格绑定到Dictionary<string, object>。

然而，在我允许用户粘贴新订单的一个屏幕上，我注意到有时并非所有值都是持久的，通常是当它们粘贴大量数据时，比如500行。我怀疑这是因为我使用的是Dictionary而不是ConcurrentDictionary所以并非所有对Dictionary的写入都被保留。

订单对象：

public interface IOrder : IDictionary<string, object>, 
{
    IOrderDataDictionary<string, object> OrderData { get; set; }
}

OrderDataDictionary

public class OrderDataDictionary<TKey, TValue> : IOrderDataDictionary<TKey, TValue>
{
    private static readonly ILog Log = LogManager.GetLogger(typeof(OrderDataDictionary<TKey, TValue>));
    private readonly IDictionary<TKey, TValue> _innerDictionary;

    #region Constructors
    public OrderDataDictionary()
    {
        _innerDictionary = new Dictionary<TKey, TValue>();
    }
    public OrderDataDictionary(int capacity)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(capacity);
    }

    public OrderDataDictionary(IDictionary<TKey, TValue> dictionary)
    {
        _innerDictionary = new Dictionary<TKey, TValue>(dictionary);
    }
    ...
}

添加到词典：

public Order ParseRows(List<string> rawRow, OrderType orderType)
{
    Order order = GenerateOrderEntryRow(orderType);
    List<string> row = rawRow.Select(x => x.ToString()).ToList();

    foreach (BulkEntryColumnConfig column in _pasteHeader[orderType])
    {
        if (!column.IncludeInRequest || !column.AutoParse)
            continue;

        string rawVal = row[column.Index];

        if (column.DataType == typeof (string))
        {
            Log.DebugFormat("{0}:{1}", column.Name, rawVal);
            order.OrderData[column.Name] = rawVal;
        }
    }
    ...
    return order;
}

顺序

public Order()
{
    _innerDictionary = new OrderDataDictionary<string, object>();
    OrderData = _innerDictionary;
}


public Order(IDictionary<string, object> dictionary)
{
    _innerDictionary = new OrderDataDictionary<string, object>(dictionary);
    OrderData = _innerDictionary;
}

GenerateOrderEntryRow（）

public Order GenerateOrderRow(OrderType orderType)
{
    Dictionary<string, object> dict = new Dictionary<string, object>();

    foreach (KeyValuePair<string, string> col in _columnDefinition[orderType])
    {
        dict.Add(col.Key, null);
    }

    dict["OrderType"] = orderType.ToString();
    Order row = new Order(dict);

    return row;
}

调用ParseRows（）

return Task<IList<Order>>.Factory.StartNew(() => {...ParseRows()...}

关键行是order.OrderData[column.Name] = rawVal;我在那里使用索引器为字典添加值。

我永远不会调用Order()，这意味着以后可能会调整基础字典的大小。我只从GenerateOrderEntryRow()调用Order（IDictionary字典），所以除非在其他地方隐式调用它。

我的问题是，为什么并非所有值都存储正确，我应该将Order.OrderData修改为ConcurrentDictionary类型吗？这会解决一些错过的写入问题吗？

字典

0 个答案: