awesome-repositories.com
Blog
awesome-repositories.com

Descoperă cele mai bune repository-uri open source cu căutare AI.

ExploreazăCăutări recomandateAlternative open-sourceSoftware self-hostedBlogHartă site
ProiectDespreCum realizăm clasamentulPresăServer MCP
LegalConfidențialitateTermeni
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
microsoft avatar

microsoft/RulesEngine

0
View on GitHub↗
4,299 stele·614 fork-uri·C#·MIT·1 vizualizaremicrosoft.github.io/RulesEngine↗

RulesEngine

RulesEngine is a business logic evaluator for .NET that executes complex rule workflows and dynamic expressions against input data. It functions as a dynamic expression evaluator and an externalized logic framework, allowing the definition and management of business rules in JSON format to change application behavior without recompiling code.

The project decouples decision logic from source code by loading policies from external files or databases. It supports the registration of custom classes and methods to extend standard expression capabilities through type injection.

The framework covers automated workflow orchestration, complex condition validation, and the evaluation of standalone logic expressions. It includes capabilities for parameter aliasing to simplify long rule definitions and triggers specific events or actions based on rule evaluation outcomes.

Features

  • Runtime .NET - Provides a .NET business logic evaluator for executing complex rule workflows and dynamic expressions.
  • Business Rule Evaluation - Computes results using predefined logic policies and input data to determine if specific conditions are met.
  • External Rule Management - Stores business rules as structured data in external files or databases to update policies at runtime.
  • Dynamic Logic Configuration - Updates application behavior and policy rules using JSON without needing to recompile or redeploy code.
  • Automated Workflow Orchestration - Orchestrates sequences of conditional rules to trigger specific events or actions based on input data.
  • Expression Evaluators - Provides an engine for processing mathematical and logical expressions against data at runtime.
  • Dynamic Logic Evaluators - Provides a tool for parsing and computing standalone logical expressions and data queries within a .NET environment.
  • General Purpose JSON Rule Engines - Provides a system for defining and storing logic policies in JSON format to change application behavior without recompiling.
  • Dynamic Rule Engines - Functions as a dynamic rule engine that evaluates custom logic and validations at runtime without requiring recompilation.
  • Externalized Logic Frameworks - Provides a framework for decoupling business rules from source code by loading policies from external files or databases.
  • Externalized Logic Schemas - Enables loading rule definitions from external sources to update policies without requiring a full application redeploy.
  • Externalized Policy Management - Decouples decision logic from source code by loading policies from external files or databases.
  • Rule Chain Workflows - Implements sequential rule execution where results trigger subsequent logic steps.
  • Workflow Orchestration - Executes a sequence of rules against input objects to determine which specific conditions are triggered.
  • Conditional Logic Evaluation - Evaluates multi-step logical requirements and data dependencies to verify business criteria.
  • Runtime Logic Parsing - Provides runtime parsing of string-based logic statements into executable operations against input data.
  • Fact-Based Rule Triggering - Triggers success or failure events by matching rule conditions against runtime data facts.
  • Rule-Driven Action Triggers - Automatically runs specific code or chains additional rules after a result is determined.
  • Rule Engine Type Injections - Allows registering custom classes or types to make their properties and methods available within rule expressions.
  • Evaluator Logic Extensions - Supports registering external classes and methods to perform complex evaluations that exceed standard expression capabilities.
  • JSON Policy Definitions - Allows specifying business logic and policies using a JSON data format that supports custom expressions and query operations.
  • Expression Parameter Aliasing - Simplifies complex data identifiers with named labels to enhance the maintainability of rule definitions.
  • Expression Simplifications - Provides the ability to break down large logical statements into smaller, reusable intermediate expressions within rule definitions.
  • Input Parameter Mapping - Allows assigning context-specific names to input data sources to replace generic identifiers with meaningful labels.
  • Reflection-Based Property Accessors - Uses reflection-based property accessors to expose external class properties and methods to the engine.
  • Rule Parameter Aliasing - Replaces complex expressions with global or local aliases to improve the maintainability of long rule definitions.

Istoric stele

Graficul istoricului de stele pentru microsoft/rulesengineGraficul istoricului de stele pentru microsoft/rulesengine

Căutare AI

Explorează mai multe repository-uri excelente

Descrie ce ai nevoie în limbaj simplu — AI-ul sortează mii de proiecte open source selectate în funcție de relevanță.

Start searching with AI

Alternative open-source pentru RulesEngine

Proiecte open-source similare, clasificate după numărul de funcționalități comune cu RulesEngine.
  • knetic/govaluateAvatar Knetic

    Knetic/govaluate

    3,940Vezi pe GitHub↗

    govaluate is a Go expression evaluator and runtime logic parser. It functions as a dynamic rule engine that converts string-based expressions into executable operations, allowing for the calculation of mathematical and logical expressions at runtime. The library enables the execution of business rules and custom formulas without recompiling source code. It supports extending evaluation behavior through the injection of external parameters and the execution of user-defined custom functions. The system provides capabilities for dynamic data validation, including regular expression matching and

    Goevaluationexpressiongo
    Vezi pe GitHub↗3,940
  • cachecontrol/json-rules-engineAvatar CacheControl

    CacheControl/json-rules-engine

    3,088Vezi pe GitHub↗

    This project is a rule-based decision system that decouples complex business logic from application code by representing rules as portable, structured data. It functions as a business logic engine that evaluates nested boolean conditions to determine application outcomes based on dynamic inputs. The engine distinguishes itself by supporting the asynchronous resolution of external data, allowing it to fetch and inject real-time facts into the evaluation process at runtime. It utilizes a recursive evaluation model to process hierarchical rule sets and triggers event-driven actions immediately u

    JavaScriptbusiness-rulesenginejson
    Vezi pe GitHub↗3,088
  • antonmedv/exprAvatar antonmedv

    antonmedv/expr

    7,905Vezi pe GitHub↗

    Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

    Go
    Vezi pe GitHub↗7,905
  • expr-lang/exprAvatar expr-lang

    expr-lang/expr

    7,906Vezi pe GitHub↗

    Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll

    Gobytecodeconfiguration-languageengine
    Vezi pe GitHub↗7,906
Vezi toate cele 30 alternative pentru RulesEngine→

Întrebări frecvente

Ce face microsoft/rulesengine?

RulesEngine is a business logic evaluator for .NET that executes complex rule workflows and dynamic expressions against input data. It functions as a dynamic expression evaluator and an externalized logic framework, allowing the definition and management of business rules in JSON format to change application behavior without recompiling code.

Care sunt principalele funcționalități ale microsoft/rulesengine?

Principalele funcționalități ale microsoft/rulesengine sunt: Runtime .NET, Business Rule Evaluation, External Rule Management, Dynamic Logic Configuration, Automated Workflow Orchestration, Expression Evaluators, Dynamic Logic Evaluators, General Purpose JSON Rule Engines.

Care sunt câteva alternative open-source pentru microsoft/rulesengine?

Alternativele open-source pentru microsoft/rulesengine includ: knetic/govaluate — govaluate is a Go expression evaluator and runtime logic parser. It functions as a dynamic rule engine that converts… cachecontrol/json-rules-engine — This project is a rule-based decision system that decouples complex business logic from application code by… antonmedv/expr — Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic… expr-lang/expr — Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic… killme2008/aviatorscript — Aviatorscript is a high-performance scripting language and expression evaluation engine designed for integration… google/cel-go — cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of…