System.Linq.Dynamic.Core

Defines a dynamic assembly that has the specified name and access rights.

The name of the assembly. The access rights of the assembly. An object that represents the new assembly.

Defines the types of string literal parsing that can be performed.

Represents the default string literal parsing type. Double quotes should be escaped using the default escape character (a \). To check if a Value equals a double quote, use this c# code:


            var expression = "Value == \"\\\"\"";

Represents a string literal parsing type where a double quote should be escaped by an extra double quote ("). To check if a Value equals a double quote, use this c# code:


            var expression = "Value == \"\"\"\"";

The abstract DynamicLinqCustomTypeProvider which is used by the DefaultDynamicLinqCustomTypeProvider and can be used by a custom TypeProvider like in .NET Core.

Additional types which should also be resolved.

Initializes a new instance of the class.

A list of additional types (without the DynamicLinqTypeAttribute annotation) which should also be resolved.

Finds the unique types annotated with DynamicLinqTypeAttribute.

The assemblies to process.

Resolve a type which is annotated with DynamicLinqTypeAttribute or when the type is listed in AdditionalTypes.

The assemblies to inspect. The typename to resolve. A resolved or null when not found.

Resolve a type which is annotated with DynamicLinqTypeAttribute by the simple (short) name. Also when the type is listed in AdditionalTypes.

The assemblies to inspect. The simple typename to resolve. A resolved or null when not found.

Gets the assembly types annotated with in an Exception friendly way.

The assemblies to process. Array of

The default implementation for . Scans the current AppDomain for all types marked with , and adds them as custom Dynamic Link types. This class is used as default for full .NET Framework and .NET Core App 2.x and higher.

Initializes a new instance of the class. Backwards compatibility for issue https://github.com/zzzprojects/System.Linq.Dynamic.Core/issues/830.

Defines whether to cache the CustomTypes (including extension methods) which are found in the Application Domain. Default set to 'true'.

Initializes a new instance of the class.

The parsing configuration. Defines whether to cache the CustomTypes (including extension methods) which are found in the Application Domain. Default set to 'true'.

Initializes a new instance of the class.

The parsing configuration. A list of additional types (without the DynamicLinqTypeAttribute annotation) which should also be resolved. Defines whether to cache the CustomTypes (including extension methods) which are found in the Application Domain. Default set to 'true'.

Indicates to Dynamic Linq to consider the Type as a valid dynamic linq type.

Interface for providing functionality to find custom types for or resolve any type.

Returns a list of custom types that System.Linq.Dynamic.Core will understand.

A list of custom types.

Returns a list of custom extension methods that System.Linq.Dynamic.Core will understand.

A list of custom extension methods that System.Linq.Dynamic.Core will understand.

Resolve any type by fullname which is registered in the current application domain.

The typename to resolve. A resolved or null when not found.

Resolve any type by the simple name which is registered in the current application domain.

The typename to resolve. A resolved or null when not found.

Default implementation.

Provides a base class for dynamic objects. In addition to the methods defined here, the following items are added using reflection: - default constructor - constructor with all the properties as parameters (if not linq-to-entities) - all properties (also with getter and setters) - ToString() method - Equals() method - GetHashCode() method

Gets the dynamic property by name.

The type. Name of the property. T

Gets the dynamic property value by name.

Name of the property. value

Sets the dynamic property value by name.

The type. Name of the property. The value.

Sets the dynamic property value by name.

Name of the property. The value.

Gets or sets the with the specified name.

The . The name. Value from the property.

Determines whether a property with the specified name exists in the collection.

The name of the property to locate. Cannot be null. true if a property with the specified name exists; otherwise, false.

Returns the enumeration of all dynamic member names.

A sequence that contains dynamic member names.

Provides the implementation for operations that get member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as getting a value for a property.

Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement, where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive. The result of the get operation. For example, if the method is called for a property, you can assign the property value to . true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a run-time exception is thrown.)

Provides the implementation for operations that set member values. Classes derived from the class can override this method to specify dynamic behavior for operations such as setting a value for a property.

Provides information about the object that called the dynamic operation. The binder.Name property provides the name of the member to which the value is being assigned. For example, for the statement sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, binder.Name returns "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive. The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where sampleObject is an instance of the class derived from the class, the is "Test". true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)

A factory to create dynamic classes, based on .

Initializes the class.

Create a GenericComparerType based on the GenericType and an instance of a .

The GenericType The instance Type

The CreateType method creates a new data class with a given set of public properties and returns the System.Type object for the newly created class. If a data class with an identical sequence of properties has already been created, the System.Type object for this class is returned. Data classes implement private instance variables and read/write property accessors for the specified properties.Data classes also override the Equals and GetHashCode members to implement by-value equality. Data classes are created in an in-memory assembly in the current application domain. All data classes inherit from and are given automatically generated names that should be considered private (the names will be unique within the application domain but not across multiple invocations of the application). Note that once created, a data class stays in memory for the lifetime of the current application domain. There is currently no way to unload a dynamically created data class. The dynamic expression parser uses the CreateClass methods to generate classes from data object initializers. This feature in turn is often used with the dynamic Select method to create projections.

The DynamicProperties Create a constructor with parameters. Default set to true. Note that for Linq-to-Database objects, this needs to be set to false. Type

Create an instance of a based on a list of .

The dynamic properties including the value you want to set in the generated instance. Create a constructor with parameters. Default set to true. Note that for Linq-to-Database objects, this needs to be set to false. Instance of a .

Determines whether a type is publicly accessible from an external (dynamic) assembly. Non-public types (e.g., compiler-generated anonymous types) cannot be used as generic type arguments in EqualityComparer<T> from a dynamic assembly without causing a at runtime.

Generates the key. Anonymous classes are generics based. The generic classes are distinguished by number of parameters and name of parameters. The specific types of the parameters are the generic arguments.

The dynamic properties. if set to true [create parameter ctor].

Used for unit-testing

Define async extensions on .

Async creates an array of dynamic objects from a .

A to create an array from. A cast to. The (optional). An Array that contains the elements from the input sequence.

Async creates an array of dynamic objects from a .

A to create an array from. The (optional). An array that contains the elements from the input sequence.

Async creates an array of dynamic objects from a .

The generic type. A to create an array from. The (optional). An Array{T} that contains the elements from the input sequence.

Async creates a list of dynamic objects from a .

A to create an array from. A cast to. The (optional). An List that contains the elements from the input sequence.

Async creates a list of dynamic objects from a .

A to create a list from. The (optional). A List that contains the elements from the input sequence.

Async creates a list of dynamic objects from an .

Generic Type A to create a list from. The (optional). A List{T} that contains the elements from the input sequence.

Define extensions on .

Creates an array of dynamic objects from a .

A to create an array from. An array that contains the elements from the input sequence.

Creates an array of dynamic objects from a .

The generic type. A to create an array from. An Array{T} that contains the elements from the input sequence.

Creates an array of dynamic objects from a .

A to create an array from. A cast to. An Array that contains the elements from the input sequence.

Creates a list of dynamic objects from a .

A to create an array from. A List that contains the elements from the input sequence.

Creates a list of dynamic objects from a .

A to create an array from. A cast to. A List that contains the elements from the input sequence.

Creates a list of dynamic objects from a .

Generic Type A to create an array from. A List{T} that contains the elements from the input sequence.

Helper class to convert an expression into an LambdaExpression

Parses an expression into a LambdaExpression.

The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The type of the result. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The type of the result. The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The type of the result. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. A array from ParameterExpressions. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The type of the result. The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. A array from ParameterExpressions. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The `it`-Type. The type of the result. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a Typed Expression.

The `it`-Type. The type of the result. The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The Configuration for the parsing. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The delegate type. The Configuration for the parsing. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The Configuration for the parsing. The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The delegate type. The Configuration for the parsing. The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

The delegate type. The Configuration for the parsing. if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. The main type from the dynamic class expression. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The delegate type. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The Configuration for the parsing. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression. (Also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities.)

The delegate type. The Configuration for the parsing. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Parses an expression into a LambdaExpression.

if set to true then also create a constructor for all the parameters. Note that this doesn't work for Linq-to-Database entities. A array from ParameterExpressions. Type of the result. If not specified, it will be generated dynamically. The expression. An object array that contains zero or more objects which are used as replacement values. The generated

Code is based on SqlLinq by dkackman (https://github.com/dkackman/SqlLinq/blob/210b594e37f14061424397368ed750ce547c21e7/License.md) however it's modified to solve several issues.

DynamicProperty

Initializes a new instance of the class.

The name from the property. The type from the property.

Gets the name from the property.

The name from the property.

Gets the type from the property.

The type from the property.

DynamicPropertyWithValue

Gets the value from the property.

Initializes a new instance of the class.

The name from the property. The value from the property.

Provides a set of static (Shared in Visual Basic) methods for querying data structures that implement . It allows dynamic string based querying. Very handy when, at compile time, you don't know the type of queries that will be generated, or when downstream components only return column names to sort and filter by.

Dynamically runs an aggregate function on the IQueryable.

The IQueryable data source. The name of the function to run. Can be Sum, Average, Min or Max. The name of the property to aggregate over. The value of the aggregate function run over the specified property.

Determines whether all the elements of a sequence satisfy a condition.

A sequence whose elements to test for a condition. A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Determines whether all the elements of a sequence satisfy a condition.

A sequence whose elements to test for a condition. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.

Determines whether a sequence contains any elements.

A sequence to check for being empty.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Any();

true if the source sequence contains any elements; otherwise, false.

Determines whether a sequence contains any elements.

A sequence to check for being empty. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Any("Income > 50");
            var result2 = queryable.Any("Income > @0", 50);
            var result3 = queryable.Select("Roles.Any()");

true if the source sequence contains any elements; otherwise, false.

Determines whether a sequence contains any elements.

A sequence to check for being empty. A cached Lambda Expression. true if the source sequence contains any elements; otherwise, false.

Computes the average of a sequence of numeric values.

A sequence of numeric values to calculate the average of.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Average();
            var result2 = queryable.Select("Roles.Average()");

The average of the values in the sequence.

Computes the average of a sequence of numeric values.

A sequence of numeric values to calculate the average of. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Average("Income");

The average of the values in the sequence.

Computes the average of a sequence of numeric values.

A sequence of numeric values to calculate the average of. A Lambda Expression. The average of the values in the sequence.

Returns the input typed as of dynamic.

The sequence to type as of dynamic. The input typed as of dynamic.

Converts the elements of an to the specified type.

The that contains the elements to be converted. The type to convert the elements of source to. An that contains each element of the source sequence converted to the specified type.

Converts the elements of an to the specified type.

The that contains the elements to be converted. The . The type to convert the elements of source to. An that contains each element of the source sequence converted to the specified type.

Converts the elements of an to the specified type.

The that contains the elements to be converted. The type to convert the elements of source to. An that contains each element of the source sequence converted to the specified type.

Returns the number of elements in a sequence.

The that contains the elements to be counted.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Count();

The number of elements in the input sequence.

Returns the number of elements in a sequence.

The that contains the elements to be counted. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Count("Income > 50");
            var result2 = queryable.Count("Income > @0", 50);
            var result3 = queryable.Select("Roles.Count()");

The number of elements in the specified sequence that satisfies a condition.

Returns the number of elements in a sequence.

The that contains the elements to be counted. A cached Lambda Expression. The number of elements in the specified sequence that satisfies a condition.

Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

The to return a default value for if empty.


            IQueryable queryable = employees.DefaultIfEmpty();

An that contains default if source is empty; otherwise, source.

Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

The to return a default value for if empty. The value to return if the sequence is empty.


            IQueryable queryable = employees.DefaultIfEmpty(new Employee());

An that contains defaultValue if source is empty; otherwise, source.

Returns distinct elements from a sequence by using the default equality comparer to compare values.

The sequence to remove duplicate elements from.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Distinct();
            var result2 = queryable.Select("Roles.Distinct()");

An that contains distinct elements from the source sequence.

Returns the first element of a sequence.

The to return the first element of. The first element in source.

Returns the first element of a sequence that satisfies a specified condition.

The to return the first element of. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. The first element in source that passes the test in predicate.

Returns the first element of a sequence that satisfies a specified condition.

The to return the first element of. A cached Lambda Expression. The first element in source that passes the test in predicate.

Returns the first element of a sequence, or a default value if the sequence contains no elements.

The to return the first element of. default if source is empty; otherwise, the first element in source.

Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.

The to return the first element of. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. default if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

Returns the first element of a sequence that satisfies a specified condition or a default value if no such element is found.

The to return the first element of. A cached Lambda Expression. default if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. A string expression to specify a result value from each group. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A where each element represents a projection over a group and its key.


            var groupResult1 = queryable.GroupBy("NumberPropertyAsKey", "StringProperty");
            var groupResult2 = queryable.GroupBy("new (NumberPropertyAsKey, StringPropertyAsKey)", "new (StringProperty1, StringProperty2)");

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. A string expression to specify a result value from each group. The comparer to use. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A where each element represents a projection over a group and its key.

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. A string expression to specify a result value from each group. A where each element represents a projection over a group and its key.


            var groupResult1 = queryable.GroupBy("NumberPropertyAsKey", "StringProperty");
            var groupResult2 = queryable.GroupBy("new (NumberPropertyAsKey, StringPropertyAsKey)", "new (StringProperty1, StringProperty2)");

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. A string expression to specify a result value from each group. The comparer to use. A where each element represents a projection over a group and its key.

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A where each element represents a projection over a group and its key.


            var groupResult1 = queryable.GroupBy("NumberPropertyAsKey");
            var groupResult2 = queryable.GroupBy("new (NumberPropertyAsKey, StringPropertyAsKey)");

Groups the elements of a sequence according to a specified key string function and creates a result value from each group and its key.

A whose elements to group. The . A string expression to specify the key for each element. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. The comparer to use. A where each element represents a projection over a group and its key.

Groups the elements of a sequence according to multiple specified key string functions and creates a result value from each group (and subgroups) and its key.

A whose elements to group. The . expressions to specify the keys for each element. A of type where each element represents a projection over a group, its key, and its subgroups.

Groups the elements of a sequence according to multiple specified key functions and creates a result value from each group (and subgroups) and its key.

A whose elements to group. Lambda expressions to specify the keys for each element. A of type where each element represents a projection over a group, its key, and its subgroups.

Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.

The first sequence to join. The . The sequence to join to the first sequence. A dynamic function to extract the join key from each element of the first sequence. A dynamic function to extract the join key from each element of the second sequence. A dynamic function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence. An object array that contains zero or more objects to insert into the predicates as parameters. Similar to the way String.Format formats strings. An obtained by performing a grouped join on two sequences.

Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.

The first sequence to join. The . The sequence to join to the first sequence. A dynamic function to extract the join key from each element of the first sequence. A dynamic function to extract the join key from each element of the second sequence. A dynamic function to create a result element from two matching elements. An object array that contains zero or more objects to insert into the predicates as parameters. Similar to the way String.Format formats strings. An obtained by performing an inner join on two sequences.

Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.

The type of the elements of both sequences, and the result. The first sequence to join. The . The sequence to join to the first sequence. A dynamic function to extract the join key from each element of the first sequence. A dynamic function to extract the join key from each element of the second sequence. A dynamic function to create a result element from two matching elements. An object array that contains zero or more objects to insert into the predicates as parameters. Similar to the way String.Format formats strings. This overload only works on elements where both sequences and the resulting element match. An that has elements of type TResult obtained by performing an inner join on two sequences.

Returns the last element of a sequence.

The to return the last element of. The last element in source.

Returns the last element of a sequence that satisfies a specified condition.

The to return the last element of. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. The first element in source that passes the test in predicate.

Returns the last element of a sequence that satisfies a specified condition.

The to return the last element of. A cached Lambda Expression. The first element in source that passes the test in predicate.

Returns the last element of a sequence, or a default value if the sequence contains no elements.

The to return the last element of. default if source is empty; otherwise, the last element in source.

Returns the last element of a sequence that satisfies a specified condition, or a default value if the sequence contains no elements.

The to return the last element of. A cached Lambda Expression. The first element in source that passes the test in predicate.

Returns the number of elements in a sequence.

The that contains the elements to be counted.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.LongCount();

The number of elements in the input sequence.

Returns the number of elements in a sequence.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.LongCount("Income > 50");
            var result2 = queryable.LongCount("Income > @0", 50);
            var result3 = queryable.Select("Roles.LongCount()");

The number of elements in the specified sequence that satisfies a condition.

Returns the number of elements in a sequence.

The that contains the elements to be counted. A cached Lambda Expression. The number of elements in the specified sequence that satisfies a condition.

Computes the max element of a sequence.

A sequence of values to calculate find the max for.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Max();
            var result2 = queryable.Select("Roles.Max()");

The max element in the sequence.

Computes the max element of a sequence.

A sequence of values to calculate find the max for. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Max("Income");

The max element in the sequence.

Computes the max element of a sequence.

A sequence of values to calculate find the max for. A Lambda Expression. The max element in the sequence.

Computes the min element of a sequence.

A sequence of values to calculate find the min for.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Min();
            var result2 = queryable.Select("Roles.Min()");

The min element in the sequence.

Computes the min element of a sequence.

A sequence of values to calculate find the min for. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Min("Income");

The min element in the sequence.

Computes the min element of a sequence.

A sequence of values to calculate find the min for. A Lambda Expression. The min element in the sequence.

Filters the elements of an based on a specified type.

An whose elements to filter. The type to filter the elements of the sequence on. A collection that contains the elements from source that have the type.

Filters the elements of an based on a specified type.

An whose elements to filter. The . The type to filter the elements of the sequence on. A collection that contains the elements from source that have the type.

Filters the elements of an based on a specified type.

An whose elements to filter. The type to filter the elements of the sequence on. A collection that contains the elements from source that have the type.

Sorts the elements of a sequence in ascending or descending order according to a key.

The type of the elements of source. A sequence of values to order. The . An expression string to indicate values to order by. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A whose elements are sorted according to the specified .


            ("NumberProperty");
            var resultSingleDescending = queryable.OrderBy("NumberProperty DESC");
            var resultMultiple = queryable.OrderBy("NumberProperty, StringProperty");
            ]]>

Sorts the elements of a sequence in ascending or descending order according to a key.

The type of the elements of source. A sequence of values to order. The . An expression string to indicate values to order by. The comparer to use. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A whose elements are sorted according to the specified .

Sorts the elements of a sequence in ascending or descending order according to a key.

The type of the elements of source. A sequence of values to order. An expression string to indicate values to order by. The comparer to use. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A whose elements are sorted according to the specified .

Sorts the elements of a sequence in ascending or descending order according to a key.

A sequence of values to order. The . An expression string to indicate values to order by. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A whose elements are sorted according to the specified .


            var resultSingle = queryable.OrderBy("NumberProperty");
            var resultSingleDescending = queryable.OrderBy("NumberProperty DESC");
            var resultMultiple = queryable.OrderBy("NumberProperty, StringProperty DESC");

Sorts the elements of a sequence in ascending or descending order according to a key.

A sequence of values to order. The . An expression string to indicate values to order by. The comparer to use. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A whose elements are sorted according to the specified .

Returns the elements as paged.

The IQueryable to return elements from. The page to return. The number of elements per page. A that contains the paged elements.

Returns the elements as paged.

The type of the source. The IQueryable to return elements from. The page to return. The number of elements per page. A that contains the paged elements.

Returns the elements as paged and include the CurrentPage, PageCount, PageSize and RowCount.

The IQueryable to return elements from. The page to return. The number of elements per page. If this optional parameter has been defined, this value is used as the RowCount instead of executing a Linq `Count()`. PagedResult

Returns the elements as paged and include the CurrentPage, PageCount, PageSize and RowCount.

The type of the source. The IQueryable to return elements from. The page to return. The number of elements per page. If this optional parameter has been defined, this value is used as the RowCount instead of executing a Linq `Count()`. PagedResult{TSource}

Inverts the order of the elements in a sequence.

A sequence of values to reverse. A whose elements correspond to those of the input sequence in reverse order.

Projects each element of a sequence into a new form.

A sequence of values to project. The . A projection string expression to apply to each element. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An whose elements are the result of invoking a projection string on each element of source.


            var singleField = queryable.Select("StringProperty");
            var dynamicObject = queryable.Select("new (StringProperty1, StringProperty2 as OtherStringPropertyName)");

Projects each element of a sequence into a new class of type TResult. Details see .

The type of the result. A sequence of values to project. The . A projection string expression to apply to each element. An object array that contains zero or more objects to insert into the predicate as parameters. An whose elements are the result of invoking a projection string on each element of source.


            ("new (Username, Pwd as Password)");
            ]]>

Projects each element of a sequence into a new class of type TResult. Details see http://solutionizing.net/category/linq/

A sequence of values to project. The . The result type. A projection string expression to apply to each element. An object array that contains zero or more objects to insert into the predicate as parameters. An whose elements are the result of invoking a projection string on each element of source.


            var users = queryable.Select(typeof(User), "new (Username, Pwd as Password)");

Projects each element of a sequence to an and combines the resulting sequences into one sequence.


            var roles = users.SelectMany("Roles");

Projects each element of a sequence to an and combines the resulting sequences into one sequence.

A sequence of values to project. The . A projection string expression to apply to each element. The result type. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.


            var permissions = users.SelectMany(typeof(Permission), "Roles.SelectMany(Permissions)");

Projects each element of a sequence to an and combines the resulting sequences into one sequence.

The type of the result. A sequence of values to project. The . A projection string expression to apply to each element. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An whose elements are the result of invoking a one-to-many projection function on each element of the input sequence.


            ("Roles.SelectMany(Permissions)");
            ]]>

Projects each element of a sequence to an and invokes a result selector function on each element therein. The resulting values from each intermediate sequence are combined into a single, one-dimensional sequence and returned.

A sequence of values to project. The . A projection function to apply to each element of the input sequence. A projection function to apply to each element of each intermediate sequence. Should only use x and y as parameter names. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An whose elements are the result of invoking the one-to-many projection function on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

A sequence of values to project. The . A projection function to apply to each element of the input sequence. The name from collectionParameter to use. Default is x. A projection function to apply to each element of each intermediate sequence. The name from resultParameterName to use. Default is y. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. An whose elements are the result of invoking the one-to-many projection function on each element of source and then mapping each of those sequence elements and their corresponding source element to a result element.

Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

A to return the single element of. The single element of the input sequence.

Returns the only element of a sequence that satisfies a specified condition, and throws an exception if there is not exactly one element in the sequence.

The to return the last element of. A cached Lambda Expression. The first element in source that passes the test in predicate.

Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

A to return the single element of. The single element of the input sequence, or default if the sequence contains no elements.

Returns the only element of a sequence that satisfies a specified condition or a default value if the sequence is empty; and throws an exception if there is not exactly one element in the sequence.

The to return the last element of. A cached Lambda Expression. The first element in source that passes the test in predicate.

Bypasses a specified number of elements in a sequence and then returns the remaining elements.

A to return elements from. The number of elements to skip before returning the remaining elements. A that contains elements that occur after the specified index in the input sequence.

Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.SkipWhile("Income > 50");
            var result2 = queryable.SkipWhile("Income > @0", 50);

An that contains elements from source starting at the first element in the linear series that does not pass the test specified by predicate.

Computes the sum of a sequence of numeric values.

A sequence of numeric values to calculate the sum of.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.Sum();
            var result2 = queryable.Select("Roles.Sum()");

The sum of the values in the sequence.

Computes the sum of a sequence of numeric values.

A sequence of numeric values to calculate the sum of. The . A function to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.


            IQueryable queryable = employees.AsQueryable();
            var result = queryable.Sum("Income");

The sum of the values in the sequence.

Computes the sum of a sequence of numeric values.

A sequence of numeric values to calculate the sum of. A Lambda Expression. The sum of the values in the sequence.

Returns a specified number of contiguous elements from the start of a sequence.

The sequence to return elements from. The number of elements to return. A that contains the specified number of elements from the start of source.

Returns elements from a sequence as long as a specified condition is true.


            IQueryable queryable = employees.AsQueryable();
            var result1 = queryable.TakeWhile("Income > 50");
            var result2 = queryable.TakeWhile("Income > @0", 50);

An that contains elements from the input sequence occurring before the element at which the test specified by predicate no longer passes.

Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.


            ("LastName");
            var resultSingle = result.ThenBy("NumberProperty");
            var resultSingleDescending = result.ThenBy("NumberProperty DESC");
            var resultMultiple = result.ThenBy("NumberProperty, StringProperty");
            ]]>

Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.


            var result = queryable.OrderBy("LastName");
            var resultSingle = result.OrderBy("NumberProperty");
            var resultSingleDescending = result.OrderBy("NumberProperty DESC");
            var resultMultiple = result.OrderBy("NumberProperty, StringProperty DESC");

Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.

Filters a sequence of values based on a predicate.

The type of the elements of source. A to filter. The . An expression string to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A that contains elements from the input sequence that satisfy the condition specified by predicate.


            var result1 = queryable.Where("NumberProperty = 1");
            var result2 = queryable.Where("NumberProperty = @0", 1);
            var result3 = queryable.Where("StringProperty = null");
            var result4 = queryable.Where("StringProperty = \"abc\"");
            var result5 = queryable.Where("StringProperty = @0", "abc");

Filters a sequence of values based on a predicate.

A to filter. The . An expression string to test each element for a condition. An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings. A that contains elements from the input sequence that satisfy the condition specified by predicate.


            var result1 = queryable.Where("NumberProperty = 1");
            var result2 = queryable.Where("NumberProperty = @0", 1);
            var result3 = queryable.Where("StringProperty = null");
            var result4 = queryable.Where("StringProperty = \"abc\"");
            var result5 = queryable.Where("StringProperty = @0", "abc");

Filters a sequence of values based on a predicate.

A to filter. A cached Lambda Expression. A that contains elements from the input sequence that satisfy the condition specified by LambdaExpression.

Provides a set of static extension methods for querying data structures that implement . It supports a FormattableString string as predicate.

Represents errors that occur while parsing dynamic linq string expressions.

The location in the parsed string that produced the . If the value is -1, the position is unknown.

Initializes a new instance of the class with a specified error message and position.

The message that describes the error. The exception that is the cause of the current exception, or a null reference if no inner exception is specified.

Initializes a new instance of the class with a specified error message and position.

The message that describes the error. The location in the parsed string that produced the The exception that is the cause of the current exception, or a null reference if no inner exception is specified.

Creates and returns a string representation of the current exception.

A string representation of the current exception.

When overridden in a derived class, sets the with information about the exception.

The that holds the serialized object data about the exception being thrown. The that contains contextual information about the source or destination.

Extensibility point: If you want to modify expanded queries before executing them set your own functionality to override empty QueryOptimizer

Place to optimize your queries. Example: Add a reference to Nuget package Linq.Expression.Optimizer and in your program initializers set Extensibility.QueryOptimizer = ExpressionOptimizer.visit;

The result of a call to a .GroupByMany() overload.

The key value of the group.

The number of resulting elements in the group.

The resulting elements in the group.

The resulting subgroups in the group.

Returns a showing the key of the group and the number of items in the group.

A that represents this instance.

IAssemblyHelper interface which is used to retrieve assemblies that have been loaded into the execution context of this application domain.

Gets the assemblies that have been loaded into the execution context of this application domain.

An array of assemblies in this application domain.

Interface for QueryableAnalyzer.

Determines whether the specified query (and provider) supports LinqToObjects.

The query to check. The provider to check (can be null). true/false

PagedResult

Gets or sets the queryable.

The queryable.

Gets or sets the current page.

The current page.

Gets or sets the page count.

The page count.

Gets or sets the size of the page.

The size of the page.

Gets or sets the row count.

The row count.

PagedResult{TSource}

The type of the source.

Gets or sets the queryable.

The queryable.

Generates a random 16 character word derived from a Guid value.

Based on gblog by graeme-hill. https://github.com/graeme-hill/gblog/blob/master/source_content/articles/2014.139_entity-framework-dynamic-queries-and-parameterization.mkd

All Enum types from mscorlib/netstandard.

ExpressionParser

Gets name for the `it` field. By default this is set to the KeyWord value "it".

There was a problem when an expression contained multiple lambdas where the ItName was not cleared and freed for the next lambda. This variable stores the ItName of the last parsed lambda. Not used internally by ExpressionParser, but used to preserve compatibility of parsingConfig.RenameParameterExpression which was designed to only work with mono-lambda expressions.

Initializes a new instance of the class.

The parameters. The expression. The values. The parsing configuration.

Initializes a new instance of the class.

The parameters. The expression. The values. The parsing configuration. Indicate that this instance will be used for parsing orderBy. Default value is false.

Uses the TextParser to parse the string into the specified result type.

Type of the result. if set to true [create parameter ctor]. Expression

ExpressionPromoter

Initializes a new instance of the class.

The ParsingConfig.

If the types are different (and not null), try to convert the object type to other type.

Expression promoter is used to promote object or value types to their destination type when an automatic promotion is available such as: int to int?.

Promote an expression.

Source expression Destination data type to promote If the match must be exact Convert expression The promoted or null.

NumberParser

Initializes a new instance of the class.

The ParsingConfig.

Tries to parse the text into a IntegerLiteral ConstantExpression.

The current token position (needed for error reporting). The text.

Parse the text into a Real ConstantExpression.

Tries to parse the number (text) into the specified type.

The text. The type. The result.

Parses the number (text) into the specified type.

The text. The type.

Parse a Double and Single Quoted string. Some parts of the code is based on https://github.com/zzzprojects/Eval-Expression.NET

#794

Check for implicit conversion operators (op_Implicit) from returnType to type. Look for op_Implicit on the source type or the target type.

Configuration class for System.Linq.Dynamic.Core.

Default ParsingConfig

Default ParsingConfig for EntityFramework Core 2.1 and higher

Default ParsingConfig for CosmosDb

Defines if the resolution should be case-sensitive for: - fields and properties - (extension) methods - constant expressions ("null", "true", "false") - keywords ("it", "parent", "root") - functions ("as", "cast", "iif", "is", "isnull", "new", "np") - operator aliases ("eq", "equal", "ne", "notequal", "neq", "lt", "LessThan", "le", "LessThanEqual", "gt", "GreaterThan", "ge", "GreaterThanEqual", "and", "AndAlso", "or", "OrElse", "not", "mod") Default value is false.

Gets or sets the .

Sets the CustomTypeProvider to .

Defines whether to cache the CustomTypes (including extension methods) which are found in the Application Domain. Default set to true.

Sets the CustomTypeProvider to .

Defines whether to cache the CustomTypes (including extension methods) which are found in the Application Domain. Default set to true. A list of additional types (without the DynamicLinqTypeAttribute annotation) which should also be resolved.

Load additional assemblies from the current domain base directory. Note: only used when full .NET Framework and .NET Core App 2.x and higher. Default value is false.

Gets or sets the .

Determines if the context keywords (it, parent, and root) are valid and usable inside a Dynamic Linq string expression. Does not affect the usability of the equivalent context symbols ($, ^ and ~). Default value is false.

Gets or sets a value indicating whether the EntityFramework version supports evaluating GroupBy at database level. See https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-2.1#linq-groupby-translation Remark: when this setting is set to true, make sure to supply this ParsingConfig as first parameter on the extension methods. Default value is false.

Use Parameterized Names in generated dynamic SQL query. See https://github.com/graeme-hill/gblog/blob/master/source_content/articles/2014.139_entity-framework-dynamic-queries-and-parameterization.mkd Default value is false.

Allows the New() keyword to evaluate any available Type. Default value is false.

Renames the (Typed)ParameterExpression empty Name to the correct supplied name from `it`. Default value is false.

Prevents any System.Linq.Expressions.ParameterExpression.Name value from being empty by substituting a random 16 character word. Default value is false.

By default, when a member is not found in a type and the type has a string based index accessor it will be parsed as an index accessor. Use this flag to disable this behaviour and have parsing fail when parsing an expression where a member access on a non-existing member happens. Default value is false.

By default, finding types by a simple name is not supported. Use this flag to use the CustomTypeProvider to resolve types by a simple name like "Employee" instead of "MyDatabase.Entities.Employee". Note that a first matching type is returned and this functionality needs to scan all types from all assemblies, so use with caution. Default value is false.

Support enumeration-types from the System namespace in mscorlib. An example could be "StringComparison". Default value is true.

By default, a DateTime (like 'Fri, 10 May 2019 11:03:17 GMT') is parsed as local time. Use this flag to parse all DateTime strings as UTC. Default value is false.

The number parsing culture. Default value is CultureInfo.InvariantCulture

Additional TypeConverters

When using the NullPropagating function np(...), use a "default value" for non-nullable value types instead of "null value". Default value is false.

Support casting to a full qualified type using a string (double-quoted value).


            var result = queryable.Select($"\"System.DateTime\"(LastUpdate)");

Default value is true.

When the type and property have the same name the parser takes the property instead of type when this setting is set to true. This setting is also used for calling ExtensionMethods. Default value is true.

Support a "." in a property-name. Used in the 'new (a.b as a.b)' syntax. Default value is false.

Disallows the New() keyword to be used to construct a class. Default value is false.

Caches constant expressions to enhance performance. Periodic cleanup is performed to manage cache size, governed by this configuration.

Converts typeof(object) to the correct type to allow comparison (Equal, NotEqual, GreaterThan, GreaterThanEqual, LessThan and LessThanEqual). Default value is false. When set to true, the following code will work correct:


              50").ToList();
             ]]>

Defines the type of string literal parsing that will be performed. Default value is StringLiteralParsingType.Default.

When set to true, the parser will restrict the OrderBy and ThenBy methods to only allow properties or fields. If set to false, any expression is allowed. Default value is true.

When set to true, the parser will allow the use of the Equals(object obj), Equals(object objA, object objB), ReferenceEquals(object objA, object objB) and ToString() methods on the type. Default value is false.

TextParser which can be used to parse a text into tokens.

The current parsed .

Constructor for TextParser

This method is used to clone the current .

Cloned

Peek the next character.

The next character, or \0 if end of string.

Go to the next token.

Check if the current token is the specified .

The tokenId to check. The (optional) error message.

Check if the current token is an with the provided id .

The id

Try to get a token based on the id or .

The ids. The tokenIds. The found token, or default when not found.

Token

The TokenId.

The Original TokenId.

The text.

The position.

TokenId which defines the text which is parsed.

Converts the specified object to a .

The date format context. The date culture. The object to be converted. A that represents the specified object. The conversion cannot be performed.

Returns a type converter for the specified type.

The System.Type of the target component. A System.ComponentModel.TypeConverter for the specified type.

Cache Configuration Options

Sets a Time-To-Live (TTL) for items in the constant expression cache to prevent uncontrolled growth. Items not accessed within this TTL will be expired, allowing garbage collection to reclaim the memory. Default is 10 minutes.

Configures the minimum number of items required in the constant expression cache before triggering cleanup. This prevents frequent cleanups, especially in caches with few items. A default value of null implies that cleanup is always allowed to run, helping in timely removal of unused cache items.

Sets the frequency for running the cleanup process in the Constant Expression cache. By default, cleanup occurs every 10 minutes.

Enables returning expired cache items in scenarios where cleanup, running on a separate thread, has not yet removed them. This allows for the retrieval of an expired object without needing to clear and recreate it if a request is made concurrently with cleanup. Particularly useful when cached items are deterministic, ensuring consistent results even from expired entries. Default true;

Sliding Thread Safe Cache

The length of time any object would survive before being removed Only look for expired objects over specific periods If defined, only allow the cleanup process after x number of cached items have been stored Provides the Time for the Caching object. Default will be created if not supplied. Used for Testing classes If a request for an item happens to be expired, but is still in known, don't expire it and return it instead.

Sliding Thread Safe Cache

The to use. Provides the Time for the Caching object. Default will be created if not supplied. Used for Testing classes

Cache TTL value

Provide the number of items in the cache

Add or update the item in the cache, at the same time update the expiration time

Attempt to get the value from the cache. This will extend the cache expiration time if the item is found

Key Value

Renames a single (Typed)ParameterExpression in an Expression.

Initializes a new instance of the class.

The new name (the oldName is assumed to be "").

Initializes a new instance of the class.

The old name. The new name.

Renames a single (Typed)ParameterExpression from specified expression.

The expression. The new generated (Typed)ParameterExpression. Renamed Expression

To fix 'xxx' is null on at least one execution path. See also https://rules.sonarsource.com/csharp/RSPEC-3900.

Specifies that when a method returns , the parameter will not be even if the corresponding type allows it.

Gets the return value condition. If the method returns this value, the associated parameter will not be .

Initializes the attribute with the specified return value condition.

The return value condition. If the method returns this value, the associated parameter will not be .

https://github.com/castleproject/Core/blob/netcore/src/Castle.Core/Compatibility/IntrospectionExtensions.cs

Indicates whether a specified string is null, empty, or consists only of white-space characters. Recreates the same functionality as System.String.IsNullOrWhiteSpace but included here for compatibility with net35.

The string to test. true if the value parameter is null or System.String.Empty, or if value consists exclusively of white-space characters.