niko
2545 lines
212 KiB
C#
2545 lines
212 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: 0x02000053 RID: 83
|
|
[Token(Token = "0x2000053")]
|
|
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: 0x06000251 RID: 593 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000251")]
|
|
[Address(RVA = "0x543580", Offset = "0x542380", VA = "0x180543580")]
|
|
public static BinaryExpression Assign(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000252 RID: 594 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000252")]
|
|
[Address(RVA = "0x54B000", Offset = "0x549E00", VA = "0x18054B000")]
|
|
private static BinaryExpression GetUserDefinedBinaryOperator(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000253 RID: 595 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000253")]
|
|
[Address(RVA = "0x5498C0", Offset = "0x5486C0", VA = "0x1805498C0")]
|
|
private static BinaryExpression GetMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000254 RID: 596 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000254")]
|
|
[Address(RVA = "0x549650", Offset = "0x548450", VA = "0x180549650")]
|
|
private static BinaryExpression GetMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression conversion, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000255 RID: 597 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000255")]
|
|
[Address(RVA = "0x54AD90", Offset = "0x549B90", VA = "0x18054AD90")]
|
|
private static BinaryExpression GetUserDefinedBinaryOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000256 RID: 598 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000256")]
|
|
[Address(RVA = "0x54AB20", Offset = "0x549920", VA = "0x18054AB20")]
|
|
private static BinaryExpression GetUserDefinedAssignOperatorOrThrow(ExpressionType binaryType, string name, Expression left, Expression right, LambdaExpression conversion, bool liftToNull)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000257 RID: 599 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000257")]
|
|
[Address(RVA = "0x54B330", Offset = "0x54A130", VA = "0x18054B330")]
|
|
private static MethodInfo GetUserDefinedBinaryOperator(ExpressionType binaryType, Type leftType, Type rightType, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000258 RID: 600 RVA: 0x00002898 File Offset: 0x00000A98
|
|
[Token(Token = "0x6000258")]
|
|
[Address(RVA = "0x54C680", Offset = "0x54B480", VA = "0x18054C680")]
|
|
private static bool IsLiftingConditionalLogicalOperator(Type left, Type right, MethodInfo method, ExpressionType binaryType)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x06000259 RID: 601 RVA: 0x000028B0 File Offset: 0x00000AB0
|
|
[Token(Token = "0x6000259")]
|
|
[Address(RVA = "0x552950", Offset = "0x551750", VA = "0x180552950")]
|
|
internal static bool ParameterIsAssignable(ParameterInfo pi, Type argType)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600025A RID: 602 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x600025A")]
|
|
[Address(RVA = "0x556ED0", Offset = "0x555CD0", VA = "0x180556ED0")]
|
|
private static void ValidateParamswithOperandsOrThrow(Type paramType, Type operandType, ExpressionType exprType, string name)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600025B RID: 603 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x600025B")]
|
|
[Address(RVA = "0x556DA0", Offset = "0x555BA0", VA = "0x180556DA0")]
|
|
private static void ValidateOperator(MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600025C RID: 604 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x600025C")]
|
|
[Address(RVA = "0x556A50", Offset = "0x555850", VA = "0x180556A50")]
|
|
private static void ValidateMethodInfo(MethodInfo method, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600025D RID: 605 RVA: 0x000028C8 File Offset: 0x00000AC8
|
|
[Token(Token = "0x600025D")]
|
|
[Address(RVA = "0x54C710", Offset = "0x54B510", VA = "0x18054C710")]
|
|
private static bool IsNullComparison(Expression left, Expression right)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600025E RID: 606 RVA: 0x000028E0 File Offset: 0x00000AE0
|
|
[Token(Token = "0x600025E")]
|
|
[Address(RVA = "0x54C810", Offset = "0x54B610", VA = "0x18054C810")]
|
|
private static bool IsNullConstant(Expression e)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x0600025F RID: 607 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x600025F")]
|
|
[Address(RVA = "0x5575E0", Offset = "0x5563E0", VA = "0x1805575E0")]
|
|
private static void ValidateUserDefinedConditionalLogicOperator(ExpressionType nodeType, Type left, Type right, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000260 RID: 608 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000260")]
|
|
[Address(RVA = "0x558080", Offset = "0x556E80", VA = "0x180558080")]
|
|
private static void VerifyOpTrueFalse(ExpressionType nodeType, Type left, MethodInfo opTrue, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000261 RID: 609 RVA: 0x000028F8 File Offset: 0x00000AF8
|
|
[Token(Token = "0x6000261")]
|
|
[Address(RVA = "0x54CAD0", Offset = "0x54B8D0", VA = "0x18054CAD0")]
|
|
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: 0x06000262 RID: 610 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000262")]
|
|
[Address(RVA = "0x54E6F0", Offset = "0x54D4F0", VA = "0x18054E6F0")]
|
|
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: 0x06000263 RID: 611 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000263")]
|
|
[Address(RVA = "0x54D5A0", Offset = "0x54C3A0", VA = "0x18054D5A0")]
|
|
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. 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: 0x06000264 RID: 612 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000264")]
|
|
[Address(RVA = "0x548280", Offset = "0x547080", VA = "0x180548280")]
|
|
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: 0x06000265 RID: 613 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000265")]
|
|
[Address(RVA = "0x553780", Offset = "0x552580", VA = "0x180553780")]
|
|
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>
|
|
/// <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: 0x06000266 RID: 614 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000266")]
|
|
[Address(RVA = "0x551C10", Offset = "0x550A10", VA = "0x180551C10")]
|
|
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: 0x06000267 RID: 615 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000267")]
|
|
[Address(RVA = "0x5538C0", Offset = "0x5526C0", VA = "0x1805538C0")]
|
|
public static BinaryExpression ReferenceNotEqual(Expression left, Expression right)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000268 RID: 616 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000268")]
|
|
[Address(RVA = "0x548FF0", Offset = "0x547DF0", VA = "0x180548FF0")]
|
|
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: 0x06000269 RID: 617 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000269")]
|
|
[Address(RVA = "0x54BF30", Offset = "0x54AD30", VA = "0x18054BF30")]
|
|
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: 0x0600026A RID: 618 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026A")]
|
|
[Address(RVA = "0x54D490", Offset = "0x54C290", VA = "0x18054D490")]
|
|
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: 0x0600026B RID: 619 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026B")]
|
|
[Address(RVA = "0x54BE20", Offset = "0x54AC20", VA = "0x18054BE20")]
|
|
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: 0x0600026C RID: 620 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026C")]
|
|
[Address(RVA = "0x54D380", Offset = "0x54C180", VA = "0x18054D380")]
|
|
public static BinaryExpression LessThanOrEqual(Expression left, Expression right, bool liftToNull, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0600026D RID: 621 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026D")]
|
|
[Address(RVA = "0x548E00", Offset = "0x547C00", VA = "0x180548E00")]
|
|
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: 0x0600026E RID: 622 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026E")]
|
|
[Address(RVA = "0x542470", Offset = "0x541270", VA = "0x180542470")]
|
|
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: 0x0600026F RID: 623 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600026F")]
|
|
[Address(RVA = "0x552270", Offset = "0x551070", VA = "0x180552270")]
|
|
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: 0x06000270 RID: 624 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000270")]
|
|
[Address(RVA = "0x546590", Offset = "0x545390", VA = "0x180546590")]
|
|
public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000271 RID: 625 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000271")]
|
|
[Address(RVA = "0x555800", Offset = "0x554600", VA = "0x180555800")]
|
|
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: 0x06000272 RID: 626 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000272")]
|
|
[Address(RVA = "0x542270", Offset = "0x541070", VA = "0x180542270")]
|
|
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: 0x06000273 RID: 627 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000273")]
|
|
[Address(RVA = "0x541E00", Offset = "0x540C00", VA = "0x180541E00")]
|
|
public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method, LambdaExpression conversion)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000274 RID: 628 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000274")]
|
|
[Address(RVA = "0x556B30", Offset = "0x555930", VA = "0x180556B30")]
|
|
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: 0x06000275 RID: 629 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000275")]
|
|
[Address(RVA = "0x541BA0", Offset = "0x5409A0", VA = "0x180541BA0")]
|
|
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: 0x06000276 RID: 630 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000276")]
|
|
[Address(RVA = "0x542060", Offset = "0x540E60", VA = "0x180542060")]
|
|
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: 0x06000277 RID: 631 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000277")]
|
|
[Address(RVA = "0x554900", Offset = "0x553700", VA = "0x180554900")]
|
|
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: 0x06000278 RID: 632 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000278")]
|
|
[Address(RVA = "0x554490", Offset = "0x553290", VA = "0x180554490")]
|
|
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: 0x06000279 RID: 633 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000279")]
|
|
[Address(RVA = "0x554230", Offset = "0x553030", VA = "0x180554230")]
|
|
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: 0x0600027A RID: 634 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027A")]
|
|
[Address(RVA = "0x5546F0", Offset = "0x5534F0", VA = "0x1805546F0")]
|
|
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: 0x0600027B RID: 635 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027B")]
|
|
[Address(RVA = "0x547FB0", Offset = "0x546DB0", VA = "0x180547FB0")]
|
|
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: 0x0600027C RID: 636 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027C")]
|
|
[Address(RVA = "0x547D50", Offset = "0x546B50", VA = "0x180547D50")]
|
|
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: 0x0600027D RID: 637 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027D")]
|
|
[Address(RVA = "0x550770", Offset = "0x54F570", VA = "0x180550770")]
|
|
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: 0x0600027E RID: 638 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027E")]
|
|
[Address(RVA = "0x550510", Offset = "0x54F310", VA = "0x180550510")]
|
|
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: 0x0600027F RID: 639 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600027F")]
|
|
[Address(RVA = "0x551050", Offset = "0x54FE50", VA = "0x180551050")]
|
|
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: 0x06000280 RID: 640 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000280")]
|
|
[Address(RVA = "0x550BE0", Offset = "0x54F9E0", VA = "0x180550BE0")]
|
|
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: 0x06000281 RID: 641 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000281")]
|
|
[Address(RVA = "0x550980", Offset = "0x54F780", VA = "0x180550980")]
|
|
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: 0x06000282 RID: 642 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000282")]
|
|
[Address(RVA = "0x550E40", Offset = "0x54FC40", VA = "0x180550E40")]
|
|
public static BinaryExpression MultiplyChecked(Expression left, Expression right, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000283 RID: 643 RVA: 0x00002910 File Offset: 0x00000B10
|
|
[Token(Token = "0x6000283")]
|
|
[Address(RVA = "0x54C890", Offset = "0x54B690", VA = "0x18054C890")]
|
|
private static bool IsSimpleShift(Type left, Type right)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x06000284 RID: 644 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000284")]
|
|
[Address(RVA = "0x54A9F0", Offset = "0x5497F0", VA = "0x18054A9F0")]
|
|
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: 0x06000285 RID: 645 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000285")]
|
|
[Address(RVA = "0x54D150", Offset = "0x54BF50", VA = "0x18054D150")]
|
|
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: 0x06000286 RID: 646 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000286")]
|
|
[Address(RVA = "0x54CEC0", Offset = "0x54BCC0", VA = "0x18054CEC0")]
|
|
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: 0x06000287 RID: 647 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000287")]
|
|
[Address(RVA = "0x554000", Offset = "0x552E00", VA = "0x180554000")]
|
|
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: 0x06000288 RID: 648 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000288")]
|
|
[Address(RVA = "0x553D70", Offset = "0x552B70", VA = "0x180553D70")]
|
|
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: 0x06000289 RID: 649 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000289")]
|
|
[Address(RVA = "0x542B70", Offset = "0x541970", VA = "0x180542B70")]
|
|
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: 0x0600028A RID: 650 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028A")]
|
|
[Address(RVA = "0x542910", Offset = "0x541710", VA = "0x180542910")]
|
|
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: 0x0600028B RID: 651 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028B")]
|
|
[Address(RVA = "0x552740", Offset = "0x551540", VA = "0x180552740")]
|
|
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: 0x0600028C RID: 652 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028C")]
|
|
[Address(RVA = "0x552010", Offset = "0x550E10", VA = "0x180552010")]
|
|
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: 0x0600028D RID: 653 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028D")]
|
|
[Address(RVA = "0x5485F0", Offset = "0x5473F0", VA = "0x1805485F0")]
|
|
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: 0x0600028E RID: 654 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028E")]
|
|
[Address(RVA = "0x548390", Offset = "0x547190", VA = "0x180548390")]
|
|
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: 0x0600028F RID: 655 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600028F")]
|
|
[Address(RVA = "0x552D40", Offset = "0x551B40", VA = "0x180552D40")]
|
|
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: 0x06000290 RID: 656 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000290")]
|
|
[Address(RVA = "0x552BB0", Offset = "0x5519B0", VA = "0x180552BB0")]
|
|
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: 0x06000291 RID: 657 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000291")]
|
|
[Address(RVA = "0x5431D0", Offset = "0x541FD0", VA = "0x1805431D0")]
|
|
public static BinaryExpression ArrayIndex(Expression array, Expression index)
|
|
{
|
|
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: 0x06000292 RID: 658 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000292")]
|
|
[Address(RVA = "0x544120", Offset = "0x542F20", VA = "0x180544120")]
|
|
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: 0x06000293 RID: 659 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000293")]
|
|
[Address(RVA = "0x543E10", Offset = "0x542C10", VA = "0x180543E10")]
|
|
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: 0x06000294 RID: 660 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000294")]
|
|
[Address(RVA = "0x543D90", Offset = "0x542B90", VA = "0x180543D90")]
|
|
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: 0x06000295 RID: 661 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000295")]
|
|
[Address(RVA = "0x543C00", Offset = "0x542A00", VA = "0x180543C00")]
|
|
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: 0x06000296 RID: 662 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000296")]
|
|
[Address(RVA = "0x543EB0", Offset = "0x542CB0", VA = "0x180543EB0")]
|
|
public static BlockExpression Block(Type type, IEnumerable<ParameterExpression> variables, IEnumerable<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000297 RID: 663 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000297")]
|
|
[Address(RVA = "0x5437A0", Offset = "0x5425A0", VA = "0x1805437A0")]
|
|
private static BlockExpression BlockCore(Type type, ReadOnlyCollection<ParameterExpression> variables, ReadOnlyCollection<Expression> expressions)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000298 RID: 664 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x6000298")]
|
|
[Address(RVA = "0x557D80", Offset = "0x556B80", VA = "0x180557D80")]
|
|
internal static void ValidateVariables(ReadOnlyCollection<ParameterExpression> varList, string collectionName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000299 RID: 665 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000299")]
|
|
[Address(RVA = "0x54A590", Offset = "0x549390", VA = "0x18054A590")]
|
|
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: 0x0600029A RID: 666 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029A")]
|
|
[Address(RVA = "0x54E790", Offset = "0x54D590", VA = "0x18054E790")]
|
|
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: 0x0600029B RID: 667 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029B")]
|
|
[Address(RVA = "0x546B80", Offset = "0x545980", VA = "0x180546B80")]
|
|
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: 0x0600029C RID: 668 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029C")]
|
|
[Address(RVA = "0x546D40", Offset = "0x545B40", VA = "0x180546D40")]
|
|
public static ConditionalExpression Condition(Expression test, Expression ifTrue, Expression ifFalse, Type type)
|
|
{
|
|
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: 0x0600029D RID: 669 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029D")]
|
|
[Address(RVA = "0x546F90", Offset = "0x545D90", VA = "0x180546F90")]
|
|
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: 0x0600029E RID: 670 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029E")]
|
|
[Address(RVA = "0x547020", Offset = "0x545E20", VA = "0x180547020")]
|
|
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: 0x0600029F RID: 671 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x600029F")]
|
|
[Address(RVA = "0x5481C0", Offset = "0x546FC0", VA = "0x1805481C0")]
|
|
public static DefaultExpression Empty()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
/// <summary>Constructs a new instance of <see cref="T:System.Linq.Expressions.Expression" />.</summary>
|
|
// Token: 0x060002A0 RID: 672 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A0")]
|
|
[Address(RVA = "0x3F5100", Offset = "0x3F3F00", VA = "0x1803F5100")]
|
|
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: 0x17000056 RID: 86
|
|
// (get) Token: 0x060002A1 RID: 673 RVA: 0x00002928 File Offset: 0x00000B28
|
|
[Token(Token = "0x17000056")]
|
|
public virtual ExpressionType NodeType
|
|
{
|
|
[Token(Token = "0x60002A1")]
|
|
[Address(RVA = "0x558400", Offset = "0x557200", VA = "0x180558400", 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: 0x17000057 RID: 87
|
|
// (get) Token: 0x060002A2 RID: 674 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x17000057")]
|
|
public virtual Type Type
|
|
{
|
|
[Token(Token = "0x60002A2")]
|
|
[Address(RVA = "0x5584E0", Offset = "0x5572E0", VA = "0x1805584E0", 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: 0x17000058 RID: 88
|
|
// (get) Token: 0x060002A3 RID: 675 RVA: 0x00002940 File Offset: 0x00000B40
|
|
[Token(Token = "0x17000058")]
|
|
public virtual bool CanReduce
|
|
{
|
|
[Token(Token = "0x60002A3")]
|
|
[Address(RVA = "0x403930", Offset = "0x402730", VA = "0x180403930", 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: 0x060002A4 RID: 676 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A4")]
|
|
[Address(RVA = "0x553720", Offset = "0x552520", VA = "0x180553720", 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: 0x060002A5 RID: 677 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A5")]
|
|
[Address(RVA = "0x558220", Offset = "0x557020", VA = "0x180558220", 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: 0x060002A6 RID: 678 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A6")]
|
|
[Address(RVA = "0x541B70", Offset = "0x540970", VA = "0x180541B70", 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: 0x060002A7 RID: 679 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A7")]
|
|
[Address(RVA = "0x553630", Offset = "0x552430", VA = "0x180553630")]
|
|
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: 0x060002A8 RID: 680 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002A8")]
|
|
[Address(RVA = "0x554C60", Offset = "0x553A60", VA = "0x180554C60", Slot = "3")]
|
|
public override string ToString()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002A9 RID: 681 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002A9")]
|
|
[Address(RVA = "0x553A00", Offset = "0x552800", VA = "0x180553A00")]
|
|
private static void RequiresCanRead(IReadOnlyList<Expression> items, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002AA RID: 682 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002AA")]
|
|
[Address(RVA = "0x553B10", Offset = "0x552910", VA = "0x180553B10")]
|
|
private static void RequiresCanWrite(Expression expression, string paramName)
|
|
{
|
|
}
|
|
|
|
/// <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: 0x060002AB RID: 683 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AB")]
|
|
[Address(RVA = "0x54BCE0", Offset = "0x54AAE0", VA = "0x18054BCE0")]
|
|
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: 0x060002AC RID: 684 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AC")]
|
|
[Address(RVA = "0x54E9F0", Offset = "0x54D7F0", VA = "0x18054E9F0")]
|
|
public static GotoExpression MakeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type type)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002AD RID: 685 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002AD")]
|
|
[Address(RVA = "0x555A90", Offset = "0x554890", VA = "0x180555A90")]
|
|
private static void ValidateGoto(LabelTarget target, ref Expression value, string targetParameter, string valueParameter, Type type)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002AE RID: 686 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002AE")]
|
|
[Address(RVA = "0x555960", Offset = "0x554760", VA = "0x180555960")]
|
|
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: 0x060002AF RID: 687 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002AF")]
|
|
[Address(RVA = "0x54EB70", Offset = "0x54D970", VA = "0x18054EB70")]
|
|
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: 0x060002B0 RID: 688 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B0")]
|
|
[Address(RVA = "0x542E40", Offset = "0x541C40", VA = "0x180542E40")]
|
|
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: 0x060002B1 RID: 689 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B1")]
|
|
[Address(RVA = "0x542EB0", Offset = "0x541CB0", VA = "0x180542EB0")]
|
|
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: 0x060002B2 RID: 690 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B2")]
|
|
[Address(RVA = "0x552F70", Offset = "0x551D70", VA = "0x180552F70")]
|
|
public static IndexExpression Property(Expression instance, PropertyInfo indexer, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B3 RID: 691 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B3")]
|
|
[Address(RVA = "0x54EAC0", Offset = "0x54D8C0", VA = "0x18054EAC0")]
|
|
private static IndexExpression MakeIndexProperty(Expression instance, PropertyInfo indexer, string paramName, ReadOnlyCollection<Expression> argList)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B4 RID: 692 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002B4")]
|
|
[Address(RVA = "0x555D20", Offset = "0x554B20", VA = "0x180555D20")]
|
|
private static void ValidateIndexedProperty(Expression instance, PropertyInfo indexer, string paramName, ref ReadOnlyCollection<Expression> argList)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002B5 RID: 693 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002B5")]
|
|
[Address(RVA = "0x555540", Offset = "0x554340", VA = "0x180555540")]
|
|
private static void ValidateAccessor(Expression instance, MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection<Expression> arguments, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002B6 RID: 694 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002B6")]
|
|
[Address(RVA = "0x555170", Offset = "0x553F70", VA = "0x180555170")]
|
|
private static void ValidateAccessorArgumentTypes(MethodInfo method, ParameterInfo[] indexes, ref ReadOnlyCollection<Expression> arguments, string paramName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002B7 RID: 695 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B7")]
|
|
[Address(RVA = "0x54C1A0", Offset = "0x54AFA0", VA = "0x18054C1A0")]
|
|
internal static InvocationExpression Invoke(Expression expression, Expression arg0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002B8 RID: 696 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B8")]
|
|
[Address(RVA = "0x549460", Offset = "0x548260", VA = "0x180549460")]
|
|
internal static MethodInfo GetInvokeMethod(Expression expression)
|
|
{
|
|
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: 0x060002B9 RID: 697 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002B9")]
|
|
[Address(RVA = "0x54CB70", Offset = "0x54B970", VA = "0x18054CB70")]
|
|
public static LabelExpression Label(LabelTarget target, Expression defaultValue)
|
|
{
|
|
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: 0x060002BA RID: 698 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BA")]
|
|
[Address(RVA = "0x54CC20", Offset = "0x54BA20", VA = "0x18054CC20")]
|
|
public static LabelTarget Label(Type type, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002BB RID: 699 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BB")]
|
|
[Address(RVA = "0x547730", Offset = "0x546530", VA = "0x180547730")]
|
|
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: 0x060002BC RID: 700 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BC")]
|
|
[Address(RVA = "0x2174770", Offset = "0x2173570", VA = "0x182174770")]
|
|
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="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: 0x060002BD RID: 701 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BD")]
|
|
[Address(RVA = "0x21746E0", Offset = "0x21734E0", VA = "0x1821746E0")]
|
|
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: 0x060002BE RID: 702 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BE")]
|
|
[Address(RVA = "0x21747F0", Offset = "0x21735F0", VA = "0x1821747F0")]
|
|
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: 0x060002BF RID: 703 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002BF")]
|
|
[Address(RVA = "0x54CD00", Offset = "0x54BB00", VA = "0x18054CD00")]
|
|
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: 0x060002C0 RID: 704 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C0")]
|
|
[Address(RVA = "0x54CDF0", Offset = "0x54BBF0", VA = "0x18054CDF0")]
|
|
public static LambdaExpression Lambda(Type delegateType, Expression body, string name, bool tailCall, IEnumerable<ParameterExpression> parameters)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002C1 RID: 705 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002C1")]
|
|
[Address(RVA = "0x5563A0", Offset = "0x5551A0", VA = "0x1805563A0")]
|
|
private static void ValidateLambdaArgs(Type delegateType, ref Expression body, ReadOnlyCollection<ParameterExpression> parameters, string paramName)
|
|
{
|
|
}
|
|
|
|
/// <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: 0x060002C2 RID: 706 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C2")]
|
|
[Address(RVA = "0x548800", Offset = "0x547600", VA = "0x180548800")]
|
|
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: 0x060002C3 RID: 707 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C3")]
|
|
[Address(RVA = "0x5489D0", Offset = "0x5477D0", VA = "0x1805489D0")]
|
|
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: 0x060002C4 RID: 708 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C4")]
|
|
[Address(RVA = "0x553080", Offset = "0x551E80", VA = "0x180553080")]
|
|
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: 0x060002C5 RID: 709 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C5")]
|
|
[Address(RVA = "0x553220", Offset = "0x552020", VA = "0x180553220")]
|
|
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: 0x060002C6 RID: 710 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C6")]
|
|
[Address(RVA = "0x54ED00", Offset = "0x54DB00", VA = "0x18054ED00")]
|
|
public static MemberExpression MakeMemberAccess(Expression expression, MemberInfo member)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002C7 RID: 711 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C7")]
|
|
[Address(RVA = "0x544260", Offset = "0x543060", VA = "0x180544260")]
|
|
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: 0x060002C8 RID: 712 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C8")]
|
|
[Address(RVA = "0x544360", Offset = "0x543160", VA = "0x180544360")]
|
|
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: 0x060002C9 RID: 713 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002C9")]
|
|
[Address(RVA = "0x5449A0", Offset = "0x5437A0", VA = "0x1805449A0")]
|
|
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: 0x060002CA RID: 714 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CA")]
|
|
[Address(RVA = "0x544530", Offset = "0x543330", VA = "0x180544530")]
|
|
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: 0x060002CB RID: 715 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CB")]
|
|
[Address(RVA = "0x546190", Offset = "0x544F90", VA = "0x180546190")]
|
|
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: 0x060002CC RID: 716 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CC")]
|
|
[Address(RVA = "0x545CE0", Offset = "0x544AE0", VA = "0x180545CE0")]
|
|
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: 0x060002CD RID: 717 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CD")]
|
|
[Address(RVA = "0x5451E0", Offset = "0x543FE0", VA = "0x1805451E0")]
|
|
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: 0x060002CE RID: 718 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CE")]
|
|
[Address(RVA = "0x544870", Offset = "0x543670", VA = "0x180544870")]
|
|
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: 0x060002CF RID: 719 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002CF")]
|
|
[Address(RVA = "0x5455D0", Offset = "0x5443D0", VA = "0x1805455D0")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002D0 RID: 720 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D0")]
|
|
[Address(RVA = "0x545650", Offset = "0x544450", VA = "0x180545650")]
|
|
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: 0x060002D1 RID: 721 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D1")]
|
|
[Address(RVA = "0x545A10", Offset = "0x544810", VA = "0x180545A10")]
|
|
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: 0x060002D2 RID: 722 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D2")]
|
|
[Address(RVA = "0x545250", Offset = "0x544050", VA = "0x180545250")]
|
|
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: 0x060002D3 RID: 723 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D3")]
|
|
[Address(RVA = "0x545850", Offset = "0x544650", VA = "0x180545850")]
|
|
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: 0x060002D4 RID: 724 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D4")]
|
|
[Address(RVA = "0x544C20", Offset = "0x543A20", VA = "0x180544C20")]
|
|
public static MethodCallExpression Call(Expression instance, MethodInfo method, IEnumerable<Expression> arguments)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002D5 RID: 725 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D5")]
|
|
[Address(RVA = "0x5569C0", Offset = "0x5557C0", VA = "0x1805569C0")]
|
|
private static ParameterInfo[] ValidateMethodAndGetParameters(Expression instance, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002D6 RID: 726 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002D6")]
|
|
[Address(RVA = "0x556F70", Offset = "0x555D70", VA = "0x180556F70")]
|
|
private static void ValidateStaticOrInstanceMethod(Expression instance, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002D7 RID: 727 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002D7")]
|
|
[Address(RVA = "0x555780", Offset = "0x554580", VA = "0x180555780")]
|
|
private static void ValidateCallInstanceType(Type instanceType, MethodInfo method)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002D8 RID: 728 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002D8")]
|
|
[Address(RVA = "0x555770", Offset = "0x554570", VA = "0x180555770")]
|
|
private static void ValidateArgumentTypes(MethodBase method, ExpressionType nodeKind, ref ReadOnlyCollection<Expression> arguments, string methodParamName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002D9 RID: 729 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002D9")]
|
|
[Address(RVA = "0x54A9E0", Offset = "0x5497E0", VA = "0x18054A9E0")]
|
|
private static ParameterInfo[] GetParametersForValidation(MethodBase method, ExpressionType nodeKind)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002DA RID: 730 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002DA")]
|
|
[Address(RVA = "0x555760", Offset = "0x554560", VA = "0x180555760")]
|
|
private static void ValidateArgumentCount(MethodBase method, ExpressionType nodeKind, int count, ParameterInfo[] pis)
|
|
{
|
|
}
|
|
|
|
// Token: 0x060002DB RID: 731 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DB")]
|
|
[Address(RVA = "0x556AF0", Offset = "0x5558F0", VA = "0x180556AF0")]
|
|
private static Expression ValidateOneArgument(MethodBase method, ExpressionType nodeKind, Expression arg, ParameterInfo pi, string methodParamName, string argumentParamName)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002DC RID: 732 RVA: 0x00002958 File Offset: 0x00000B58
|
|
[Token(Token = "0x60002DC")]
|
|
[Address(RVA = "0x554CE0", Offset = "0x553AE0", VA = "0x180554CE0")]
|
|
private static bool TryQuote(Type parameterType, ref Expression argument)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002DD RID: 733 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DD")]
|
|
[Address(RVA = "0x548B80", Offset = "0x547980", VA = "0x180548B80")]
|
|
private static MethodInfo FindMethod(Type type, string methodName, Type[] typeArgs, Expression[] args, BindingFlags flags)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002DE RID: 734 RVA: 0x00002970 File Offset: 0x00000B70
|
|
[Token(Token = "0x60002DE")]
|
|
[Address(RVA = "0x54C310", Offset = "0x54B110", VA = "0x18054C310")]
|
|
private static bool IsCompatible(MethodBase m, Expression[] arguments)
|
|
{
|
|
return default(bool);
|
|
}
|
|
|
|
// Token: 0x060002DF RID: 735 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002DF")]
|
|
[Address(RVA = "0x542D80", Offset = "0x541B80", VA = "0x180542D80")]
|
|
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: 0x060002E0 RID: 736 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E0")]
|
|
[Address(RVA = "0x5517F0", Offset = "0x5505F0", VA = "0x1805517F0")]
|
|
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: 0x060002E1 RID: 737 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E1")]
|
|
[Address(RVA = "0x551860", Offset = "0x550660", VA = "0x180551860")]
|
|
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: 0x060002E2 RID: 738 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E2")]
|
|
[Address(RVA = "0x551560", Offset = "0x550360", VA = "0x180551560")]
|
|
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: 0x060002E3 RID: 739 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E3")]
|
|
[Address(RVA = "0x552A70", Offset = "0x551870", VA = "0x180552A70")]
|
|
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: 0x060002E4 RID: 740 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E4")]
|
|
[Address(RVA = "0x5529C0", Offset = "0x5517C0", VA = "0x1805529C0")]
|
|
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: 0x060002E5 RID: 741 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E5")]
|
|
[Address(RVA = "0x558000", Offset = "0x556E00", VA = "0x180558000")]
|
|
public static ParameterExpression Variable(Type type, string name)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002E6 RID: 742 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002E6")]
|
|
[Address(RVA = "0x557EE0", Offset = "0x556CE0", VA = "0x180557EE0")]
|
|
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: 0x060002E7 RID: 743 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E7")]
|
|
[Address(RVA = "0x554C70", Offset = "0x553A70", VA = "0x180554C70")]
|
|
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: 0x060002E8 RID: 744 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002E8")]
|
|
[Address(RVA = "0x54F100", Offset = "0x54DF00", VA = "0x18054F100")]
|
|
public static TryExpression MakeTry(Type type, Expression body, Expression @finally, Expression fault, IEnumerable<CatchBlock> handlers)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002E9 RID: 745 RVA: 0x00002053 File Offset: 0x00000253
|
|
[Token(Token = "0x60002E9")]
|
|
[Address(RVA = "0x557060", Offset = "0x555E60", VA = "0x180557060")]
|
|
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: 0x060002EA RID: 746 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EA")]
|
|
[Address(RVA = "0x54F2E0", Offset = "0x54E0E0", VA = "0x18054F2E0")]
|
|
public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002EB RID: 747 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EB")]
|
|
[Address(RVA = "0x54B820", Offset = "0x54A620", VA = "0x18054B820")]
|
|
private static UnaryExpression GetUserDefinedUnaryOperatorOrThrow(ExpressionType unaryType, string name, Expression operand)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002EC RID: 748 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EC")]
|
|
[Address(RVA = "0x54B9C0", Offset = "0x54A7C0", VA = "0x18054B9C0")]
|
|
private static UnaryExpression GetUserDefinedUnaryOperator(ExpressionType unaryType, string name, Expression operand)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002ED RID: 749 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002ED")]
|
|
[Address(RVA = "0x54A1F0", Offset = "0x548FF0", VA = "0x18054A1F0")]
|
|
private static UnaryExpression GetMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002EE RID: 750 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EE")]
|
|
[Address(RVA = "0x54B610", Offset = "0x54A410", VA = "0x18054B610")]
|
|
private static UnaryExpression GetUserDefinedCoercionOrThrow(ExpressionType coercionType, Expression expression, Type convertToType)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002EF RID: 751 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002EF")]
|
|
[Address(RVA = "0x54B750", Offset = "0x54A550", VA = "0x18054B750")]
|
|
private static UnaryExpression GetUserDefinedCoercion(ExpressionType coercionType, Expression expression, Type convertToType)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x060002F0 RID: 752 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F0")]
|
|
[Address(RVA = "0x549EA0", Offset = "0x548CA0", VA = "0x180549EA0")]
|
|
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: 0x060002F1 RID: 753 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F1")]
|
|
[Address(RVA = "0x5513E0", Offset = "0x5501E0", VA = "0x1805513E0")]
|
|
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: 0x060002F2 RID: 754 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F2")]
|
|
[Address(RVA = "0x554E30", Offset = "0x553C30", VA = "0x180554E30")]
|
|
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: 0x060002F3 RID: 755 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F3")]
|
|
[Address(RVA = "0x551260", Offset = "0x550060", VA = "0x180551260")]
|
|
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: 0x060002F4 RID: 756 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F4")]
|
|
[Address(RVA = "0x551D20", Offset = "0x550B20", VA = "0x180551D20")]
|
|
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: 0x060002F5 RID: 757 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F5")]
|
|
[Address(RVA = "0x54C520", Offset = "0x54B320", VA = "0x18054C520")]
|
|
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: 0x060002F6 RID: 758 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F6")]
|
|
[Address(RVA = "0x54C970", Offset = "0x54B770", VA = "0x18054C970")]
|
|
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: 0x060002F7 RID: 759 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F7")]
|
|
[Address(RVA = "0x551EB0", Offset = "0x550CB0", VA = "0x180551EB0")]
|
|
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: 0x060002F8 RID: 760 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F8")]
|
|
[Address(RVA = "0x554CF0", Offset = "0x553AF0", VA = "0x180554CF0")]
|
|
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: 0x060002F9 RID: 761 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002F9")]
|
|
[Address(RVA = "0x554F90", Offset = "0x553D90", VA = "0x180554F90")]
|
|
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: 0x060002FA RID: 762 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FA")]
|
|
[Address(RVA = "0x5476C0", Offset = "0x5464C0", VA = "0x1805476C0")]
|
|
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: 0x060002FB RID: 763 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FB")]
|
|
[Address(RVA = "0x5474E0", Offset = "0x5462E0", VA = "0x1805474E0")]
|
|
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: 0x060002FC RID: 764 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FC")]
|
|
[Address(RVA = "0x547470", Offset = "0x546270", VA = "0x180547470")]
|
|
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: 0x060002FD RID: 765 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FD")]
|
|
[Address(RVA = "0x547270", Offset = "0x546070", VA = "0x180547270")]
|
|
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: 0x060002FE RID: 766 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FE")]
|
|
[Address(RVA = "0x5433B0", Offset = "0x5421B0", VA = "0x1805433B0")]
|
|
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: 0x060002FF RID: 767 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x60002FF")]
|
|
[Address(RVA = "0x553520", Offset = "0x552320", VA = "0x180553520")]
|
|
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: 0x06000300 RID: 768 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000300")]
|
|
[Address(RVA = "0x554B10", Offset = "0x553910", VA = "0x180554B10")]
|
|
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: 0x06000301 RID: 769 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000301")]
|
|
[Address(RVA = "0x54C040", Offset = "0x54AE40", VA = "0x18054C040")]
|
|
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: 0x06000302 RID: 770 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000302")]
|
|
[Address(RVA = "0x547BF0", Offset = "0x5469F0", VA = "0x180547BF0")]
|
|
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>
|
|
/// <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: 0x06000303 RID: 771 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000303")]
|
|
[Address(RVA = "0x552F00", Offset = "0x551D00", VA = "0x180552F00")]
|
|
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: 0x06000304 RID: 772 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000304")]
|
|
[Address(RVA = "0x552E90", Offset = "0x551C90", VA = "0x180552E90")]
|
|
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: 0x06000305 RID: 773 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000305")]
|
|
[Address(RVA = "0x552B40", Offset = "0x551940", VA = "0x180552B40")]
|
|
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: 0x06000306 RID: 774 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000306")]
|
|
[Address(RVA = "0x552AD0", Offset = "0x5518D0", VA = "0x180552AD0")]
|
|
public static UnaryExpression PostDecrementAssign(Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000307 RID: 775 RVA: 0x00002050 File Offset: 0x00000250
|
|
[Token(Token = "0x6000307")]
|
|
[Address(RVA = "0x54EEC0", Offset = "0x54DCC0", VA = "0x18054EEC0")]
|
|
private static UnaryExpression MakeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x0400011B RID: 283
|
|
[Token(Token = "0x400011B")]
|
|
private static readonly CacheDict<Type, MethodInfo> s_lambdaDelegateCache;
|
|
|
|
// Token: 0x0400011C RID: 284
|
|
[Token(Token = "0x400011C")]
|
|
private static CacheDict<Type, Func<Expression, string, bool, ReadOnlyCollection<ParameterExpression>, LambdaExpression>> s_lambdaFactories;
|
|
|
|
// Token: 0x0400011D RID: 285
|
|
[Token(Token = "0x400011D")]
|
|
private static ConditionalWeakTable<Expression, Expression.ExtensionInfo> s_legacyCtorSupportTable;
|
|
|
|
// Token: 0x02000054 RID: 84
|
|
[Token(Token = "0x2000054")]
|
|
internal class BinaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000055 RID: 85
|
|
[Token(Token = "0x2000055")]
|
|
internal class BlockExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000056 RID: 86
|
|
[Token(Token = "0x2000056")]
|
|
internal class CatchBlockProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000057 RID: 87
|
|
[Token(Token = "0x2000057")]
|
|
internal class ConditionalExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000058 RID: 88
|
|
[Token(Token = "0x2000058")]
|
|
internal class ConstantExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000059 RID: 89
|
|
[Token(Token = "0x2000059")]
|
|
internal class DebugInfoExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005A RID: 90
|
|
[Token(Token = "0x200005A")]
|
|
internal class DefaultExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005B RID: 91
|
|
[Token(Token = "0x200005B")]
|
|
internal class GotoExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005C RID: 92
|
|
[Token(Token = "0x200005C")]
|
|
internal class IndexExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005D RID: 93
|
|
[Token(Token = "0x200005D")]
|
|
internal class InvocationExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005E RID: 94
|
|
[Token(Token = "0x200005E")]
|
|
internal class LabelExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200005F RID: 95
|
|
[Token(Token = "0x200005F")]
|
|
internal class LambdaExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000060 RID: 96
|
|
[Token(Token = "0x2000060")]
|
|
internal class ListInitExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000061 RID: 97
|
|
[Token(Token = "0x2000061")]
|
|
internal class LoopExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000062 RID: 98
|
|
[Token(Token = "0x2000062")]
|
|
internal class MemberExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000063 RID: 99
|
|
[Token(Token = "0x2000063")]
|
|
internal class MemberInitExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000064 RID: 100
|
|
[Token(Token = "0x2000064")]
|
|
internal class MethodCallExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000065 RID: 101
|
|
[Token(Token = "0x2000065")]
|
|
internal class NewArrayExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000066 RID: 102
|
|
[Token(Token = "0x2000066")]
|
|
internal class NewExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000067 RID: 103
|
|
[Token(Token = "0x2000067")]
|
|
internal class ParameterExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000068 RID: 104
|
|
[Token(Token = "0x2000068")]
|
|
internal class RuntimeVariablesExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x02000069 RID: 105
|
|
[Token(Token = "0x2000069")]
|
|
internal class SwitchCaseProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006A RID: 106
|
|
[Token(Token = "0x200006A")]
|
|
internal class SwitchExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006B RID: 107
|
|
[Token(Token = "0x200006B")]
|
|
internal class TryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006C RID: 108
|
|
[Token(Token = "0x200006C")]
|
|
internal class TypeBinaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006D RID: 109
|
|
[Token(Token = "0x200006D")]
|
|
internal class UnaryExpressionProxy
|
|
{
|
|
}
|
|
|
|
// Token: 0x0200006E RID: 110
|
|
[Token(Token = "0x200006E")]
|
|
private class ExtensionInfo
|
|
{
|
|
// Token: 0x0400011E RID: 286
|
|
[FieldOffset(Offset = "0x10")]
|
|
[Token(Token = "0x400011E")]
|
|
internal readonly ExpressionType NodeType;
|
|
|
|
// Token: 0x0400011F RID: 287
|
|
[FieldOffset(Offset = "0x18")]
|
|
[Token(Token = "0x400011F")]
|
|
internal readonly Type Type;
|
|
}
|
|
}
|
|
}
|