我有许多不可变的值类型类,例如EmailAddress
,它们确保任何非null实例都有效。我希望在使用MongoDB C#Driver持久化时,将这些类型的对象的序列化控制为标准字符串表示形式("123@abc.com"
)。
我已尝试实现IBsonSerilizer
,但它只允许根级别的对象或数组。我能用Json.NET实现适当的Json Serilization,我应该采用不同的方法吗?
答案 0 :(得分:5)
我认为你的意思是这样的EmailAddress类:
[BsonSerializer(typeof(EmailAddressSerializer))]
public class EmailAddress
{
private string _value;
public EmailAddress(string value)
{
_value = value;
}
public string Value
{
get { return _value; }
}
}
我使用了一个属性将EmailAddress类链接到自定义序列化程序,可以像这样实现:
public class EmailAddressSerializer : BsonBaseSerializer
{
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (bsonReader.GetCurrentBsonType() == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
var value = bsonReader.ReadString();
return new EmailAddress(value);
}
}
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
if (value == null)
{
bsonWriter.WriteNull();
}
else
{
var emailAddress = (EmailAddress)value;
bsonWriter.WriteString(emailAddress.Value);
}
}
}
您无法将EmailAddress序列化为根文档(因为它不是文档...)。但您可以使用嵌入在其他文档中的EmailAddress。例如:
public class Person
{
public int Id { get; set; }
public EmailAddress EmailAddress { get; set; }
}
您可以使用以下代码进行测试:
var person = new Person { Id = 1, EmailAddress = new EmailAddress("joe@xyz.com") };
var json = person.ToJson();
var rehyrdated = BsonSerializer.Deserialize<Person>(json);
生成的JSON / BSON文档是:
{ "_id" : 1, "EmailAddress" : "joe@xyz.com" }
答案 1 :(得分:1)
我试图通过创建一个约定来解决这个问题,该约定映射了与构造函数匹配的所有只读属性以及匹配的构造函数。
假设你有一个类:
public class Person
{
public string FirstName { get; }
public string LastName { get; }
public string FullName => FirstName + LastName;
public ImmutablePocoSample(string lastName)
{
LastName = lastName;
}
public ImmutablePocoSample(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
}
以下是约定的代码:
/// <summary>
/// A convention that map all read only properties for which a matching constructor is found.
/// Also matching constructors are mapped.
/// </summary>
public class ImmutablePocoConvention : ConventionBase, IClassMapConvention
{
private readonly BindingFlags _bindingFlags;
public ImmutablePocoConvention()
: this(BindingFlags.Instance | BindingFlags.Public)
{ }
public ImmutablePocoConvention(BindingFlags bindingFlags)
{
_bindingFlags = bindingFlags | BindingFlags.DeclaredOnly;
}
public void Apply(BsonClassMap classMap)
{
var readOnlyProperties = classMap.ClassType.GetTypeInfo()
.GetProperties(_bindingFlags)
.Where(p => IsReadOnlyProperty(classMap, p))
.ToList();
foreach (var constructor in classMap.ClassType.GetConstructors())
{
// If we found a matching constructor then we map it and all the readonly properties
var matchProperties = GetMatchingProperties(constructor, readOnlyProperties);
if (matchProperties.Any())
{
// Map constructor
classMap.MapConstructor(constructor);
// Map properties
foreach (var p in matchProperties)
classMap.MapMember(p);
}
}
}
private static List<PropertyInfo> GetMatchingProperties(ConstructorInfo constructor, List<PropertyInfo> properties)
{
var matchProperties = new List<PropertyInfo>();
var ctorParameters = constructor.GetParameters();
foreach (var ctorParameter in ctorParameters)
{
var matchProperty = properties.FirstOrDefault(p => ParameterMatchProperty(ctorParameter, p));
if (matchProperty == null)
return new List<PropertyInfo>();
matchProperties.Add(matchProperty);
}
return matchProperties;
}
private static bool ParameterMatchProperty(ParameterInfo parameter, PropertyInfo property)
{
return string.Equals(property.Name, parameter.Name, System.StringComparison.InvariantCultureIgnoreCase)
&& parameter.ParameterType == property.PropertyType;
}
private static bool IsReadOnlyProperty(BsonClassMap classMap, PropertyInfo propertyInfo)
{
// we can't read
if (!propertyInfo.CanRead)
return false;
// we can write (already handled by the default convention...)
if (propertyInfo.CanWrite)
return false;
// skip indexers
if (propertyInfo.GetIndexParameters().Length != 0)
return false;
// skip overridden properties (they are already included by the base class)
var getMethodInfo = propertyInfo.GetMethod;
if (getMethodInfo.IsVirtual && getMethodInfo.GetBaseDefinition().DeclaringType != classMap.ClassType)
return false;
return true;
}
}
您可以使用以下方式注册我:
ConventionRegistry.Register(
nameof(ImmutablePocoConvention),
new ConventionPack { new ImmutablePocoConvention() },
_ => true);
答案 2 :(得分:0)
在我读完 @Davide Icardi 的答案后,我发现convention内置了不可变对象。
只需注册惯例
即可ConventionRegistry.Register(nameof(ImmutableTypeClassMapConvention),
new ConventionPack { new ImmutableTypeClassMapConvention()}, type => true);