BsonCreatorMap.cs

/* Copyright 2010-present MongoDB Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Reflection;

namespaceMongoDB.Bson.Serialization
{
/// <summary>
/// Represents a mapping to a delegate and its arguments.
/// </summary>
publicclassBsonCreatorMap
{
// private fields
privatereadonlyBsonClassMap_classMap;
privatereadonlyMemberInfo_memberInfo;// null if there is no corresponding constructor or factory method
privatereadonlyDelegate_delegate;
privatebool_isFrozen;
privateList<MemberInfo>_arguments;// the members that define the values for the delegate's parameters

// these values are set when Freeze is called
privateList<string>_elementNames;// the element names of the serialized arguments
privateDictionary<string,object>_defaultValues;// not all arguments have default values

// constructors
/// <summary>
/// Initializes a new instance of the BsonCreatorMap class.
/// </summary>
/// <param name="classMap">The class map.</param>
/// <param name="memberInfo">The member info (null if none).</param>
/// <param name="delegate">The delegate.</param>
publicBsonCreatorMap(BsonClassMapclassMap,MemberInfomemberInfo,Delegate@delegate)
{
if(classMap==null)
{
thrownewArgumentNullException("classMap");
}
if(@delegate==null)
{
thrownewArgumentNullException("delegate");
}

_classMap=classMap;
_memberInfo=memberInfo;
_delegate=@delegate;
}

// public properties
/// <summary>
/// Gets the arguments.
/// </summary>
publicIEnumerable<MemberInfo>Arguments
{
get{return_arguments;}
}

/// <summary>
/// Gets the class map that this creator map belongs to.
/// </summary>
publicBsonClassMapClassMap
{
get{return_classMap;}
}

/// <summary>
/// Gets the delegeate
/// </summary>
publicDelegateDelegate
{
get{return_delegate;}
}

/// <summary>
/// Gets the element names.
/// </summary>
publicIEnumerable<string>ElementNames
{
get
{
if(!_isFrozen){ThrowNotFrozenException();}
return_elementNames;
}
}

/// <summary>
/// Gets the member info (null if none).
/// </summary>
publicMemberInfoMemberInfo
{
get{return_memberInfo;}
}

// public methods
/// <inheritdoc/>
publicoverrideboolEquals(objectobj)
{
if(object.ReferenceEquals(obj,null)){returnfalse;}
if(object.ReferenceEquals(this,obj)){returntrue;}
// note: we can't compare _classMap(s) because that would result in infinite recursion
// note: if _memberInfo(s) are Equal we have to ignore the _delegate(s)
// so this is the best implementation we can have
return
GetType().Equals(obj.GetType())&&
objisBsonCreatorMapother&&
(_memberInfo!=null&&object.Equals(_memberInfo,other._memberInfo)||object.Equals(_delegate,other._delegate));
}

/// <summary>
/// Freezes the creator map.
/// </summary>
publicvoidFreeze()
{
if(!_isFrozen)
{
varallMemberMaps=_classMap.AllMemberMaps;

varelementNames=newList<string>();
vardefaultValues=newDictionary<string,object>();

varexpectedArgumentsCount=GetExpectedArgumentsCount();
if(_arguments!=null)
{
if(_arguments.Count!=expectedArgumentsCount)
{
thrownewBsonSerializationException($"Creator map for class {_classMap.ClassType.FullName} has {expectedArgumentsCount} arguments, not {_arguments.Count}.");
}

foreach(varargumentin_arguments)
{
varmemberMap=allMemberMaps.FirstOrDefault(m =>IsSameMember(m.MemberInfo,argument));
if(memberMap==null)
{
varmessage=string.Format("Member '{0}' is not mapped.",argument.Name);
thrownewBsonSerializationException(message);
}
elementNames.Add(memberMap.ElementName);
if(memberMap.IsDefaultValueSpecified)
{
defaultValues.Add(memberMap.ElementName,memberMap.DefaultValue);
}
}
}
else
{
if(expectedArgumentsCount!=0)
{
thrownewBsonSerializationException($"Creator map for class {_classMap.ClassType.FullName} has {expectedArgumentsCount} arguments, but none are configured.");
}
}

_elementNames=elementNames;
_defaultValues=defaultValues;
_isFrozen=true;
}
}

/// <inheritdoc/>
publicoverrideintGetHashCode()=>0;

/// <summary>
/// Gets whether there is a default value for a missing element.
/// </summary>
/// <param name="elementName">The element name.</param>
/// <returns>True if there is a default value for element name; otherwise, false.</returns>
publicboolHasDefaultValue(stringelementName)
{
if(!_isFrozen){ThrowNotFrozenException();}
return_defaultValues.ContainsKey(elementName);
}

/// <summary>
/// Sets the arguments for the creator map.
/// </summary>
/// <param name="arguments">The arguments.</param>
/// <returns>The creator map.</returns>
publicBsonCreatorMapSetArguments(IEnumerable<MemberInfo>arguments)
{
if(arguments==null)
{
thrownewArgumentNullException("arguments");
}
if(_isFrozen){ThrowFrozenException();}
varargumentsList=arguments.ToList();// only enumerate once

varexpectedArgumentsCount=GetExpectedArgumentsCount();
if(argumentsList.Count!=expectedArgumentsCount)
{
thrownewArgumentException($"Creator map for class {_classMap.ClassType.FullName} has {expectedArgumentsCount} arguments, not {argumentsList.Count}.",nameof(arguments));
}

_arguments=argumentsList;
returnthis;
}

/// <summary>
/// Sets the arguments for the creator map.
/// </summary>
/// <param name="argumentNames">The argument names.</param>
/// <returns>The creator map.</returns>
publicBsonCreatorMapSetArguments(IEnumerable<string>argumentNames)
{
if(argumentNames==null)
{
thrownewArgumentNullException("argumentNames");
}
if(_isFrozen){ThrowFrozenException();}

varclassTypeInfo=_classMap.ClassType.GetTypeInfo();
vararguments=newList<MemberInfo>();
foreach(varargumentNameinargumentNames)
{
varbindingFlags=BindingFlags.Instance|BindingFlags.NonPublic|BindingFlags.Public;
varmemberInfos=classTypeInfo.GetMembers(bindingFlags)
.Where(m =>m.Name==argumentName&&(misFieldInfo||misPropertyInfo))
.ToArray();
if(memberInfos.Length==0)
{
varmessage=string.Format("Class '{0}' does not have a member named '{1}'.",_classMap.ClassType.FullName,argumentName);
thrownewBsonSerializationException(message);
}
elseif(memberInfos.Length>1)
{
varmessage=string.Format("Class '{0}' has more than one member named '{1}'.",_classMap.ClassType.FullName,argumentName);
thrownewBsonSerializationException(message);
}
arguments.Add(memberInfos[0]);
}

SetArguments(arguments);
returnthis;
}

// internal methods
internalobjectCreateInstance(Dictionary<string,object>values)
{
vararguments=newList<object>();

// get the values for the arguments to be passed to the creator delegate
foreach(varelementNamein_elementNames)
{
objectargument;
if(values.TryGetValue(elementName,outargument))
{
values.Remove(elementName);
}
elseif(!_defaultValues.TryGetValue(elementName,outargument))
{
// shouldn't happen unless there is a bug in ChooseBestCreator
thrownewBsonInternalException();
}
arguments.Add(argument);
}

return_delegate.DynamicInvoke(arguments.ToArray());
}

// private methods
privateintGetExpectedArgumentsCount()
{
varconstructorInfo=_memberInfoasConstructorInfo;
if(constructorInfo!=null)
{
returnconstructorInfo.GetParameters().Length;
}

varmethodInfo=_memberInfoasMethodInfo;
if(methodInfo!=null)
{
returnmethodInfo.GetParameters().Length;
}

vardelegateParameters=_delegate.GetMethodInfo().GetParameters();
if(delegateParameters.Length==0)
{
return0;
}
else
{
// check if delegate is closed over its first parameter
if(_delegate.Target!=null&&_delegate.Target.GetType()==delegateParameters[0].ParameterType)
{
returndelegateParameters.Length-1;
}
else
{
returndelegateParameters.Length;
}
}
}

privateboolIsSameMember(MemberInfoa,MemberInfob)
{
// two MemberInfos refer to the same member if the Module and MetadataToken are equal
returna.Module==b.Module&&a.MetadataToken==b.MetadataToken;
}

privatevoidThrowFrozenException()
{
thrownewInvalidOperationException("BsonCreatorMap is frozen.");
}

privatevoidThrowNotFrozenException()
{
thrownewInvalidOperationException("BsonCreatorMap is not frozen.");
}
}
}