niko
2841 lines
233 KiB
C#
2841 lines
233 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Dynamic.Utils;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using Cpp2IlInjected;
|
|
|
|
namespace System.Linq.Expressions
|
|
{
|
|
/// <summary>Provides the base class from which the classes that represent expression tree nodes are derived. It also contains <see langword="static" /> (<see langword="Shared" /> in Visual Basic) factory methods to create the various node types. This is an <see langword="abstract" /> class.</summary>
|
|
// Token: 0x02000058 RID: 88
|
|
[Token(Token = "0x2000058")]
|
|
public abstract class Expression
|
|
{
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Assign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
// Token: 0x06000297 RID: 663 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000297")]
|
|
[Address(RVA = "0x869FB0", Offset = "0x868FB0", VA = "0x180869FB0")]
|
|
public static BinaryExpression Assign(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000298 RID: 664 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000298")]
|
|
[Address(RVA = "0x872060", Offset = "0x871060", VA = "0x180872060")]
|
|
private static BinaryExpression GetUserDefinedBinaryOperator(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000299 RID: 665 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000299")]
|
|
[Address(RVA = "0x870920", Offset = "0x86F920", VA = "0x180870920")]
|
|
private static BinaryExpression GetMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600029A RID: 666 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029A")]
|
|
[Address(RVA = "0x8706B0", Offset = "0x86F6B0", VA = "0x1808706B0")]
|
|
private static BinaryExpression GetMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression conversion, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600029B RID: 667 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029B")]
|
|
[Address(RVA = "0x871DF0", Offset = "0x870DF0", VA = "0x180871DF0")]
|
|
private static BinaryExpression GetUserDefinedBinaryOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600029C RID: 668 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029C")]
|
|
[Address(RVA = "0x871B80", Offset = "0x870B80", VA = "0x180871B80")]
|
|
private static BinaryExpression GetUserDefinedAssignOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, LambdaExpression conversion, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600029D RID: 669 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029D")]
|
|
[Address(RVA = "0x872390", Offset = "0x871390", VA = "0x180872390")]
|
|
private static MethodInfo GetUserDefinedBinaryOperator(ExpressionType binaryType, Type leftType, Type rightType, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600029E RID: 670 RVA: 0x00002AC0 File Offset: 0x00000CC0
|
|
[Token(Token = "0x600029E")]
|
|
[Address(RVA = "0x8748E0", Offset = "0x8738E0", VA = "0x1808748E0")]
|
|
private static bool IsLiftingConditionalLogicalOperator(Type left, Type right, MethodInfo method, ExpressionType binaryType)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600029F RID: 671 RVA: 0x00002AD8 File Offset: 0x00000CD8
|
|
[Token(Token = "0x600029F")]
|
|
[Address(RVA = "0x87AE20", Offset = "0x879E20", VA = "0x18087AE20")]
|
|
internal static bool ParameterIsAssignable(ParameterInfo pi, Type argType)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002A0 RID: 672 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A0")]
|
|
[Address(RVA = "0x87F550", Offset = "0x87E550", VA = "0x18087F550")]
|
|
private static void ValidateParamswithOperandsOrThrow(Type paramType, Type operandType, ExpressionType exprType, string name)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002A1 RID: 673 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A1")]
|
|
[Address(RVA = "0x87F420", Offset = "0x87E420", VA = "0x18087F420")]
|
|
private static void ValidateOperator(MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002A2 RID: 674 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A2")]
|
|
[Address(RVA = "0x87F0D0", Offset = "0x87E0D0", VA = "0x18087F0D0")]
|
|
private static void ValidateMethodInfo(MethodInfo method, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002A3 RID: 675 RVA: 0x00002AF0 File Offset: 0x00000CF0
|
|
[Token(Token = "0x60002A3")]
|
|
[Address(RVA = "0x874970", Offset = "0x873970", VA = "0x180874970")]
|
|
private static bool IsNullComparison(Expression left, Expression right)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002A4 RID: 676 RVA: 0x00002B08 File Offset: 0x00000D08
|
|
[Token(Token = "0x60002A4")]
|
|
[Address(RVA = "0x874A70", Offset = "0x873A70", VA = "0x180874A70")]
|
|
private static bool IsNullConstant(Expression e)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002A5 RID: 677 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A5")]
|
|
[Address(RVA = "0x87FC60", Offset = "0x87EC60", VA = "0x18087FC60")]
|
|
private static void ValidateUserDefinedConditionalLogicOperator(ExpressionType nodeType, Type left, Type right, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002A6 RID: 678 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A6")]
|
|
[Address(RVA = "0x880700", Offset = "0x87F700", VA = "0x180880700")]
|
|
private static void VerifyOpTrueFalse(ExpressionType nodeType, Type left, MethodInfo opTrue, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002A7 RID: 679 RVA: 0x00002B20 File Offset: 0x00000D20
|
|
[Token(Token = "0x60002A7")]
|
|
[Address(RVA = "0x874D30", Offset = "0x873D30", VA = "0x180874D30")]
|
|
private static bool IsValidLiftedConditionalLogicalOperator(Type left, Type right, ParameterInfo[] pms)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" />, given the left operand, right operand and implementing method, by calling the appropriate factory method.</summary>
|
|
/// <param name="binaryType">The <see cref="T:System.Linq.Expressions.ExpressionType" /> that specifies the type of binary operation.</param>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the left operand.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the right operand.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that specifies the implementing method.</param>
|
|
/// <returns>The <see cref="T:System.Linq.Expressions.BinaryExpression" /> that results from calling the appropriate factory method.</returns>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="binaryType" /> does not correspond to a binary expression node.</exception>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
// Token: 0x060002A8 RID: 680 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A8")]
|
|
[Address(RVA = "0x876B50", Offset = "0x875B50", VA = "0x180876B50")]
|
|
public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" />, given the left operand, right operand, implementing method and type conversion function, by calling the appropriate factory method.</summary>
|
|
/// <param name="binaryType">The <see cref="T:System.Linq.Expressions.ExpressionType" /> that specifies the type of binary operation.</param>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the left operand.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the right operand.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that specifies the implementing method.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> that represents a type conversion function. This parameter is used only if <paramref name="binaryType" /> is <see cref="F:System.Linq.Expressions.ExpressionType.Coalesce" /> or compound assignment..</param>
|
|
/// <returns>The <see cref="T:System.Linq.Expressions.BinaryExpression" /> that results from calling the appropriate factory method.</returns>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="binaryType" /> does not correspond to a binary expression node.</exception>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
// Token: 0x060002A9 RID: 681 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A9")]
|
|
[Address(RVA = "0x875B70", Offset = "0x874B70", VA = "0x180875B70")]
|
|
public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an equality comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Equal" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The equality operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002AA RID: 682 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AA")]
|
|
[Address(RVA = "0x86F270", Offset = "0x86E270", VA = "0x18086F270")]
|
|
public static BinaryExpression Equal(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an equality comparison. The implementing method can be specified.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Equal" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the equality operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002AB RID: 683 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AB")]
|
|
[Address(RVA = "0x86F2E0", Offset = "0x86E2E0", VA = "0x18086F2E0")]
|
|
public static BinaryExpression Equal(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a reference equality comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Equal" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002AC RID: 684 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AC")]
|
|
[Address(RVA = "0x87BCB0", Offset = "0x87ACB0", VA = "0x18087BCB0")]
|
|
public static BinaryExpression ReferenceEqual(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an inequality comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NotEqual" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The inequality operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002AD RID: 685 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AD")]
|
|
[Address(RVA = "0x87A070", Offset = "0x879070", VA = "0x18087A070")]
|
|
public static BinaryExpression NotEqual(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an inequality comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NotEqual" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the inequality operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002AE RID: 686 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AE")]
|
|
[Address(RVA = "0x87A0E0", Offset = "0x8790E0", VA = "0x18087A0E0")]
|
|
public static BinaryExpression NotEqual(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a reference inequality comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NotEqual" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002AF RID: 687 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AF")]
|
|
[Address(RVA = "0x87BDF0", Offset = "0x87ADF0", VA = "0x18087BDF0")]
|
|
public static BinaryExpression ReferenceNotEqual(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B0 RID: 688 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B0")]
|
|
[Address(RVA = "0x870050", Offset = "0x86F050", VA = "0x180870050")]
|
|
private static BinaryExpression GetEqualityComparisonOperator(ExpressionType binaryType, string opName, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a "greater than" numeric comparison. The implementing method can be specified.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.GreaterThan" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the "greater than" operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002B1 RID: 689 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B1")]
|
|
[Address(RVA = "0x872F00", Offset = "0x871F00", VA = "0x180872F00")]
|
|
public static BinaryExpression GreaterThan(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a "less than" numeric comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.LessThan" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the "less than" operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002B2 RID: 690 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B2")]
|
|
[Address(RVA = "0x875950", Offset = "0x874950", VA = "0x180875950")]
|
|
public static BinaryExpression LessThan(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a "greater than or equal" numeric comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.GreaterThanOrEqual" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the "greater than or equal" operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002B3 RID: 691 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B3")]
|
|
[Address(RVA = "0x872DF0", Offset = "0x871DF0", VA = "0x180872DF0")]
|
|
public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a "less than or equal" numeric comparison.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="liftToNull">
|
|
/// <see langword="true" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="true" />; <see langword="false" /> to set <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" /> to <see langword="false" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.LessThanOrEqual" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.IsLiftedToNull" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the "less than or equal" operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002B4 RID: 692 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B4")]
|
|
[Address(RVA = "0x875840", Offset = "0x874840", VA = "0x180875840")]
|
|
public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B5 RID: 693 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B5")]
|
|
[Address(RVA = "0x86FE60", Offset = "0x86EE60", VA = "0x18086FE60")]
|
|
private static BinaryExpression GetComparisonOperator(ExpressionType binaryType, string opName, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a conditional <see langword="AND" /> operation that evaluates the second operand only if the first operand is resolved to true. The implementing method can be specified.</summary>
|
|
/// <param name="left">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.AndAlso" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the bitwise <see langword="AND" /> operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.-or-
|
|
/// <paramref name="method" /> is <see langword="null" /> and <paramref name="left" />.Type and <paramref name="right" />.Type are not the same Boolean type.</exception>
|
|
// Token: 0x060002B6 RID: 694 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B6")]
|
|
[Address(RVA = "0x868EA0", Offset = "0x867EA0", VA = "0x180868EA0")]
|
|
public static BinaryExpression AndAlso(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a conditional <see langword="OR" /> operation that evaluates the second operand only if the first operand evaluates to <see langword="false" />.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.OrElse" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the bitwise <see langword="OR" /> operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.-or-
|
|
/// <paramref name="method" /> is <see langword="null" /> and <paramref name="left" />.Type and <paramref name="right" />.Type are not the same Boolean type.</exception>
|
|
// Token: 0x060002B7 RID: 695 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B7")]
|
|
[Address(RVA = "0x87A740", Offset = "0x879740", VA = "0x18087A740")]
|
|
public static BinaryExpression OrElse(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a coalescing operation, given a conversion function.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Coalesce" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="left" />.Type and <paramref name="right" />.Type are not convertible to each other.-or-
|
|
/// <paramref name="conversion" /> is not <see langword="null" /> and <paramref name="conversion" />.Type is a delegate type that does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of <paramref name="left" /> does not represent a reference type or a nullable value type.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of <paramref name="left" /> represents a type that is not assignable to the parameter type of the delegate type <paramref name="conversion" />.Type.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of <paramref name="right" /> is not equal to the return type of the delegate type <paramref name="conversion" />.Type.</exception>
|
|
// Token: 0x060002B8 RID: 696 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B8")]
|
|
[Address(RVA = "0x86D480", Offset = "0x86C480", VA = "0x18086D480")]
|
|
public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B9 RID: 697 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B9")]
|
|
[Address(RVA = "0x87DE80", Offset = "0x87CE80", VA = "0x18087DE80")]
|
|
private static Type ValidateCoalesceArgTypes(Type left, Type right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic addition operation that does not have overflow checking. The implementing method can be specified.</summary>
|
|
/// <param name="left">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Add" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the addition operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002BA RID: 698 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BA")]
|
|
[Address(RVA = "0x868CA0", Offset = "0x867CA0", VA = "0x180868CA0")]
|
|
public static BinaryExpression Add(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an addition assignment operation that does not have overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.AddAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002BB RID: 699 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BB")]
|
|
[Address(RVA = "0x868830", Offset = "0x867830", VA = "0x180868830")]
|
|
public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002BC RID: 700 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002BC")]
|
|
[Address(RVA = "0x87F1B0", Offset = "0x87E1B0", VA = "0x18087F1B0")]
|
|
private static void ValidateOpAssignConversionLambda(LambdaExpression conversion, Expression left, MethodInfo method, ExpressionType nodeType)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an addition assignment operation that has overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.AddAssignChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002BD RID: 701 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BD")]
|
|
[Address(RVA = "0x8685D0", Offset = "0x8675D0", VA = "0x1808685D0")]
|
|
public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic addition operation that has overflow checking. The implementing method can be specified.</summary>
|
|
/// <param name="left">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.AddChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the addition operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002BE RID: 702 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BE")]
|
|
[Address(RVA = "0x868A90", Offset = "0x867A90", VA = "0x180868A90")]
|
|
public static BinaryExpression AddChecked(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic subtraction operation that does not have overflow checking.</summary>
|
|
/// <param name="left">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Subtract" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the subtraction operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002BF RID: 703 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BF")]
|
|
[Address(RVA = "0x87CF80", Offset = "0x87BF80", VA = "0x18087CF80")]
|
|
public static BinaryExpression Subtract(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a subtraction assignment operation that does not have overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.SubtractAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C0 RID: 704 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C0")]
|
|
[Address(RVA = "0x87CB10", Offset = "0x87BB10", VA = "0x18087CB10")]
|
|
public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a subtraction assignment operation that has overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.SubtractAssignChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C1 RID: 705 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C1")]
|
|
[Address(RVA = "0x87C8B0", Offset = "0x87B8B0", VA = "0x18087C8B0")]
|
|
public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic subtraction operation that has overflow checking.</summary>
|
|
/// <param name="left">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.SubtractChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the subtraction operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002C2 RID: 706 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C2")]
|
|
[Address(RVA = "0x87CD70", Offset = "0x87BD70", VA = "0x18087CD70")]
|
|
public static BinaryExpression SubtractChecked(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic division operation. The implementing method can be specified.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Divide" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the division operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002C3 RID: 707 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C3")]
|
|
[Address(RVA = "0x86EFA0", Offset = "0x86DFA0", VA = "0x18086EFA0")]
|
|
public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a division assignment operation that does not have overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.DivideAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C4 RID: 708 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C4")]
|
|
[Address(RVA = "0x86ED40", Offset = "0x86DD40", VA = "0x18086ED40")]
|
|
public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic remainder operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Modulo" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the modulus operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002C5 RID: 709 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C5")]
|
|
[Address(RVA = "0x878BD0", Offset = "0x877BD0", VA = "0x180878BD0")]
|
|
public static BinaryExpression Modulo(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a remainder assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ModuloAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C6 RID: 710 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C6")]
|
|
[Address(RVA = "0x878970", Offset = "0x877970", VA = "0x180878970")]
|
|
public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic multiplication operation that does not have overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Multiply" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the multiplication operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002C7 RID: 711 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C7")]
|
|
[Address(RVA = "0x8794B0", Offset = "0x8784B0", VA = "0x1808794B0")]
|
|
public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a multiplication assignment operation that does not have overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MultiplyAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C8 RID: 712 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C8")]
|
|
[Address(RVA = "0x879040", Offset = "0x878040", VA = "0x180879040")]
|
|
public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a multiplication assignment operation that has overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MultiplyAssignChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002C9 RID: 713 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C9")]
|
|
[Address(RVA = "0x878DE0", Offset = "0x877DE0", VA = "0x180878DE0")]
|
|
public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents an arithmetic multiplication operation that has overflow checking.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MultiplyChecked" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the multiplication operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002CA RID: 714 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CA")]
|
|
[Address(RVA = "0x8792A0", Offset = "0x8782A0", VA = "0x1808792A0")]
|
|
public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002CB RID: 715 RVA: 0x00002B38 File Offset: 0x00000D38
|
|
[Token(Token = "0x60002CB")]
|
|
[Address(RVA = "0x874AF0", Offset = "0x873AF0", VA = "0x180874AF0")]
|
|
private static bool IsSimpleShift(Type left, Type right)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002CC RID: 716 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CC")]
|
|
[Address(RVA = "0x871A50", Offset = "0x870A50", VA = "0x180871A50")]
|
|
private static Type GetResultTypeOfShift(Type left, Type right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise left-shift operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.LeftShift" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the left-shift operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002CD RID: 717 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CD")]
|
|
[Address(RVA = "0x875610", Offset = "0x874610", VA = "0x180875610")]
|
|
public static BinaryExpression LeftShift(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise left-shift assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.LeftShiftAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002CE RID: 718 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CE")]
|
|
[Address(RVA = "0x875380", Offset = "0x874380", VA = "0x180875380")]
|
|
public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise right-shift operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.RightShift" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the right-shift operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002CF RID: 719 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CF")]
|
|
[Address(RVA = "0x87C680", Offset = "0x87B680", VA = "0x18087C680")]
|
|
public static BinaryExpression RightShift(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise right-shift assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.RightShiftAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002D0 RID: 720 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D0")]
|
|
[Address(RVA = "0x87C3F0", Offset = "0x87B3F0", VA = "0x18087C3F0")]
|
|
public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise <see langword="AND" /> operation. The implementing method can be specified.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.And" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the bitwise <see langword="AND" /> operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002D1 RID: 721 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D1")]
|
|
[Address(RVA = "0x8695A0", Offset = "0x8685A0", VA = "0x1808695A0")]
|
|
public static BinaryExpression And(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise AND assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.AndAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002D2 RID: 722 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D2")]
|
|
[Address(RVA = "0x869340", Offset = "0x868340", VA = "0x180869340")]
|
|
public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise <see langword="OR" /> operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Or" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the bitwise <see langword="OR" /> operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002D3 RID: 723 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D3")]
|
|
[Address(RVA = "0x87AC10", Offset = "0x879C10", VA = "0x18087AC10")]
|
|
public static BinaryExpression Or(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise OR assignment operation.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.OrAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002D4 RID: 724 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D4")]
|
|
[Address(RVA = "0x87A4E0", Offset = "0x8794E0", VA = "0x18087A4E0")]
|
|
public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise <see langword="XOR" /> operation, using op_ExclusiveOr for user-defined types. The implementing method can be specified.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ExclusiveOr" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the <see langword="XOR" /> operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.</exception>
|
|
// Token: 0x060002D5 RID: 725 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D5")]
|
|
[Address(RVA = "0x86F650", Offset = "0x86E650", VA = "0x18086F650")]
|
|
public static BinaryExpression ExclusiveOr(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents a bitwise XOR assignment operation, using op_ExclusiveOr for user-defined types.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ExclusiveOrAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002D6 RID: 726 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D6")]
|
|
[Address(RVA = "0x86F3F0", Offset = "0x86E3F0", VA = "0x18086F3F0")]
|
|
public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents raising a number to a power.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Power" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="left" /> or <paramref name="right" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly two arguments.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the exponentiation operator is not defined for <paramref name="left" />.Type and <paramref name="right" />.Type.-or-
|
|
/// <paramref name="method" /> is <see langword="null" /> and <paramref name="left" />.Type and/or <paramref name="right" />.Type are not <see cref="T:System.Double" />.</exception>
|
|
// Token: 0x060002D7 RID: 727 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D7")]
|
|
[Address(RVA = "0x87B210", Offset = "0x87A210", VA = "0x18087B210")]
|
|
public static BinaryExpression Power(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents raising an expression to a power and assigning the result back to the expression.</summary>
|
|
/// <param name="left">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="right">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Method" /> property equal to.</param>
|
|
/// <param name="conversion">A <see cref="T:System.Linq.Expressions.LambdaExpression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.PowerAssign" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Right" />, <see cref="P:System.Linq.Expressions.BinaryExpression.Method" />, and <see cref="P:System.Linq.Expressions.BinaryExpression.Conversion" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002D8 RID: 728 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D8")]
|
|
[Address(RVA = "0x87B080", Offset = "0x87A080", VA = "0x18087B080")]
|
|
public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BinaryExpression" /> that represents applying an array index operator to an array of rank one.</summary>
|
|
/// <param name="array">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> property equal to.</param>
|
|
/// <param name="index">A <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.BinaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ArrayIndex" /> and the <see cref="P:System.Linq.Expressions.BinaryExpression.Left" /> and <see cref="P:System.Linq.Expressions.BinaryExpression.Right" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="array" /> or <paramref name="index" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="array" />.Type does not represent an array type.-or-
|
|
/// <paramref name="array" />.Type represents an array type whose rank is not 1.-or-
|
|
/// <paramref name="index" />.Type does not represent the <see cref="T:System.Int32" /> type.</exception>
|
|
// Token: 0x060002D9 RID: 729 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D9")]
|
|
[Address(RVA = "0x869C00", Offset = "0x868C00", VA = "0x180869C00")]
|
|
public static BinaryExpression ArrayIndex(Expression array, Expression index)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains two expressions and has no variables.</summary>
|
|
/// <param name="arg0">The first expression in the block.</param>
|
|
/// <param name="arg1">The second expression in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DA RID: 730 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DA")]
|
|
[Address(RVA = "0x86AA60", Offset = "0x869A60", VA = "0x18086AA60")]
|
|
public static BlockExpression Block(Expression arg0, Expression arg1)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains three expressions and has no variables.</summary>
|
|
/// <param name="arg0">The first expression in the block.</param>
|
|
/// <param name="arg1">The second expression in the block.</param>
|
|
/// <param name="arg2">The third expression in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DB RID: 731 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DB")]
|
|
[Address(RVA = "0x86AFF0", Offset = "0x869FF0", VA = "0x18086AFF0")]
|
|
public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains four expressions and has no variables.</summary>
|
|
/// <param name="arg0">The first expression in the block.</param>
|
|
/// <param name="arg1">The second expression in the block.</param>
|
|
/// <param name="arg2">The third expression in the block.</param>
|
|
/// <param name="arg3">The fourth expression in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DC RID: 732 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DC")]
|
|
[Address(RVA = "0x86A970", Offset = "0x869970", VA = "0x18086A970")]
|
|
public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains five expressions and has no variables.</summary>
|
|
/// <param name="arg0">The first expression in the block.</param>
|
|
/// <param name="arg1">The second expression in the block.</param>
|
|
/// <param name="arg2">The third expression in the block.</param>
|
|
/// <param name="arg3">The fourth expression in the block.</param>
|
|
/// <param name="arg4">The fifth expression in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DD RID: 733 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DD")]
|
|
[Address(RVA = "0x86AEE0", Offset = "0x869EE0", VA = "0x18086AEE0")]
|
|
public static BlockExpression Block(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given expressions and has no variables.</summary>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DE RID: 734 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DE")]
|
|
[Address(RVA = "0x86A7C0", Offset = "0x8697C0", VA = "0x18086A7C0")]
|
|
public static BlockExpression Block(IEnumerable<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given expressions, has no variables and has specific result type.</summary>
|
|
/// <param name="type">The result type of the block.</param>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002DF RID: 735 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DF")]
|
|
[Address(RVA = "0x86ADA0", Offset = "0x869DA0", VA = "0x18086ADA0")]
|
|
public static BlockExpression Block(Type type, params Expression[] expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given expressions, has no variables and has specific result type.</summary>
|
|
/// <param name="type">The result type of the block.</param>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002E0 RID: 736 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E0")]
|
|
[Address(RVA = "0x86A8D0", Offset = "0x8698D0", VA = "0x18086A8D0")]
|
|
public static BlockExpression Block(Type type, IEnumerable<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given variables and expressions.</summary>
|
|
/// <param name="type">The result type of the block.</param>
|
|
/// <param name="variables">The variables in the block.</param>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002E1 RID: 737 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E1")]
|
|
[Address(RVA = "0x86A850", Offset = "0x869850", VA = "0x18086A850")]
|
|
public static BlockExpression Block(Type type, IEnumerable<ParameterExpression> variables, params Expression[] expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given variables and expressions.</summary>
|
|
/// <param name="variables">The variables in the block.</param>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002E2 RID: 738 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E2")]
|
|
[Address(RVA = "0x86A630", Offset = "0x869630", VA = "0x18086A630")]
|
|
public static BlockExpression Block(IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.BlockExpression" /> that contains the given variables and expressions.</summary>
|
|
/// <param name="type">The result type of the block.</param>
|
|
/// <param name="variables">The variables in the block.</param>
|
|
/// <param name="expressions">The expressions in the block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.BlockExpression" />.</returns>
|
|
// Token: 0x060002E3 RID: 739 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E3")]
|
|
[Address(RVA = "0x86AB30", Offset = "0x869B30", VA = "0x18086AB30")]
|
|
public static BlockExpression Block(Type type, IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002E4 RID: 740 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E4")]
|
|
[Address(RVA = "0x86A1D0", Offset = "0x8691D0", VA = "0x18086A1D0")]
|
|
private static BlockExpression BlockCore(Type type, ReadOnlyCollection<ParameterExpression> variables, ReadOnlyCollection<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002E5 RID: 741 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002E5")]
|
|
[Address(RVA = "0x880400", Offset = "0x87F400", VA = "0x180880400")]
|
|
internal static void ValidateVariables(ReadOnlyCollection<ParameterExpression> varList, string collectionName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002E6 RID: 742 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E6")]
|
|
[Address(RVA = "0x8715F0", Offset = "0x8705F0", VA = "0x1808715F0")]
|
|
private static BlockExpression GetOptimizedBlockExpression(IReadOnlyList<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.CatchBlock" /> representing a catch statement with the specified elements.</summary>
|
|
/// <param name="type">The <see cref="P:System.Linq.Expressions.Expression.Type" /> of <see cref="T:System.Exception" /> this <see cref="T:System.Linq.Expressions.CatchBlock" /> will handle.</param>
|
|
/// <param name="variable">A <see cref="T:System.Linq.Expressions.ParameterExpression" /> representing a reference to the <see cref="T:System.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="T:System.Exception" /> filter.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.CatchBlock" />.</returns>
|
|
// Token: 0x060002E7 RID: 743 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E7")]
|
|
[Address(RVA = "0x876BF0", Offset = "0x875BF0", VA = "0x180876BF0")]
|
|
public static CatchBlock MakeCatchBlock(Type type, ParameterExpression variable, Expression body, Expression filter)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that represents a conditional statement.</summary>
|
|
/// <param name="test">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" /> property equal to.</param>
|
|
/// <param name="ifTrue">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" /> property equal to.</param>
|
|
/// <param name="ifFalse">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Conditional" /> and the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" />, <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" />, and <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="test" /> or <paramref name="ifTrue" /> or <paramref name="ifFalse" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="test" />.Type is not <see cref="T:System.Boolean" />.-or-
|
|
/// <paramref name="ifTrue" />.Type is not equal to <paramref name="ifFalse" />.Type.</exception>
|
|
// Token: 0x060002E8 RID: 744 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E8")]
|
|
[Address(RVA = "0x86DA70", Offset = "0x86CA70", VA = "0x18086DA70")]
|
|
public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that represents a conditional statement.</summary>
|
|
/// <param name="test">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" /> property equal to.</param>
|
|
/// <param name="ifTrue">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" /> property equal to.</param>
|
|
/// <param name="ifFalse">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="P:System.Linq.Expressions.Expression.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Conditional" /> and the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" />, <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" />, and <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse" /> properties set to the specified values.</returns>
|
|
// Token: 0x060002E9 RID: 745 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E9")]
|
|
[Address(RVA = "0x86DC30", Offset = "0x86CC30", VA = "0x18086DC30")]
|
|
public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that represents a conditional block with an <see langword="if" /> statement.</summary>
|
|
/// <param name="test">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" /> property equal to.</param>
|
|
/// <param name="ifTrue">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ConditionalExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Conditional" /> and the <see cref="P:System.Linq.Expressions.ConditionalExpression.Test" />, <see cref="P:System.Linq.Expressions.ConditionalExpression.IfTrue" />, properties set to the specified values. The <see cref="P:System.Linq.Expressions.ConditionalExpression.IfFalse" /> property is set to default expression and the type of the resulting <see cref="T:System.Linq.Expressions.ConditionalExpression" /> returned by this method is <see cref="T:System.Void" />.</returns>
|
|
// Token: 0x060002EA RID: 746 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EA")]
|
|
[Address(RVA = "0x873010", Offset = "0x872010", VA = "0x180873010")]
|
|
public static ConditionalExpression IfThen(Expression test, Expression ifTrue)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.ConstantExpression" /> that has the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> property set to the specified value.</summary>
|
|
/// <param name="value">An <see cref="T:System.Object" /> to set the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ConstantExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Constant" /> and the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> property set to the specified value.</returns>
|
|
// Token: 0x060002EB RID: 747 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EB")]
|
|
[Address(RVA = "0x86DE80", Offset = "0x86CE80", VA = "0x18086DE80")]
|
|
public static ConstantExpression Constant(object value)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.ConstantExpression" /> that has the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> properties set to the specified values.</summary>
|
|
/// <param name="value">An <see cref="T:System.Object" /> to set the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ConstantExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Constant" /> and the <see cref="P:System.Linq.Expressions.ConstantExpression.Value" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="type" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="value" /> is not <see langword="null" /> and <paramref name="type" /> is not assignable from the dynamic type of <paramref name="value" />.</exception>
|
|
// Token: 0x060002EC RID: 748 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EC")]
|
|
[Address(RVA = "0x86DF10", Offset = "0x86CF10", VA = "0x18086DF10")]
|
|
public static ConstantExpression Constant(object value, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an empty expression that has <see cref="T:System.Void" /> type.</summary>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.DefaultExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Default" /> and the <see cref="P:System.Linq.Expressions.Expression.Type" /> property set to <see cref="T:System.Void" />.</returns>
|
|
// Token: 0x060002ED RID: 749 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002ED")]
|
|
[Address(RVA = "0x86F1B0", Offset = "0x86E1B0", VA = "0x18086F1B0")]
|
|
public static DefaultExpression Empty()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.DefaultExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.Type" /> property set to the specified type.</summary>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.DefaultExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Default" /> and the <see cref="P:System.Linq.Expressions.Expression.Type" /> property set to the specified type.</returns>
|
|
// Token: 0x060002EE RID: 750 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EE")]
|
|
[Address(RVA = "0x86EC40", Offset = "0x86DC40", VA = "0x18086EC40")]
|
|
public static DefaultExpression Default(Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Constructs a new instance of <see cref="T:System.Linq.Expressions.Expression" />.</summary>
|
|
// Token: 0x060002EF RID: 751 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002EF")]
|
|
[Address(RVA = "0x412370", Offset = "0x411370", VA = "0x180412370")]
|
|
protected Expression()
|
|
{
|
|
}
|
|
|
|
/// <summary>Gets the node type of this <see cref="T:System.Linq.Expressions.Expression" />.</summary>
|
|
/// <returns>One of the <see cref="T:System.Linq.Expressions.ExpressionType" /> values.</returns>
|
|
// Token: 0x1700006E RID: 110
|
|
// (get) Token: 0x060002F0 RID: 752 RVA: 0x00002B50 File Offset: 0x00000D50
|
|
[Token(Token = "0x1700006E")]
|
|
public virtual ExpressionType NodeType
|
|
{
|
|
[Token(Token = "0x60002F0")]
|
|
[Address(RVA = "0x880A80", Offset = "0x87FA80", VA = "0x180880A80", Slot = "4")]
|
|
get
|
|
{
|
|
return ExpressionType.Add;
|
|
}
|
|
}
|
|
|
|
/// <summary>Gets the static type of the expression that this <see cref="T:System.Linq.Expressions.Expression" /> represents.</summary>
|
|
/// <returns>The <see cref="T:System.Type" /> that represents the static type of the expression.</returns>
|
|
// Token: 0x1700006F RID: 111
|
|
// (get) Token: 0x060002F1 RID: 753 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x1700006F")]
|
|
public virtual Type Type
|
|
{
|
|
[Token(Token = "0x60002F1")]
|
|
[Address(RVA = "0x880B60", Offset = "0x87FB60", VA = "0x180880B60", Slot = "5")]
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>Indicates that the node can be reduced to a simpler node. If this returns true, Reduce() can be called to produce the reduced form.</summary>
|
|
/// <returns>True if the node can be reduced, otherwise false.</returns>
|
|
// Token: 0x17000070 RID: 112
|
|
// (get) Token: 0x060002F2 RID: 754 RVA: 0x00002B68 File Offset: 0x00000D68
|
|
[Token(Token = "0x17000070")]
|
|
public virtual bool CanReduce
|
|
{
|
|
[Token(Token = "0x60002F2")]
|
|
[Address(RVA = "0x424690", Offset = "0x423690", VA = "0x180424690", Slot = "6")]
|
|
get
|
|
{
|
|
return default(bool);
|
|
}
|
|
}
|
|
|
|
/// <summary>Reduces this node to a simpler expression. If CanReduce returns true, this should return a valid expression. This method can return another node which itself must be reduced.</summary>
|
|
/// <returns>The reduced expression.</returns>
|
|
// Token: 0x060002F3 RID: 755 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F3")]
|
|
[Address(RVA = "0x87BC50", Offset = "0x87AC50", VA = "0x18087BC50", Slot = "7")]
|
|
public virtual Expression Reduce()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Reduces the node and then calls the visitor delegate on the reduced expression. The method throws an exception if the node is not reducible.</summary>
|
|
/// <param name="visitor">An instance of <see cref="T:System.Func`2" />.</param>
|
|
/// <returns>The expression being visited, or an expression which should replace it in the tree.</returns>
|
|
// Token: 0x060002F4 RID: 756 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F4")]
|
|
[Address(RVA = "0x8808A0", Offset = "0x87F8A0", VA = "0x1808808A0", Slot = "8")]
|
|
protected internal virtual Expression VisitChildren(ExpressionVisitor visitor)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Dispatches to the specific visit method for this node type. For example, <see cref="T:System.Linq.Expressions.MethodCallExpression" /> calls the <see cref="M:System.Linq.Expressions.ExpressionVisitor.VisitMethodCall(System.Linq.Expressions.MethodCallExpression)" />.</summary>
|
|
/// <param name="visitor">The visitor to visit this node with.</param>
|
|
/// <returns>The result of visiting this node.</returns>
|
|
// Token: 0x060002F5 RID: 757 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F5")]
|
|
[Address(RVA = "0x8685A0", Offset = "0x8675A0", VA = "0x1808685A0", Slot = "9")]
|
|
protected internal virtual Expression Accept(ExpressionVisitor visitor)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Reduces this node to a simpler expression. If CanReduce returns true, this should return a valid expression. This method can return another node which itself must be reduced.</summary>
|
|
/// <returns>The reduced expression.</returns>
|
|
// Token: 0x060002F6 RID: 758 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F6")]
|
|
[Address(RVA = "0x87BB60", Offset = "0x87AB60", VA = "0x18087BB60")]
|
|
public Expression ReduceAndCheck()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns a textual representation of the <see cref="T:System.Linq.Expressions.Expression" />.</summary>
|
|
/// <returns>A textual representation of the <see cref="T:System.Linq.Expressions.Expression" />.</returns>
|
|
// Token: 0x060002F7 RID: 759 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F7")]
|
|
[Address(RVA = "0x87D2E0", Offset = "0x87C2E0", VA = "0x18087D2E0", Slot = "3")]
|
|
public override string ToString()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002F8 RID: 760 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002F8")]
|
|
[Address(RVA = "0x87BF30", Offset = "0x87AF30", VA = "0x18087BF30")]
|
|
private static void RequiresCanRead(IReadOnlyList<Expression> items, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002F9 RID: 761 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002F9")]
|
|
[Address(RVA = "0x87C040", Offset = "0x87B040", VA = "0x18087C040")]
|
|
private static void RequiresCanWrite(Expression expression, string paramName)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.GotoExpression" /> representing a break statement.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> that the <see cref="T:System.Linq.Expressions.GotoExpression" /> will jump to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.GotoExpression" /> with <see cref="P:System.Linq.Expressions.GotoExpression.Kind" /> equal to Break, the <see cref="P:System.Linq.Expressions.GotoExpression.Target" /> property set to <paramref name="target" />, and a null value to be passed to the target label upon jumping.</returns>
|
|
// Token: 0x060002FA RID: 762 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FA")]
|
|
[Address(RVA = "0x86B0B0", Offset = "0x86A0B0", VA = "0x18086B0B0")]
|
|
public static GotoExpression Break(LabelTarget target)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.GotoExpression" /> representing a return statement.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> that the <see cref="T:System.Linq.Expressions.GotoExpression" /> will jump to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.GotoExpression" /> with <see cref="P:System.Linq.Expressions.GotoExpression.Kind" /> equal to Return, the <see cref="P:System.Linq.Expressions.GotoExpression.Target" /> property set to <paramref name="target" />, and a null value to be passed to the target label upon jumping.</returns>
|
|
// Token: 0x060002FB RID: 763 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FB")]
|
|
[Address(RVA = "0x87C350", Offset = "0x87B350", VA = "0x18087C350")]
|
|
public static GotoExpression Return(LabelTarget target)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.GotoExpression" /> representing a return statement. The value passed to the label upon jumping can be specified.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> that the <see cref="T:System.Linq.Expressions.GotoExpression" /> will jump to.</param>
|
|
/// <param name="value">The value that will be passed to the associated label upon jumping.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.GotoExpression" /> with <see cref="P:System.Linq.Expressions.GotoExpression.Kind" /> equal to Continue, the <see cref="P:System.Linq.Expressions.GotoExpression.Target" /> property set to <paramref name="target" />, and <paramref name="value" /> to be passed to the target label upon jumping.</returns>
|
|
// Token: 0x060002FC RID: 764 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FC")]
|
|
[Address(RVA = "0x87C2A0", Offset = "0x87B2A0", VA = "0x18087C2A0")]
|
|
public static GotoExpression Return(LabelTarget target, Expression value)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.GotoExpression" /> representing a "go to" statement. The value passed to the label upon jumping can be specified.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> that the <see cref="T:System.Linq.Expressions.GotoExpression" /> will jump to.</param>
|
|
/// <param name="value">The value that will be passed to the associated label upon jumping.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.GotoExpression" /> with <see cref="P:System.Linq.Expressions.GotoExpression.Kind" /> equal to Goto, the <see cref="P:System.Linq.Expressions.GotoExpression.Target" /> property set to <paramref name="target" />, and <paramref name="value" /> to be passed to the target label upon jumping.</returns>
|
|
// Token: 0x060002FD RID: 765 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FD")]
|
|
[Address(RVA = "0x872D40", Offset = "0x871D40", VA = "0x180872D40")]
|
|
public static GotoExpression Goto(LabelTarget target, Expression value)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.GotoExpression" /> representing a jump of the specified <see cref="T:System.Linq.Expressions.GotoExpressionKind" />. The value passed to the label upon jumping can also be specified.</summary>
|
|
/// <param name="kind">The <see cref="T:System.Linq.Expressions.GotoExpressionKind" /> of the <see cref="T:System.Linq.Expressions.GotoExpression" />.</param>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> that the <see cref="T:System.Linq.Expressions.GotoExpression" /> will jump to.</param>
|
|
/// <param name="value">The value that will be passed to the associated label upon jumping.</param>
|
|
/// <param name="type">An <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.GotoExpression" /> with <see cref="P:System.Linq.Expressions.GotoExpression.Kind" /> equal to <paramref name="kind" />, the <see cref="P:System.Linq.Expressions.GotoExpression.Target" /> property set to <paramref name="target" />, the <see cref="P:System.Linq.Expressions.Expression.Type" /> property set to <paramref name="type" />, and <paramref name="value" /> to be passed to the target label upon jumping.</returns>
|
|
// Token: 0x060002FE RID: 766 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FE")]
|
|
[Address(RVA = "0x876E50", Offset = "0x875E50", VA = "0x180876E50")]
|
|
public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002FF RID: 767 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002FF")]
|
|
[Address(RVA = "0x87E110", Offset = "0x87D110", VA = "0x18087E110")]
|
|
private static void ValidateGoto(LabelTarget target, ref Expression value, string targetParameter, string valueParameter, Type type)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000300 RID: 768 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000300")]
|
|
[Address(RVA = "0x87DFE0", Offset = "0x87CFE0", VA = "0x18087DFE0")]
|
|
private static void ValidateGotoType(Type expectedType, ref Expression value, string paramName)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.IndexExpression" /> that represents accessing an indexed property in an object.</summary>
|
|
/// <param name="instance">The object to which the property belongs. It should be null if the property is <see langword="static" /> (<see langword="shared" /> in Visual Basic).</param>
|
|
/// <param name="indexer">An <see cref="T:System.Linq.Expressions.Expression" /> representing the property to index.</param>
|
|
/// <param name="arguments">An IEnumerable<Expression> (IEnumerable (Of Expression) in Visual Basic) that contains the arguments that will be used to index the property.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.IndexExpression" />.</returns>
|
|
// Token: 0x06000301 RID: 769 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000301")]
|
|
[Address(RVA = "0x876FD0", Offset = "0x875FD0", VA = "0x180876FD0")]
|
|
public static IndexExpression MakeIndex(Expression instance, PropertyInfo indexer, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.IndexExpression" /> to access an array.</summary>
|
|
/// <param name="array">An expression representing the array to index.</param>
|
|
/// <param name="indexes">An array that contains expressions used to index the array.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.IndexExpression" />.</returns>
|
|
// Token: 0x06000302 RID: 770 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000302")]
|
|
[Address(RVA = "0x869870", Offset = "0x868870", VA = "0x180869870")]
|
|
public static IndexExpression ArrayAccess(Expression array, params Expression[] indexes)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.IndexExpression" /> to access a multidimensional array.</summary>
|
|
/// <param name="array">An expression that represents the multidimensional array.</param>
|
|
/// <param name="indexes">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> containing expressions used to index the array.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.IndexExpression" />.</returns>
|
|
// Token: 0x06000303 RID: 771 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000303")]
|
|
[Address(RVA = "0x8698E0", Offset = "0x8688E0", VA = "0x1808698E0")]
|
|
public static IndexExpression ArrayAccess(Expression array, IEnumerable<Expression> indexes)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.IndexExpression" /> representing the access to an indexed property.</summary>
|
|
/// <param name="instance">The object to which the property belongs. If the property is static/shared, it must be null.</param>
|
|
/// <param name="indexer">The <see cref="T:System.Reflection.PropertyInfo" /> that represents the property to index.</param>
|
|
/// <param name="arguments">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> of <see cref="T:System.Linq.Expressions.Expression" /> objects that are used to index the property.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.IndexExpression" />.</returns>
|
|
// Token: 0x06000304 RID: 772 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000304")]
|
|
[Address(RVA = "0x87B4A0", Offset = "0x87A4A0", VA = "0x18087B4A0")]
|
|
public static IndexExpression Property(Expression instance, PropertyInfo indexer, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000305 RID: 773 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000305")]
|
|
[Address(RVA = "0x876F20", Offset = "0x875F20", VA = "0x180876F20")]
|
|
private static IndexExpression MakeIndexProperty(Expression instance, PropertyInfo indexer, string paramName, ReadOnlyCollection<Expression> argList)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000306 RID: 774 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000306")]
|
|
[Address(RVA = "0x87E3A0", Offset = "0x87D3A0", VA = "0x18087E3A0")]
|
|
private static void ValidateIndexedProperty(Expression instance, PropertyInfo indexer, string paramName, ref ReadOnlyCollection<Expression> argList)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000307 RID: 775 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000307")]
|
|
[Address(RVA = "0x87DBC0", Offset = "0x87CBC0", VA = "0x18087DBC0")]
|
|
private static void ValidateAccessor(Expression instance, MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection<Expression> arguments, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000308 RID: 776 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000308")]
|
|
[Address(RVA = "0x87D7F0", Offset = "0x87C7F0", VA = "0x18087D7F0")]
|
|
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection<Expression> arguments, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000309 RID: 777 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000309")]
|
|
[Address(RVA = "0x873B40", Offset = "0x872B40", VA = "0x180873B40")]
|
|
internal static InvocationExpression Invoke(Expression expression)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600030A RID: 778 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030A")]
|
|
[Address(RVA = "0x873C30", Offset = "0x872C30", VA = "0x180873C30")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600030B RID: 779 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030B")]
|
|
[Address(RVA = "0x873960", Offset = "0x872960", VA = "0x180873960")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0, Expression arg1)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600030C RID: 780 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030C")]
|
|
[Address(RVA = "0x8740A0", Offset = "0x8730A0", VA = "0x1808740A0")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0, Expression arg1, Expression arg2)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600030D RID: 781 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030D")]
|
|
[Address(RVA = "0x8742D0", Offset = "0x8732D0", VA = "0x1808742D0")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0, Expression arg1, Expression arg2, Expression arg3)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600030E RID: 782 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030E")]
|
|
[Address(RVA = "0x873DA0", Offset = "0x872DA0", VA = "0x180873DA0")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.InvocationExpression" /> that applies a delegate or lambda expression to a list of argument expressions.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the delegate or lambda expression to be applied to.</param>
|
|
/// <param name="arguments">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects that represent the arguments that the delegate or lambda expression is applied to.</param>
|
|
/// <returns>An <see cref="T:System.Linq.Expressions.InvocationExpression" /> that applies the specified delegate or lambda expression to the provided arguments.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="expression" />.Type does not represent a delegate type or an <see cref="T:System.Linq.Expressions.Expression`1" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="arguments" /> is not assignable to the type of the corresponding parameter of the delegate represented by <paramref name="expression" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="arguments" /> does not contain the same number of elements as the list of parameters for the delegate represented by <paramref name="expression" />.</exception>
|
|
// Token: 0x0600030F RID: 783 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600030F")]
|
|
[Address(RVA = "0x8732D0", Offset = "0x8722D0", VA = "0x1808732D0")]
|
|
public static InvocationExpression Invoke(Expression expression, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000310 RID: 784 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000310")]
|
|
[Address(RVA = "0x8704C0", Offset = "0x86F4C0", VA = "0x1808704C0")]
|
|
internal static MethodInfo GetInvokeMethod(Expression expression)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LabelExpression" /> representing a label without a default value.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> which this <see cref="T:System.Linq.Expressions.LabelExpression" /> will be associated with.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.LabelExpression" /> without a default value.</returns>
|
|
// Token: 0x06000311 RID: 785 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000311")]
|
|
[Address(RVA = "0x875050", Offset = "0x874050", VA = "0x180875050")]
|
|
public static LabelExpression Label(LabelTarget target)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LabelExpression" /> representing a label with the given default value.</summary>
|
|
/// <param name="target">The <see cref="T:System.Linq.Expressions.LabelTarget" /> which this <see cref="T:System.Linq.Expressions.LabelExpression" /> will be associated with.</param>
|
|
/// <param name="defaultValue">The value of this <see cref="T:System.Linq.Expressions.LabelExpression" /> when the label is reached through regular control flow.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.LabelExpression" /> with the given default value.</returns>
|
|
// Token: 0x06000312 RID: 786 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000312")]
|
|
[Address(RVA = "0x874DD0", Offset = "0x873DD0", VA = "0x180874DD0")]
|
|
public static LabelExpression Label(LabelTarget target, Expression defaultValue)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LabelTarget" /> representing a label with void type and no name.</summary>
|
|
/// <returns>The new <see cref="T:System.Linq.Expressions.LabelTarget" />.</returns>
|
|
// Token: 0x06000313 RID: 787 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000313")]
|
|
[Address(RVA = "0x874FC0", Offset = "0x873FC0", VA = "0x180874FC0")]
|
|
public static LabelTarget Label()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LabelTarget" /> representing a label with void type and the given name.</summary>
|
|
/// <param name="name">The name of the label.</param>
|
|
/// <returns>The new <see cref="T:System.Linq.Expressions.LabelTarget" />.</returns>
|
|
// Token: 0x06000314 RID: 788 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000314")]
|
|
[Address(RVA = "0x875130", Offset = "0x874130", VA = "0x180875130")]
|
|
public static LabelTarget Label(string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LabelTarget" /> representing a label with the given type.</summary>
|
|
/// <param name="type">The type of value that is passed when jumping to the label.</param>
|
|
/// <returns>The new <see cref="T:System.Linq.Expressions.LabelTarget" />.</returns>
|
|
// Token: 0x06000315 RID: 789 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000315")]
|
|
[Address(RVA = "0x874E80", Offset = "0x873E80", VA = "0x180874E80")]
|
|
public static LabelTarget Label(Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.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="T:System.Linq.Expressions.LabelTarget" />.</returns>
|
|
// Token: 0x06000316 RID: 790 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000316")]
|
|
[Address(RVA = "0x874EE0", Offset = "0x873EE0", VA = "0x180874EE0")]
|
|
public static LabelTarget Label(Type type, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000317 RID: 791 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000317")]
|
|
[Address(RVA = "0x86E620", Offset = "0x86D620", VA = "0x18086E620")]
|
|
internal static LambdaExpression CreateLambda(Type delegateType, Expression body, string name, bool tailCall, ReadOnlyCollection<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.Expression`1" /> where the delegate type is known at compile time.</summary>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to.</param>
|
|
/// <param name="parameters">An array of <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection.</param>
|
|
/// <typeparam name="TDelegate">A delegate type.</typeparam>
|
|
/// <returns>An <see cref="T:System.Linq.Expressions.Expression`1" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Lambda" /> and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="body" /> is <see langword="null" />.-or-One or more elements in <paramref name="parameters" /> are <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="TDelegate" /> is not a delegate type.-or-
|
|
/// <paramref name="body" />.Type represents a type that is not assignable to the return type of <paramref name="TDelegate" />.-or-
|
|
/// <paramref name="parameters" /> does not contain the same number of elements as the list of parameters for <paramref name="TDelegate" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="parameters" /> is not assignable from the type of the corresponding parameter type of <paramref name="TDelegate" />.</exception>
|
|
// Token: 0x06000318 RID: 792 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000318")]
|
|
[Address(RVA = "0x27D68B0", Offset = "0x27D58B0", VA = "0x1827D68B0")]
|
|
public static Expression<TDelegate> Lambda<TDelegate>(Expression body, params ParameterExpression[] parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.Expression`1" /> where the delegate type is known at compile time.</summary>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to.</param>
|
|
/// <param name="parameters">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection.</param>
|
|
/// <typeparam name="TDelegate">A delegate type.</typeparam>
|
|
/// <returns>An <see cref="T:System.Linq.Expressions.Expression`1" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Lambda" /> and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="body" /> is <see langword="null" />.-or-One or more elements in <paramref name="parameters" /> are <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="TDelegate" /> is not a delegate type.-or-
|
|
/// <paramref name="body" />.Type represents a type that is not assignable to the return type of <paramref name="TDelegate" />.-or-
|
|
/// <paramref name="parameters" /> does not contain the same number of elements as the list of parameters for <paramref name="TDelegate" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="parameters" /> is not assignable from the type of the corresponding parameter type of <paramref name="TDelegate" />.</exception>
|
|
// Token: 0x06000319 RID: 793 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000319")]
|
|
[Address(RVA = "0x27D67A0", Offset = "0x27D57A0", VA = "0x1827D67A0")]
|
|
public static Expression<TDelegate> Lambda<TDelegate>(Expression body, IEnumerable<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.Expression`1" /> where the delegate type is known at compile time.</summary>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to.</param>
|
|
/// <param name="tailCall">A <see cref="T:System.Boolean" /> that indicates if tail call optimization will be applied when compiling the created expression.</param>
|
|
/// <param name="parameters">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection.</param>
|
|
/// <typeparam name="TDelegate">The delegate type. </typeparam>
|
|
/// <returns>An <see cref="T:System.Linq.Expressions.Expression`1" /> that has the <see cref="P:System.Linq.Expressions.LambdaExpression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Lambda" /> and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
// Token: 0x0600031A RID: 794 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600031A")]
|
|
[Address(RVA = "0x27D6820", Offset = "0x27D5820", VA = "0x1827D6820")]
|
|
public static Expression<TDelegate> Lambda<TDelegate>(Expression body, bool tailCall, IEnumerable<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates an <see cref="T:System.Linq.Expressions.Expression`1" /> where the delegate type is known at compile time.</summary>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to.</param>
|
|
/// <param name="name">The name of the lambda. Used for generating debugging info.</param>
|
|
/// <param name="tailCall">A <see cref="T:System.Boolean" /> that indicates if tail call optimization will be applied when compiling the created expression.</param>
|
|
/// <param name="parameters">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection.</param>
|
|
/// <typeparam name="TDelegate">The delegate type. </typeparam>
|
|
/// <returns>An <see cref="T:System.Linq.Expressions.Expression`1" /> that has the <see cref="P:System.Linq.Expressions.LambdaExpression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Lambda" /> and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
// Token: 0x0600031B RID: 795 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600031B")]
|
|
[Address(RVA = "0x27D6930", Offset = "0x27D5930", VA = "0x1827D6930")]
|
|
public static Expression<TDelegate> Lambda<TDelegate>(Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LambdaExpression" /> by first constructing a delegate type. It can be used when the delegate type is not known at compile time.</summary>
|
|
/// <param name="delegateType">A <see cref="T:System.Type" /> that represents a delegate signature for the lambda.</param>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to.</param>
|
|
/// <param name="parameters">An array of <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection.</param>
|
|
/// <returns>An object that represents a lambda expression which has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Lambda" /> and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="delegateType" /> or <paramref name="body" /> is <see langword="null" />.-or-One or more elements in <paramref name="parameters" /> are <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="delegateType" /> does not represent a delegate type.-or-
|
|
/// <paramref name="body" />.Type represents a type that is not assignable to the return type of the delegate type represented by <paramref name="delegateType" />.-or-
|
|
/// <paramref name="parameters" /> does not contain the same number of elements as the list of parameters for the delegate type represented by <paramref name="delegateType" />.-or-The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="parameters" /> is not assignable from the type of the corresponding parameter type of the delegate type represented by <paramref name="delegateType" />.</exception>
|
|
// Token: 0x0600031C RID: 796 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600031C")]
|
|
[Address(RVA = "0x8751C0", Offset = "0x8741C0", VA = "0x1808751C0")]
|
|
public static LambdaExpression Lambda(Type delegateType, Expression body, params ParameterExpression[] parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a LambdaExpression by first constructing a delegate type.</summary>
|
|
/// <param name="delegateType">A <see cref="P:System.Linq.Expressions.Expression.Type" /> representing the delegate signature for the lambda.</param>
|
|
/// <param name="body">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> property equal to. </param>
|
|
/// <param name="name">The name for the lambda. Used for emitting debug information.</param>
|
|
/// <param name="tailCall">A <see cref="T:System.Boolean" /> that indicates if tail call optimization will be applied when compiling the created expression. </param>
|
|
/// <param name="parameters">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.ParameterExpression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> collection. </param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.LambdaExpression" /> that has the <see cref="P:System.Linq.Expressions.LambdaExpression.NodeType" /> property equal to Lambda and the <see cref="P:System.Linq.Expressions.LambdaExpression.Body" /> and <see cref="P:System.Linq.Expressions.LambdaExpression.Parameters" /> properties set to the specified values.</returns>
|
|
// Token: 0x0600031D RID: 797 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600031D")]
|
|
[Address(RVA = "0x8752B0", Offset = "0x8742B0", VA = "0x1808752B0")]
|
|
public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600031E RID: 798 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x600031E")]
|
|
[Address(RVA = "0x87EA20", Offset = "0x87DA20", VA = "0x18087EA20")]
|
|
private static void ValidateLambdaArgs(Type delegateType, ref Expression body, ReadOnlyCollection<ParameterExpression> parameters, string paramName)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.LoopExpression" /> with the given body.</summary>
|
|
/// <param name="body">The body of the loop.</param>
|
|
/// <param name="break">The break target used by the loop body.</param>
|
|
/// <param name="continue">The continue target used by the loop body.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.LoopExpression" />.</returns>
|
|
// Token: 0x0600031F RID: 799 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600031F")]
|
|
[Address(RVA = "0x875A60", Offset = "0x874A60", VA = "0x180875A60")]
|
|
public static LoopExpression Loop(Expression body, LabelTarget @break, LabelTarget @continue)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MemberExpression" /> that represents accessing a field.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> property equal to. For <see langword="static" /> (<see langword="Shared" /> in Visual Basic), <paramref name="expression" /> must be <see langword="null" />.</param>
|
|
/// <param name="field">The <see cref="T:System.Reflection.FieldInfo" /> to set the <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MemberExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MemberAccess" /> and the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> and <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="field" /> is <see langword="null" />.-or-The field represented by <paramref name="field" /> is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic) and <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="expression" />.Type is not assignable to the declaring type of the field represented by <paramref name="field" />.</exception>
|
|
// Token: 0x06000320 RID: 800 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000320")]
|
|
[Address(RVA = "0x86F860", Offset = "0x86E860", VA = "0x18086F860")]
|
|
public static MemberExpression Field(Expression expression, FieldInfo field)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MemberExpression" /> that represents accessing a field given the name of the field.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> whose <see cref="P:System.Linq.Expressions.Expression.Type" /> contains a field named <paramref name="fieldName" />. This can be null for static fields.</param>
|
|
/// <param name="fieldName">The name of a field to be accessed.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MemberExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MemberAccess" />, the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> property set to <paramref name="expression" />, and the <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> property set to the <see cref="T:System.Reflection.FieldInfo" /> that represents the field denoted by <paramref name="fieldName" />.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="fieldName" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">No field named <paramref name="fieldName" /> is defined in <paramref name="expression" />.Type or its base types.</exception>
|
|
// Token: 0x06000321 RID: 801 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000321")]
|
|
[Address(RVA = "0x86FA30", Offset = "0x86EA30", VA = "0x18086FA30")]
|
|
public static MemberExpression Field(Expression expression, string fieldName)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MemberExpression" /> that represents accessing a property.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> whose <see cref="P:System.Linq.Expressions.Expression.Type" /> contains a property named <paramref name="propertyName" />. This can be <see langword="null" /> for static properties.</param>
|
|
/// <param name="propertyName">The name of a property to be accessed.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MemberExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MemberAccess" />, the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> property set to <paramref name="expression" />, and the <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> property set to the <see cref="T:System.Reflection.PropertyInfo" /> that represents the property denoted by <paramref name="propertyName" />.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="propertyName" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">No property named <paramref name="propertyName" /> is defined in <paramref name="expression" />.Type or its base types.</exception>
|
|
// Token: 0x06000322 RID: 802 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000322")]
|
|
[Address(RVA = "0x87B5B0", Offset = "0x87A5B0", VA = "0x18087B5B0")]
|
|
public static MemberExpression Property(Expression expression, string propertyName)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MemberExpression" /> that represents accessing a property.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> property equal to. This can be null for static properties.</param>
|
|
/// <param name="property">The <see cref="T:System.Reflection.PropertyInfo" /> to set the <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MemberExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.MemberAccess" /> and the <see cref="P:System.Linq.Expressions.MemberExpression.Expression" /> and <see cref="P:System.Linq.Expressions.MemberExpression.Member" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="property" /> is <see langword="null" />.-or-The property that <paramref name="property" /> represents is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic) and <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="expression" />.Type is not assignable to the declaring type of the property that <paramref name="property" /> represents.</exception>
|
|
// Token: 0x06000323 RID: 803 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000323")]
|
|
[Address(RVA = "0x87B750", Offset = "0x87A750", VA = "0x18087B750")]
|
|
public static MemberExpression Property(Expression expression, PropertyInfo property)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MemberExpression" /> that represents accessing either a field or a property.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the object that the member belongs to. This can be null for static members.</param>
|
|
/// <param name="member">The <see cref="T:System.Reflection.MemberInfo" /> that describes the field or property to be accessed.</param>
|
|
/// <returns>The <see cref="T:System.Linq.Expressions.MemberExpression" /> that results from calling the appropriate factory method.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="member" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="member" /> does not represent a field or property.</exception>
|
|
// Token: 0x06000324 RID: 804 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000324")]
|
|
[Address(RVA = "0x877160", Offset = "0x876160", VA = "0x180877160")]
|
|
public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000325 RID: 805 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000325")]
|
|
[Address(RVA = "0x86B150", Offset = "0x86A150", VA = "0x18086B150")]
|
|
internal static MethodCallExpression Call(MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a <see langword="static" /> (<see langword="Shared" /> in Visual Basic) method that takes one argument.</summary>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is null.</exception>
|
|
// Token: 0x06000326 RID: 806 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000326")]
|
|
[Address(RVA = "0x86B250", Offset = "0x86A250", VA = "0x18086B250")]
|
|
public static MethodCallExpression Call(MethodInfo method, Expression arg0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a static method that takes two arguments.</summary>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is null.</exception>
|
|
// Token: 0x06000327 RID: 807 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000327")]
|
|
[Address(RVA = "0x86B890", Offset = "0x86A890", VA = "0x18086B890")]
|
|
public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a static method that takes three arguments.</summary>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <param name="arg2">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the third argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is null.</exception>
|
|
// Token: 0x06000328 RID: 808 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000328")]
|
|
[Address(RVA = "0x86B420", Offset = "0x86A420", VA = "0x18086B420")]
|
|
public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a static method that takes four arguments.</summary>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <param name="arg2">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the third argument.</param>
|
|
/// <param name="arg3">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the fourth argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is null.</exception>
|
|
// Token: 0x06000329 RID: 809 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000329")]
|
|
[Address(RVA = "0x86D080", Offset = "0x86C080", VA = "0x18086D080")]
|
|
public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a static method that takes five arguments.</summary>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <param name="arg2">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the third argument.</param>
|
|
/// <param name="arg3">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the fourth argument.</param>
|
|
/// <param name="arg4">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the fifth argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is null.</exception>
|
|
// Token: 0x0600032A RID: 810 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032A")]
|
|
[Address(RVA = "0x86CBD0", Offset = "0x86BBD0", VA = "0x18086CBD0")]
|
|
public static MethodCallExpression Call(MethodInfo method, Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a static (Shared in Visual Basic) method.</summary>
|
|
/// <param name="method">The <see cref="T:System.Reflection.MethodInfo" /> that represents the target method.</param>
|
|
/// <param name="arguments">A collection of <see cref="T:System.Linq.Expressions.Expression" /> that represents the call arguments.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
// Token: 0x0600032B RID: 811 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032B")]
|
|
[Address(RVA = "0x86C0D0", Offset = "0x86B0D0", VA = "0x18086C0D0")]
|
|
public static MethodCallExpression Call(MethodInfo method, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method that takes no arguments.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> that specifies the instance for an instance method call (pass <see langword="null" /> for a <see langword="static" /> (<see langword="Shared" /> in Visual Basic) method).</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is <see langword="null" />.-or-
|
|
/// <paramref name="instance" /> is <see langword="null" /> and <paramref name="method" /> represents an instance method.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="instance" />.Type is not assignable to the declaring type of the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x0600032C RID: 812 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032C")]
|
|
[Address(RVA = "0x86B760", Offset = "0x86A760", VA = "0x18086B760")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method that takes arguments.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> that specifies the instance for an instance method call (pass <see langword="null" /> for a <see langword="static" /> (<see langword="Shared" /> in Visual Basic) method).</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arguments">An array of <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> collection.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" />, <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" />, and <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is <see langword="null" />.-or-
|
|
/// <paramref name="instance" /> is <see langword="null" /> and <paramref name="method" /> represents an instance method.-or-
|
|
/// <paramref name="arguments" /> is not <see langword="null" /> and one or more of its elements is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="instance" />.Type is not assignable to the declaring type of the method represented by <paramref name="method" />.-or-The number of elements in <paramref name="arguments" /> does not equal the number of parameters for the method represented by <paramref name="method" />.-or-One or more of the elements of <paramref name="arguments" /> is not assignable to the corresponding parameter for the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x0600032D RID: 813 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032D")]
|
|
[Address(RVA = "0x86C4C0", Offset = "0x86B4C0", VA = "0x18086C4C0")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600032E RID: 814 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032E")]
|
|
[Address(RVA = "0x86C540", Offset = "0x86B540", VA = "0x18086C540")]
|
|
internal static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method that takes two arguments.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> that specifies the instance for an instance call. (pass null for a static (Shared in Visual Basic) method).</param>
|
|
/// <param name="method">The <see cref="T:System.Reflection.MethodInfo" /> that represents the target method.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
// Token: 0x0600032F RID: 815 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600032F")]
|
|
[Address(RVA = "0x86C900", Offset = "0x86B900", VA = "0x18086C900")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method that takes three arguments.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> that specifies the instance for an instance call. (pass null for a static (Shared in Visual Basic) method).</param>
|
|
/// <param name="method">The <see cref="T:System.Reflection.MethodInfo" /> that represents the target method.</param>
|
|
/// <param name="arg0">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the first argument.</param>
|
|
/// <param name="arg1">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the second argument.</param>
|
|
/// <param name="arg2">The <see cref="T:System.Linq.Expressions.Expression" /> that represents the third argument.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> and <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> properties set to the specified values.</returns>
|
|
// Token: 0x06000330 RID: 816 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000330")]
|
|
[Address(RVA = "0x86C140", Offset = "0x86B140", VA = "0x18086C140")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, Expression arg0, Expression arg1, Expression arg2)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method by calling the appropriate factory method.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> whose <see cref="P:System.Linq.Expressions.Expression.Type" /> property value will be searched for a specific method.</param>
|
|
/// <param name="methodName">The name of the method.</param>
|
|
/// <param name="typeArguments">An array of <see cref="T:System.Type" /> objects that specify the type parameters of the generic method. This argument should be null when methodName specifies a non-generic method.</param>
|
|
/// <param name="arguments">An array of <see cref="T:System.Linq.Expressions.Expression" /> objects that represents the arguments to the method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" />, the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> property equal to <paramref name="instance" />, <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> set to the <see cref="T:System.Reflection.MethodInfo" /> that represents the specified instance method, and <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> set to the specified arguments.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="instance" /> or <paramref name="methodName" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">No method whose name is <paramref name="methodName" />, whose type parameters match <paramref name="typeArguments" />, and whose parameter types match <paramref name="arguments" /> is found in <paramref name="instance" />.Type or its base types.-or-More than one method whose name is <paramref name="methodName" />, whose type parameters match <paramref name="typeArguments" />, and whose parameter types match <paramref name="arguments" /> is found in <paramref name="instance" />.Type or its base types.</exception>
|
|
// Token: 0x06000331 RID: 817 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000331")]
|
|
[Address(RVA = "0x86C740", Offset = "0x86B740", VA = "0x18086C740")]
|
|
public static MethodCallExpression Call(Expression instance, string methodName, Type[] typeArguments, params Expression[] arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that represents a call to a method that takes arguments.</summary>
|
|
/// <param name="instance">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" /> property equal to (pass <see langword="null" /> for a <see langword="static" /> (<see langword="Shared" /> in Visual Basic) method).</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" /> property equal to.</param>
|
|
/// <param name="arguments">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> collection.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.MethodCallExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Call" /> and the <see cref="P:System.Linq.Expressions.MethodCallExpression.Object" />, <see cref="P:System.Linq.Expressions.MethodCallExpression.Method" />, and <see cref="P:System.Linq.Expressions.MethodCallExpression.Arguments" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="method" /> is <see langword="null" />.-or-
|
|
/// <paramref name="instance" /> is <see langword="null" /> and <paramref name="method" /> represents an instance method.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="instance" />.Type is not assignable to the declaring type of the method represented by <paramref name="method" />.-or-The number of elements in <paramref name="arguments" /> does not equal the number of parameters for the method represented by <paramref name="method" />.-or-One or more of the elements of <paramref name="arguments" /> is not assignable to the corresponding parameter for the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x06000332 RID: 818 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000332")]
|
|
[Address(RVA = "0x86BB10", Offset = "0x86AB10", VA = "0x18086BB10")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000333 RID: 819 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000333")]
|
|
[Address(RVA = "0x87F040", Offset = "0x87E040", VA = "0x18087F040")]
|
|
private static ParameterInfo[] ValidateMethodAndGetParameters(Expression instance, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000334 RID: 820 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000334")]
|
|
[Address(RVA = "0x87F5F0", Offset = "0x87E5F0", VA = "0x18087F5F0")]
|
|
private static void ValidateStaticOrInstanceMethod(Expression instance, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000335 RID: 821 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000335")]
|
|
[Address(RVA = "0x87DE00", Offset = "0x87CE00", VA = "0x18087DE00")]
|
|
private static void ValidateCallInstanceType(Type instanceType, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000336 RID: 822 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000336")]
|
|
[Address(RVA = "0x87DDF0", Offset = "0x87CDF0", VA = "0x18087DDF0")]
|
|
private static void ValidateArgumentTypes(MethodBase method, ExpressionType nodeKind, ref ReadOnlyCollection<Expression> arguments, string methodParamName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000337 RID: 823 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000337")]
|
|
[Address(RVA = "0x871A40", Offset = "0x870A40", VA = "0x180871A40")]
|
|
private static ParameterInfo[] GetParametersForValidation(MethodBase method, ExpressionType nodeKind)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000338 RID: 824 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000338")]
|
|
[Address(RVA = "0x87DDE0", Offset = "0x87CDE0", VA = "0x18087DDE0")]
|
|
private static void ValidateArgumentCount(MethodBase method, ExpressionType nodeKind, int count, ParameterInfo[] pis)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000339 RID: 825 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000339")]
|
|
[Address(RVA = "0x87F170", Offset = "0x87E170", VA = "0x18087F170")]
|
|
private static Expression ValidateOneArgument(MethodBase method, ExpressionType nodeKind, Expression arg, ParameterInfo pi, string methodParamName, string argumentParamName)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600033A RID: 826 RVA: 0x00002B80 File Offset: 0x00000D80
|
|
[Token(Token = "0x600033A")]
|
|
[Address(RVA = "0x87D360", Offset = "0x87C360", VA = "0x18087D360")]
|
|
private static bool TryQuote(Type parameterType, ref Expression argument)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600033B RID: 827 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600033B")]
|
|
[Address(RVA = "0x86FBE0", Offset = "0x86EBE0", VA = "0x18086FBE0")]
|
|
private static MethodInfo FindMethod(Type type, string methodName, Type[] typeArgs, Expression[] args, BindingFlags flags)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600033C RID: 828 RVA: 0x00002B98 File Offset: 0x00000D98
|
|
[Token(Token = "0x600033C")]
|
|
[Address(RVA = "0x874570", Offset = "0x873570", VA = "0x180874570")]
|
|
private static bool IsCompatible(MethodBase m, Expression[] arguments)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600033D RID: 829 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600033D")]
|
|
[Address(RVA = "0x8697B0", Offset = "0x8687B0", VA = "0x1808697B0")]
|
|
private static MethodInfo ApplyTypeArgs(MethodInfo m, Type[] typeArgs)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that represents creating a one-dimensional array and initializing it from a list of elements.</summary>
|
|
/// <param name="type">A <see cref="T:System.Type" /> that represents the element type of the array.</param>
|
|
/// <param name="initializers">An array of <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> collection.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NewArrayInit" /> and the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> property set to the specified value.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="type" /> or <paramref name="initializers" /> is <see langword="null" />.-or-An element of <paramref name="initializers" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="initializers" /> represents a type that is not assignable to the type <paramref name="type" />.</exception>
|
|
// Token: 0x0600033E RID: 830 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600033E")]
|
|
[Address(RVA = "0x879C50", Offset = "0x878C50", VA = "0x180879C50")]
|
|
public static NewArrayExpression NewArrayInit(Type type, params Expression[] initializers)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that represents creating a one-dimensional array and initializing it from a list of elements.</summary>
|
|
/// <param name="type">A <see cref="T:System.Type" /> that represents the element type of the array.</param>
|
|
/// <param name="initializers">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> collection.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NewArrayInit" /> and the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> property set to the specified value.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="type" /> or <paramref name="initializers" /> is <see langword="null" />.-or-An element of <paramref name="initializers" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="initializers" /> represents a type that is not assignable to the type that <paramref name="type" /> represents.</exception>
|
|
// Token: 0x0600033F RID: 831 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600033F")]
|
|
[Address(RVA = "0x879CC0", Offset = "0x878CC0", VA = "0x180879CC0")]
|
|
public static NewArrayExpression NewArrayInit(Type type, IEnumerable<Expression> initializers)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that represents creating an array that has a specified rank.</summary>
|
|
/// <param name="type">A <see cref="T:System.Type" /> that represents the element type of the array.</param>
|
|
/// <param name="bounds">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> that contains <see cref="T:System.Linq.Expressions.Expression" /> objects to use to populate the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> collection.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.NewArrayExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NewArrayBounds" /> and the <see cref="P:System.Linq.Expressions.NewArrayExpression.Expressions" /> property set to the specified value.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="type" /> or <paramref name="bounds" /> is <see langword="null" />.-or-An element of <paramref name="bounds" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">The <see cref="P:System.Linq.Expressions.Expression.Type" /> property of an element of <paramref name="bounds" /> does not represent an integral type.</exception>
|
|
// Token: 0x06000340 RID: 832 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000340")]
|
|
[Address(RVA = "0x8799C0", Offset = "0x8789C0", VA = "0x1808799C0")]
|
|
public static NewArrayExpression NewArrayBounds(Type type, IEnumerable<Expression> bounds)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.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>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ParameterExpression" /> node with the specified name and type.</returns>
|
|
// Token: 0x06000341 RID: 833 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000341")]
|
|
[Address(RVA = "0x87AF40", Offset = "0x879F40", VA = "0x18087AF40")]
|
|
public static ParameterExpression Parameter(Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.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 printing purpose only.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ParameterExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Parameter" /> and the <see cref="P:System.Linq.Expressions.Expression.Type" /> and <see cref="P:System.Linq.Expressions.ParameterExpression.Name" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="type" /> is <see langword="null" />.</exception>
|
|
// Token: 0x06000342 RID: 834 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000342")]
|
|
[Address(RVA = "0x87AE90", Offset = "0x879E90", VA = "0x18087AE90")]
|
|
public static ParameterExpression Parameter(Type type, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.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. This name is used for debugging or printing purpose only.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.ParameterExpression" /> node with the specified name and type.</returns>
|
|
// Token: 0x06000343 RID: 835 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000343")]
|
|
[Address(RVA = "0x880680", Offset = "0x87F680", VA = "0x180880680")]
|
|
public static ParameterExpression Variable(Type type, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000344 RID: 836 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000344")]
|
|
[Address(RVA = "0x880560", Offset = "0x87F560", VA = "0x180880560")]
|
|
private static void Validate(Type type, bool allowByRef)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.TryExpression" /> representing a try block with a finally block and no catch statements.</summary>
|
|
/// <param name="body">The body of the try block.</param>
|
|
/// <param name="finally">The body of the finally block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.TryExpression" />.</returns>
|
|
// Token: 0x06000345 RID: 837 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000345")]
|
|
[Address(RVA = "0x87D2F0", Offset = "0x87C2F0", VA = "0x18087D2F0")]
|
|
public static TryExpression TryFinally(Expression body, Expression @finally)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.TryExpression" /> representing a try block with the specified elements.</summary>
|
|
/// <param name="type">The result type of the try expression. If null, bodh and all handlers must have identical type.</param>
|
|
/// <param name="body">The body of the try block.</param>
|
|
/// <param name="finally">The body of the finally block. Pass null if the try block has no finally block associated with it.</param>
|
|
/// <param name="fault">The body of the fault block. Pass null if the try block has no fault block associated with it.</param>
|
|
/// <param name="handlers">A collection of <see cref="T:System.Linq.Expressions.CatchBlock" />s representing the catch statements to be associated with the try block.</param>
|
|
/// <returns>The created <see cref="T:System.Linq.Expressions.TryExpression" />.</returns>
|
|
// Token: 0x06000346 RID: 838 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000346")]
|
|
[Address(RVA = "0x877560", Offset = "0x876560", VA = "0x180877560")]
|
|
public static TryExpression MakeTry(Type type, Expression body, Expression @finally, Expression fault, IEnumerable<CatchBlock> handlers)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000347 RID: 839 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000347")]
|
|
[Address(RVA = "0x87F6E0", Offset = "0x87E6E0", VA = "0x18087F6E0")]
|
|
private static void ValidateTryAndCatchHaveSameType(Type type, Expression tryBody, ReadOnlyCollection<CatchBlock> handlers)
|
|
{
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" />, given an operand and implementing method, by calling the appropriate factory method.</summary>
|
|
/// <param name="unaryType">The <see cref="T:System.Linq.Expressions.ExpressionType" /> that specifies the type of unary operation.</param>
|
|
/// <param name="operand">An <see cref="T:System.Linq.Expressions.Expression" /> that represents the operand.</param>
|
|
/// <param name="type">The <see cref="T:System.Type" /> that specifies the type to be converted to (pass <see langword="null" /> if not applicable).</param>
|
|
/// <param name="method">The <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>The <see cref="T:System.Linq.Expressions.UnaryExpression" /> that results from calling the appropriate factory method.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="operand" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="unaryType" /> does not correspond to a unary expression node.</exception>
|
|
// Token: 0x06000348 RID: 840 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000348")]
|
|
[Address(RVA = "0x877740", Offset = "0x876740", VA = "0x180877740")]
|
|
public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000349 RID: 841 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000349")]
|
|
[Address(RVA = "0x872880", Offset = "0x871880", VA = "0x180872880")]
|
|
private static UnaryExpression GetUserDefinedUnaryOperatorOrThrow(ExpressionType unaryType, string name, Expression operand)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600034A RID: 842 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034A")]
|
|
[Address(RVA = "0x872A20", Offset = "0x871A20", VA = "0x180872A20")]
|
|
private static UnaryExpression GetUserDefinedUnaryOperator(ExpressionType unaryType, string name, Expression operand)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600034B RID: 843 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034B")]
|
|
[Address(RVA = "0x871250", Offset = "0x870250", VA = "0x180871250")]
|
|
private static UnaryExpression GetMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600034C RID: 844 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034C")]
|
|
[Address(RVA = "0x872670", Offset = "0x871670", VA = "0x180872670")]
|
|
private static UnaryExpression GetUserDefinedCoercionOrThrow(ExpressionType coercionType, Expression expression, Type convertToType)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600034D RID: 845 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034D")]
|
|
[Address(RVA = "0x8727B0", Offset = "0x8717B0", VA = "0x1808727B0")]
|
|
private static UnaryExpression GetUserDefinedCoercion(ExpressionType coercionType, Expression expression, Type convertToType)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600034E RID: 846 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034E")]
|
|
[Address(RVA = "0x870F00", Offset = "0x86FF00", VA = "0x180870F00")]
|
|
private static UnaryExpression GetMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type convertToType, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an arithmetic negation operation.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Negate" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the unary minus operator is not defined for <paramref name="expression" />.Type.-or-
|
|
/// <paramref name="expression" />.Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x0600034F RID: 847 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600034F")]
|
|
[Address(RVA = "0x879840", Offset = "0x878840", VA = "0x180879840")]
|
|
public static UnaryExpression Negate(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a unary plus operation.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.UnaryPlus" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the unary plus operator is not defined for <paramref name="expression" />.Type.-or-
|
|
/// <paramref name="expression" />.Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x06000350 RID: 848 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000350")]
|
|
[Address(RVA = "0x87D4B0", Offset = "0x87C4B0", VA = "0x18087D4B0")]
|
|
public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an arithmetic negation operation that has overflow checking. The implementing method can be specified.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.NegateChecked" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the unary minus operator is not defined for <paramref name="expression" />.Type.-or-
|
|
/// <paramref name="expression" />.Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x06000351 RID: 849 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000351")]
|
|
[Address(RVA = "0x8796C0", Offset = "0x8786C0", VA = "0x1808796C0")]
|
|
public static UnaryExpression NegateChecked(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a bitwise complement operation. The implementing method can be specified.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Not" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">
|
|
/// <paramref name="method" /> is <see langword="null" /> and the unary not operator is not defined for <paramref name="expression" />.Type.-or-
|
|
/// <paramref name="expression" />.Type (or its corresponding non-nullable type if it is a nullable value type) is not assignable to the argument type of the method represented by <paramref name="method" />.</exception>
|
|
// Token: 0x06000352 RID: 850 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000352")]
|
|
[Address(RVA = "0x87A1F0", Offset = "0x8791F0", VA = "0x18087A1F0")]
|
|
public static UnaryExpression Not(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns whether the expression evaluates to false.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to evaluate.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>An instance of <see cref="T:System.Linq.Expressions.UnaryExpression" />.</returns>
|
|
// Token: 0x06000353 RID: 851 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000353")]
|
|
[Address(RVA = "0x874780", Offset = "0x873780", VA = "0x180874780")]
|
|
public static UnaryExpression IsFalse(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns whether the expression evaluates to true.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to evaluate.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>An instance of <see cref="T:System.Linq.Expressions.UnaryExpression" />.</returns>
|
|
// Token: 0x06000354 RID: 852 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000354")]
|
|
[Address(RVA = "0x874BD0", Offset = "0x873BD0", VA = "0x180874BD0")]
|
|
public static UnaryExpression IsTrue(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Returns the expression representing the ones complement.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" />.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>An instance of <see cref="T:System.Linq.Expressions.UnaryExpression" />.</returns>
|
|
// Token: 0x06000355 RID: 853 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000355")]
|
|
[Address(RVA = "0x87A380", Offset = "0x879380", VA = "0x18087A380")]
|
|
public static UnaryExpression OnesComplement(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an explicit reference or boxing conversion where <see langword="null" /> is supplied if the conversion fails.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.TypeAs" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="type" /> is <see langword="null" />.</exception>
|
|
// Token: 0x06000356 RID: 854 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000356")]
|
|
[Address(RVA = "0x87D370", Offset = "0x87C370", VA = "0x18087D370")]
|
|
public static UnaryExpression TypeAs(Expression expression, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an explicit unboxing.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to unbox.</param>
|
|
/// <param name="type">The new <see cref="T:System.Type" /> of the expression.</param>
|
|
/// <returns>An instance of <see cref="T:System.Linq.Expressions.UnaryExpression" />.</returns>
|
|
// Token: 0x06000357 RID: 855 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000357")]
|
|
[Address(RVA = "0x87D610", Offset = "0x87C610", VA = "0x18087D610")]
|
|
public static UnaryExpression Unbox(Expression expression, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a type conversion operation.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Convert" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="type" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">No conversion operator is defined between <paramref name="expression" />.Type and <paramref name="type" />.</exception>
|
|
// Token: 0x06000358 RID: 856 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000358")]
|
|
[Address(RVA = "0x86E5B0", Offset = "0x86D5B0", VA = "0x18086E5B0")]
|
|
public static UnaryExpression Convert(Expression expression, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a conversion operation for which the implementing method is specified.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Convert" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" />, <see cref="P:System.Linq.Expressions.Expression.Type" />, and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="type" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">No conversion operator is defined between <paramref name="expression" />.Type and <paramref name="type" />.-or-
|
|
/// <paramref name="expression" />.Type is not assignable to the argument type of the method represented by <paramref name="method" />.-or-The return type of the method represented by <paramref name="method" /> is not assignable to <paramref name="type" />.-or-
|
|
/// <paramref name="expression" />.Type or <paramref name="type" /> is a nullable value type and the corresponding non-nullable value type does not equal the argument type or the return type, respectively, of the method represented by <paramref name="method" />.</exception>
|
|
/// <exception cref="T:System.Reflection.AmbiguousMatchException">More than one method that matches the <paramref name="method" /> description was found.</exception>
|
|
// Token: 0x06000359 RID: 857 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000359")]
|
|
[Address(RVA = "0x86E3D0", Offset = "0x86D3D0", VA = "0x18086E3D0")]
|
|
public static UnaryExpression Convert(Expression expression, Type type, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a conversion operation that throws an exception if the target type is overflowed.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ConvertChecked" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> and <see cref="P:System.Linq.Expressions.Expression.Type" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="type" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">No conversion operator is defined between <paramref name="expression" />.Type and <paramref name="type" />.</exception>
|
|
// Token: 0x0600035A RID: 858 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035A")]
|
|
[Address(RVA = "0x86E360", Offset = "0x86D360", VA = "0x18086E360")]
|
|
public static UnaryExpression ConvertChecked(Expression expression, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <param name="type">A <see cref="T:System.Type" /> to set the <see cref="P:System.Linq.Expressions.Expression.Type" /> property equal to.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ConvertChecked" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" />, <see cref="P:System.Linq.Expressions.Expression.Type" />, and <see cref="P:System.Linq.Expressions.UnaryExpression.Method" /> properties set to the specified values.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> or <paramref name="type" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="method" /> is not <see langword="null" /> and the method it represents returns <see langword="void" />, is not <see langword="static" /> (<see langword="Shared" /> in Visual Basic), or does not take exactly one argument.</exception>
|
|
/// <exception cref="T:System.InvalidOperationException">No conversion operator is defined between <paramref name="expression" />.Type and <paramref name="type" />.-or-
|
|
/// <paramref name="expression" />.Type is not assignable to the argument type of the method represented by <paramref name="method" />.-or-The return type of the method represented by <paramref name="method" /> is not assignable to <paramref name="type" />.-or-
|
|
/// <paramref name="expression" />.Type or <paramref name="type" /> is a nullable value type and the corresponding non-nullable value type does not equal the argument type or the return type, respectively, of the method represented by <paramref name="method" />.</exception>
|
|
/// <exception cref="T:System.Reflection.AmbiguousMatchException">More than one method that matches the <paramref name="method" /> description was found.</exception>
|
|
// Token: 0x0600035B RID: 859 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035B")]
|
|
[Address(RVA = "0x86E160", Offset = "0x86D160", VA = "0x18086E160")]
|
|
public static UnaryExpression ConvertChecked(Expression expression, Type type, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an expression for obtaining the length of a one-dimensional array.</summary>
|
|
/// <param name="array">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.ArrayLength" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to <paramref name="array" />.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="array" /> is <see langword="null" />.</exception>
|
|
/// <exception cref="T:System.ArgumentException">
|
|
/// <paramref name="array" />.Type does not represent an array type.</exception>
|
|
// Token: 0x0600035C RID: 860 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035C")]
|
|
[Address(RVA = "0x869DE0", Offset = "0x868DE0", VA = "0x180869DE0")]
|
|
public static UnaryExpression ArrayLength(Expression array)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents an expression that has a constant value of type <see cref="T:System.Linq.Expressions.Expression" />.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to set the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property equal to.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that has the <see cref="P:System.Linq.Expressions.Expression.NodeType" /> property equal to <see cref="F:System.Linq.Expressions.ExpressionType.Quote" /> and the <see cref="P:System.Linq.Expressions.UnaryExpression.Operand" /> property set to the specified value.</returns>
|
|
/// <exception cref="T:System.ArgumentNullException">
|
|
/// <paramref name="expression" /> is <see langword="null" />.</exception>
|
|
// Token: 0x0600035D RID: 861 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035D")]
|
|
[Address(RVA = "0x87BA50", Offset = "0x87AA50", VA = "0x18087BA50")]
|
|
public static UnaryExpression Quote(Expression expression)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents a throwing of an exception with a given type.</summary>
|
|
/// <param name="value">An <see cref="T:System.Linq.Expressions.Expression" />.</param>
|
|
/// <param name="type">The new <see cref="T:System.Type" /> of the expression.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the exception.</returns>
|
|
// Token: 0x0600035E RID: 862 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035E")]
|
|
[Address(RVA = "0x87D190", Offset = "0x87C190", VA = "0x18087D190")]
|
|
public static UnaryExpression Throw(Expression value, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the incrementing of the expression by 1.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to increment.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the incremented expression.</returns>
|
|
// Token: 0x0600035F RID: 863 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600035F")]
|
|
[Address(RVA = "0x873170", Offset = "0x872170", VA = "0x180873170")]
|
|
public static UnaryExpression Increment(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the decrementing of the expression by 1.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to decrement.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the decremented expression.</returns>
|
|
// Token: 0x06000360 RID: 864 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000360")]
|
|
[Address(RVA = "0x86EAE0", Offset = "0x86DAE0", VA = "0x18086EAE0")]
|
|
public static UnaryExpression Decrement(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that increments the expression by 1 and assigns the result back to the expression.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to apply the operations on.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the resultant expression.</returns>
|
|
// Token: 0x06000361 RID: 865 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000361")]
|
|
[Address(RVA = "0x87B440", Offset = "0x87A440", VA = "0x18087B440")]
|
|
public static UnaryExpression PreIncrementAssign(Expression expression)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that increments the expression by 1 and assigns the result back to the expression.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to apply the operations on.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the resultant expression.</returns>
|
|
// Token: 0x06000362 RID: 866 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000362")]
|
|
[Address(RVA = "0x87B3D0", Offset = "0x87A3D0", VA = "0x18087B3D0")]
|
|
public static UnaryExpression PreIncrementAssign(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that decrements the expression by 1 and assigns the result back to the expression.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to apply the operations on.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the resultant expression.</returns>
|
|
// Token: 0x06000363 RID: 867 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000363")]
|
|
[Address(RVA = "0x87B360", Offset = "0x87A360", VA = "0x18087B360")]
|
|
public static UnaryExpression PreDecrementAssign(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the assignment of the expression followed by a subsequent increment by 1 of the original expression.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to apply the operations on.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the resultant expression.</returns>
|
|
// Token: 0x06000364 RID: 868 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000364")]
|
|
[Address(RVA = "0x87B010", Offset = "0x87A010", VA = "0x18087B010")]
|
|
public static UnaryExpression PostIncrementAssign(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Creates a <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the assignment of the expression followed by a subsequent decrement by 1 of the original expression.</summary>
|
|
/// <param name="expression">An <see cref="T:System.Linq.Expressions.Expression" /> to apply the operations on.</param>
|
|
/// <param name="method">A <see cref="T:System.Reflection.MethodInfo" /> that represents the implementing method.</param>
|
|
/// <returns>A <see cref="T:System.Linq.Expressions.UnaryExpression" /> that represents the resultant expression.</returns>
|
|
// Token: 0x06000365 RID: 869 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000365")]
|
|
[Address(RVA = "0x87AFA0", Offset = "0x879FA0", VA = "0x18087AFA0")]
|
|
public static UnaryExpression PostDecrementAssign(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000366 RID: 870 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000366")]
|
|
[Address(RVA = "0x877320", Offset = "0x876320", VA = "0x180877320")]
|
|
private static UnaryExpression MakeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0400014B RID: 331
|
|
[Token(Token = "0x400014B")]
|
|
private static readonly CacheDict<Type, MethodInfo> s_lambdaDelegateCache;
|
|
|
|
// Token: 0x0400014C RID: 332
|
|
[Token(Token = "0x400014C")]
|
|
private static CacheDict<Type, Func<Expression, string, bool, ReadOnlyCollection<ParameterExpression>, LambdaExpression>> s_lambdaFactories;
|
|
|
|
// Token: 0x0400014D RID: 333
|
|
[Token(Token = "0x400014D")]
|
|
private static ConditionalWeakTable<Expression, Expression.ExtensionInfo> s_legacyCtorSupportTable;
|
|
|
|
// Token: 0x02000059 RID: 89
|
|
[Token(Token = "0x2000059")]
|
|
internal class BinaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005A RID: 90
|
|
[Token(Token = "0x200005A")]
|
|
internal class BlockExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005B RID: 91
|
|
[Token(Token = "0x200005B")]
|
|
internal class CatchBlockProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005C RID: 92
|
|
[Token(Token = "0x200005C")]
|
|
internal class ConditionalExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005D RID: 93
|
|
[Token(Token = "0x200005D")]
|
|
internal class ConstantExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005E RID: 94
|
|
[Token(Token = "0x200005E")]
|
|
internal class DebugInfoExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005F RID: 95
|
|
[Token(Token = "0x200005F")]
|
|
internal class DefaultExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000060 RID: 96
|
|
[Token(Token = "0x2000060")]
|
|
internal class GotoExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000061 RID: 97
|
|
[Token(Token = "0x2000061")]
|
|
internal class IndexExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000062 RID: 98
|
|
[Token(Token = "0x2000062")]
|
|
internal class InvocationExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000063 RID: 99
|
|
[Token(Token = "0x2000063")]
|
|
internal class LabelExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000064 RID: 100
|
|
[Token(Token = "0x2000064")]
|
|
internal class LambdaExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000065 RID: 101
|
|
[Token(Token = "0x2000065")]
|
|
internal class ListInitExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000066 RID: 102
|
|
[Token(Token = "0x2000066")]
|
|
internal class LoopExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000067 RID: 103
|
|
[Token(Token = "0x2000067")]
|
|
internal class MemberExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000068 RID: 104
|
|
[Token(Token = "0x2000068")]
|
|
internal class MemberInitExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000069 RID: 105
|
|
[Token(Token = "0x2000069")]
|
|
internal class MethodCallExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006A RID: 106
|
|
[Token(Token = "0x200006A")]
|
|
internal class NewArrayExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006B RID: 107
|
|
[Token(Token = "0x200006B")]
|
|
internal class NewExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006C RID: 108
|
|
[Token(Token = "0x200006C")]
|
|
internal class ParameterExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006D RID: 109
|
|
[Token(Token = "0x200006D")]
|
|
internal class RuntimeVariablesExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006E RID: 110
|
|
[Token(Token = "0x200006E")]
|
|
internal class SwitchCaseProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006F RID: 111
|
|
[Token(Token = "0x200006F")]
|
|
internal class SwitchExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000070 RID: 112
|
|
[Token(Token = "0x2000070")]
|
|
internal class TryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000071 RID: 113
|
|
[Token(Token = "0x2000071")]
|
|
internal class TypeBinaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000072 RID: 114
|
|
[Token(Token = "0x2000072")]
|
|
internal class UnaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000073 RID: 115
|
|
[Token(Token = "0x2000073")]
|
|
private class ExtensionInfo
|
|
{
|
|
// Token: 0x0400014E RID: 334
|
|
[FieldOffset(Offset = "0x10")]
|
|
[Token(Token = "0x400014E")]
|
|
internal readonly ExpressionType NodeType;
|
|
|
|
// Token: 0x0400014F RID: 335
|
|
[FieldOffset(Offset = "0x18")]
|
|
[Token(Token = "0x400014F")]
|
|
internal readonly Type Type;
|
|
}
|
|
}
|
|
}
|