pauldeen79.CrossCutting.ProcessingPipeline 9.0.8

CrossCutting

Generic utilities and other stuff, usable in any layer of any solution. We're targeting .NET Standard 2.0, so you can even use .NET Framework 4.x if you want to.

This repository consists of the following packages:

Using NSubstitute or Moq as mock factory for CrossCutting.Common.Testing

To use NSubstitute as a mock factory for the code in CrossCutting.Common.Testing, create a test helper project within your solution, and add the following code:

    public static void ShouldThrowArgumentNullExceptionsInConstructorsOnNullArguments(
        this Type type,
        Func<ParameterInfo, bool>? parameterPredicate = null,
        Func<ParameterInfo, object?>? parameterReplaceDelegate = null,
        Func<ConstructorInfo, bool>? constructorPredicate = null)
        => ShouldThrowArgumentNullExceptionsInConstructorsOnNullArguments(
            type,
            t => t.CreateInstance(parameterType => Substitute.For(new[] { parameterType }, Array.Empty<object>()), parameterReplaceDelegate, constructorPredicate),
            parameterPredicate,
            parameterReplaceDelegate,
            constructorPredicate);

You can easily replace NSubstitute with Moq, if you want, by changing the factory delegate argument to this:

t => t.CreateInstance(parameterType => ((Mock)Activator.CreateInstance(typeof(Mock<>).MakeGenericType(parameterType))).Object, parameterReplaceDelegate, constructorPredicate),

Upgrade from 2.x to 3.0

There has been a breaking change in the Result class, which lead to a new major version. To port the old code, you can fix most errors by replace this:

Result<([^>]+)>\.([^(]+)\(

With this:

Result.$2<$1>(

Upgrade Parsers from 6.x to 7.0

There have been some breaking changes.

• FunctionParseResult has been renamed to FunctionCall, because that's what it is.
• IFunctionResultParser has been renamed to IFunction, and Parse has been renamed to Evaluate, because that's what it is.
• IPlaceholderProcessor has been renamed to IPlaceholder, and Process has been renamed to Evaluate, because that's what it is.
• Some parsers and evaluators now have a Validate method, to check whether the input is valid. This way, you can check validity without actually performing the action.
• IVariable and IVariableProcessor now have a method called Evaluate instead of Process, which is more descriptive.
• IExpressionParser has been renamed to IExpressionEvaluator and IExpressionParserProcessor to IExpression.
• IExpressionStringParser has been renamed to IExpressionStringEvaluator and IExpresionStringParserProcessor to IExpressionString.
• IMathematicExpressionParser has been renamed to IMathematicExpressionEvaluator and IMathematicExpressionProcessor to IMathematicExpression.
• FormattableStringParserResult has been renamed to GenericFormattableString.

ExpressionEvaluator

The ExpressionEvaluator is a complete rewrite of the Parsers project, where and Expression is the entry type for everything. An expression can contain the following things:

• Strings, like "hello world"
• Interpolated strings, like "hello {name}"
• Booleans "true" and "false"
• Constructors like "new DateTime(2025, 1 ,1)"
• DateTime.Now and DateTime.Today, as well as the Date and DateTime functions to create a custom DateTime value
• Numeric values, both integer and floating point types like "1.3" and "12"
• Mathematic operators like +, -, * and /, including brackets, for example "(1 + 1) * 13"
• Binary operators && and || for example "true && true"
• Unary operator ! to inverse a boolean value like "!true"
• Comparison operators <, ⇐, >, >=, == and != for example "true != false"
• Indexers like MyArray[1]
• Built-in methods for DateTime values: AddDays, AddHours, AddMinuts, AddMonths, AddSeconds and AddYears
• Built-in functions for String values: Left, Right, Mid
• Built-in methods for String values: ToCamelCase, ToLower, ToPascalCase and ToUpper
• Cast and Convert functions to cast and convert values to other types
• Coalesce function, to get the first value that is not null
• ToString method to convert objects to string
• IsNull function to check for null values
• Optional support for reflection to get property values or invoke methods
• Type-safe properties, without reflection: Array.Length, String.Length, ICollection.Count, and Year/Month/Day/Hour/Minute/Second/Date for DateTime
• Support for context using delegates, in order to allow lazy evaluation
• Support for adding custom functions and generic functions, using dependency injection
• Support for adding custom expression components, using dependency injection
• Support for adding custom instance methods, constructors and properties, using dependency injection

Design decisions:

• Extendable through Dependency Injection
• Result-based, exception free. When an exception occurs, just check the Status property of the result, and you can see the details using the Exception property if you want
• Free of reflection by default, but you can enable it
• Allow duck-typing for properties and methods, with or without reflection
• Without reflection, you have to write DotExpressionComponents to implement the members
• Basic support for discoverability and validation, using a Parse method. This will return the status (Ok/Invalid) and the return type of the expression, as well as some details like the inner results, and the type that handles this expression