|
static private ArgumentMemberNotDeclOnType ( object p0, object p1, string paramName ) : |
||
| p0 | object | |
| p1 | object | |
| paramName | string | |
| Результат | ||
/// <summary>
/// Creates a <see cref="WithCSharpExpression"/> that represents a with expression applied to an anonymous type.
/// </summary>
/// <param name="object">The expression representing the object to clone and mutate.</param>
/// <param name="members">The members of the anonymous type in the order of their assignment by the constructor parameters.</param>
/// <param name="initializers">The initializers used to mutate the cloned object.</param>
/// <returns>The created <see cref="WithCSharpExpression"/>.</returns>
public static WithCSharpExpression With(Expression @object, IEnumerable <MemberInfo> members, IEnumerable <MemberInitializer> initializers)
{
RequiresNotNull(@object, nameof(@object));
RequiresNotNull(members, nameof(members));
RequiresNotNull(initializers, nameof(initializers));
var membersCollection = members.ToReadOnly();
var initializersCollection = initializers.ToReadOnly();
ValidateWithReceiverAndInitializers(@object, initializersCollection, requiresCanAssign: false);
var membersCount = membersCollection.Count;
var newMembers = new MemberInfo[membersCount];
var memberTypes = new Type[membersCount];
for (var i = 0; i < membersCount; i++)
{
var member = membersCollection[i];
RequiresNotNull(member, nameof(member));
if (!AreEquivalent(member.DeclaringType, @object.Type))
{
throw LinqError.ArgumentMemberNotDeclOnType(member.Name, @object.Type.Name);
}
ValidateAnonymousTypeMember(ref member, out var memberType);
newMembers[i] = member;
memberTypes[i] = memberType;
}
membersCollection = newMembers.ToReadOnly();
var ctor = @object.Type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, binder: null, memberTypes, modifiers: null);
if (ctor == null)
{
throw Error.NoAnonymousTypeConstructorFound(@object.Type);
}
return(new WithCSharpExpression(@object, initializersCollection, clone: null, membersCollection));
}
private static void ValidateNewArgs(ConstructorInfo constructor, ref ReadOnlyCollection <Expression> arguments, ref ReadOnlyCollection <MemberInfo> members)
{
ParameterInfo[] pis;
if ((pis = constructor.GetParametersCached()).Length > 0)
{
if (arguments.Count != pis.Length)
{
throw Error.IncorrectNumberOfConstructorArguments();
}
if (arguments.Count != members.Count)
{
throw Error.IncorrectNumberOfArgumentsForMembers();
}
Expression[] newArguments = null;
MemberInfo[] newMembers = null;
for (int i = 0, n = arguments.Count; i < n; i++)
{
Expression arg = arguments[i];
RequiresCanRead(arg, nameof(arguments), i);
MemberInfo member = members[i];
ContractUtils.RequiresNotNull(member, nameof(members), i);
if (!TypeUtils.AreEquivalent(member.DeclaringType, constructor.DeclaringType))
{
throw Error.ArgumentMemberNotDeclOnType(member.Name, constructor.DeclaringType.Name, nameof(members), i);
}
Type memberType;
ValidateAnonymousTypeMember(ref member, out memberType, nameof(members), i);
if (!TypeUtils.AreReferenceAssignable(memberType, arg.Type))
{
if (!TryQuote(memberType, ref arg))
{
throw Error.ArgumentTypeDoesNotMatchMember(arg.Type, memberType, nameof(arguments), i);
}
}
ParameterInfo pi = pis[i];
Type pType = pi.ParameterType;
if (pType.IsByRef)
{
pType = pType.GetElementType();
}
if (!TypeUtils.AreReferenceAssignable(pType, arg.Type))
{
if (!TryQuote(pType, ref arg))
{
throw Error.ExpressionTypeDoesNotMatchConstructorParameter(arg.Type, pType, nameof(arguments), i);
}
}
if (newArguments == null && arg != arguments[i])
{
newArguments = new Expression[arguments.Count];
for (int j = 0; j < i; j++)
{
newArguments[j] = arguments[j];
}
}
if (newArguments != null)
{
newArguments[i] = arg;
}
if (newMembers == null && member != members[i])
{
newMembers = new MemberInfo[members.Count];
for (int j = 0; j < i; j++)
{
newMembers[j] = members[j];
}
}
if (newMembers != null)
{
newMembers[i] = member;
}
}
if (newArguments != null)
{
arguments = new TrueReadOnlyCollection <Expression>(newArguments);
}
if (newMembers != null)
{
members = new TrueReadOnlyCollection <MemberInfo>(newMembers);
}
}
else if (arguments != null && arguments.Count > 0)
{
throw Error.IncorrectNumberOfConstructorArguments();
}
else if (members != null && members.Count > 0)
{
throw Error.IncorrectNumberOfMembersForGivenConstructor();
}
}
