public void ConditionalWithConstantRuleUsingFactory(string valueToCheck, string expectedOutput) { var trueRule = ConstantRulesFactory.CreateConstantRule <string, string>("element is present in the collection"); var falseRule = ConstantRulesFactory.CreateConstantRule <string, string>("element is not present in the collection"); var searchList = new List <string> { "one", "two", "three", "four", "five", "six" }; var containsRule = ContainsValueRuleFactory.CreateContainsValueRule(searchList, "System.StringComparer", "OrdinalIgnoreCase"); var containsTextRule = ConditionalRulesFactory.CreateConditionalFuncRule <string, string>(containsRule, trueRule, falseRule); var compileResult = containsTextRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(containsTextRule)}:{Environment.NewLine}" + $"{containsTextRule.ExpressionDebugView()}"); var ruleResult = containsTextRule.Execute(valueToCheck); _testOutputHelper.WriteLine($"expected: {expectedOutput} - actual: {ruleResult}"); ruleResult.Should().BeEquivalentTo(expectedOutput); }
public void CallAStringMethodOnDescriptionObjectUsingFactory() { // Description is a string - Call Contains method on Description // compiles to: Param_0.Description.Contains("cool") var const1 = ConstantRulesFactory.CreateConstantRule <string>("cool"); var gameNameContainsKeyWordCool = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Contains", null, (g => g.Description), new List <Rule> { const1 }); var compileResult = gameNameContainsKeyWordCool.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(gameNameContainsKeyWordCool)}:{Environment.NewLine}" + $"{gameNameContainsKeyWordCool.ExpressionDebugView()}"); // check to see if _game1 description contains keyword "cool" var executeResult = gameNameContainsKeyWordCool.Execute(_game1); executeResult.Should().BeFalse(); // check to see if _game2 description contains keyword "cool" executeResult = gameNameContainsKeyWordCool.Execute(_game2); executeResult.Should().BeTrue(); }
public void UpdateStringRefUsingFactory() { var sourceDataRule = ConstantRulesFactory.CreateConstantRule <string>("something"); var rule = UpdateValueRulesFactory.CreateUpdateRefValueRule <string>(sourceDataRule); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"UpdateRefValueRule<string>:{Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var string1 = "one"; rule.RefUpdate(ref string1); string1.Should().Be("something"); // source value shall come as argument var rule2 = UpdateValueRulesFactory.CreateUpdateRefValueRule <string>(); compileResult = rule2.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"UpdateRefValueRule<string, string>:{Environment.NewLine}" + $"{rule2.ExpressionDebugView()}"); string1 = null; rule2.RefUpdate(ref string1, "some other value"); string1.Should().Be("some other value"); }
public void UpdateIntRefUsingFactory() { var sourceDataRule = ConstantRulesFactory.CreateConstantRule <int>("99"); var rule = UpdateValueRulesFactory.CreateUpdateRefValueRule <int>(sourceDataRule); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{rule.ExpressionDebugView()}"); var myInt = 0; rule.RefUpdate(ref myInt); myInt.Should().Be(99); var rule2 = UpdateValueRulesFactory.CreateUpdateRefValueRule <int>(); compileResult = rule2.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"UpdateRefValueRule<int, int>:{Environment.NewLine}" + $"{rule2.ExpressionDebugView()}"); rule2.RefUpdate(ref myInt, -99); myInt.Should().Be(-99); }
public void CallCreateGameStaticMethod3UsingFactory() { //var game = Game.CreateGame("game", "description", 1, true); var methodParams = new List <Rule> { ConstantRulesFactory.CreateConstantRule <string>("game"), ConstantRulesFactory.CreateConstantRule <string>("description"), ConstantRulesFactory.CreateConstantRule <int>("1"), ConstantRulesFactory.CreateConstantRule <bool>("true") }; var rule = MethodCallRulesFactory.CreateStaticMethodCallRule <Game>("CreateGame", "ModelForUnitTests.Game", methodParams); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"rule: {Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var game = rule.Execute(); game.Should().NotBeNull(); game.Name.Should().Be("game"); _testOutputHelper.WriteLine($"{game}"); }
public void ConditionalRuleLookAtOneValueUpdateAnotherUsingFactory() { var const1 = ConstantRulesFactory.CreateConstantRule <int>("999"); var trueRule = UpdateValueRulesFactory.CreateUpdateValueRule <Player>(p => p.CurrentCoOrdinates.X, const1); var const2 = ConstantRulesFactory.CreateConstantRule <string>("ab"); var validationRule = ValidationRulesFactory.CreateValidationRule <Player>(p => p.Country.CountryCode, LogicalOperatorAtTheRootLevel.Equal, const2); var conditionalUpdate = ConditionalRulesFactory.CreateConditionalIfThActionRule <Player>(validationRule, trueRule); var compileResult = conditionalUpdate.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(conditionalUpdate)}:{Environment.NewLine}" + $"{conditionalUpdate.ExpressionDebugView()}"); var player = new Player { Country = new Country { CountryCode = "ab" }, CurrentCoOrdinates = new CoOrdinate { X = 1, Y = 1 } }; conditionalUpdate.Execute(player); player.CurrentCoOrdinates.X.Should().Be(999); _testOutputHelper.WriteLine($"expected: 999 - actual: {player.CurrentCoOrdinates.X}"); }
public void RuleToCheckIfAnIntegerMatchesRuleValueOrNotUsingFactory() { var constRule = ConstantRulesFactory.CreateConstantRule <int>("5"); var numberShouldBe5Rule = ValidationRulesFactory.CreateValidationRule <int>( LogicalOperatorAtTheRootLevel.Equal, constRule); var compileResult = numberShouldBe5Rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(numberShouldBe5Rule)}:{Environment.NewLine}{numberShouldBe5Rule.ExpressionDebugView()}"); var numberShouldNotBe5Rule = ValidationRulesFactory.CreateValidationRule <int>( LogicalOperatorAtTheRootLevel.NotEqual, constRule); compileResult = numberShouldNotBe5Rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(numberShouldNotBe5Rule)}:{Environment.NewLine}" + $"{numberShouldNotBe5Rule.ExpressionDebugView()}"); var ruleExecuteResult = numberShouldBe5Rule.IsValid(5); ruleExecuteResult.Should().BeTrue(); _testOutputHelper.WriteLine($"with 5 {nameof(numberShouldBe5Rule)} execute result: {ruleExecuteResult}"); ruleExecuteResult = numberShouldBe5Rule.IsValid(6); ruleExecuteResult.Should().BeFalse(); ruleExecuteResult = numberShouldNotBe5Rule.IsValid(6); ruleExecuteResult.Should().BeTrue(); _testOutputHelper.WriteLine($"with 6 {nameof(numberShouldNotBe5Rule)} execute result: {ruleExecuteResult}"); ruleExecuteResult = numberShouldNotBe5Rule.IsValid(5); ruleExecuteResult.Should().BeFalse(); }
public void ConditionalRuleToUpdateNameUsingFactory() { var trueRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>(g => g.Name, ConstantRulesFactory.CreateConstantRule <string>("updated name")); var methodParams = new List <Rule> { ConstantRulesFactory.CreateConstantRule <string>("some name"), ConstantRulesFactory.CreateConstantRule <StringComparison>("CurrentCultureIgnoreCase") }; var methodCallRule = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Equals", null, g => g.Name, methodParams); var conditionalUpdateValue = ConditionalRulesFactory.CreateConditionalIfThActionRule <Game>(methodCallRule, trueRule); var compileResult = conditionalUpdateValue.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(conditionalUpdateValue)}:{Environment.NewLine}" + $"{conditionalUpdateValue.ExpressionDebugView()}"); var game = new Game { Name = "some name" }; _testOutputHelper.WriteLine($"before game.Name: {game.Name}"); conditionalUpdateValue.Execute(game); _testOutputHelper.WriteLine($"after game.Name: {game.Name}"); game.Name.Should().Be("updated name"); }
static void Main(string[] args) { Console.WriteLine("Hello World!"); var rule = ConstantRulesFactory.CreateConstantRule <string>("value"); var compile = rule.Compile(); var result = rule.Get(); //var foo = GetSomeNullValue(); }
public void CreateConstantRuleTest5UsingFactory() { var rule = ConstantRulesFactory.CreateConstantRule <int, bool?>("false"); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var value = rule.Get(int.MinValue); value.Should().Be(false); }
public void CreateConstantRuleTest2UsingFactory() { var rule = ConstantRulesFactory.CreateConstantRule <double>("99.1"); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var value = rule.Get(); _testOutputHelper.WriteLine($"expected: 99.1 - actual: {value}"); value.Should().Be(99.1); }
public void ValidationRuleWithOrElseChildrenValidationRulesUsingFactory() { var nullGame = ConstantRulesFactory.CreateConstantRule <Game>("null"); var child1 = ValidationRulesFactory.CreateValidationRule <Game>(LogicalOperatorAtTheRootLevel.Equal, nullGame); var nullString = ConstantRulesFactory.CreateConstantRule <string>("null"); var grandChild1 = ValidationRulesFactory.CreateValidationRule <Game>(g => g.Name, LogicalOperatorAtTheRootLevel.NotEqual, nullString); var int3Const = ConstantRulesFactory.CreateConstantRule <int>("3"); var grandChild2 = ValidationRulesFactory.CreateValidationRule <Game>(g => g.Name.Length, LogicalOperatorAtTheRootLevel.GreaterThan, int3Const); var child2 = ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.AndAlso, new List <Rule> { grandChild1, grandChild2 }); var gameIsNullOrNameIsGreaterThan3CharsRule = ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.OrElse, new List <Rule> { child1, child2 }); var compileResult = gameIsNullOrNameIsGreaterThan3CharsRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(gameIsNullOrNameIsGreaterThan3CharsRule)}:{Environment.NewLine}" + $"{gameIsNullOrNameIsGreaterThan3CharsRule.ExpressionDebugView()}"); var validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(_game); validationResult.Should().BeTrue(); validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(null); validationResult.Should().BeTrue(); validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(new Game { Name = null }); validationResult.Should().BeFalse(); validationResult = gameIsNullOrNameIsGreaterThan3CharsRule.IsValid(new Game { Name = "a" }); validationResult.Should().BeFalse(); }
public void CreateConstantRuleTest3UsingFactory() { var stringValue = "55"; var rule = ConstantRulesFactory.CreateConstantRule <int, string>(stringValue); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var value = rule.Get(int.MinValue); _testOutputHelper.WriteLine($"expected: {stringValue} - actual: {value}"); value.Should().BeOfType <string>().And.Be(stringValue); }
public void UpdatePropertyFromAnotherRuleUsingFactory() { var game = new Game { Name = "game name" }; var const1 = ConstantRulesFactory.CreateConstantRule <string>("name from constant rule"); var nameChangeRule = UpdateValueRulesFactory.CreateUpdateValueRule <Game>((g => g.Name), const1); var compileResult = nameChangeRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(nameChangeRule)}:{Environment.NewLine}" + $"{nameChangeRule.ExpressionDebugView()}"); _testOutputHelper.WriteLine($"before game.Name: {game.Name}"); nameChangeRule.UpdateFieldOrPropertyValue(game); game.Name.Should().Be("name from constant rule"); _testOutputHelper.WriteLine($"after game.Name: {game.Name}"); }
public void CheckToSeeIfPlayerExistsInAGameUsingFactory(int id, bool expectedResult) { // call HasPlayer method on the game object // compiles to: Param_0.HasPlayer(1000) var const1 = ConstantRulesFactory.CreateConstantRule <int>(id.ToString()); var gameHasPlayerWithCertainId = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("HasPlayer", null, null, new List <Rule> { const1 }); var compileResult = gameHasPlayerWithCertainId.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(gameHasPlayerWithCertainId)}:{Environment.NewLine}" + $"{gameHasPlayerWithCertainId.ExpressionDebugView()}"); var executeResult = gameHasPlayerWithCertainId.Execute(_game1); executeResult.Should().Be(expectedResult); }
public void ApplyRuleToSubFieldOrPropertyUsingFactory() { var constRule = ConstantRulesFactory.CreateConstantRule <int>("3"); var nameLengthGreaterThan3Rule = ValidationRulesFactory.CreateValidationRule <Game>((g => g.Name.Length), LogicalOperatorAtTheRootLevel.GreaterThan, constRule); var compileResult = nameLengthGreaterThan3Rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(nameLengthGreaterThan3Rule)}:{Environment.NewLine}" + $"{nameLengthGreaterThan3Rule.ExpressionDebugView()}"); var validationResult = nameLengthGreaterThan3Rule.IsValid(_game); validationResult.Should().BeTrue(); var someGameWithShortName = new Game { Name = "foo" }; validationResult = nameLengthGreaterThan3Rule.IsValid(someGameWithShortName); validationResult.Should().BeFalse(); }
public void RuleToCheckIfRootObjectIsNullOrNotUsingFactory() { var constRule = ConstantRulesFactory.CreateConstantRule <Game>("null"); var checkForNotNullRule = ValidationRulesFactory.CreateValidationRule <Game>( LogicalOperatorAtTheRootLevel.NotEqual, constRule); var compileResult = checkForNotNullRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(checkForNotNullRule)}:{Environment.NewLine}{checkForNotNullRule.ExpressionDebugView()}"); var checkForNullRule = ValidationRulesFactory.CreateValidationRule <Game>( LogicalOperatorAtTheRootLevel.Equal, constRule); compileResult = checkForNullRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(checkForNullRule)}:{Environment.NewLine}{checkForNullRule.ExpressionDebugView()}"); var ruleExecuteResult = checkForNotNullRule.IsValid(_game); ruleExecuteResult.Should().BeTrue(); _testOutputHelper.WriteLine($"with non-null parameter validationResult = {ruleExecuteResult}; expecting true"); ruleExecuteResult = checkForNotNullRule.IsValid(null); ruleExecuteResult.Should().BeFalse(); _testOutputHelper.WriteLine($"with null parameter validationResult = {ruleExecuteResult}; expecting false"); ruleExecuteResult = checkForNullRule.IsValid(_game); ruleExecuteResult.Should().BeFalse(); _testOutputHelper.WriteLine($"with non-null parameter validationResult = {ruleExecuteResult}; expecting false"); ruleExecuteResult = checkForNullRule.IsValid(null); ruleExecuteResult.Should().BeTrue(); _testOutputHelper.WriteLine($"with null parameter validationResult = {ruleExecuteResult}; expecting true"); }
public void CallEqualsMethodOnNameUsingConstantRuleUsingFactory(string param1, bool expectedResult) { // call Equals method on Name string object // compiles to: Param_0.Name.Equals("Game 1", CurrentCultureIgnoreCase) var param1Const = ConstantRulesFactory.CreateConstantRule <string>(param1); var param2Const = ConstantRulesFactory.CreateConstantRule <StringComparison>("CurrentCultureIgnoreCase"); var nameEqualsRule = MethodCallRulesFactory.CreateMethodCallRule <Game, bool>("Equals", null, (g => g.Name), new List <Rule> { param1Const, param2Const }); var compileResult = nameEqualsRule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(nameEqualsRule)}:{Environment.NewLine}" + $"{nameEqualsRule.ExpressionDebugView()}"); var executeResult = nameEqualsRule.Execute(_game1); executeResult.Should().Be(expectedResult); executeResult = nameEqualsRule.Execute(_game2); executeResult.Should().Be(!expectedResult); }
public void IfValueContainsReturnDiffValue2UsingFactory(string searchValue, string expectedValue) { var collectionToSearch = new List <string> { "one", "two", "three", "four", "five", "six" }; var containsValueRule = ContainsValueRuleFactory.CreateContainsValueRule(collectionToSearch, "System.StringComparer", "OrdinalIgnoreCase"); var trueRule = ConstantRulesFactory.CreateConstantRule <string, string>("six-six-six"); var falseRule = SelfReturnRuleFactory.CreateSelfReturnRule <string>(); var valueReplacementIfBad = ConditionalRulesFactory.CreateConditionalFuncRule <string, string>(containsValueRule, trueRule, falseRule); var compileResult = valueReplacementIfBad.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(valueReplacementIfBad)}:{Environment.NewLine}" + $"{valueReplacementIfBad.ExpressionDebugView()}"); var ruleResult = valueReplacementIfBad.Execute(searchValue); _testOutputHelper.WriteLine($"expected: {expectedValue} - actual: {ruleResult}"); ruleResult.Should().Be(expectedValue); }
public void ValidationRuleWithOneNotChildUsingFactory() { var constRule = ConstantRulesFactory.CreateConstantRule <Game>("null"); var child1 = ValidationRulesFactory.CreateValidationRule <Game>(LogicalOperatorAtTheRootLevel.NotEqual, constRule); var gameNullRuleByUsingNotWithNotEqualToNullChild = ValidationRulesFactory.CreateValidationRule <Game>(ChildrenBindingOperator.Not, new List <Rule> { child1 }); var compileResult = gameNullRuleByUsingNotWithNotEqualToNullChild.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(gameNullRuleByUsingNotWithNotEqualToNullChild)}:{Environment.NewLine}" + $"{gameNullRuleByUsingNotWithNotEqualToNullChild.ExpressionDebugView()}"); var validationResult = gameNullRuleByUsingNotWithNotEqualToNullChild.IsValid(_game); validationResult.Should().BeFalse(); validationResult = gameNullRuleByUsingNotWithNotEqualToNullChild.IsValid(null); validationResult.Should().BeTrue(); }
public void CreateValidationRuleTest1UsingFactory() { var constRule = ConstantRulesFactory.CreateConstantRule <int>(value: "100"); var rule = ValidationRulesFactory.CreateValidationRule <Game>((g => g.Ranking), LogicalOperatorAtTheRootLevel.LessThan, constRule); var compileResult = rule.Compile(); compileResult.Should().BeTrue(); _testOutputHelper.WriteLine($"{nameof(rule)}:{Environment.NewLine}" + $"{rule.ExpressionDebugView()}"); var game = new Game { Ranking = 98 }; var result = rule.IsValid(game); result.Should().BeTrue(); game.Ranking = 100; result = rule.IsValid(game); result.Should().BeFalse(); }
private static void LoadAndCompileRules() { var nullOrder = ConstantRulesFactory.CreateConstantRule <Order>("null"); var orderRule = ValidationRulesFactory.CreateValidationRule <Order>(LogicalOperatorAtTheRootLevel.NotEqual, nullOrder); orderRule.RuleError = new RuleError { Code = "c1", Message = "order can't be null" }; if (orderRule.Compile()) { OrderRules.Add(orderRule); } var nullCustomer = ConstantRulesFactory.CreateConstantRule <Customer>("null"); var nullProduct = ConstantRulesFactory.CreateConstantRule <Product>("null"); var child1Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer, LogicalOperatorAtTheRootLevel.NotEqual, nullCustomer); var child2Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product, LogicalOperatorAtTheRootLevel.NotEqual, nullProduct); var orderCustomerAndProductCannotBeNullRule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso, new List <Rule> { child1Rule, child2Rule }); orderCustomerAndProductCannotBeNullRule.RuleError = new RuleError { Code = "c2", Message = "Customer and/or Product can't be null" }; if (orderCustomerAndProductCannotBeNullRule.Compile()) { OrderRules.Add(orderCustomerAndProductCannotBeNullRule); } var nullStrRule = ConstantRulesFactory.CreateConstantRule <string>("null"); var child3Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.FirstName, LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule); var len2Rule = ConstantRulesFactory.CreateConstantRule <int>("2"); var child4Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.FirstName.Length, LogicalOperatorAtTheRootLevel.GreaterThan, len2Rule); var orderCustomerFirstNameRule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso, new List <Rule> { child3Rule, child4Rule }); orderCustomerFirstNameRule.RuleError = new RuleError { Code = "c3", Message = "first name can't be null/empty and has to be 3+ chars long" }; if (orderCustomerFirstNameRule.Compile()) { OrderRules.Add(orderCustomerFirstNameRule); } var child5Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.LastName, LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule); var len3Rule = ConstantRulesFactory.CreateConstantRule <int>("3"); var child6Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer.LastName.Length, LogicalOperatorAtTheRootLevel.GreaterThan, len3Rule); var orderCustomerLastNameRule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso, new List <Rule> { child5Rule, child6Rule }); orderCustomerLastNameRule.RuleError = new RuleError { Code = "c4", Message = "last name can't be null/empty and has to be 4+ chars long" }; if (orderCustomerLastNameRule.Compile()) { OrderRules.Add(orderCustomerLastNameRule); } var zeroRule = ConstantRulesFactory.CreateConstantRule <int>("0"); var child7Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Id, LogicalOperatorAtTheRootLevel.GreaterThan, zeroRule); var child81Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Name, LogicalOperatorAtTheRootLevel.NotEqual, nullStrRule); var len4Rule = ConstantRulesFactory.CreateConstantRule <int>("4"); var child82Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product.Name.Length, LogicalOperatorAtTheRootLevel.GreaterThan, len4Rule); var child8Rule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso, new List <Rule> { child81Rule, child82Rule }); var orderProductIdPositiveOrNameGreaterThan5 = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.OrElse, new List <Rule> { child7Rule, child8Rule }); orderProductIdPositiveOrNameGreaterThan5.RuleError = new RuleError { Code = "c5", Message = "product id must be greater than zero or name has to be 5+ chars" }; if (orderProductIdPositiveOrNameGreaterThan5.Compile()) { OrderRules.Add(orderProductIdPositiveOrNameGreaterThan5); } }
static void Main(string[] args) { Console.WriteLine("Sample4RuleCreateMadeEasy - simple tutorial - quick start how-to"); //var orderCustomerAndProductCannotBeNullRule = new ValidationRule<Order> //{ // OperatorToUse = "AndAlso", // RuleError = new RuleError { Code = "c2", Message = "Customer and/or Product can't be null"}, // ChildrenRules = // { // new ValidationRule<Order> // { // OperatorToUse = "NotEqual", // ObjectToValidate = "Customer", // ValueToValidateAgainst = new ConstantRule<Customer>{Value = "null"} // }, // new ValidationRule<Order> // { // OperatorToUse = "NotEqual", // ObjectToValidate = "Product", // ValueToValidateAgainst = new ConstantRule<Product>{Value = "null"}} // } //}; var nullCustomer = ConstantRulesFactory.CreateConstantRule <Customer>("null"); var nullProduct = ConstantRulesFactory.CreateConstantRule <Product>("null"); var child1Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Customer, LogicalOperatorAtTheRootLevel.NotEqual, nullCustomer); var child2Rule = ValidationRulesFactory.CreateValidationRule <Order>(o => o.Product, LogicalOperatorAtTheRootLevel.NotEqual, nullProduct); var orderCustomerAndProductCannotBeNullRule = ValidationRulesFactory.CreateValidationRule <Order>(ChildrenBindingOperator.AndAlso, new List <Rule> { child1Rule, child2Rule }); orderCustomerAndProductCannotBeNullRule.RuleError = new RuleError { Code = "c2", Message = "Customer and/or Product can't be null" }; var compiledResult = orderCustomerAndProductCannotBeNullRule.Compile(); Debug.WriteLine($"compiledResult: {compiledResult}"); // true var order = new Order(); var isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order); if (!isValidOrder) { Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " + $"{orderCustomerAndProductCannotBeNullRule.RuleError}"); } // add a customer object order.Customer = new Customer(); isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order); if (!isValidOrder) { Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " + $"{orderCustomerAndProductCannotBeNullRule.RuleError}"); } // add a product object order.Product = new Product(); isValidOrder = orderCustomerAndProductCannotBeNullRule.IsValid(order); if (!isValidOrder) { Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule not valid: " + $"{orderCustomerAndProductCannotBeNullRule.RuleError}"); } var converter = new JsonConverterForRule(); var jsonDoc = JsonConvert.SerializeObject(orderCustomerAndProductCannotBeNullRule, Formatting.Indented, converter); Debug.WriteLine($"orderCustomerAndProductCannotBeNullRule converted to Json:{Environment.NewLine}{jsonDoc}"); // this shall throw a null exception //orderCustomerAndProductCannotBeNullRule.IsValid(null); }