আমি একটি নিয়ম ইঞ্জিন তৈরি করেছি যা আপনাকে আপনার প্রশ্নের বর্ণনার চেয়ে আলাদা পদ্ধতির গ্রহণ করে তবে আমি মনে করি আপনি এটি আপনার বর্তমান পদ্ধতির চেয়ে অনেক বেশি নমনীয় বলে মনে করবেন।
আপনার বর্তমান পদ্ধতির একক সত্তা, "ব্যবহারকারী" এবং আপনার অবিচলিত নিয়মগুলি "সম্পত্তি নাম", "অপারেটর" এবং "মান" সনাক্ত করে seems আমার প্যাটার্নটি পরিবর্তে আমার ডেটাবেজে "এক্সপ্রেশন" কলামে প্রিডিট (ফানক <টি, বুল>) এর জন্য সি # কোড সঞ্চয় করে। বর্তমান নকশায়, কোড জেনারেশনটি ব্যবহার করে আমি আমার ডাটাবেস থেকে "বিধিগুলি" জিজ্ঞাসা করছি এবং "বিধি" প্রকারের সাথে একটি অ্যাসেমবিলি সংকলন করছি, প্রতিটি "পরীক্ষার" পদ্ধতি সহ with প্রতিটি নিয়ম প্রয়োগ করা হয় ইন্টারফেসের জন্য স্বাক্ষর এখানে:
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-বারের ঘটনা এবং আপনার বিধিগুলি মূল্যায়নের সময় প্রতিচ্ছবি ব্যবহার না করে আপনি একটি পারফরম্যান্স লাভ পান। আপনার অভিব্যক্তি রানটাইমের সময় যাচাই করা হয়েছে কারণ কোনও সম্পত্তির নামের বানান ইত্যাদি থাকলে সমাবেশটি সঠিকভাবে উত্পন্ন হয় না etc.
ইন-মেমরি এসেম্বলি তৈরির মেকানিকগুলি নিম্নরূপ:
- আপনার নিয়মগুলি ডিবি থেকে লোড করুন
- স্ট্রিংবিল্ডার এবং কিছু স্ট্রিং কনটেনটেশন ব্যবহার করে নিয়মগুলি এবং প্রত্যেকটির জন্য পুনরাবৃত্তি করুন IDataRule থেকে উত্তরাধিকার সূত্রে প্রাপ্ত শ্রেণীর প্রতিনিধিত্ব করে পাঠ্য লিখুন
- কোডডোম ব্যবহার করে সংকলন করুন - আরও তথ্য
এটি আসলে বেশ সহজ কারণ সংখ্যাগরিষ্ঠর জন্য এই কোডটি নির্মাণকারীতে সম্পত্তি বাস্তবায়ন এবং মান সূচনা। তা ছাড়া, কেবলমাত্র অন্য কোডটি হ'ল এক্সপ্রেশন।
দ্রষ্টব্য: কোডডোমে একটি সীমাবদ্ধতার কারণে আপনার অভিব্যক্তিটি .NET 2.0 (কোনও ল্যাম্বডাস বা অন্যান্য সি # 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
এর বাইরে আমি একটি ক্লাস করেছি যা আমি "ডেটাআরোলকলেশন" নামে পরিচিত, যা আইকোলিকেশন> প্রয়োগ করে। এটি আমাকে "টেস্টএল" সক্ষমতা তৈরি করতে সক্ষম করেছে এবং নাম অনুসারে একটি নির্দিষ্ট নিয়ম চালানোর জন্য একটি সূচক তৈরি করতে সক্ষম করেছে। এই দুটি পদ্ধতির বাস্তবায়ন এখানে দেওয়া হল।
/// <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);
}
আরও কোড: কোড জেনারেশন সম্পর্কিত কোডের জন্য একটি অনুরোধ ছিল। আমি নীচে অন্তর্ভুক্ত করেছি এমন 'RuleAsorsesGenerator' নামক শ্রেণিতে কার্যকারিতাটি encapsulated করেছি।
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;
}
}
}
}
যদি থেকে থাকে তাহলে অন্যান্য প্রশ্ন বা মন্তব্য বা আরও কোড নমুনার জন্য অনুরোধ, আমাকে জানাতে।