C# 存储复合/嵌套对象图_C#_Bson_Mongodb .net Driver

C# 存储复合/嵌套对象图

C# 存储复合/嵌套对象图,c#,bson,mongodb-.net-driver,C#,Bson,Mongodb .net Driver,我目前正在Mongo DB中开发一个文档库，其中包含特定项目的完整材料明细。分解是经过计算的，包含一个复合结构域模型： public interface IReagent { int ItemId { get; set; } int Quantity { get; set; } ConcurrentBag<IReagent> Reagents { get; set; } } public class Craft : IReagent { publi

我目前正在Mongo DB中开发一个文档库，其中包含特定项目的完整材料明细。分解是经过计算的，包含一个复合结构

域模型：

public interface IReagent
{
    int ItemId { get; set; }
    int Quantity { get; set; }
    ConcurrentBag<IReagent> Reagents { get; set; }
}

public class Craft : IReagent
{
    public int ItemId { get; set; }
    public int Quantity { get; set; }
    public int SpellId { get; set; }
    public int Skill { get; set; }
    public Profession Profession { get; set; }
    public ConcurrentBag<IReagent> Reagents { get; set; }
}

public class Reagent : IReagent
{
    public int ItemId { get; set; }
    public int Quantity { get; set; }
    public ConcurrentBag<IReagent> Reagents { get; set; }
}

它的外观示例

有什么问题吗？

问题是您使用的是抽象列表，它无法将这些抽象序列化为JSON，因此基本上您需要编写自己的自定义序列化。下面是我编写的自定义序列化示例：

 public class FieldsWrapper : IBsonSerializable
    {
        public List<DataFieldValue> DataFieldValues { get; set; }


        public object Deserialize(MongoDB.Bson.IO.BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
        {
        if (nominalType != typeof(FieldsWrapper)) throw new ArgumentException("Cannot deserialize anything but self");
        var doc = BsonDocument.ReadFrom(bsonReader);
        var list = new List<DataFieldValue>();
        foreach (var name in doc.Names)
        {
            var val = doc[name];
            if (val.IsString)
                list.Add(new DataFieldValue {LocalIdentifier = name, Values = new List<string> {val.AsString}});
            else if (val.IsBsonArray)
            {
                DataFieldValue df = new DataFieldValue {LocalIdentifier = name};
                foreach (var elem in val.AsBsonArray)
                {
                    df.Values.Add(elem.AsString);
                }
                list.Add(df);
            }
        }
        return new FieldsWrapper {DataFieldValues = list};
        }


        public void Serialize(MongoDB.Bson.IO.BsonWriter bsonWriter, Type nominalType, IBsonSerializationOptions options)
        {
            if (nominalType != typeof (FieldsWrapper))
                throw new ArgumentException("Cannot serialize anything but self");
            bsonWriter.WriteStartDocument();
            foreach (var dataFieldValue in DataFieldValues)
            {

                bsonWriter.WriteName(dataFieldValue.LocalIdentifier);
                if (dataFieldValue.Values.Count != 1)
                {
                    var list = new string[dataFieldValue.Values.Count];
                    for (int i = 0; i < dataFieldValue.Values.Count; i++)
                        list[i] = dataFieldValue.Values[i];
                    BsonSerializer.Serialize(bsonWriter, list); 
                }
                else
                {
                    BsonSerializer.Serialize(bsonWriter, dataFieldValue.Values[0]); 
                }
            }
            bsonWriter.WriteEndDocument();
        }

    }

public-class-FieldsWrapper:IBsonSerializable
{
公共列表DataFieldValues{get；set；}
公共对象反序列化（MongoDB.Bson.IO.BsonReader-BsonReader，类型nominalType，IBsonSerializationOptions）
{
if（nominalType！=typeof（FieldsWrapper））抛出新的ArgumentException（“不能反序列化除self以外的任何内容”）；
var doc=BsonDocument.ReadFrom（bsonReader）；
var list=新列表（）；
foreach（文档名称中的变量名称）
{
var val=单据[名称]；
如果（val.IsString）
添加（新数据字段值{LocalIdentifier=name，值=新列表{val.AsString}）；
else if（val.IsBsonArray）
{
DataFieldValue df=新DataFieldValue{LocaliIdentifier=name}；
foreach（val.AsBsonArray中的var元素）
{
df.Values.Add（元素关联）；
}
列表。添加（df）；
}
}
返回新的FieldsWrapper{DataFieldValues=list}；
}
public void序列化（MongoDB.Bson.IO.BsonWriter BsonWriter，类型nominalType，IBsonSerializationOptions）
{
if（nominalType！=typeof（FieldsWrapper））
抛出新ArgumentException（“无法序列化除self以外的任何内容”）；
bsonWriter.WriteStartDocument（）；
foreach（DataFieldValues中的var dataFieldValue）
{
bsonWriter.WriteName（dataFieldValue.LocalIdentifier）；
如果（dataFieldValue.Values.Count！=1）
{
var list=新字符串[dataFieldValue.Values.Count]；
对于（int i=0；i


在你的情况下，我会在试剂类的层次上编写我的自定义序列化，实现IBMsonSerializer工作：）做了一个快速的模型，它工作得很好：D我从某人那里得到了另一个建议，他说一个列表
可以工作，我将在本周晚些时候尝试。然后把结果贴在这里
/* 3131 */
{
  "_id" : ObjectId("4e4d58df77d2cf00691aaef2"),
  "ItemId" : 28432,
  "Quantity" : 0,
  "Reagents" : [{
      "ItemId" : 23448,
      "Quantity" : 0,
      "Reagents" : [{
          "ItemId" : 23447,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23427,
              "Quantity" : 2,
              "Reagents" : []
            }]
        }, {
          "ItemId" : 23445,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23424,
              "Quantity" : 2,
              "Reagents" : []
            }]
        }]
    }, {
      "ItemId" : 23572,
      "Quantity" : 8,
      "Reagents" : []
    }, {
      "ItemId" : 28431,
      "Quantity" : 0,
      "Reagents" : [{
          "ItemId" : 23571,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 21885,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 21884,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 22451,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 21885,
                  "Quantity" : 1,
                  "Reagents" : []
                }]
            }, {
              "ItemId" : 22452,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 22457,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 21884,
                  "Quantity" : 1,
                  "Reagents" : []
                }]
            }]
        }, {
          "ItemId" : 22456,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 21885,
              "Quantity" : 1,
              "Reagents" : []
            }]
        }, {
          "ItemId" : 23573,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23446,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23425,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }]
        }, {
          "ItemId" : 23448,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23447,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23427,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }, {
              "ItemId" : 23445,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23424,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }]
        }]
    }]
}
序列化实现：
public void Serialize(MongoDB.Bson.IO.BsonWriter bsonWriter, Type nominalType, MongoDB.Bson.Serialization.IBsonSerializationOptions options)
{
    if (nominalType != typeof(IReagent) && nominalType != typeof(Reagent) && nominalType != typeof(Craft))
    {
        throw new ArgumentException("Cannot serialize anything but self");
    }

    bsonWriter.WriteStartDocument();

    bsonWriter.WriteInt32("ItemId", this.ItemId);
    bsonWriter.WriteInt32("Quantity", this.Quantity);

    if (this.Reagents != null)
    {
        bsonWriter.WriteName("Reagents");
        bsonWriter.WriteStartArray();

        foreach (var r in this.Reagents)
        {
            BsonSerializer.Serialize(bsonWriter, r.GetType(), r, options);
        }

        bsonWriter.WriteEndArray();
    }

    bsonWriter.WriteEndDocument();

}
我假设传入时它是非null的？我可以检查一下吗？您真的需要这里的ConcurrentBag
？列表
是否不够？你会觉得那样更快乐吗？请注意，我还想知道IReagant
作为一个接口是否是一个基本问题，因为除非它存储类型信息（即具体的reagant类型），否则当我在运行时调试中选中“crafts”时，它不知道重建什么，因为它包含一个复合结构。我使用MS的并行.NET 4.0库来计算对象图，因此需要使用ConcurrentBag来避免使用锁。我已经开始怀疑这样的事情了。它不支持接口，尽管Craft也是一个实现IReagent并被存储。存储Craft
的实例不同于存储恰好是Craft
的IReagent
的实例。特别是对于序列化库（请相信我；p），我相信您：D只是想知道为什么序列化程序识别Craft而不是IEnumerable。它基本上是一个混合了工艺或试剂的具体实例的列表。我想BSON序列化程序没有那么智能。我还对Redis做了一些测试（在这种情况下，Redis驱动程序可以正常工作）。我想添加一个自定义序列化程序（如下所示）可以解决这个问题：）因为在Craft
的情况下，它知道类型-它是Craft
。现在：您为IReagant创建了什么对象？感谢您的发帖，我今晚将尝试一下：）
/* 3131 */
{
  "_id" : ObjectId("4e4d58df77d2cf00691aaef2"),
  "ItemId" : 28432,
  "Quantity" : 0,
  "Reagents" : [{
      "ItemId" : 23448,
      "Quantity" : 0,
      "Reagents" : [{
          "ItemId" : 23447,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23427,
              "Quantity" : 2,
              "Reagents" : []
            }]
        }, {
          "ItemId" : 23445,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23424,
              "Quantity" : 2,
              "Reagents" : []
            }]
        }]
    }, {
      "ItemId" : 23572,
      "Quantity" : 8,
      "Reagents" : []
    }, {
      "ItemId" : 28431,
      "Quantity" : 0,
      "Reagents" : [{
          "ItemId" : 23571,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 21885,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 21884,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 22451,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 21885,
                  "Quantity" : 1,
                  "Reagents" : []
                }]
            }, {
              "ItemId" : 22452,
              "Quantity" : 1,
              "Reagents" : []
            }, {
              "ItemId" : 22457,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 21884,
                  "Quantity" : 1,
                  "Reagents" : []
                }]
            }]
        }, {
          "ItemId" : 22456,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 21885,
              "Quantity" : 1,
              "Reagents" : []
            }]
        }, {
          "ItemId" : 23573,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23446,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23425,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }]
        }, {
          "ItemId" : 23448,
          "Quantity" : 0,
          "Reagents" : [{
              "ItemId" : 23447,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23427,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }, {
              "ItemId" : 23445,
              "Quantity" : 0,
              "Reagents" : [{
                  "ItemId" : 23424,
                  "Quantity" : 2,
                  "Reagents" : []
                }]
            }]
        }]
    }]
}
public void Serialize(MongoDB.Bson.IO.BsonWriter bsonWriter, Type nominalType, MongoDB.Bson.Serialization.IBsonSerializationOptions options)
{
    if (nominalType != typeof(IReagent) && nominalType != typeof(Reagent) && nominalType != typeof(Craft))
    {
        throw new ArgumentException("Cannot serialize anything but self");
    }

    bsonWriter.WriteStartDocument();

    bsonWriter.WriteInt32("ItemId", this.ItemId);
    bsonWriter.WriteInt32("Quantity", this.Quantity);

    if (this.Reagents != null)
    {
        bsonWriter.WriteName("Reagents");
        bsonWriter.WriteStartArray();

        foreach (var r in this.Reagents)
        {
            BsonSerializer.Serialize(bsonWriter, r.GetType(), r, options);
        }

        bsonWriter.WriteEndArray();
    }

    bsonWriter.WriteEndDocument();

}