मैंने एक नियम इंजन का निर्माण किया जो आपके प्रश्न में उल्लिखित की तुलना में एक अलग दृष्टिकोण लेता है, लेकिन मुझे लगता है कि आप इसे अपने वर्तमान दृष्टिकोण की तुलना में अधिक लचीला पाएंगे।
आपका वर्तमान दृष्टिकोण एक एकल इकाई, "उपयोगकर्ता" पर केंद्रित होता है, और आपके लगातार नियम "प्रॉपर्टीनाम", "ऑपरेटर" और "मूल्य" की पहचान करते हैं। मेरा पैटर्न, बजाय मेरे डेटाबेस में एक "अभिव्यक्ति" कॉलम में एक विधेय (फ़ंक <टी, बूल>) के लिए सी # कोड संग्रहीत करता है। वर्तमान डिजाइन में, कोड पीढ़ी का उपयोग करते हुए मैं अपने डेटाबेस से "नियमों" को क्वेरी कर रहा हूं और "नियम" प्रकार के साथ एक विधानसभा का संकलन कर रहा हूं, प्रत्येक "टेस्ट" विधि के साथ। यहां प्रत्येक नियम को लागू करने वाले इंटरफ़ेस के लिए हस्ताक्षर है:
public interface IDataRule<TEntity>
{
/// <summary>
/// Evaluates the validity of a rule given an instance of an entity
/// </summary>
/// <param name="entity">Entity to evaluate</param>
/// <returns>result of the evaluation</returns>
bool Test(TEntity entity);
/// <summary>
/// The unique indentifier for a rule.
/// </summary>
int RuleId { get; set; }
/// <summary>
/// Common name of the rule, not unique
/// </summary>
string RuleName { get; set; }
/// <summary>
/// Indicates the message used to notify the user if the rule fails
/// </summary>
string ValidationMessage { get; set; }
/// <summary>
/// indicator of whether the rule is enabled or not
/// </summary>
bool IsEnabled { get; set; }
/// <summary>
/// Represents the order in which a rule should be executed relative to other rules
/// </summary>
int SortOrder { get; set; }
}
"अभिव्यक्ति" को "टेस्ट" विधि के शरीर के रूप में संकलित किया जाता है जब एप्लिकेशन पहले निष्पादित होता है। जैसा कि आप देख सकते हैं कि तालिका में अन्य कॉलम भी नियम पर प्रथम श्रेणी के गुणों के रूप में सामने आए हैं ताकि एक डेवलपर को यह अनुभव करने के लिए लचीलापन हो कि उपयोगकर्ता को विफलता या सफलता के बारे में कैसे सूचित किया जाता है।
इन-मेमोरी असेंबली बनाना आपके आवेदन के दौरान 1 बार की घटना है और आपको अपने नियमों का मूल्यांकन करते समय प्रतिबिंब का उपयोग नहीं करने से प्रदर्शन लाभ मिलता है। आपकी अभिव्यक्तियों को रनटाइम पर चेक किया जाता है क्योंकि असेंबली सही ढंग से उत्पन्न नहीं होगी यदि कोई संपत्ति का नाम गलत है, आदि।
इन-मेमोरी असेंबली बनाने के यांत्रिकी निम्नानुसार हैं:
- अपने नियमों को डीबी से लोड करें
- नियमों का पालन करें और प्रत्येक के लिए, एक स्ट्रिंगबुलस्टाइल और कुछ स्ट्रिंग कॉन्सेप्टन का उपयोग करके पाठ लिखें जो उस वर्ग का प्रतिनिधित्व करता है जो IDataRule से विरासत में मिला है
- कोडम - अधिक जानकारी का उपयोग कर संकलन करें
यह वास्तव में काफी सरल है क्योंकि बहुमत के लिए यह कोड संपत्ति कार्यान्वयन और निर्माण में मूल्य आरंभीकरण है। इसके अलावा, केवल अन्य कोड एक्सप्रेशन है।
नोट: एक सीमा है कि आपकी अभिव्यक्ति .NET 2.0 होनी चाहिए (कोडबॉम में किसी सीमा के कारण कोई लैम्ब्डा या अन्य C # 3.0 सुविधाएँ नहीं)।
उसके लिए कुछ नमूना कोड यहाँ दिया गया है।
sb.AppendLine(string.Format("\tpublic class {0} : SomeCompany.ComponentModel.IDataRule<{1}>", className, typeName));
sb.AppendLine("\t{");
sb.AppendLine("\t\tprivate int _ruleId = -1;");
sb.AppendLine("\t\tprivate string _ruleName = \"\";");
sb.AppendLine("\t\tprivate string _ruleType = \"\";");
sb.AppendLine("\t\tprivate string _validationMessage = \"\";");
/// ...
sb.AppendLine("\t\tprivate bool _isenabled= false;");
// constructor
sb.AppendLine(string.Format("\t\tpublic {0}()", className));
sb.AppendLine("\t\t{");
sb.AppendLine(string.Format("\t\t\tRuleId = {0};", ruleId));
sb.AppendLine(string.Format("\t\t\tRuleName = \"{0}\";", ruleName.TrimEnd()));
sb.AppendLine(string.Format("\t\t\tRuleType = \"{0}\";", ruleType.TrimEnd()));
sb.AppendLine(string.Format("\t\t\tValidationMessage = \"{0}\";", validationMessage.TrimEnd()));
// ...
sb.AppendLine(string.Format("\t\t\tSortOrder = {0};", sortOrder));
sb.AppendLine("\t\t}");
// properties
sb.AppendLine("\t\tpublic int RuleId { get { return _ruleId; } set { _ruleId = value; } }");
sb.AppendLine("\t\tpublic string RuleName { get { return _ruleName; } set { _ruleName = value; } }");
sb.AppendLine("\t\tpublic string RuleType { get { return _ruleType; } set { _ruleType = value; } }");
/// ... more properties -- omitted
sb.AppendLine(string.Format("\t\tpublic bool Test({0} entity) ", typeName));
sb.AppendLine("\t\t{");
// #############################################################
// NOTE: This is where the expression from the DB Column becomes
// the body of the Test Method, such as: return "entity.Prop1 < 5"
// #############################################################
sb.AppendLine(string.Format("\t\t\treturn {0};", expressionText.TrimEnd()));
sb.AppendLine("\t\t}"); // close method
sb.AppendLine("\t}"); // close Class
इसके अलावा मैंने "DataRuleCollection" नामक एक वर्ग बनाया, जिसने ICollection> को लागू किया। इसने मुझे एक "TestAll" क्षमता और एक विशिष्ट नियम को नाम से निष्पादित करने के लिए एक अनुक्रमणिका बनाने में सक्षम किया। यहाँ उन दो तरीकों के लिए कार्यान्वयन हैं।
/// <summary>
/// Indexer which enables accessing rules in the collection by name
/// </summary>
/// <param name="ruleName">a rule name</param>
/// <returns>an instance of a data rule or null if the rule was not found.</returns>
public IDataRule<TEntity, bool> this[string ruleName]
{
get { return Contains(ruleName) ? list[ruleName] : null; }
}
// in this case the implementation of the Rules Collection is:
// DataRulesCollection<IDataRule<User>> and that generic flows through to the rule.
// there are also some supporting concepts here not otherwise outlined, such as a "FailedRules" IList
public bool TestAllRules(User target)
{
rules.FailedRules.Clear();
var result = true;
foreach (var rule in rules.Where(x => x.IsEnabled))
{
result = rule.Test(target);
if (!result)
{
rules.FailedRules.Add(rule);
}
}
return (rules.FailedRules.Count == 0);
}
अधिक कोड: कोड पीढ़ी से संबंधित कोड के लिए एक अनुरोध था। मैंने aps RulesAssemblyGenerator ’नामक एक वर्ग में कार्यक्षमता को समझाया, जिसे मैंने नीचे शामिल किया है।
namespace Xxx.Services.Utils
{
public static class RulesAssemblyGenerator
{
static List<string> EntityTypesLoaded = new List<string>();
public static void Execute(string typeName, string scriptCode)
{
if (EntityTypesLoaded.Contains(typeName)) { return; }
// only allow the assembly to load once per entityType per execution session
Compile(new CSharpCodeProvider(), scriptCode);
EntityTypesLoaded.Add(typeName);
}
private static void Compile(CodeDom.CodeDomProvider provider, string source)
{
var param = new CodeDom.CompilerParameters()
{
GenerateExecutable = false,
IncludeDebugInformation = false,
GenerateInMemory = true
};
var path = System.Reflection.Assembly.GetExecutingAssembly().Location;
var root_Dir = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "Bin");
param.ReferencedAssemblies.Add(path);
// Note: This dependencies list are included as assembly reference and they should list out all dependencies
// That you may reference in your Rules or that your entity depends on.
// some assembly names were changed... clearly.
var dependencies = new string[] { "yyyyyy.dll", "xxxxxx.dll", "NHibernate.dll", "ABC.Helper.Rules.dll" };
foreach (var dependency in dependencies)
{
var assemblypath = System.IO.Path.Combine(root_Dir, dependency);
param.ReferencedAssemblies.Add(assemblypath);
}
// reference .NET basics for C# 2.0 and C#3.0
param.ReferencedAssemblies.Add(@"C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.dll");
param.ReferencedAssemblies.Add(@"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Core.dll");
var compileResults = provider.CompileAssemblyFromSource(param, source);
var output = compileResults.Output;
if (compileResults.Errors.Count != 0)
{
CodeDom.CompilerErrorCollection es = compileResults.Errors;
var edList = new List<DataRuleLoadExceptionDetails>();
foreach (CodeDom.CompilerError s in es)
edList.Add(new DataRuleLoadExceptionDetails() { Message = s.ErrorText, LineNumber = s.Line });
var rde = new RuleDefinitionException(source, edList.ToArray());
throw rde;
}
}
}
}
यदि कोई अन्य प्रश्न या टिप्पणी या आगे के कोड नमूने के लिए अनुरोध हैं, तो मुझे बताएं।