Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataEntity / System / Data / Common / CommandTrees / ExpressionBuilder / DbExpressionBuilder.cs / 1599186 / DbExpressionBuilder.cs
//---------------------------------------------------------------------- //// Copyright (c) Microsoft Corporation. All rights reserved. // // // @owner [....] // @backupOwner [....] //--------------------------------------------------------------------- using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Data.Common; using System.Globalization; using System.IO; using System.Linq; using System.Diagnostics; using System.Text; using System.Text.RegularExpressions; using System.Data.Common.Utils; using System.Data.Metadata.Edm; using System.Data.Common.CommandTrees.Internal; using System.Data.Common.CommandTrees.ExpressionBuilder.Internal; using System.Reflection; using System.Runtime.CompilerServices; namespace System.Data.Common.CommandTrees.ExpressionBuilder { ////// Provides an API to construct [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Db")] #if PUBLIC_DBEXPRESSIONBUILDER public #endif static class DbExpressionBuilder { #region Private Implementation private static readonly AliasGenerator _bindingAliases = new AliasGenerator("Var_", 0); private static readonly DbNullExpression _binaryNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Binary)); private static readonly DbNullExpression _boolNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Boolean)); private static readonly DbNullExpression _byteNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Byte)); private static readonly DbNullExpression _dateTimeNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.DateTime)); private static readonly DbNullExpression _dateTimeOffsetNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.DateTimeOffset)); private static readonly DbNullExpression _decimalNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Decimal)); private static readonly DbNullExpression _doubleNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Double)); private static readonly DbNullExpression _guidNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Guid)); private static readonly DbNullExpression _int16Null = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Int16)); private static readonly DbNullExpression _int32Null = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Int32)); private static readonly DbNullExpression _int64Null = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Int64)); private static readonly DbNullExpression _sbyteNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.SByte)); private static readonly DbNullExpression _singleNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Single)); private static readonly DbNullExpression _stringNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.String)); private static readonly DbNullExpression _timeNull = Null(EdmProviderManifest.Instance.GetCanonicalModelTypeUsage(PrimitiveTypeKind.Time)); private static readonly DbConstantExpression _boolTrue = Constant(true); private static readonly DbConstantExpression _boolFalse = Constant(false); #endregion #region Helpers (not strictly Command Tree API) public static KeyValuePairs and allows that API to be accessed as extension methods on the expression type itself. /// As(this DbExpression value, string alias) { return new KeyValuePair (alias, value); } public static KeyValuePair As(this DbAggregate value, string alias) { return new KeyValuePair (alias, value); } #endregion #region Bindings - Expression and Group /// /// Creates a new /// The expression to bind ///that uses a generated variable name to bind the given expression /// A new expression binding with the specified expression and a generated variable name ////// is null public static DbExpressionBinding Bind(this DbExpression input) { return DbExpressionBuilder.BindAs(input, _bindingAliases.Next()); } /// does not have a collection result type /// Creates a new /// The expression to bind /// The variable name that should be used for the binding ///that uses the specified variable name to bind the given expression /// A new expression binding with the specified expression and variable name ////// or is null public static DbExpressionBinding BindAs(this DbExpression input, string varName) { TypeUsage elementType = ArgumentValidation.ValidateBindAs(input, varName); DbVariableReferenceExpression inputRef = new DbVariableReferenceExpression(elementType, varName); return new DbExpressionBinding(input, inputRef); } /// does not have a collection result type /// Creates a new group expression binding that uses generated variable and group variable names to bind the given expression /// /// The expression to bind ///A new group expression binding with the specified expression and a generated variable name and group variable name ////// is null public static DbGroupExpressionBinding GroupBind(this DbExpression input) { string alias = _bindingAliases.Next(); return DbExpressionBuilder.GroupBindAs(input, alias, string.Format(CultureInfo.InvariantCulture, "Group{0}", alias)); } /// does not have a collection result type /// Creates a new /// The expression to bind /// The variable name that should be used for the binding /// The variable name that should be used to refer to the group when the new group expression binding is used in a group-by expression ///that uses the specified variable name and group variable names to bind the given expression /// A new group expression binding with the specified expression, variable name and group variable name ////// , or is null public static DbGroupExpressionBinding GroupBindAs(this DbExpression input, string varName, string groupVarName) { TypeUsage elementType = ArgumentValidation.ValidateGroupBindAs(input, varName, groupVarName); DbVariableReferenceExpression inputRef = new DbVariableReferenceExpression(elementType, varName); DbVariableReferenceExpression groupRef = new DbVariableReferenceExpression(elementType, groupVarName); return new DbGroupExpressionBinding(input, inputRef, groupRef); } #endregion #region Aggregates and SortClauses are required only for Binding-based method support - replaced by OrderBy[Descending]/ThenBy[Descending] and Aggregate[Distinct] methods in new API /// does not have a collection result type /// Creates a new /// The function that defines the aggregate operation. /// The argument over which the aggregate function should be calculated. ///. /// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value false ////// or is null /// public static DbFunctionAggregate Aggregate(this EdmFunction function, DbExpression argument) { return CreateFunctionAggregate(function, argument, false); } ///is not an aggregate function or has more than one argument, or /// the result type of is not equal or promotable to /// the parameter type of /// /// Creates a new /// The function that defines the aggregate operation. /// The argument over which the aggregate function should be calculated. ///that is applied in a distinct fashion. /// A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value true ////// or is null /// public static DbFunctionAggregate AggregateDistinct(this EdmFunction function, DbExpression argument) { return CreateFunctionAggregate(function, argument, true); } private static DbFunctionAggregate CreateFunctionAggregate(EdmFunction function, DbExpression argument, bool isDistinct) { EntityUtil.CheckArgumentNull(argument, "argument"); DbExpressionList funcArgs = ArgumentValidation.ValidateFunctionAggregate(function, new[] { argument }); TypeUsage resultType = function.ReturnParameter.TypeUsage; return new DbFunctionAggregate(resultType, funcArgs, function, isDistinct); } ///is not an aggregate function or has more than one argument, or /// the result type of is not equal or promotable to /// the parameter type of /// /// Creates a new /// The argument over which to perform the nest operation ///over the specified argument /// A new group aggregate representing the elements of the group referenced by the given argument. ////*ENABLE_ELEMENT_SELECTOR(*/internal/*)*/ static DbGroupAggregate GroupAggregate(DbExpression argument) { DbExpressionList arguments = ArgumentValidation.ValidateGroupAggregate(argument); TypeUsage resultType = TypeHelpers.CreateCollectionTypeUsage(argument.ResultType); return new DbGroupAggregate(resultType, arguments); } /// is null /// Creates a /// An expression that defines the logic of the Lambda function /// /// Awith the specified inline Lambda function implementation and formal parameters. /// collection that represents the formal parameters to the Lambda function. /// These variables are valid for use in the expression. /// /// A new DbLambda that describes an inline Lambda function with the specified body and formal parameters ////// . ///is null or contains null, or is null /// /// public static DbLambda Lambda(DbExpression body, IEnumerablecontains more than one element with the same variable name. /// variables) { return CreateLambda(body, variables); } /// /// Creates a /// An expression that defines the logic of the Lambda function /// /// Awith the specified inline Lambda function implementation and formal parameters. /// collection that represents the formal parameters to the Lambda function. /// These variables are valid for use in the expression. /// /// A new DbLambda that describes an inline Lambda function with the specified body and formal parameters ////// . ///is null or contains null, or is null /// /// public static DbLambda Lambda(DbExpression body, params DbVariableReferenceExpression[] variables) { return CreateLambda(body, variables); } private static DbLambda CreateLambda(DbExpression body, IEnumerablecontains more than one element with the same variable name. /// variables) { var validVars = ArgumentValidation.ValidateLambda(variables, body); return new DbLambda(validVars, body); } /// /// Creates a new /// The expression that defines the sort key ///with an ascending sort order and default collation /// A new sort clause with the given sort key and ascending sort order ////// is null public static DbSortClause ToSortClause(this DbExpression key) { ArgumentValidation.ValidateSortClause(key); return new DbSortClause(key, true, String.Empty); } /// does not have an order-comparable result type /// Creates a new /// The expression that defines the sort key ///with a descending sort order and default collation /// A new sort clause with the given sort key and descending sort order ////// is null public static DbSortClause ToSortClauseDescending(this DbExpression key) { ArgumentValidation.ValidateSortClause(key); return new DbSortClause(key, false, String.Empty); } /// does not have an order-comparable result type /// Creates a new /// The expression that defines the sort key /// The collation to sort under ///with an ascending sort order and the specified collation /// A new sort clause with the given sort key and collation, and ascending sort order ////// is null /// is empty or contains only space characters public static DbSortClause ToSortClause(this DbExpression key, string collation) { ArgumentValidation.ValidateSortClause(key, collation); return new DbSortClause(key, true, collation); } /// does not have an order-comparable result type /// Creates a new /// The expression that defines the sort key /// The collation to sort under ///with a descending sort order and the specified collation /// A new sort clause with the given sort key and collation, and descending sort order ////// is null /// is empty or contains only space characters public static DbSortClause ToSortClauseDescending(this DbExpression key, string collation) { ArgumentValidation.ValidateSortClause(key, collation); return new DbSortClause(key, false, collation); } #endregion #region Binding-based methods: All, Any, Cross|OuterApply, Cross|FullOuter|Inner|LeftOuterJoin, Filter, GroupBy, Project, Skip, Sort /// does not have an order-comparable result type /// Creates a new /// An expression binding that specifies the input set. /// An expression representing a predicate to evaluate for each member of the input set. ///that determines whether the given predicate holds for all elements of the input set. /// A new DbQuantifierExpression that represents the All operation. ////// or is null /// public static DbQuantifierExpression All(this DbExpressionBinding input, DbExpression predicate) { TypeUsage booleanResultType = ArgumentValidation.ValidateQuantifier(input, predicate); return new DbQuantifierExpression(DbExpressionKind.All, booleanResultType, input, predicate); } ///does not have a Boolean result type. /// /// Creates a new /// An expression binding that specifies the input set. /// An expression representing a predicate to evaluate for each member of the input set. ///that determines whether the given predicate holds for any element of the input set. /// A new DbQuantifierExpression that represents the Any operation. ////// or is null /// public static DbQuantifierExpression Any(this DbExpressionBinding input, DbExpression predicate) { TypeUsage booleanResultType = ArgumentValidation.ValidateQuantifier(input, predicate); return new DbQuantifierExpression(DbExpressionKind.Any, booleanResultType, input, predicate); } ///does not have a Boolean result type. /// /// Creates a new /// Anthat evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set are not included. /// that specifies the input set. /// An that specifies logic to evaluate once for each member of the input set. /// An new DbApplyExpression with the specified input and apply bindings and an ///of CrossApply. public static DbApplyExpression CrossApply(this DbExpressionBinding input, DbExpressionBinding apply) { TypeUsage resultType = ArgumentValidation.ValidateApply(input, apply); return new DbApplyExpression(DbExpressionKind.CrossApply, resultType, input, apply); } /// or is null /// Creates a new /// Anthat evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set have an apply column value of null
. ///that specifies the input set. /// An that specifies logic to evaluate once for each member of the input set. /// An new DbApplyExpression with the specified input and apply bindings and an ///of OuterApply. public static DbApplyExpression OuterApply(this DbExpressionBinding input, DbExpressionBinding apply) { TypeUsage resultType = ArgumentValidation.ValidateApply(input, apply); return new DbApplyExpression(DbExpressionKind.OuterApply, resultType, input, apply); } /// or is null /// Creates a new /// A list of expression bindings that specifies the input sets. ///that unconditionally joins the sets specified by the list of input expression bindings. /// A new DbCrossJoinExpression, with an ///of CrossJoin, that represents the unconditional join of the input sets. /// is null or contains null /// public static DbCrossJoinExpression CrossJoin(IEnumerablecontains fewer than 2 expression bindings. /// inputs) { TypeUsage resultType; System.Collections.ObjectModel.ReadOnlyCollection validInputs = ArgumentValidation.ValidateCrossJoin(inputs, out resultType); return new DbCrossJoinExpression(resultType, validInputs); } /// /// Creates a new /// Anthat joins the sets specified by the left and right /// expression bindings, on the specified join condition, using InnerJoin as the . /// that specifies the left set argument. /// An that specifies the right set argument. /// An expression that specifies the condition on which to join. /// /// A new DbJoinExpression, with an ///of InnerJoin, that represents the inner join operation applied to the left and right /// input sets under the given join condition. /// /// ///, or is null. /// /// public static DbJoinExpression InnerJoin(this DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition) { TypeUsage resultType = ArgumentValidation.ValidateJoin(left, right, joinCondition); return new DbJoinExpression(DbExpressionKind.InnerJoin, resultType, left, right, joinCondition); } ///does not have a Boolean result type. /// /// Creates a new /// Anthat joins the sets specified by the left and right /// expression bindings, on the specified join condition, using LeftOuterJoin as the . /// that specifies the left set argument. /// An that specifies the right set argument. /// An expression that specifies the condition on which to join. /// /// A new DbJoinExpression, with an ///of LeftOuterJoin, that represents the left outer join operation applied to the left and right /// input sets under the given join condition. /// /// ///, or is null. /// /// public static DbJoinExpression LeftOuterJoin(this DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition) { TypeUsage resultType = ArgumentValidation.ValidateJoin(left, right, joinCondition); return new DbJoinExpression(DbExpressionKind.LeftOuterJoin, resultType, left, right, joinCondition); } ///does not have a Boolean result type. /// /// Creates a new /// Anthat joins the sets specified by the left and right /// expression bindings, on the specified join condition, using FullOuterJoin as the . /// that specifies the left set argument. /// An that specifies the right set argument. /// An expression that specifies the condition on which to join. /// /// A new DbJoinExpression, with an ///of FullOuterJoin, that represents the full outer join operation applied to the left and right /// input sets under the given join condition. /// /// ///, or is null. /// /// public static DbJoinExpression FullOuterJoin(this DbExpressionBinding left, DbExpressionBinding right, DbExpression joinCondition) { TypeUsage resultType = ArgumentValidation.ValidateJoin(left, right, joinCondition); return new DbJoinExpression(DbExpressionKind.FullOuterJoin, resultType, left, right, joinCondition); } ///does not have a Boolean result type. /// /// Creates a new /// An expression binding that specifies the input set. /// An expression representing a predicate to evaluate for each member of the input set. ///that filters the elements in the given input set using the specified predicate. /// A new DbFilterExpression that produces the filtered set. ////// or is null /// public static DbFilterExpression Filter(this DbExpressionBinding input, DbExpression predicate) { TypeUsage resultType = ArgumentValidation.ValidateFilter(input, predicate); return new DbFilterExpression(resultType, input, predicate); } ///does not have a Boolean result type. /// /// Creates a new /// Athat groups the elements of the input set according to the specified group keys and applies the given aggregates. /// that specifies the input set. /// A list of string-expression pairs that define the grouping columns. /// A list of expressions that specify aggregates to apply. /// A new DbGroupByExpression with the specified input set, grouping keys and aggregates. ////// ///, or is null, /// contains a null key column name or expression, or /// contains a null aggregate column name or aggregate. /// /// Both ///and are empty, /// or an invalid or duplicate column name was specified. /// /// DbGroupByExpression allows either the list of keys or the list of aggregates to be empty, but not both. /// public static DbGroupByExpression GroupBy(this DbGroupExpressionBinding input, IEnumerable> keys, IEnumerable > aggregates) { DbExpressionList validKeys; System.Collections.ObjectModel.ReadOnlyCollection validAggregates; TypeUsage resultType = ArgumentValidation.ValidateGroupBy(input, keys, aggregates, out validKeys, out validAggregates); return new DbGroupByExpression(resultType, input, validKeys, validAggregates); } /// /// Creates a new /// An expression binding that specifies the input set. /// An expression to project over the set. ///that projects the specified expression over the given input set. /// A new DbProjectExpression that represents the projection operation. ///public static DbProjectExpression Project(this DbExpressionBinding input, DbExpression projection) { TypeUsage resultType = ArgumentValidation.ValidateProject(input, projection); return new DbProjectExpression(resultType, input, projection); } /// or is null /// Creates a new /// An expression binding that specifies the input set. /// A list of sort specifications that determine how the elements of the input set should be sorted. /// An expression the specifies how many elements of the ordered set to skip. ///that sorts the given input set by the given sort specifications before skipping the specified number of elements. /// A new DbSkipExpression that represents the skip operation. ////// ///, or is null, /// or contains null. /// /// public static DbSkipExpression Skip(this DbExpressionBinding input, IEnumerableis empty, /// or is not or or has a /// result type that is not equal or promotable to a 64-bit integer type. /// sortOrder, DbExpression count) { System.Collections.ObjectModel.ReadOnlyCollection validSortOrder = ArgumentValidation.ValidateSkip(input, sortOrder, count); return new DbSkipExpression(input.Expression.ResultType, input, validSortOrder, count); } /// /// Creates a new /// An expression binding that specifies the input set. /// A list of sort specifications that determine how the elements of the input set should be sorted. ///that sorts the given input set by the specified sort specifications. /// A new DbSortExpression that represents the sort operation. ////// ///or is null, /// or contains null. /// /// public static DbSortExpression Sort(this DbExpressionBinding input, IEnumerableis empty. /// sortOrder) { System.Collections.ObjectModel.ReadOnlyCollection validSortOrder = ArgumentValidation.ValidateSort(input, sortOrder); return new DbSortExpression(input.Expression.ResultType, input, validSortOrder); } #endregion #region Leaf Expressions - Null, Constant, Parameter, Scan #if DBEXPRESSIONBUILDER_NULLCONSTANTS // Binary public static DbNullExpression NullBinary { get { return _binaryNull; } } // Boolean public static DbNullExpression NullBoolean { get { return _boolNull; } } // Byte public static DbNullExpression NullByte { get { return _byteNull; } } // DateTime public static DbNullExpression NullDateTime { get { return _dateTimeNull; } } // DateTimeOffset public static DbNullExpression NullDateTimeOffset { get { return _dateTimeOffsetNull; } } // Decimal public static DbNullExpression NullDecimal { get { return _decimalNull; } } // Double public static DbNullExpression NullDouble { get { return _doubleNull; } } // Guid public static DbNullExpression NullGuid { get { return _guidNull; } } // Int16 public static DbNullExpression NullInt16 { get { return _int16Null; } } // Int32 public static DbNullExpression NullInt32 { get { return _int32Null; } } // Int64 public static DbNullExpression NullInt64 { get { return _int64Null; } } // SByte public static DbNullExpression NullSByte { get { return _sbyteNull; } } // Single public static DbNullExpression NullSingle { get { return _singleNull; } } // String public static DbNullExpression NullString { get { return _stringNull; } } // Time public static DbNullExpression NullTime { get { return _timeNull; } } #endif /// /// Creates a new /// The type of the null value. ///, which represents a typed null value. /// An instance of DbNullExpression ///public static DbNullExpression Null(this TypeUsage nullType) { ArgumentValidation.ValidateNull(nullType); return new DbNullExpression(nullType); } /// is null /// Creates a ///with the Boolean value true
. ///A DbConstantExpression with the Boolean value true. public static DbConstantExpression True { get { return _boolTrue; } } ////// Creates a ///with the Boolean value false
. ///A DbConstantExpression with the Boolean value false. public static DbConstantExpression False { get { return _boolFalse; } } ////// Creates a new /// The constant value to represent. ///with the given constant value. /// A new DbConstantExpression with the given value. ////// is null public static DbConstantExpression Constant(object value) { TypeUsage constantType = ArgumentValidation.ValidateConstant(value); return new DbConstantExpression(constantType, value); } /// is not an instance of a valid constant type /// Creates a new /// The type of the constant value. /// The constant value to represent. ///of the specified primitive type with the given constant value. /// A new DbConstantExpression with the given value and a result type of ///. /// or is null /// public static DbConstantExpression Constant(this TypeUsage constantType, object value) { ArgumentValidation.ValidateConstant(constantType, value); return new DbConstantExpression(constantType, value); } ///is not an instance of a valid constant type, /// does not represent a primitive type, or /// is of a different primitive type than that represented by /// /// Creates a new /// The type of the referenced parameter /// The name of the referenced parameter ///that references a parameter with the specified name and type. /// /// A DbParameterReferenceExpression that represents a reference to a parameter with the specified name and type; /// the result type of the expression will be the same as public static DbParameterReferenceExpression Parameter(this TypeUsage type, string name) { ArgumentValidation.ValidateParameter(type, name); return new DbParameterReferenceExpression(type, name); } ///. /// /// Creates a new /// The type of the referenced variable /// The name of the referenced variable ///that references a variable with the specified name and type. /// /// A DbVariableReferenceExpression that represents a reference to a variable with the specified name and type; /// the result type of the expression will be the same as public static DbVariableReferenceExpression Variable(this TypeUsage type, string name) { ArgumentValidation.ValidateVariable(type, name); return new DbVariableReferenceExpression(type, name); } ///. /// /// Creates a new /// Metadata for the entity or relationship set to reference. ///that references the specified entity or relationship set. /// A new DbScanExpression based on the specified entity or relationship set. ///public static DbScanExpression Scan(this EntitySetBase targetSet) { TypeUsage resultType = ArgumentValidation.ValidateScan(targetSet); return new DbScanExpression(resultType, targetSet); } #endregion #region Boolean Operators - And, Or, Not /// is null /// Creates an /// A Boolean expression that specifies the left argument. /// A Boolean expression that specifies the right argument. ///that performs the logical And of the left and right arguments. /// A new DbAndExpression with the specified arguments. ////// or is null /// public static DbAndExpression And(this DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateAnd(left, right); return new DbAndExpression(resultType, left, right); } ///or does not have a Boolean result type. /// /// Creates an /// A Boolean expression that specifies the left argument. /// A Boolean expression that specifies the right argument. ///that performs the logical Or of the left and right arguments. /// A new DbOrExpression with the specified arguments. ////// or is null /// public static DbOrExpression Or(this DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateOr(left, right); return new DbOrExpression(resultType, left, right); } ///or does not have a Boolean result type. /// /// Creates a /// A Boolean expression that specifies the argument. ///that performs the logical negation of the given argument. /// A new DbNotExpression with the specified argument. ////// is null /// public static DbNotExpression Not(this DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateNot(argument); return new DbNotExpression(resultType, argument); } #endregion #region Arithmetic Operators - Divide, Minus, Modulo, Multiply, Plus, UnaryMinus private static DbArithmeticExpression CreateArithmetic(DbExpressionKind kind, DbExpression left, DbExpression right) { TypeUsage numericResultType; DbExpressionList arguments = ArgumentValidation.ValidateArithmetic(left, right, out numericResultType); return new DbArithmeticExpression(kind, numericResultType, arguments); } ///does not have a Boolean result type. /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that divides the left argument by the right argument. /// A new DbArithmeticExpression representing the division operation. ////// or is null /// No common numeric result type exists between public static DbArithmeticExpression Divide(this DbExpression left, DbExpression right) { return CreateArithmetic(DbExpressionKind.Divide, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that subtracts the right argument from the left argument. /// A new DbArithmeticExpression representing the subtraction operation. ////// or is null /// No common numeric result type exists between public static DbArithmeticExpression Minus(this DbExpression left, DbExpression right) { return CreateArithmetic(DbExpressionKind.Minus, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that computes the remainder of the left argument divided by the right argument. /// A new DbArithmeticExpression representing the modulo operation. ////// or is null /// No common numeric result type exists between public static DbArithmeticExpression Modulo(this DbExpression left, DbExpression right) { return CreateArithmetic(DbExpressionKind.Modulo, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that multiplies the left argument by the right argument. /// A new DbArithmeticExpression representing the multiplication operation. ////// or is null /// No common numeric result type exists between public static DbArithmeticExpression Multiply(this DbExpression left, DbExpression right) { return CreateArithmetic(DbExpressionKind.Multiply, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that adds the left argument to the right argument. /// A new DbArithmeticExpression representing the addition operation. ////// or is null /// No common numeric result type exists between public static DbArithmeticExpression Plus(this DbExpression left, DbExpression right) { return CreateArithmetic(DbExpressionKind.Plus, left, right); } ///and . /// /// Creates a new /// An expression that specifies the argument. ///that negates the value of the argument. /// A new DbArithmeticExpression representing the negation operation. ////// is null /// No numeric result type exists for public static DbArithmeticExpression UnaryMinus(this DbExpression argument) { TypeUsage resultType; DbExpressionList args = ArgumentValidation.ValidateArithmetic(argument, out resultType); return new DbArithmeticExpression(DbExpressionKind.UnaryMinus, resultType, args); } ///. /// /// Creates a new /// An expression that specifies the argument. ///that negates the value of the argument. /// A new DbArithmeticExpression representing the negation operation. ////// is null /// No numeric result type exists for public static DbArithmeticExpression Negate(this DbExpression argument) { return DbExpressionBuilder.UnaryMinus(argument); } #endregion #region Comparison Operators - Equal, NotEqual, GreaterThan, LessThan, GreaterThanEqual, LessThanEqual, IsNull, Like private static DbComparisonExpression CreateComparison(DbExpressionKind kind, DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateComparison(kind, left, right); return new DbComparisonExpression(kind, resultType, left, right); } ///. /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that compares the left and right arguments for equality. /// A new DbComparisonExpression representing the equality comparison. ////// or is null /// No common equality-comparable result type exists between public static DbComparisonExpression Equal(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.Equals, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that compares the left and right arguments for inequality. /// A new DbComparisonExpression representing the inequality comparison. ////// or is null /// No common equality-comparable result type exists between public static DbComparisonExpression NotEqual(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.NotEquals, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that determines whether the left argument is greater than the right argument. /// A new DbComparisonExpression representing the greater-than comparison. ////// or is null /// No common order-comparable result type exists between public static DbComparisonExpression GreaterThan(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.GreaterThan, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that determines whether the left argument is less than the right argument. /// A new DbComparisonExpression representing the less-than comparison. ////// or is null /// No common order-comparable result type exists between public static DbComparisonExpression LessThan(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.LessThan, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that determines whether the left argument is greater than or equal to the right argument. /// A new DbComparisonExpression representing the greater-than-or-equal-to comparison. ////// or is null /// No common result type that is both equality- and order-comparable exists between public static DbComparisonExpression GreaterThanOrEqual(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.GreaterThanOrEquals, left, right); } ///and . /// /// Creates a new /// An expression that specifies the left argument. /// An expression that specifies the right argument. ///that determines whether the left argument is less than or equal to the right argument. /// A new DbComparisonExpression representing the less-than-or-equal-to comparison. ////// or is null /// No common result type that is both equality- and order-comparable exists between public static DbComparisonExpression LessThanOrEqual(this DbExpression left, DbExpression right) { return DbExpressionBuilder.CreateComparison(DbExpressionKind.LessThanOrEquals, left, right); } ///and . /// /// Creates a new /// An expression that specifies the argument. ///that determines whether the specified argument is null. /// A new DbIsNullExpression with the specified argument. ////// is null public static DbIsNullExpression IsNull(this DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateIsNull(argument); return new DbIsNullExpression(resultType, argument, false); } /// has a collection result type. /// Creates a new /// An expression that specifies the input string. /// An expression that specifies the pattern string. ///that compares the specified input string to the given pattern. /// A new DbLikeExpression with the specified input, pattern and a null escape. ////// or is null public static DbLikeExpression Like(this DbExpression argument, DbExpression pattern) { TypeUsage resultType = ArgumentValidation.ValidateLike(argument, pattern); DbExpression escape = DbExpressionBuilder.Null(pattern.ResultType); return new DbLikeExpression(resultType, argument, pattern, escape); } /// or does not have a string result type. /// Creates a new /// An expression that specifies the input string. /// An expression that specifies the pattern string. /// An optional expression that specifies the escape string. ///that compares the specified input string to the given pattern using the optional escape. /// A new DbLikeExpression with the specified input, pattern and escape. ////// , or is null public static DbLikeExpression Like(this DbExpression argument, DbExpression pattern, DbExpression escape) { TypeUsage resultType = ArgumentValidation.ValidateLike(argument, pattern, escape); return new DbLikeExpression(resultType, argument, pattern, escape); } #endregion #region Type Operators - Cast, Treat, OfType, OfTypeOnly, IsOf, IsOfOnly /// , or does not have a string result type. /// Creates a new /// The argument to which the cast should be applied. /// Type metadata that specifies the type to cast to. ///that applies a cast operation to a polymorphic argument. /// A new DbCastExpression with the specified argument and target type. ////// or is null The specified cast is not valid. public static DbCastExpression CastTo(this DbExpression argument, TypeUsage toType) { ArgumentValidation.ValidateCastTo(argument, toType); return new DbCastExpression(toType, argument); } ////// Creates a new /// An expression that specifies the instance. /// Type metadata for the treat-as type. ///. /// A new DbTreatExpression with the specified argument and type. ////// or is null /// is not in the same type hierarchy as the result type of . /// /// DbTreatExpression requires that public static DbTreatExpression TreatAs(this DbExpression argument, TypeUsage treatType) { ArgumentValidation.ValidateTreatAs(argument, treatType); return new DbTreatExpression(treatType, argument); } ///has a polymorphic result type, /// and that is a type from the same type hierarchy as that result type. /// /// Creates a new /// Athat produces a set consisting of the elements of the given input set that are of the specified type. /// that specifies the input set. /// Type metadata for the type that elements of the input set must have to be included in the resulting set. /// A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of ///. /// or is null /// ///does not have a collection result type, or /// is not a type in the same type hierarchy as the element type of the /// collection result type of . /// /// DbOfTypeExpression requires that public static DbOfTypeExpression OfType(this DbExpression argument, TypeUsage type) { TypeUsage collectionOfTypeResultType = ArgumentValidation.ValidateOfType(argument, type); return new DbOfTypeExpression(DbExpressionKind.OfType, collectionOfTypeResultType, argument, type); } ///has a collection result type with /// a polymorphic element type, and that is a type from the same type hierarchy as that element type. /// /// Creates a new /// Anthat produces a set consisting of the elements of the given input set that are of exactly the specified type. /// that specifies the input set. /// Type metadata for the type that elements of the input set must match exactly to be included in the resulting set. /// A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of ///. /// or is null /// ///does not have a collection result type, or /// is not a type in the same type hierarchy as the element type of the /// collection result type of . /// /// DbOfTypeExpression requires that public static DbOfTypeExpression OfTypeOnly(this DbExpression argument, TypeUsage type) { TypeUsage collectionOfTypeResultType = ArgumentValidation.ValidateOfType(argument, type); return new DbOfTypeExpression(DbExpressionKind.OfTypeOnly, collectionOfTypeResultType, argument, type); } ///has a collection result type with /// a polymorphic element type, and that is a type from the same type hierarchy as that element type. /// /// Creates a new /// An expression that specifies the instance. /// Type metadata that specifies the type that the instance's result type should be compared to. ///that determines whether the given argument is of the specified type or a subtype. /// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOf. ////// or is null /// ///is not in the same type hierarchy as the result type of . /// /// DbIsOfExpression requires that public static DbIsOfExpression IsOf(this DbExpression argument, TypeUsage type) { TypeUsage booleanResultType = ArgumentValidation.ValidateIsOf(argument, type); return new DbIsOfExpression(DbExpressionKind.IsOf, booleanResultType, argument, type); } ///has a polymorphic result type, /// and that is a type from the same type hierarchy as that result type. /// /// Creates a new /// An expression that specifies the instance. /// Type metadata that specifies the type that the instance's result type should be compared to. ///expression that determines whether the given argument is of the specified type, and only that type (not a subtype). /// A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOfOnly. ////// or is null /// ///is not in the same type hierarchy as the result type of . /// /// DbIsOfExpression requires that public static DbIsOfExpression IsOfOnly(this DbExpression argument, TypeUsage type) { TypeUsage booleanResultType = ArgumentValidation.ValidateIsOf(argument, type); return new DbIsOfExpression(DbExpressionKind.IsOfOnly, booleanResultType, argument, type); } #endregion #region Ref Operators - Deref, EntityRef, Ref, RefKey, RelationshipNavigation ///has a polymorphic result type, /// and that is a type from the same type hierarchy as that result type. /// /// Creates a new /// Anthat retrieves a specific Entity given a reference expression /// that provides the reference. This expression must have a reference Type /// A new DbDerefExpression that retrieves the specified Entity ////// is null [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Deref")] public static DbDerefExpression Deref(this DbExpression argument) { TypeUsage entityResultType = ArgumentValidation.ValidateDeref(argument); return new DbDerefExpression(entityResultType, argument); } /// does not have a reference result type. /// Creates a new /// The expression that provides the entity. This expression must have an entity result type. ///that retrieves the ref of the specifed entity in structural form. /// A new DbEntityRefExpression that retrieves a reference to the specified entity. ////// is null public static DbEntityRefExpression GetEntityRef(this DbExpression argument) { TypeUsage refResultType = ArgumentValidation.ValidateGetEntityRef(argument); return new DbEntityRefExpression(refResultType, argument); } /// does not have an entity result type. /// Creates a new /// The entity set in which the referenced element resides. /// A collection ofthat encodes a reference to a specific entity based on key values. /// s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. /// A new DbRefExpression that references the element with the specified key values in the given entity set. ////// is null, or is null or contains null. /// The count of public static DbRefExpression CreateRef(this EntitySet entitySet, IEnumerabledoes not match the count of key members declared by the 's element type, /// or contains an expression with a result type that is not compatible with the type of the corresponding key member. /// keyValues) { return CreateRefExpression(entitySet, keyValues); } /// /// Creates a new /// The entity set in which the referenced element resides. /// A collection ofthat encodes a reference to a specific entity based on key values. /// s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. /// A new DbRefExpression that references the element with the specified key values in the given entity set. ////// is null, or is null or contains null. /// The count of public static DbRefExpression CreateRef(this EntitySet entitySet, params DbExpression[] keyValues) { return CreateRefExpression(entitySet, keyValues); } ///does not match the count of key members declared by the 's element type, /// or contains an expression with a result type that is not compatible with the type of the corresponding key member. /// /// Creates a new /// The entity set in which the referenced element resides. /// The specific type of the referenced entity. This must be an entity type from the same hierarchy as the entity set's element type. /// A collection ofthat encodes a reference to a specific entity of a given type based on key values. /// s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. /// A new DbRefExpression that references the element with the specified key values in the given entity set. ////// or is null, or is null or contains null. /// is not from the same type hierarchy (a subtype, supertype, or the same type) as 's element type. /// The count of public static DbRefExpression CreateRef(this EntitySet entitySet, EntityType entityType, IEnumerabledoes not match the count of key members declared by the 's element type, /// or contains an expression with a result type that is not compatible with the type of the corresponding key member. /// keyValues) { return CreateRefExpression(entitySet, entityType, keyValues); } /// /// Creates a new /// The entity set in which the referenced element resides. /// The specific type of the referenced entity. This must be an entity type from the same hierarchy as the entity set's element type. /// A collection ofthat encodes a reference to a specific entity of a given type based on key values. /// s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. /// A new DbRefExpression that references the element with the specified key values in the given entity set. ////// or is null, or is null or contains null. /// is not from the same type hierarchy (a subtype, supertype, or the same type) as 's element type. /// The count of public static DbRefExpression CreateRef(this EntitySet entitySet, EntityType entityType, params DbExpression[] keyValues) { return CreateRefExpression(entitySet, entityType, keyValues); } private static DbRefExpression CreateRefExpression(EntitySet entitySet, IEnumerabledoes not match the count of key members declared by the 's element type, /// or contains an expression with a result type that is not compatible with the type of the corresponding key member. /// keyValues) { DbExpression keyConstructor; TypeUsage refResultType = ArgumentValidation.ValidateCreateRef(entitySet, keyValues, out keyConstructor); return new DbRefExpression(refResultType, entitySet, keyConstructor); } private static DbRefExpression CreateRefExpression(EntitySet entitySet, EntityType entityType, IEnumerable keyValues) { DbExpression keyConstructor; TypeUsage refResultType = ArgumentValidation.ValidateCreateRef(entitySet, entityType, keyValues, out keyConstructor); return new DbRefExpression(refResultType, entitySet, keyConstructor); } /// /// Creates a new /// The Entity set in which the referenced element resides. /// Athat encodes a reference to a specific Entity based on key values. /// that constructs a record with columns that match (in number, type, and order) the Key properties of the referenced Entity type. /// A new DbRefExpression that references the element with the specified key values in the given Entity set. ////// or is null /// ///does not have a record result type that matches the key properties of the referenced entity set's entity type. /// /// public static DbRefExpression RefFromKey(this EntitySet entitySet, DbExpression keyRow) { TypeUsage refResultType = ArgumentValidation.ValidateRefFromKey(entitySet, keyRow); return new DbRefExpression(refResultType, entitySet, keyRow); } ///should be an expression that specifies the key values that identify the referenced entity within the given entity set. /// The result type of should contain a corresponding column for each key property defined by 's entity type. /// /// Creates a new /// The Entity set in which the referenced element resides. /// Athat encodes a reference to a specific Entity based on key values. /// that constructs a record with columns that match (in number, type, and order) the Key properties of the referenced Entity type. /// The type of the Entity that the reference should refer to. /// A new DbRefExpression that references the element with the specified key values in the given Entity set. ////// , or is null /// ///is not in the same type hierarchy as the entity set's entity type, or does not have a /// record result type that matches the key properties of the referenced entity set's entity type. /// /// public static DbRefExpression RefFromKey(this EntitySet entitySet, DbExpression keyRow, EntityType entityType) { TypeUsage refResultType = ArgumentValidation.ValidateRefFromKey(entitySet, keyRow, entityType); return new DbRefExpression(refResultType, entitySet, keyRow); } ///should be an expression that specifies the key values that identify the referenced entity within the given entity set. /// The result type of should contain a corresponding column for each key property defined by 's entity type. /// /// Creates a new /// The expression that provides the reference. This expression must have a reference Type with an Entity element type. ///that retrieves the key values of the specifed reference in structural form. /// A new DbRefKeyExpression that retrieves the key values of the specified reference. ////// is null public static DbRefKeyExpression GetRefKey(this DbExpression argument) { TypeUsage rowResultType = ArgumentValidation.ValidateGetRefKey(argument); return new DbRefKeyExpression(rowResultType, argument); } /// does not have a reference result type. /// Creates a new /// An expression the specifies the instance from which naviagtion should occur /// Metadata for the property that represents the end of the relationship from which navigation should occur /// Metadata for the property that represents the end of the relationship to which navigation should occur ///representing the navigation of a composition or association relationship. /// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance ////// , or is null /// ///and are not declared by the same relationship type, or /// has a result type that is not compatible with the property type of . /// /// public static DbRelationshipNavigationExpression Navigate(this DbExpression navigateFrom, RelationshipEndMember fromEnd, RelationshipEndMember toEnd) { RelationshipType relType; TypeUsage resultType = ArgumentValidation.ValidateNavigate(navigateFrom, fromEnd, toEnd, out relType); return new DbRelationshipNavigationExpression(resultType, relType, fromEnd, toEnd, navigateFrom); } ///requires that navigation always occur from a reference, and so must always have a reference result type. /// /// Creates a new /// Metadata for the relation type that represents the relationship /// The name of the property of the relation type that represents the end of the relationship from which navigation should occur /// The name of the property of the relation type that represents the end of the relationship to which navigation should occur /// An expression the specifies the instance from which naviagtion should occur ///representing the navigation of a composition or association relationship. /// A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance ////// ///, , or is null. /// /// ///is not associated with this command tree's metadata workspace or is associated with a different command tree, /// or does not declare a relation end property with name or , /// or has a result type that is not compatible with the property type of the relation end property with name . /// /// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] public static DbRelationshipNavigationExpression Navigate(this RelationshipType type, string fromEndName, string toEndName, DbExpression navigateFrom) { RelationshipEndMember fromEnd; RelationshipEndMember toEnd; TypeUsage resultType = ArgumentValidation.ValidateNavigate(navigateFrom, type, fromEndName, toEndName, out fromEnd, out toEnd); return new DbRelationshipNavigationExpression(resultType, type, fromEnd, toEnd, navigateFrom); } #endregion #region Unary and Binary Set Operators - Distinct, Element, IsEmpty, Except, Intersect, UnionAll, Limit ///requires that navigation always occur from a reference, and so must always have a reference result type. /// /// Creates a new /// An expression that defines the set over which to perfom the distinct operation. ///that removes duplicates from the given set argument. /// A new DbDistinctExpression that represents the distinct operation applied to the specified set argument. ////// is null public static DbDistinctExpression Distinct(this DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateDistinct(argument); return new DbDistinctExpression(resultType, argument); } /// does not have a collection result type. /// Creates a new /// An expression that specifies the input set. ///that converts a single-member set into a singleton. /// A DbElementExpression that represents the conversion of the single-member set argument to a singleton. ////// is null public static DbElementExpression Element(this DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateElement(argument); return new DbElementExpression(resultType, argument); } /// does not have a collection result type. /// Creates a new /// An expression that specifies the input set ///that determines whether the specified set argument is an empty set. /// A new DbIsEmptyExpression with the specified argument. ////// is null public static DbIsEmptyExpression IsEmpty(this DbExpression argument) { TypeUsage booleanResultType = ArgumentValidation.ValidateIsEmpty(argument); return new DbIsEmptyExpression(booleanResultType, argument); } /// does not have a collection result type. /// Creates a new /// An expression that defines the left set argument. /// An expression that defines the right set argument. ///that computes the subtraction of the right set argument from the left set argument. /// A new DbExceptExpression that represents the difference of the left argument from the right argument. ////// or is null No common collection result type exists between public static DbExceptExpression Except(this DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateExcept(left, right); return new DbExceptExpression(resultType, left, right); } ///and . /// Creates a new /// An expression that defines the left set argument. /// An expression that defines the right set argument. ///that computes the intersection of the left and right set arguments. /// A new DbIntersectExpression that represents the intersection of the left and right arguments. ////// or is null No common collection result type exists between public static DbIntersectExpression Intersect(this DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateIntersect(left, right); return new DbIntersectExpression(resultType, left, right); } ///and . /// Creates a new /// An expression that defines the left set argument. /// An expression that defines the right set argument. ///that computes the union of the left and right set arguments and does not remove duplicates. /// A new DbUnionAllExpression that union, including duplicates, of the the left and right arguments. ////// or is null No common collection result type exists between public static DbUnionAllExpression UnionAll(this DbExpression left, DbExpression right) { TypeUsage resultType = ArgumentValidation.ValidateUnionAll(left, right); return new DbUnionAllExpression(resultType, left, right); } ///and . /// Creates a new /// An expression that specifies the input collection. /// An expression that specifies the limit value. ///that restricts the number of elements in the Argument collection to the specified count Limit value. /// Tied results are not included in the output. /// A new DbLimitExpression with the specified argument and count limit values that does not include tied results. ////// or is null /// public static DbLimitExpression Limit(this DbExpression argument, DbExpression count) { TypeUsage resultType = ArgumentValidation.ValidateLimit(argument, count); return new DbLimitExpression(resultType, argument, count, false); } #endregion #region General Operators - Case, Function, NewInstance, Property ///does not have a collection result type, /// or does not have a result type that is equal or promotable to a 64-bit integer type. /// /// Creates a new /// A list of expressions that provide the conditional for of each case. /// A list of expressions that provide the result of each case. /// An expression that defines the result when no case is matched. ///. /// A new DbCaseExpression with the specified cases and default result. ////// ///or is null or contains null, /// or is null. /// /// public static DbCaseExpression Case(IEnumerableor is empty or contains an expression with a non-Boolean result type, or /// No common result type exists for all expressions in and . /// whenExpressions, IEnumerable thenExpressions, DbExpression elseExpression) { DbExpressionList validWhens; DbExpressionList validThens; TypeUsage resultType = ArgumentValidation.ValidateCase(whenExpressions, thenExpressions, elseExpression, out validWhens, out validThens); return new DbCaseExpression(resultType, validWhens, validThens, elseExpression); } /// /// Creates a new /// Metadata for the function to invoke. /// A list of expressions that provide the arguments to the function. ///representing the invocation of the specified function with the given arguments. /// A new DbFunctionExpression representing the function invocation. ////// ///is null, or is null or contains null. /// /// The count of public static DbFunctionExpression Invoke(this EdmFunction function, IEnumerabledoes not equal the number of parameters declared by , /// or contains an expression that has a result type that is not equal or promotable /// to the corresponding function parameter type. /// arguments) { return InvokeFunction(function, arguments); } /// /// Creates a new /// Metadata for the function to invoke. /// Expressions that provide the arguments to the function. ///representing the invocation of the specified function with the given arguments. /// A new DbFunctionExpression representing the function invocation. ////// ///is null, or is null or contains null. /// /// The count of public static DbFunctionExpression Invoke(this EdmFunction function, params DbExpression[] arguments) { return InvokeFunction(function, arguments); } private static DbFunctionExpression InvokeFunction(EdmFunction function, IEnumerabledoes not equal the number of parameters declared by , /// or contains an expression that has a result type that is not equal or promotable /// to the corresponding function parameter type. /// arguments) { DbExpressionList validArguments; TypeUsage resultType = ArgumentValidation.ValidateFunction(function, arguments, out validArguments); return new DbFunctionExpression(resultType, function, validArguments); } /// /// Creates a new /// Arepresenting the application of the specified Lambda function to the given arguments. /// instance representing the Lambda function to apply. /// A list of expressions that provide the arguments. /// A new DbLambdaExpression representing the Lambda function application. ////// ///is null, or is null or contains null. /// /// The count of public static DbLambdaExpression Invoke(this DbLambda lambda, IEnumerabledoes not equal the number of variables declared by , /// or contains an expression that has a result type that is not equal or promotable /// to the corresponding variable type. /// arguments) { return InvokeLambda(lambda, arguments); } /// /// Creates a new /// Arepresenting the application of the specified Lambda function to the given arguments. /// instance representing the Lambda function to apply. /// Expressions that provide the arguments. /// A new DbLambdaExpression representing the Lambda function application. ////// ///is null, or is null or contains null. /// /// The count of public static DbLambdaExpression Invoke(this DbLambda lambda, params DbExpression[] arguments) { return InvokeLambda(lambda, arguments); } private static DbLambdaExpression InvokeLambda(DbLambda lambda, IEnumerabledoes not equal the number of variables declared by , /// or contains an expression that has a result type that is not equal or promotable /// to the corresponding variable type. /// arguments) { DbExpressionList validArguments; TypeUsage resultType = ArgumentValidation.ValidateInvoke(lambda, arguments, out validArguments); return new DbLambdaExpression(resultType, lambda, validArguments); } /// /// Creates a new /// The type of the new instance. /// Expressions that specify values of the new instances, interpreted according to the instance's type. ///. If the type argument is a collection type, the arguments specify the elements of the collection. Otherwise the arguments are used as property or column values in the new instance. /// A new DbNewInstanceExpression with the specified type and arguments. ////// or is null, or contains null /// ///is empty or the result types of the contained expressions do not match the requirements of (as explained in the remarks section). /// /// public static DbNewInstanceExpression New(this TypeUsage instanceType, IEnumerable/// if ///is a a collection type then every expression in must have a result type that is promotable to the element type of the . /// /// if ///is a row type, must contain as many expressions as there are columns in the row /// type, and the result type of each expression must be equal or promotable to the type of the corresponding column. A row type that does not declare any columns is invalid. /// /// if ///is an entity type, must contain as many expressions as there are properties defined by the type, /// and the result type of each expression must be equal or promotable to the type of the corresponding property. /// arguments) { return NewInstance(instanceType, arguments); } /// /// Creates a new /// The type of the new instance. /// Expressions that specify values of the new instances, interpreted according to the instance's type. ///. If the type argument is a collection type, the arguments specify the elements of the collection. Otherwise the arguments are used as property or column values in the new instance. /// A new DbNewInstanceExpression with the specified type and arguments. ////// or is null, or contains null /// ///is empty or the result types of the contained expressions do not match the requirements of (as explained in the remarks section). /// /// public static DbNewInstanceExpression New(this TypeUsage instanceType, params DbExpression[] arguments) { return NewInstance(instanceType, arguments); } private static DbNewInstanceExpression NewInstance(TypeUsage instanceType, IEnumerable/// if ///is a a collection type then every expression in must have a result type that is promotable to the element type of the . /// /// if ///is a row type, must contain as many expressions as there are columns in the row /// type, and the result type of each expression must be equal or promotable to the type of the corresponding column. A row type that does not declare any columns is invalid. /// /// if ///is an entity type, must contain as many expressions as there are properties defined by the type, /// and the result type of each expression must be equal or promotable to the type of the corresponding property. /// arguments) { DbExpressionList validArguments; TypeUsage resultType = ArgumentValidation.ValidateNew(instanceType, arguments, out validArguments); return new DbNewInstanceExpression(resultType, validArguments); } /// /// Creates a new /// A list of expressions that provide the elements of the collection ///that constructs a collection containing the specified elements. The type of the collection is based on the common type of the elements. If no common element type exists an exception is thrown. /// A new DbNewInstanceExpression with the specified collection type and arguments. ////// is null, or contains null /// public static DbNewInstanceExpression NewCollection(IEnumerableis empty or contains expressions for which no common result type exists. /// elements) { return CreateNewCollection(elements); } /// /// Creates a new /// A list of expressions that provide the elements of the collection ///that constructs a collection containing the specified elements. The type of the collection is based on the common type of the elements. If no common element type exists an exception is thrown. /// A new DbNewInstanceExpression with the specified collection type and arguments. ////// is null, or contains null /// public static DbNewInstanceExpression NewCollection(params DbExpression[] elements) { return CreateNewCollection(elements); } private static DbNewInstanceExpression CreateNewCollection(IEnumerableis empty or contains expressions for which no common result type exists. /// elements) { DbExpressionList validElements; TypeUsage collectionResultType = ArgumentValidation.ValidateNewCollection(elements, out validElements); return new DbNewInstanceExpression(collectionResultType, validElements); } /// /// Creates a new /// The type metadata for the collection to create ///that constructs an empty collection of the specified collection type. /// A new DbNewInstanceExpression with the specified collection type and an empty ///Arguments
list./// is null public static DbNewInstanceExpression NewEmptyCollection(this TypeUsage collectionType) { DbExpressionList validElements; TypeUsage validResultType = ArgumentValidation.ValidateNewEmptyCollection(collectionType, out validElements); return new DbNewInstanceExpression(validResultType, validElements); } /// is not a collection type /// Creates a new /// A list of string-DbExpression key-value pairs that defines the structure and values of the row. ///that produces a row with the specified named columns and the given values, specified as expressions. /// A new DbNewInstanceExpression that represents the construction of the row. ////// is null or contains an element with a null column name or expression /// public static DbNewInstanceExpression NewRow(IEnumerableis empty, or contains a duplicate or invalid column name /// > columnValues) { DbExpressionList validElements; TypeUsage resultType = ArgumentValidation.ValidateNewRow(columnValues, out validElements); return new DbNewInstanceExpression(resultType, validElements); } /// /// Creates a new /// The instance from which to retrieve the property. May be null if the property is static. /// Metadata for the property to retrieve. ///representing the retrieval of the specified property. /// A new DbPropertyExpression representing the property retrieval. ///[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "required for this feature")] public static DbPropertyExpression Property(this DbExpression instance, EdmProperty propertyMetadata) { return PropertyFromMember(instance, propertyMetadata, "propertyMetadata"); } /// is null or is null and the property is not static. /// Creates a new /// The instance from which to retrieve the navigation property. /// Metadata for the navigation property to retrieve. ///representing the retrieval of the specified navigation property. /// A new DbPropertyExpression representing the navigation property retrieval. ///[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "required for this feature")] public static DbPropertyExpression Property(this DbExpression instance, NavigationProperty navigationProperty) { return PropertyFromMember(instance, navigationProperty, "navigationProperty"); } /// is null or is null. /// Creates a new /// The instance from which to retrieve the relationship end member. /// Metadata for the relationship end member to retrieve. ///representing the retrieval of the specified relationship end member. /// A new DbPropertyExpression representing the relationship end member retrieval. ///[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "required for this feature")] public static DbPropertyExpression Property(this DbExpression instance, RelationshipEndMember relationshipEnd) { return PropertyFromMember(instance, relationshipEnd, "relationshipEnd"); } /// is null or is null and the property is not static. /// Creates a new /// The name of the property to retrieve. /// The instance from which to retrieve the property. ///representing the retrieval of the instance property with the specified name from the given instance. /// A new DbPropertyExpression that represents the property retrieval ////// is null or is null and the property is not static. No property with the specified name is declared by the type of public static DbPropertyExpression Property(this DbExpression instance, string propertyName) { return PropertyByName(instance, propertyName, false); } ///. /// Creates a new /// The name of the property to retrieve. /// The instance from which to retrieve the property. ///representing the retrieval of the instance property with the specified name from the given instance. /// A case-insensitive lookup for a property with the specified name is performed on the result type of . /// A new DbPropertyExpression that represents the property retrieval ////// is null or is null and the property is not static. No property with the specified name is declared by the type of public static DbPropertyExpression PropertyIgnoreCase(this DbExpression instance, string propertyName) { return PropertyByName(instance, propertyName, true); } private static DbPropertyExpression PropertyFromMember(DbExpression instance, EdmMember property, string propertyArgumentName) { TypeUsage resultType = ArgumentValidation.ValidateProperty(instance, property, propertyArgumentName); return new DbPropertyExpression(resultType, property, instance); } private static DbPropertyExpression PropertyByName(DbExpression instance, string propertyName, bool ignoreCase) { EdmMember property; TypeUsage resultType = ArgumentValidation.ValidateProperty(instance, propertyName, ignoreCase, out property); return new DbPropertyExpression(resultType, property, instance); } #endregion #region Lambda-based methods: All, Any, Cross|OuterApply, Cross|FullOuter|Inner|LeftOuterJoin, Filter, GroupBy, Project, Skip, Sort private static string ExtractAlias(MethodInfo method) { Debug.Assert(method != null, "Ensure method is non-null before calling ExtractAlias"); string[] aliases = ExtractAliases(method); Debug.Assert(aliases.Length > 0, "Incompatible method: at least one parameter is required"); return aliases[0]; } internal static string[] ExtractAliases(MethodInfo method) { Debug.Assert(method != null, "Ensure method is non-null before calling ExtractAlias"); ParameterInfo[] methodParams = method.GetParameters(); int start; int paramCount; if (method.IsStatic && typeof(System.Runtime.CompilerServices.Closure) == methodParams[0].ParameterType) { // Static lambda method has additional first closure parameter start = 1; paramCount = methodParams.Length - 1; } else { // Otherwise, method parameters align directly with arguments start = 0; paramCount = methodParams.Length; } string[] paramNames = new string[paramCount]; bool generateNames = methodParams.Skip(start).Any(p => p.Name == null); for (int idx = start; idx < methodParams.Length; idx++) { paramNames[idx - start] = (generateNames ? _bindingAliases.Next() : methodParams[idx].Name); } return paramNames; } private static DbExpressionBinding ConvertToBinding. (DbExpression source, Func argument, string argumentName, out TResult argumentResult) { return ConvertToBinding(source, "source", argument, argumentName, out argumentResult); } private static DbExpressionBinding ConvertToBinding (DbExpression source, string sourceName, Func argument, string argumentName, out TResult argumentResult) { EntityUtil.CheckArgumentNull(source, sourceName); EntityUtil.CheckArgumentNull(argument, argumentName); string alias = ExtractAlias(argument.Method); DbExpressionBinding binding = DbExpressionBuilder.BindAs(source, alias); argumentResult = argument(binding.Variable); return binding; } private static DbExpressionBinding[] ConvertToBinding(DbExpression left, string leftArgumentName, DbExpression right, string rightArgumentName, Func argument, string argumentName, out DbExpression argumentExp) { EntityUtil.CheckArgumentNull(left, leftArgumentName); EntityUtil.CheckArgumentNull(right, rightArgumentName); EntityUtil.CheckArgumentNull(argument, argumentName); string[] aliases = ExtractAliases(argument.Method); DbExpressionBinding leftBinding = DbExpressionBuilder.BindAs(left, aliases[0]); DbExpressionBinding rightBinding = DbExpressionBuilder.BindAs(right, aliases[1]); argumentExp = argument(leftBinding.Variable, rightBinding.Variable); return new[] { leftBinding, rightBinding }; } [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] private static bool TryGetAnonymousTypeValues (object instance, out List > values) { Debug.Assert(instance != null, "Ensure instance is non-null before calling TryGetAnonymousTypeValues"); // The following heuristic is used to approximate whether or not TInstance is an anonymous type: // - Derived directly from System.Object // - Declares only public instance properties // - All public instance properties are readable and of an appropriate type values = null; if (typeof(TInstance).BaseType.Equals(typeof(object)) && typeof(TInstance).GetProperties(BindingFlags.Static).Length == 0 && typeof(TInstance).GetProperties(BindingFlags.Instance | BindingFlags.NonPublic).Length == 0) { List > foundValues = null; foreach (PropertyInfo pi in typeof(TInstance).GetProperties(BindingFlags.Public | BindingFlags.Instance)) { if (pi.CanRead && typeof(TRequired).IsAssignableFrom(pi.PropertyType)) { if (foundValues == null) { foundValues = new List >(); } foundValues.Add(new KeyValuePair (pi.Name, (TRequired)pi.GetValue(instance, null))); } else { foundValues = null; break; } } values = foundValues; } return (values != null); } private static bool TryResolveToConstant(Type type, object value, out DbExpression constantOrNullExpression) { constantOrNullExpression = null; Type valueType = type; if (type.IsGenericType && typeof(Nullable<>).Equals(type.GetGenericTypeDefinition())) { valueType = type.GetGenericArguments()[0]; } PrimitiveType primitiveType = null; if (ClrProviderManifest.Instance.TryGetPrimitiveType(valueType, out primitiveType)) { TypeUsage resultType = TypeHelpers.GetLiteralTypeUsage(primitiveType.PrimitiveTypeKind); if (null == value) { constantOrNullExpression = DbExpressionBuilder.Null(resultType); } else { constantOrNullExpression = DbExpressionBuilder.Constant(resultType, value); } } return (constantOrNullExpression != null); } private static DbExpression ResolveToExpression (TArgument argument) { object untypedArgument = argument; DbExpression constantResult; if (TryResolveToConstant(typeof(TArgument), untypedArgument, out constantResult)) { return constantResult; } if (null == untypedArgument) { return (DbExpression)null; } // Direct DbExpression result if (typeof(DbExpression).IsAssignableFrom(typeof(TArgument))) { return (DbExpression)untypedArgument; } // Row if (typeof(Row).Equals(typeof(TArgument))) { return ((Row)untypedArgument).ToExpression(); } // Conversion from anonymous type instance to DbNewInstanceExpression of a corresponding row type List > columnValues; if (TryGetAnonymousTypeValues (untypedArgument, out columnValues)) { return DbExpressionBuilder.NewRow(columnValues); } // The specified instance cannot be resolved to a DbExpression throw EntityUtil.NotSupported(Entity.Strings.Cqt_Factory_MethodResultTypeNotSupported(typeof(TArgument).FullName)); } private static DbApplyExpression CreateApply(DbExpression source, Func > apply, Func resultBuilder) { KeyValuePair applyTemplate; DbExpressionBinding sourceBinding = ConvertToBinding(source, apply, "apply", out applyTemplate); DbExpressionBinding applyBinding = DbExpressionBuilder.BindAs(applyTemplate.Value, applyTemplate.Key); return resultBuilder(sourceBinding, applyBinding); } /// /// Creates a new /// /// An expression that specifies the input set. /// /// /// A method representing a predicate to evaluate for each member of the input set. /// This method must produce an expression with a Boolean result type that provides /// the predicate logic. /// ///that determines whether the given predicate holds for all elements of the input set. /// A new DbQuantifierExpression that represents the All operation. ////// or is null The expression produced by ///is null /// does not have a collection result type. /// The expression produced by public static DbQuantifierExpression All(this DbExpression source, Funcdoes not have a Boolean result type. /// predicate) { DbExpression predicateExp; DbExpressionBinding input = ConvertToBinding(source, predicate, "predicate", out predicateExp); return DbExpressionBuilder.All(input, predicateExp); } /// /// Creates a new /// An expression that specifies the input set ///that determines whether the specified set argument is non-empty. /// A new ///applied to a new with the specified argument. /// is null public static DbExpression Any(this DbExpression source) { return DbExpressionBuilder.Exists(source); } /// does not have a collection result type. /// Creates a new /// An expression that specifies the input set ///that determines whether the specified set argument is non-empty. /// A new ///applied to a new with the specified argument. /// is null public static DbExpression Exists(this DbExpression argument) { return DbExpressionBuilder.Not(DbExpressionBuilder.IsEmpty(argument)); } /// does not have a collection result type. /// Creates a new /// /// An expression that specifies the input set. /// /// /// A method representing the predicate to evaluate for each member of the input set. /// This method must produce an expression with a Boolean result type that provides /// the predicate logic. /// ///that determines whether the given predicate holds for any element of the input set. /// A new DbQuantifierExpression that represents the Any operation. ////// or is null The expression produced by ///is null /// does not have a collection result type. /// The expression produced by public static DbQuantifierExpression Any(this DbExpression source, Funcdoes not have a Boolean result type. /// predicate) { DbExpression predicateExp; DbExpressionBinding input = ConvertToBinding(source, predicate, "predicate", out predicateExp); return DbExpressionBuilder.Any(input, predicateExp); } /// /// Creates a new /// /// Athat evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set are not included. /// that specifies the input set. /// /// /// A method that specifies the logic to evaluate once for each member of the input set. /// /// An new DbApplyExpression with the specified input and apply bindings and an ///of CrossApply. /// or is null /// does not have a collection result type. The result of ///contains a name or expression that is null. The result of public static DbApplyExpression CrossApply(this DbExpression source, Funccontains a name or expression that is not valid in an expression binding. > apply) { return CreateApply(source, apply, DbExpressionBuilder.CrossApply); } // /// /// Creates a new /// /// Athat evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set have an apply column value of null
. ///that specifies the input set. /// /// /// A method that specifies the logic to evaluate once for each member of the input set. /// /// An new DbApplyExpression with the specified input and apply bindings and an ///of OuterApply. /// or is null /// does not have a collection result type. The result of ///contains a name or expression that is null. The result of public static DbApplyExpression OuterApply(this DbExpression source, Funccontains a name or expression that is not valid in an expression binding. > apply) { return CreateApply(source, apply, DbExpressionBuilder.OuterApply); } // // /// /// Creates a new /// Athat joins the sets specified by the left and right expressions, /// on the specified join condition, using FullOuterJoin as the . /// that specifies the left set argument. /// A that specifies the right set argument. /// /// A method representing the condition on which to join. /// This method must produce an expression with a Boolean result type that provides the /// logic of the join condition. /// /// /// A new DbJoinExpression, with an ///of FullOuterJoin, that represents the full outer join operation /// applied to the left and right input sets under the given join condition. /// /// ///, or is null. /// /// ///or does not have a collection result type. /// /// The expression produced by ///is null. /// /// The expression produced by public static DbJoinExpression FullOuterJoin(this DbExpression left, DbExpression right, Funcdoes not have a Boolean result type. /// joinCondition) { DbExpression condExp; DbExpressionBinding[] inputs = ConvertToBinding(left, "left", right, "right", joinCondition, "joinCondition", out condExp); return DbExpressionBuilder.FullOuterJoin(inputs[0], inputs[1], condExp); } /// /// Creates a new /// Athat joins the sets specified by the left and right expressions, /// on the specified join condition, using InnerJoin as the . /// that specifies the left set argument. /// A that specifies the right set argument. /// /// A method representing the condition on which to join. /// This method must produce an expression with a Boolean result type that provides the /// logic of the join condition. /// /// /// A new DbJoinExpression, with an ///of InnerJoin, that represents the inner join operation /// applied to the left and right input sets under the given join condition. /// /// ///, or is null. /// /// ///or does not have a collection result type. /// /// The expression produced by ///is null. /// /// The expression produced by public static DbJoinExpression InnerJoin(this DbExpression left, DbExpression right, Funcdoes not have a Boolean result type. /// joinCondition) { DbExpression condExp; DbExpressionBinding[] inputs = ConvertToBinding(left, "left", right, "right", joinCondition, "joinCondition", out condExp); return DbExpressionBuilder.InnerJoin(inputs[0], inputs[1], condExp); } /// /// Creates a new /// Athat joins the sets specified by the left and right expressions, /// on the specified join condition, using LeftOuterJoin as the . /// that specifies the left set argument. /// A that specifies the right set argument. /// /// A method representing the condition on which to join. /// This method must produce an expression with a Boolean result type that provides the /// logic of the join condition. /// /// /// A new DbJoinExpression, with an ///of LeftOuterJoin, that represents the left outer join operation /// applied to the left and right input sets under the given join condition. /// /// ///, or is null. /// /// ///or does not have a collection result type. /// /// The expression produced by ///is null. /// /// The expression produced by public static DbJoinExpression LeftOuterJoin(this DbExpression left, DbExpression right, Funcdoes not have a Boolean result type. /// joinCondition) { DbExpression condExp; DbExpressionBinding[] inputs = ConvertToBinding(left, "left", right, "right", joinCondition, "joinCondition", out condExp); return DbExpressionBuilder.LeftOuterJoin(inputs[0], inputs[1], condExp); } /// /// Creates a new /// Athat joins the sets specified by the outer and inner expressions, /// on an equality condition between the specified outer and inner keys, using InnerJoin as the . /// that specifies the outer set argument. /// A that specifies the inner set argument. /// A method that specifies how the outer key value should be derived from an element of the outer set. /// A method that specifies how the inner key value should be derived from an element of the inner set. /// /// A new DbJoinExpression, with an ///of InnerJoin, that represents the inner join operation /// applied to the left and right input sets under a join condition that compares the outer and inner key values for equality. /// /// ///, , or is null. /// /// ///or does not have a collection result type. /// /// The expression produced by ///or is null. /// /// The expressions produced by public static DbJoinExpression Join(this DbExpression outer, DbExpression inner, Funcand are not comparable for equality. /// outerKey, Func innerKey) { DbExpression leftOperand; DbExpressionBinding leftBinding = ConvertToBinding(outer, "outer", outerKey, "outerKey", out leftOperand); DbExpression rightOperand; DbExpressionBinding rightBinding = ConvertToBinding(inner, "inner", innerKey, "innerKey", out rightOperand); DbExpression joinCondition = DbExpressionBuilder.Equal(leftOperand, rightOperand); return DbExpressionBuilder.InnerJoin(leftBinding, rightBinding, joinCondition); } /// /// Creates a new /// Athat projects the specified selector over the sets specified by the outer and inner /// expressions, joined on an equality condition between the specified outer and inner keys, using InnerJoin as the . /// that specifies the outer set argument. /// A that specifies the inner set argument. /// A method that specifies how the outer key value should be derived from an element of the outer set. /// A method that specifies how the inner key value should be derived from an element of the inner set. /// /// A method that specifies how an element of the result set should be derived from elements of the inner and outer sets. /// This method must produce an instance of a type that is compatible with Join and can be resolved /// into a . /// Compatibility requirements for are described in remarks. /// /// /// A new DbProjectExpression with the specified selector as its projection, and a new DbJoinExpression as its input. /// The input DbJoinExpression is created with an ///of InnerJoin, that represents the inner join operation /// applied to the left and right input sets under a join condition that compares the outer and inner key values for equality. /// /// ///, , , or is null. /// /// ///or does not have a collection result type. /// /// The expression produced by ///or is null. /// /// The result of ///is null after conversion to DbExpression. /// /// The expressions produced by ///and are not comparable for equality. /// /// The result of ///is not compatible with SelectMany. /// /// To be compatible with Join, public static DbProjectExpression Joinmust be derived from , /// or must be an anonymous type with DbExpression-derived properties. /// /// The following are examples of supported types for ///: /// outer.Join(inner, o => o.Property("ID"), i => i.Property("ID"), (o, i) => o.Property("Name"))
(is ). /// outer.Join(inner, o => o.Property("ID"), i => i.Property("ID"), (o, i) => new { OName = o.Property("Name"), IName = i.Property("Name") })
(is an anonymous type with DbExpression-derived properties). /// (this DbExpression outer, DbExpression inner, Func outerKey, Func innerKey, Func selector) { // Defer argument validation for all but the selector to the selector-less overload of Join DbJoinExpression joinExpression = DbExpressionBuilder.Join(outer, inner, outerKey, innerKey); // Ensure that the selector is non-null; EntityUtil.CheckArgumentNull(selector, "selector"); // Bind the join expression and produce the selector based on the left and right inputs DbExpressionBinding joinBinding = DbExpressionBuilder.Bind(joinExpression); DbExpression left = DbExpressionBuilder.Property(joinBinding.Variable, joinExpression.Left.VariableName); DbExpression right = DbExpressionBuilder.Property(joinBinding.Variable, joinExpression.Right.VariableName); TSelector intermediateSelector = selector(left, right); DbExpression projection = DbExpressionBuilder.ResolveToExpression(intermediateSelector); // Project the selector over the join expression and return the resulting DbProjectExpression return DbExpressionBuilder.Project(joinBinding, projection); } /// /// Creates a new /// An expression that specifies the input set. /// /// A method that specifies how to derive the sort key expression given a member of the input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// ///that sorts the given input set by the specified sort key, /// with ascending sort order and default collation. /// A new DbSortExpression that represents the order-by operation. ////// or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by public static DbSortExpression OrderBy(this DbExpression source, Funcdoes not have an order-comparable result type. /// sortKey) { DbExpression keyExpression; DbExpressionBinding input = ConvertToBinding(source, sortKey, "sortKey", out keyExpression); DbSortClause sortClause = DbExpressionBuilder.ToSortClause(keyExpression); return DbExpressionBuilder.Sort(input, new DbSortClause[] { sortClause }); } /// /// Creates a new /// An expression that specifies the input set. /// /// A method that specifies how to derive the sort key expression given a member of the input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// /// The collation to sort under ///that sorts the given input set by the specified sort key, /// with ascending sort order and the specified collation. /// A new DbSortExpression that represents the order-by operation. ////// , or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by ///does not have an order-comparable string result type. /// public static DbSortExpression OrderBy(this DbExpression source, Func is empty or contains only space characters sortKey, string collation) { DbExpression keyExpression; DbExpressionBinding input = ConvertToBinding(source, sortKey, "sortKey", out keyExpression); DbSortClause sortClause = DbExpressionBuilder.ToSortClause(keyExpression, collation); return DbExpressionBuilder.Sort(input, new DbSortClause[] { sortClause }); } /// /// Creates a new /// An expression that specifies the input set. /// /// A method that specifies how to derive the sort key expression given a member of the input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// ///that sorts the given input set by the specified sort key, /// with descending sort order and default collation. /// A new DbSortExpression that represents the order-by operation. ////// or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by public static DbSortExpression OrderByDescending(this DbExpression source, Funcdoes not have an order-comparable result type. /// sortKey) { DbExpression keyExpression; DbExpressionBinding input = ConvertToBinding(source, sortKey, "sortKey", out keyExpression); DbSortClause sortClause = DbExpressionBuilder.ToSortClauseDescending(keyExpression); return DbExpressionBuilder.Sort(input, new DbSortClause[] { sortClause }); } /// /// Creates a new /// An expression that specifies the input set. /// /// A method that specifies how to derive the sort key expression given a member of the input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// /// The collation to sort under ///that sorts the given input set by the specified sort key, /// with descending sort order and the specified collation. /// A new DbSortExpression that represents the order-by operation. ////// , or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by ///does not have an order-comparable string result type. /// public static DbSortExpression OrderByDescending(this DbExpression source, Func is empty or contains only space characters sortKey, string collation) { DbExpression keyExpression; DbExpressionBinding input = ConvertToBinding(source, sortKey, "sortKey", out keyExpression); DbSortClause sortClause = DbExpressionBuilder.ToSortClauseDescending(keyExpression, collation); return DbExpressionBuilder.Sort(input, new DbSortClause[] { sortClause }); } /// /// Creates a new /// An expression that specifies the input set. /// /// A method that specifies how to derive the projected expression given a member of the input set. /// This method must produce an instance of a type that is compatible with Select and can be resolved /// into athat selects the specified expression over the given input set. /// . /// Compatibility requirements for are described in remarks. /// /// The method result type of ///. A new DbProjectExpression that represents the select operation. ////// or is null The result of ///is null. /// To be compatible with Select, public static DbProjectExpression Selectmust be derived from , /// or must be an anonymous type with DbExpression-derived properties. /// /// The following are examples of supported types for ///: /// source.Select(x => x.Property("Name"))
(is ). /// source.Select(x => new { Name = x.Property("Name") })
(is an anonymous type with a DbExpression-derived property). /// (this DbExpression source, Func projection) { EntityUtil.CheckArgumentNull(projection, "projection"); TProjection intermediateProjection; DbExpressionBinding input = ConvertToBinding(source, projection, "projection", out intermediateProjection); DbExpression projectionExp = ResolveToExpression(intermediateProjection); return DbExpressionBuilder.Project(input, projectionExp); } /// /// Creates a new /// /// Athat evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set are not included. /// A is then created that selects the column from each row, producing the overall collection of results. /// that specifies the input set. /// /// /// A method that represents the logic to evaluate once for each member of the input set. /// /// An new DbProjectExpression that selects the apply column from a new DbApplyExpression with the specified input and apply bindings and an ///of CrossApply. /// or is null. The expression produced by ///is null. /// does not have a collection result type. The expression produced by public static DbProjectExpression SelectMany(this DbExpression source, Funcdoes not have a collection type. apply) { DbExpression functorResult; DbExpressionBinding inputBinding = ConvertToBinding(source, apply, "apply", out functorResult); DbExpressionBinding functorBinding = DbExpressionBuilder.Bind(functorResult); DbApplyExpression intermediateApply = DbExpressionBuilder.CrossApply(inputBinding, functorBinding); DbExpressionBinding projectionBinding = DbExpressionBuilder.Bind(intermediateApply); return DbExpressionBuilder.Project(projectionBinding, DbExpressionBuilder.Property(projectionBinding.Variable, functorBinding.VariableName)); } /// /// Creates a new ///that evaluates the given expression once for each element of a given input set, /// producing a collection of rows with corresponding input and apply columns. Rows for which evaluates to an empty set are not included. /// A is then created that selects the specified over each row, producing the overall collection of results. /// The method result type of /// /// A. that specifies the input set. /// /// /// A method that represents the logic to evaluate once for each member of the input set. /// /// /// A method that specifies how an element of the result set should be derived given an element of the input and apply sets. /// This method must produce an instance of a type that is compatible with SelectMany and can be resolved into a . /// Compatibility requirements for are described in remarks. /// /// An new DbProjectExpression that selects the result of the given selector from a new DbApplyExpression with the specified input and apply bindings and an ///of CrossApply. /// , or is null. The expression produced by ///is null. The result of ///is null on conversion to DbExpression /// does not have a collection result type. The expression produced by ///does not have a collection type. /// To be compatible with SelectMany, public static DbProjectExpression SelectManymust be derived from , /// or must be an anonymous type with DbExpression-derived properties. /// /// The following are examples of supported types for ///: /// source.SelectMany(x => x.Property("RelatedCollection"), (source, apply) => apply.Property("Name"))
(is ). /// source.SelectMany(x => x.Property("RelatedCollection"), (source, apply) => new { SourceName = source.Property("Name"), RelatedName = apply.Property("Name") })
(is an anonymous type with DbExpression-derived properties). /// (this DbExpression source, Func apply, Func selector) { DbExpression functorResult; DbExpressionBinding inputBinding = ConvertToBinding(source, apply, "apply", out functorResult); EntityUtil.CheckArgumentNull(selector, "selector"); DbExpressionBinding functorBinding = DbExpressionBuilder.Bind(functorResult); DbApplyExpression intermediateApply = DbExpressionBuilder.CrossApply(inputBinding, functorBinding); DbExpressionBinding projectionBinding = DbExpressionBuilder.Bind(intermediateApply); DbExpression left = DbExpressionBuilder.Property(projectionBinding.Variable, inputBinding.VariableName); DbExpression right = DbExpressionBuilder.Property(projectionBinding.Variable, functorBinding.VariableName); TSelector selectorResult = selector(left, right); DbExpression projection = ResolveToExpression(selectorResult); return DbExpressionBuilder.Project(projectionBinding, projection); } /// /// Creates a new /// Athat skips the specified number of elements from the given sorted input set. /// that specifies the sorted input set. /// An expression the specifies how many elements of the ordered set to skip. /// A new DbSkipExpression that represents the skip operation. ////// ///or is null. /// /// public static DbSkipExpression Skip(this DbSortExpression argument, DbExpression count) { EntityUtil.CheckArgumentNull(argument, "argument"); return DbExpressionBuilder.Skip(argument.Input, argument.SortOrder, count); } ///is not or or has a /// result type that is not equal or promotable to a 64-bit integer type. /// /// Creates a new /// An expression that specifies the input collection. /// An expression that specifies the limit value. ///that restricts the number of elements in the Argument collection to the specified count Limit value. /// Tied results are not included in the output. /// A new DbLimitExpression with the specified argument and count limit values that does not include tied results. ////// or is null /// public static DbLimitExpression Take(this DbExpression argument, DbExpression count) { return DbExpressionBuilder.Limit(argument, count); } private static DbSortExpression CreateThenBy(DbSortExpression source, Funcdoes not have a collection result type, /// or does not have a result type that is equal or promotable to a 64-bit integer type. /// sortKey, bool ascending, string collation, bool useCollation) { EntityUtil.CheckArgumentNull(source, "source"); EntityUtil.CheckArgumentNull(sortKey, "sortKey"); DbExpression sortKeyResult = sortKey(source.Input.Variable); DbSortClause sortClause; if (useCollation) { sortClause = (ascending ? DbExpressionBuilder.ToSortClause(sortKeyResult, collation) : DbExpressionBuilder.ToSortClauseDescending(sortKeyResult, collation)); } else { sortClause = (ascending ? DbExpressionBuilder.ToSortClause(sortKeyResult) : DbExpressionBuilder.ToSortClauseDescending(sortKeyResult)); } List newSortOrder = new List (source.SortOrder.Count + 1); newSortOrder.AddRange(source.SortOrder); newSortOrder.Add(sortClause); return DbExpressionBuilder.Sort(source.Input, newSortOrder); } /// /// Creates a new /// A DbSortExpression that specifies the ordered input set. /// /// A method that specifies how to derive the additional sort key expression given a member of the /// input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// ///that with a sort order that includes the sort order /// of the given order input set together with the specified sort key in ascending sort order and /// with default collation. /// A new DbSortExpression that represents the new overall order-by operation. ////// or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by public static DbSortExpression ThenBy(this DbSortExpression source, Funcdoes not have an order-comparable result type. /// sortKey) { return CreateThenBy(source, sortKey, true, null, false); } /// /// Creates a new /// A DbSortExpression that specifies the ordered input set. /// /// A method that specifies how to derive the additional sort key expression given a member of the /// input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// /// The collation to sort under ///that with a sort order that includes the sort order /// of the given order input set together with the specified sort key in ascending sort order and /// with the specified collation. /// A new DbSortExpression that represents the new overall order-by operation. ////// , or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by ///does not have an order-comparable string result type. /// public static DbSortExpression ThenBy(this DbSortExpression source, Func is empty or contains only space characters sortKey, string collation) { return CreateThenBy(source, sortKey, true, collation, true); } /// /// Creates a new /// A DbSortExpression that specifies the ordered input set. /// /// A method that specifies how to derive the additional sort key expression given a member of the /// input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// ///that with a sort order that includes the sort order /// of the given order input set together with the specified sort key in descending sort order and /// with default collation. /// A new DbSortExpression that represents the new overall order-by operation. ////// or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by public static DbSortExpression ThenByDescending(this DbSortExpression source, Funcdoes not have an order-comparable result type. /// sortKey) { return CreateThenBy(source, sortKey, false, null, false); } /// /// Creates a new /// A DbSortExpression that specifies the ordered input set. /// /// A method that specifies how to derive the additional sort key expression given a member of the /// input set. /// This method must produce an expression with an order-comparable result type that provides the /// sort key definition. /// /// The collation to sort under ///that with a sort order that includes the sort order /// of the given order input set together with the specified sort key in descending sort order and /// with the specified collation. /// A new DbSortExpression that represents the new overall order-by operation. ////// , or is null. The expression produced by ///is null. /// does not have a collection result type. /// The expression produced by ///does not have an order-comparable string result type. /// public static DbSortExpression ThenByDescending(this DbSortExpression source, Func is empty or contains only space characters sortKey, string collation) { return CreateThenBy(source, sortKey, false, collation, true); } /// /// Creates a new /// /// An expression that specifies the input set. /// /// /// A method representing the predicate to evaluate for each member of the input set. /// This method must produce an expression with a Boolean result type that provides /// the predicate logic. /// ///that filters the elements in the given input set using the specified predicate. /// A new DbQuantifierExpression that represents the Any operation. ////// or is null The expression produced by ///is null /// The expression produced by public static DbFilterExpression Where(this DbExpression source, Funcdoes not have a Boolean result type. /// predicate) { DbExpression predicateExp; DbExpressionBinding input = ConvertToBinding(source, predicate, "predicate", out predicateExp); return DbExpressionBuilder.Filter(input, predicateExp); } /// /// Creates a new /// An expression that defines the left set argument. /// An expression that defines the right set argument. ///that computes the union of the left and right set arguments with duplicates removed. /// A new DbExpression that computes the union, without duplicates, of the the left and right arguments. ////// or is null No common collection result type with an equality-comparable element type exists between public static DbExpression Union(this DbExpression left, DbExpression right) { return DbExpressionBuilder.Distinct(DbExpressionBuilder.UnionAll(left, right)); } #endregion #region Internal Helper API - ideally these methods should be removed internal static DbNullExpression CreatePrimitiveNullExpression(PrimitiveTypeKind primitiveType) { switch(primitiveType) { case PrimitiveTypeKind.Binary: return _binaryNull; case PrimitiveTypeKind.Boolean: return _boolNull; case PrimitiveTypeKind.Byte: return _byteNull; case PrimitiveTypeKind.DateTime: return _dateTimeNull; case PrimitiveTypeKind.DateTimeOffset: return _dateTimeOffsetNull; case PrimitiveTypeKind.Decimal: return _decimalNull; case PrimitiveTypeKind.Double: return _doubleNull; case PrimitiveTypeKind.Guid: return _guidNull; case PrimitiveTypeKind.Int16: return _int16Null; case PrimitiveTypeKind.Int32: return _int32Null; case PrimitiveTypeKind.Int64: return _int64Null; case PrimitiveTypeKind.SByte: return _sbyteNull; case PrimitiveTypeKind.Single: return _singleNull; case PrimitiveTypeKind.String: return _stringNull; case PrimitiveTypeKind.Time: return _timeNull; default: throw EntityUtil.InvalidEnumerationValue(typeof(PrimitiveTypeKind), (int)primitiveType); } } internal static DbApplyExpression CreateApplyExpressionByKind(DbExpressionKind applyKind, DbExpressionBinding input, DbExpressionBinding apply) { Debug.Assert(DbExpressionKind.CrossApply == applyKind || DbExpressionKind.OuterApply == applyKind, "Invalid ApplyType"); switch (applyKind) { case DbExpressionKind.CrossApply: return CrossApply(input, apply); case DbExpressionKind.OuterApply: return OuterApply(input, apply); default: throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)applyKind); } } internal static DbExpression CreateJoinExpressionByKind(DbExpressionKind joinKind, DbExpression joinCondition, DbExpressionBinding input1, DbExpressionBinding input2) { Debug.Assert(DbExpressionKind.CrossJoin == joinKind || DbExpressionKind.FullOuterJoin == joinKind || DbExpressionKind.InnerJoin == joinKind || DbExpressionKind.LeftOuterJoin == joinKind, "Invalid DbExpressionKind for CreateJoinExpressionByKind"); if (DbExpressionKind.CrossJoin == joinKind) { Debug.Assert(null == joinCondition, "Condition should not be specified for CrossJoin"); return CrossJoin(new DbExpressionBinding[2] { input1, input2 }); } else { Debug.Assert(joinCondition != null, "Condition must be specified for non-CrossJoin"); switch (joinKind) { case DbExpressionKind.InnerJoin: return InnerJoin(input1, input2, joinCondition); case DbExpressionKind.LeftOuterJoin: return LeftOuterJoin(input1, input2, joinCondition); case DbExpressionKind.FullOuterJoin: return FullOuterJoin(input1, input2, joinCondition); default: throw EntityUtil.InvalidEnumerationValue(typeof(DbExpressionKind), (int)joinKind); } } } ///and . /// Used only by span rewriter, when a row could be specified as an argument /// internal static DbIsNullExpression CreateIsNullExpressionAllowingRowTypeArgument(DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateIsNull(argument, true); return new DbIsNullExpression(resultType, argument, true); } ////// Creates a new /// An expression that specifies the input set. ///that converts a single-member set with a single property /// into a singleton. The result type of the created equals the result type /// of the single property of the element of the argument. /// /// This method should only be used when the argument is of a collection type with /// element of structured type with only one property. /// A DbElementExpression that represents the conversion of the single-member set argument to a singleton. ////// is null /// internal static DbElementExpression CreateElementExpressionUnwrapSingleProperty(DbExpression argument) { TypeUsage resultType = ArgumentValidation.ValidateElement(argument); // Change the result type of the element expression to the type of the // single property of the element of its operand. IListis associated with a different command tree, /// or does not have a collection result type, or its element type is not a structured type /// with only one property /// properties = TypeHelpers.GetProperties(resultType); if (properties == null || properties.Count != 1) { throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Element_InvalidArgumentForUnwrapSingleProperty, "arg"); } resultType = properties[0].TypeUsage; return new DbElementExpression(resultType, argument, true); } /// /// Creates a new /// The relationship end from which navigation takes place ///The relationship end to which navigation may be satisifed using the target entity ref ///An expression that produces a reference to the target entity (and must therefore have a Ref result type) internal static DbRelatedEntityRef CreateRelatedEntityRef(RelationshipEndMember sourceEnd, RelationshipEndMember targetEnd, DbExpression targetEntity) { return new DbRelatedEntityRef(sourceEnd, targetEnd, targetEntity); } ///that describes how to satisfy the relationship /// navigation operation from to , which /// must be declared by the same relationship type. /// DbRelatedEntityRefs are used in conjuction with /// to construct Entity instances that are capable of resolving relationship navigation operations based on /// the provided DbRelatedEntityRefs without the need for additional navigation operations. /// Note also that this factory method is not intended to be part of the public Command Tree API /// since its intent is to support Entity constructors in view definitions that express information about /// related Entities using the 'WITH RELATIONSHIPS' clause in eSQL. /// /// Creates a new /// The type of the Entity instance that is being constructed /// Values for each (non-relationship) property of the Entity /// A (possibly empty) list ofthat constructs an instance of an Entity type /// together with the specified information about Entities related to the newly constructed Entity by' /// relationship navigations where the target end has multiplicity of at most one. /// Note that this factory method is not intended to be part of the public Command Tree API since it /// its intent is to support Entity constructors in view definitions that express information about /// related Entities using the 'WITH RELATIONSHIPS' clause in eSQL. /// s that describe Entities that are related to the constructed Entity by various relationship types. /// A new DbNewInstanceExpression that represents the construction of the Entity, and includes the specified related Entity information in the see internal static DbNewInstanceExpression CreateNewEntityWithRelationshipsExpression(EntityType entityType, IListcollection. attributeValues, IList relationships) { DbExpressionList validAttributes; System.Collections.ObjectModel.ReadOnlyCollection validRelatedRefs; TypeUsage resultType = ArgumentValidation.ValidateNewEntityWithRelationships(entityType, attributeValues, relationships, out validAttributes, out validRelatedRefs); return new DbNewInstanceExpression(resultType, validAttributes, validRelatedRefs); } #if ENABLE_NESTAGGREGATE /// /// Creates a new /// The argument over which to perform the nest operation ///over the specified argument /// A new nest aggregate with a reference to the given argument. ////// is null /*CQT_PUBLIC_API(*/internal/*)*/ NestAggregate CreateNestAggregate(Expression argument) { return new NestAggregate(this, argument); } #endif #if METHOD_EXPRESSION /// is associated with a different command tree /// Creates a new /// The metadata for the method to invoke. /// The invocation target. /// The arguments to the method. ///representing the invocation of the specified method on the given instance with the given arguments. /// A new MethodExpression that represents the method invocation. ////// ///or is null, /// or is null or contains null /// /// /*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateInstanceMethodExpression(MethodMetadata methodInfo, Expression instance, IListis not associated with this command tree's metadata workspace, /// is associated with a different command tree /// or has a result type that is not equal or promotable to the declaring type of the method, /// or contains an incorrect number of expressions, /// an expression with a result type that is not equal or promotable to the type of the corresponding /// method parameter, or an expression that is associated with a different command tree. /// args) { if (methodInfo != null && methodInfo.IsStatic) { throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_InstanceMethodRequired, "methodInfo"); } return new MethodExpression(this, methodInfo, args, instance); } /// /// Creates a new /// The metadata for the method to invoke. /// The arguments to the method. ///representing the invocation of the specified method with the given arguments. /// A new MethodExpression that represents the method invocation. ////// is null, or is null or contains null /// /*CQT_PUBLIC_API(*/internal/*)*/ MethodExpression CreateStaticMethodExpression(MethodMetadata methodInfo, IListis not associated with this command tree's metadata workspace, /// or contains an incorrect number of expressions, /// an expression with a result type that is not equal or promotable to the type of the corresponding /// method parameter, or an expression that is associated with a different command tree. /// args) { if (methodInfo != null && !methodInfo.IsStatic) { throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_Factory_StaticMethodRequired, "methodInfo"); } return new MethodExpression(this, methodInfo, args, null); } #endif #endregion } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SystemParameters.cs
- DefinitionUpdate.cs
- GridSplitter.cs
- BasicHttpSecurityElement.cs
- ComplexPropertyEntry.cs
- RegexMatch.cs
- SortDescriptionCollection.cs
- SqlTriggerContext.cs
- SafeBitVector32.cs
- DefaultEventAttribute.cs
- AccessControlEntry.cs
- DrawingContextWalker.cs
- CompilerScope.Storage.cs
- OdbcUtils.cs
- MouseWheelEventArgs.cs
- OleServicesContext.cs
- AtomMaterializer.cs
- TypographyProperties.cs
- AssemblyBuilderData.cs
- HandlerBase.cs
- Helper.cs
- DataControlFieldHeaderCell.cs
- SQLResource.cs
- AppSettingsExpressionBuilder.cs
- LayoutExceptionEventArgs.cs
- LineBreakRecord.cs
- MatrixStack.cs
- ContextBase.cs
- ColumnCollection.cs
- DefaultExpression.cs
- errorpatternmatcher.cs
- OperationInvokerTrace.cs
- ContentPropertyAttribute.cs
- HybridWebProxyFinder.cs
- PackagePart.cs
- ListControlConvertEventArgs.cs
- SecurityRuntime.cs
- DetailsViewPageEventArgs.cs
- BaseInfoTable.cs
- MsmqProcessProtocolHandler.cs
- CqlWriter.cs
- MethodBuilder.cs
- OverlappedAsyncResult.cs
- ErrorInfoXmlDocument.cs
- EntitySet.cs
- XslException.cs
- PowerStatus.cs
- RepeatInfo.cs
- FontDialog.cs
- ToolStripDropDownMenu.cs
- PageCodeDomTreeGenerator.cs
- StringAnimationBase.cs
- MemberDescriptor.cs
- DropDownButton.cs
- ProfileParameter.cs
- QueryCacheManager.cs
- ParentUndoUnit.cs
- DbModificationCommandTree.cs
- DataView.cs
- LocalizedNameDescriptionPair.cs
- ResourceWriter.cs
- DependencyPropertyConverter.cs
- GridItem.cs
- FrameworkContextData.cs
- CollectionView.cs
- CellIdBoolean.cs
- WindowsListViewGroupHelper.cs
- XsdSchemaFileEditor.cs
- TreeViewImageIndexConverter.cs
- TreeViewEvent.cs
- SqlUtil.cs
- ECDiffieHellmanCngPublicKey.cs
- PauseStoryboard.cs
- FormParameter.cs
- SEHException.cs
- ConfigurationLockCollection.cs
- XMLUtil.cs
- SimpleMailWebEventProvider.cs
- ProcessInputEventArgs.cs
- UrlMappingsSection.cs
- DefaultProfileManager.cs
- ClientClassGenerator.cs
- PropVariant.cs
- CryptoApi.cs
- FragmentQueryProcessor.cs
- CalendarButton.cs
- BufferedGraphicsManager.cs
- CodeArrayCreateExpression.cs
- AnnotationStore.cs
- OracleConnectionString.cs
- ElementInit.cs
- RectangleConverter.cs
- WebPartRestoreVerb.cs
- DefaultAuthorizationContext.cs
- WbmpConverter.cs
- TreeNodeConverter.cs
- AuthenticationException.cs
- XmlSchemaFacet.cs
- PathFigureCollectionValueSerializer.cs
- UnitControl.cs