| static private NotAMemberOfType ( object p0, object p1, string paramName ) : Exception | ||
| p0 | object | |
| p1 | object | |
| paramName | string | |
| Résultat | Exception | |
/// <summary>
/// Creates a <see cref="MemberExpression"/> accessing a property or field.
/// </summary>
/// <param name="expression">The containing object of the member. This can be null for static members.</param>
/// <param name="propertyOrFieldName">The member to be accessed.</param>
/// <returns>The created <see cref="MemberExpression"/>.</returns>
public static MemberExpression PropertyOrField(Expression expression, string propertyOrFieldName)
{
RequiresCanRead(expression, "expression");
// bind to public names first
var pi = expression.Type.GetProperty(propertyOrFieldName, _publicFlags);
if (pi != null)
{
return(Property(expression, pi));
}
var fi = expression.Type.GetField(propertyOrFieldName, _publicFlags);
if (fi != null)
{
return(Field(expression, fi));
}
pi = expression.Type.GetProperty(propertyOrFieldName, _nonPublicFlags);
if (pi != null)
{
return(Property(expression, pi));
}
fi = expression.Type.GetField(propertyOrFieldName, _nonPublicFlags);
if (fi != null)
{
return(Field(expression, fi));
}
throw Error.NotAMemberOfType(propertyOrFieldName, expression.Type);
}
/// <summary>
/// Creates a <see cref="MemberExpression"/> accessing a property or field.
/// </summary>
/// <param name="expression">The containing object of the member. This can be null for static members.</param>
/// <param name="propertyOrFieldName">The member to be accessed.</param>
/// <returns>The created <see cref="MemberExpression"/>.</returns>
public static MemberExpression PropertyOrField(Expression expression, string propertyOrFieldName)
{
RequiresCanRead(expression, nameof(expression));
// bind to public names first
PropertyInfo pi = expression.Type.GetProperty(propertyOrFieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy);
if (pi != null)
{
return(Property(expression, pi));
}
FieldInfo fi = expression.Type.GetField(propertyOrFieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy);
if (fi != null)
{
return(Field(expression, fi));
}
pi = expression.Type.GetProperty(propertyOrFieldName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy);
if (pi != null)
{
return(Property(expression, pi));
}
fi = expression.Type.GetField(propertyOrFieldName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.IgnoreCase | BindingFlags.FlattenHierarchy);
if (fi != null)
{
return(Field(expression, fi));
}
throw Error.NotAMemberOfType(propertyOrFieldName, expression.Type, nameof(propertyOrFieldName));
}
private static void ValidateMemberInitArgs(Type type, ReadOnlyCollection <MemberBinding> bindings)
{
for (int i = 0, n = bindings.Count; i < n; i++)
{
MemberBinding b = bindings[i];
ContractUtils.RequiresNotNull(b, "bindings");
if (!b.Member.DeclaringType.IsAssignableFrom(type))
{
throw Error.NotAMemberOfType(b.Member.Name, type);
}
}
}
private static void ValidateMemberInitArgs(Type type, ReadOnlyCollection <MemberBinding> bindings)
{
for (int i = 0, n = bindings.Count; i < n; i++)
{
MemberBinding b = bindings[i];
ArgumentNullException.ThrowIfNull(b, nameof(bindings));
b.ValidateAsDefinedHere(i);
if (!b.Member.DeclaringType !.IsAssignableFrom(type))
{
throw Error.NotAMemberOfType(b.Member.Name, type, nameof(bindings), i);
}
}
}
/// <summary>
/// Creates a <see cref="WithCSharpExpression"/> that represents a with expression.
/// </summary>
/// <param name="object">The expression representing the object to clone and mutate.</param>
/// <param name="clone">The method used to clone the object.</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, MethodInfo clone, IEnumerable <MemberInitializer> initializers)
{
RequiresNotNull(@object, nameof(@object));
RequiresNotNull(initializers, nameof(initializers));
var initializersCollection = initializers.ToReadOnly();
ValidateWithReceiverAndInitializers(@object, initializersCollection, requiresCanAssign: true);
if (@object.Type.IsValueType)
{
if (clone != null)
{
throw Error.WithExpressionCannotHaveCloneForValueType(@object.Type);
}
}
else
{
clone ??= @object.Type.GetNonGenericMethod("Clone", BindingFlags.Public | BindingFlags.Instance, Type.EmptyTypes);
if (clone == null)
{
throw Error.WithExpressionShouldHaveClone(@object.Type);
}
ValidateMethodInfo(clone);
if (clone.IsStatic)
{
throw Error.CloneMethodMustNotBeStatic(clone.Name);
}
if (!clone.DeclaringType.IsAssignableFrom(@object.Type))
{
throw LinqError.NotAMemberOfType(clone.Name, @object.Type);
}
if (clone.GetParametersCached().Length != 0)
{
throw Error.CloneMethodShouldHaveNoParameters(clone.Name);
}
if (!HasReferenceConversion(clone.ReturnType, @object.Type))
{
throw Error.CloneMethodShouldReturnCompatibleType(clone.Name, @object.Type);
}
}
return(new WithCSharpExpression(@object, initializersCollection, clone, members: null));
}
private static void ValidateMemberInitArgs(Type type, MemberBinding[] bindings)
{
for (int i = 0, n = bindings.Length; i < n; i++)
{
var b = bindings[i];
ContractUtils.RequiresNotNull(b, nameof(bindings));
b.ValidateAsDefinedHere(i);
// ReSharper disable once PossibleNullReferenceException
if (!b.Member.DeclaringType.IsAssignableFrom(type))
{
throw Error.NotAMemberOfType(b.Member.Name, type, nameof(bindings), i);
}
}
}
private static void ValidateWithReceiverAndInitializers(Expression @object, ReadOnlyCollection <MemberInitializer> initializers, bool requiresCanAssign)
{
RequiresCanRead(@object, nameof(@object));
for (int i = 0, count = initializers.Count; i < count; i++)
{
var initializer = initializers[i];
RequiresNotNull(initializer, nameof(initializers));
var member = initializer.Member;
if (!member.DeclaringType.IsAssignableFrom(@object.Type))
{
throw LinqError.NotAMemberOfType(member.Name, @object.Type);
}
if (requiresCanAssign)
{
switch (member)
{
case FieldInfo f:
if (f.IsInitOnly || f.IsLiteral)
{
throw Error.MemberInitializerMemberMustBeWriteable(member.Name);
}
break;
case PropertyInfo p:
if (!p.CanWrite)
{
throw Error.MemberInitializerMemberMustBeWriteable(member.Name);
}
break;
}
}
}
}
