static private TypeMustNotBePointer ( string paramName ) : Exception | ||
paramName | string | |
Résultat | Exception |
private static void ValidateGoto(LabelTarget target, ref Expression value, string targetParameter, string valueParameter, Type type) { ContractUtils.RequiresNotNull(target, targetParameter); if (value == null) { if (target.Type != typeof(void)) { throw Error.LabelMustBeVoidOrHaveExpression(nameof(target)); } if (type != null) { TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } } } else { ValidateGotoType(target.Type, ref value, valueParameter); } }
/// <summary> /// Creates a <see cref="CatchBlock"/> representing a catch statement with the specified elements. /// </summary> /// <param name="type">The <see cref="Type"/> of <see cref="Exception"/> this <see cref="CatchBlock"/> will handle.</param> /// <param name="variable">A <see cref="ParameterExpression"/> representing a reference to the <see cref="Exception"/> object caught by this handler.</param> /// <param name="body">The body of the catch statement.</param> /// <param name="filter">The body of the <see cref="Exception"/> filter.</param> /// <returns>The created <see cref="CatchBlock"/>.</returns> /// <remarks><paramref name="type"/> must be non-null and match the type of <paramref name="variable"/> (if it is supplied).</remarks> public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.Requires(variable == null || TypeUtils.AreEquivalent(variable.Type, type), nameof(variable)); if (variable == null) { TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } } else if (variable.IsByRef) { throw Error.VariableMustNotBeByRef(variable, variable.Type, nameof(variable)); } ExpressionUtils.RequiresCanRead(body, nameof(body)); if (filter != null) { ExpressionUtils.RequiresCanRead(filter, nameof(filter)); if (filter.Type != typeof(bool)) { throw Error.ArgumentMustBeBoolean(nameof(filter)); } } return(new CatchBlock(type, variable, body, filter)); }
/// <summary> /// Creates a <see cref="NewArrayExpression"/> that represents creating an array that has a specified rank. /// </summary> /// <param name="type">A <see cref="System.Type"/> that represents the element type of the array.</param> /// <param name="bounds">An <see cref="IEnumerable{T}"/> that contains <see cref="Expression"/> objects to use to populate the <see cref="NewArrayExpression.Expressions"/> collection.</param> /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayBounds"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns> public static NewArrayExpression NewArrayBounds(Type type, IEnumerable <Expression> bounds) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.RequiresNotNull(bounds, nameof(bounds)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } ReadOnlyCollection <Expression> boundsList = bounds.ToReadOnly(); int dimensions = boundsList.Count; if (dimensions <= 0) { throw Error.BoundsCannotBeLessThanOne(nameof(bounds)); } for (int i = 0; i < dimensions; i++) { Expression expr = boundsList[i]; RequiresCanRead(expr, nameof(bounds), i); if (!TypeUtils.IsInteger(expr.Type)) { throw Error.ArgumentMustBeInteger(nameof(bounds), i); } } Type arrayType; if (dimensions == 1) { //To get a vector, need call Type.MakeArrayType(). //Type.MakeArrayType(1) gives a non-vector array, which will cause type check error. arrayType = type.MakeArrayType(); } else { arrayType = type.MakeArrayType(dimensions); } return(NewArrayExpression.Make(ExpressionType.NewArrayBounds, arrayType, bounds.ToReadOnly())); }
/// <summary> /// Creates a <see cref="NewArrayExpression"/> of the specified type from the provided initializers. /// </summary> /// <param name="type">A Type that represents the element type of the array.</param> /// <param name="initializers">The expressions used to create the array elements.</param> /// <returns>A <see cref="NewArrayExpression"/> that has the <see cref="NodeType"/> property equal to <see cref="ExpressionType.NewArrayInit"/> and the <see cref="NewArrayExpression.Expressions"/> property set to the specified value.</returns> public static NewArrayExpression NewArrayInit(Type type, IEnumerable <Expression> initializers) { ContractUtils.RequiresNotNull(type, nameof(type)); ContractUtils.RequiresNotNull(initializers, nameof(initializers)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } ReadOnlyCollection <Expression> initializerList = initializers.ToReadOnly(); Expression[] newList = null; for (int i = 0, n = initializerList.Count; i < n; i++) { Expression expr = initializerList[i]; RequiresCanRead(expr, nameof(initializers), i); if (!TypeUtils.AreReferenceAssignable(type, expr.Type)) { if (!TryQuote(type, ref expr)) { throw Error.ExpressionTypeCannotInitializeArrayType(expr.Type, type); } if (newList == null) { newList = new Expression[initializerList.Count]; for (int j = 0; j < i; j++) { newList[j] = initializerList[j]; } } } if (newList != null) { newList[i] = expr; } } if (newList != null) { initializerList = new TrueReadOnlyCollection <Expression>(newList); } return(NewArrayExpression.Make(ExpressionType.NewArrayInit, type.MakeArrayType(), initializerList)); }
private static void Validate(Type type) { ContractUtils.RequiresNotNull(type, nameof(type)); TypeUtils.ValidateType(type, nameof(type)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } }
/// <summary> /// Creates a <see cref="LabelTarget"/> representing a label with the given type and name. /// </summary> /// <param name="type">The type of value that is passed when jumping to the label.</param> /// <param name="name">The name of the label.</param> /// <returns>The new <see cref="LabelTarget"/>.</returns> public static LabelTarget Label(Type type, string name) { ContractUtils.RequiresNotNull(type, nameof(type)); TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } return(new LabelTarget(type, name)); }
/// <summary> /// Creates a <see cref="DefaultExpression"/> that has the <see cref="Type"/> property set to the specified type. /// </summary> /// <param name="type">A <see cref="Type"/> to set the <see cref="Type"/> property equal to.</param> /// <returns> /// A <see cref="DefaultExpression"/> that has the <see cref="NodeType"/> property equal to /// <see cref="ExpressionType.Default"/> and the <see cref="Type"/> property set to the specified type. /// </returns> public static DefaultExpression Default(Type type) { ContractUtils.RequiresNotNull(type, nameof(type)); TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } return(new DefaultExpression(type)); }
/// <summary> /// Creates a <see cref="ParameterExpression" /> node that can be used to identify a parameter or a variable in an expression tree. /// </summary> /// <param name="type">The type of the parameter or variable.</param> /// <param name="name">The name of the parameter or variable, used for debugging or pretty printing purpose only.</param> /// <returns>A <see cref="ParameterExpression" /> node with the specified name and type.</returns> public static ParameterExpression Variable(Type type, string name) { ContractUtils.RequiresNotNull(type, nameof(type)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } return(ParameterExpression.Make(type, name, false)); }
/// <summary> /// Creates a <see cref="ConstantExpression"/> that has the <see cref="P:ConstantExpression.Value"/> /// and <see cref="P:ConstantExpression.Type"/> properties set to the specified values. . /// </summary> /// <param name="value">An <see cref="System.Object"/> to set the <see cref="P:ConstantExpression.Value"/> property equal to.</param> /// <param name="type">A <see cref="System.Type"/> to set the <see cref="P:Expression.Type"/> property equal to.</param> /// <returns> /// A <see cref="ConstantExpression"/> that has the <see cref="P:Expression.NodeType"/> property equal to /// <see cref="F:ExpressionType.Constant"/> and the <see cref="P:ConstantExpression.Value"/> and /// <see cref="P:Expression.Type"/> properties set to the specified values. /// </returns> public static ConstantExpression Constant(object value, Type type) { ContractUtils.RequiresNotNull(type, nameof(type)); TypeUtils.ValidateType(type, nameof(type)); if (type.IsByRef) { throw Error.TypeMustNotBeByRef(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } if (value == null) { if (type == typeof(object)) { return(new ConstantExpression(null)); } if (!type.GetTypeInfo().IsValueType || type.IsNullableType()) { return(new TypedConstantExpression(null, type)); } } else { Type valueType = value.GetType(); if (type == valueType) { return(new ConstantExpression(value)); } if (type.IsAssignableFrom(valueType)) { return(new TypedConstantExpression(value, type)); } } throw Error.ArgumentTypesMustMatch(); }
/// <summary> /// Creates a <see cref="ParameterExpression" /> node that can be used to identify a parameter or a variable in an expression tree. /// </summary> /// <param name="type">The type of the parameter or variable.</param> /// <param name="name">The name of the parameter or variable, used for debugging or pretty printing purpose only.</param> /// <returns>A <see cref="ParameterExpression" /> node with the specified name and type.</returns> public static ParameterExpression Parameter(Type type, string name) { ContractUtils.RequiresNotNull(type, nameof(type)); if (type == typeof(void)) { throw Error.ArgumentCannotBeOfTypeVoid(nameof(type)); } if (type.IsPointer) { throw Error.TypeMustNotBePointer(nameof(type)); } bool byref = type.IsByRef; if (byref) { type = type.GetElementType(); } return(ParameterExpression.Make(type, name, byref)); }