इलेक्ट्रॉनिक दस्तावेज़ प्रबंधन प्रणाली के निर्माण के उदाहरण पर विंडोज वर्कफ़्लो फ़ाउंडेशन का अवलोकन [भाग 2]

क्या एक छोटी सी टीम के लिए वर्कफ़्लो सिस्टम को विकसित करना एक असंभव कार्य है?

पिछली पोस्ट में, मैंने WF की वास्तुकला सुविधाओं की जांच की जब इस तकनीक को लागू करना सबसे अच्छा है। इस भाग में, मैं हस्तांतरण करूँगा कि कैसे एक विशिष्ट परियोजना में डब्ल्यूएफ को लागू किया जाता है।

इसलिए, कार्य इलेक्ट्रॉनिक दस्तावेज़ प्रबंधन प्रणाली को लागू करना है।

सुविधा के लिए, मैं इस हिस्से को कई ब्लॉकों में तोड़ दूंगा।

यह मॉड्यूल ASP.NET MVC तकनीक का उपयोग करके लागू किया गया था। आपको विभिन्न प्रकार के दस्तावेज़ बनाने और संपादित करने की अनुमति देता है, उन पर वर्कफ़्लो शुरू करते हैं। हम इसे यहां निर्दिष्ट करेंगे ताकि भविष्य में इसे संदर्भित किया जा सके, लेकिन हम इस पर विस्तार से विचार नहीं करेंगे।

हम मानते हैं कि हमारे पास दस्तावेज़ वर्ग हैं जो लगभग सामान्य इंटरफ़ेस को लागू करते हैं *:

/// <summary> ///   /// </summary> public interface IDocument { /// <summary> ///   /// </summary> int DocumentId { get; set; } /// <summary> ///   /// </summary> User Author { get; set; } /// <summary> ///    /// </summary> int AuthorId { get; set; } } 

* इसके बाद, उत्पादन कोड के सरलीकृत संस्करण का उपयोग सरल बनाने के लिए किया जाता है।

उपयोगकर्ता दस्तावेज़ गतिविधि शुरू करते हैं (बाद में - सामान्य गतिविधि)। साझा गतिविधियों में 2 इनपुट तर्क हैं:

 /// <summary> ///      /// </summary> public interface IDocumentWorkflow { /// <summary> ///   ( ) /// </summary> InArgument<int> DocumentId { get; set; } /// <summary> ///  ,   ( ) /// </summary> Inrgument<int> UserId { get; set; } } 

, यहाँ DocumentId दस्तावेज़ कुंजी है, और UserId गतिविधि शुरू करने वाले उपयोगकर्ता की कुंजी है।

इस प्रकार, सामान्य गतिविधियों में, केवल दस्तावेज़ कुंजी घुमाई जाती है, न कि संपूर्ण ऑब्जेक्ट, जो सहेजे गए वर्कफ़्लो की स्थिति को बहाल करने में समस्याओं से बचने में मदद करेगा यदि हमें भविष्य में दस्तावेज़ वर्ग को संशोधित करने की आवश्यकता है (उदाहरण के लिए, संपत्ति जोड़ें)।

इसके अलावा, प्रत्येक सामान्य गतिविधि के लिए, मेटाडेटा का एक निश्चित सेट अलग से संग्रहीत किया जाता है: लॉन्च करने के लिए विशेषाधिकार, दस्तावेजों के प्रकार जिनके द्वारा गतिविधि को चलाने की अनुमति दी जाती है, डायनेमिक LINQ - अभिव्यक्ति को यह जाँचने के लिए कि क्या इसे लॉन्च किया जा सकता है, और अन्य।

सामान्य गतिविधि - हमारे सिस्टम का कस्टम भाग - वर्कफ़्लो डिज़ाइनर द्वारा एन्कोड किया गया है और XAML के रूप में सहेजा गया है। हम नीचे डिजाइनर के कार्यान्वयन पर विचार करेंगे।

निम्नलिखित WF रनटाइम में गतिविधि लॉन्च करने के लिए कोड है।

 /// <summary> ///         /// </summary> /// <typeparam name="T">  </typeparam> /// <param name="documentId"> </param> /// <param name="userId"> </param> public static void StartDocumentWorkflow<T>(int documentId, int userId) where T: Activity, IDocumentWorkflow, new() { //              var wfApp = new WorkflowApplication(new T(), new Dictionary<string, object>() { { "DocumentId", documentid}, { "UserId", userId}}); //     wfApp.InstanceStore = new SqlWorkflowInstanceStore(ApplicationData.ConnectionString); wfApp.PersistableIdle = (e) => { // ,    –    return PersistableIdleAction.Unload; }; wfApp.Completed = (completeArg) => { //   }; wfApp.Aborted = (abortArg) => { //  }; wfApp.OnUnhandledException = (exceptionArg) => { //    return UnhandledExceptionAction.Abort; }; wfApp.Run(); } 

यहां एक बिंदु को स्पष्टीकरण की आवश्यकता है: यदि आवश्यक हो तो वर्कफ़्लो अपने राज्य को बनाए रखने में सक्षम होने के लिए, संपत्ति वर्ग का उपयोग करके भंडारण वर्ग SqlWorkflowInstanceStore का उदाहरण रनटाइम को दिया जाता है।

तो, समग्र गतिविधि ऊपर और चल रही है। लेकिन कुछ बिंदु पर, उसे अपने काम के लिए सिस्टम के उपयोगकर्ताओं से अतिरिक्त डेटा की आवश्यकता हो सकती है। इस डेटा के आधार पर, उसके तर्क के अनुसार, वह निष्पादन शाखा का चयन करता है, दस्तावेज़ के गुणों को बदलता है, सूचनाएं भेजता है, साथ ही साथ अन्य क्रियाएं भी करता है।

इसलिए, इस डेटा (बाद में - तर्क) का वर्णन करना आवश्यक है। 2 विकल्प थे। एक सार्वभौमिक प्रकार (कुंजी-मूल्य संग्रह) का वर्णन करें जिसका उपयोग किसी भी जानकारी को वर्कफ़्लो में स्थानांतरित करने के लिए किया जाएगा। लेकिन मैंने मजबूत टाइपिंग का लाभ उठाया और कस्टम तर्क की एक गतिशील रूप से भरी हुई लाइब्रेरी को लागू किया। कक्षाएं IAssignArgument इंटरफ़ेस लागू करें:

 /// <summary> ///        /// </summary> public interface IAssignArgument { /// <summary> ///  ,   /// </summary> int UserId { get; set; } } /// <summary> ///          /// </summary> public abstract class AssignArgumentBase : IAssignArgument { /// <summary> ///  ,   /// </summary> [DisplayName(" ")] [EditorBrowsable(EditorBrowsableState.Never)] public int UserId { get; set; } } [DisplayName("")] [Category("")] public sealed class Learn : AssignArgumentBase { } [DisplayName(" , , ")] [Category("")] public sealed class EnterNumberDateFile : AssignArgumentBase { [Required, DisplayName(" ")] public string Number {get; set;} [Required, DisplayName(" ")] public DateTime Date {get; set;} [FileId, Required, DisplayName("")] public int? FileId {get; set;} } 

जहाँ UserId वर्कफ़्लो के लिए Argument को स्थानांतरित करने वाले उपयोगकर्ता की कुंजी है।

अब हम स्वयं उस गतिविधि पर चलते हैं, जो इनपुट की प्रतीक्षा कर रही है। इन उद्देश्यों के लिए, NativeActivity <T> वर्ग गतिविधियों के आधार पुस्तकालय में प्रदान किया जाता है, जहां T गतिविधि का परिणाम है - हमारा तर्क। हम अपने वर्ग को मूल निवासी से विरासत में देते हैं:

 [DisplayName(" ...")] [Category("")] [Designer("DocWorkflow.Activities.Designer.GenericActivityDesigner, DocWorkflow.Activities.Designer")] public class AssignDocumentActivity<T> : NativeActivity<T> where T : class, IAssignArgument, new() { /// <summary> ///    /// </summary> [DisplayName("")] public new OutArgument<T> Result { get { return base.Result; } set { base.Result = value; } } /// <summary> ///    /// </summary> [DisplayName("")] [RequiredArgument] public InArgument<int> DocumentId { get; set; } /// <summary> ///  ,     /// </summary> [DisplayName(" ")] [RequiredArgument] public InArgument<int> UserId { get; set; } /// <summary> /// 1-  (   ): /// -       ,     ; /// -  . /// </summary> protected override void Execute(NativeActivityContext context) { var bookmarkName = Guid.NewGuid().ToString(); using (var store = new DataStore()) { store.Add(new AssignedDocumentInfo() { UserId = context.GetValue(this.UserId), WorkflowInstanceId = context.WorkflowInstanceId.ToString(), ActivityInstanceId = context.ActivityInstanceId.ToString(), WorkflowType = context.GetExtension<WorkflowInstInfo>().GetProxy().WorkflowDefinition.GetType().FullName, ArgumentType = typeof(T).FullName, BookmarkName = bookmarkName, DocumentId = context.GetValue(this.DocumentId), ActivityName = this.DisplayName, AssignedDate = DateTime.Now }); } context.CreateBookmark(bookmarkName, new BookmarkCallback(this.Continue)); } /// <summary> /// 2-  (   ): /// -       ; /// -    . /// </summary> protected void Continue(NativeActivityContext context, Bookmark bookmark, object obj) { using (var store = new DataStore()) { foreach (var item in store.AssignedDocumentInfo.Where(aa => aa.WorkflowInstanceId == context.WorkflowInstanceId.ToString() && aa.ActivityInstanceId == context.ActivityInstanceId.ToString() && aa.UserId == context.GetValue(this.UserId) && aa.BookmarkName == bookmark.Name).ToArray()) { store.Remove(item); } } Result.Set(context, (T)obj); } } 

जैसा कि आप देख सकते हैं, पहले चरण में यह गतिविधि राज्य को रिपॉजिटरी (दस्तावेज़ कुंजी, उपयोगकर्ता कुंजी जिसे कार्य सौंपा गया है, सामान्य गतिविधि का प्रकार, तर्क प्रकार, कार्रवाई का नाम, "पुनर्प्राप्ति के लिए बुकमार्क") को पुनर्स्थापित करने के लिए आवश्यक डेटा को बचाता है। दूसरे चरण में, यह इनपुट तर्क प्राप्त करता है और इसे जनरल स्ट्रीम के शरीर में उपयोग के लिए आउट पैरामीटर को पास करता है।

दस्तावेज़ कार्य मॉड्यूल, बदले में, उपयोगकर्ता को सौंपे गए कार्यों को देखता है, जब वर्कफ़्लो रिकवरी प्रक्रिया शुरू करते हैं, गतिशील रूप से तर्क के प्रकार के आधार पर एक दृश्य उत्पन्न करता है (यह कस्टम दृश्य सेट करना संभव है, निश्चित रूप से) उपयोगकर्ता से तर्क प्राप्त करता है और सामान्य गतिविधि को पुनर्स्थापित करने के लिए इसे पारित करता है। ।

तर्क की सख्त टाइपिंग ( प्रतिपक्षी तर्क है ["Prop1"] ) डिजाइनर में गतिविधि के निर्माण के चरण में तर्क के गुणों को कॉल की पुष्टि करने की अनुमति देता है।

एक धारा जो टाइप रूपांतरण के नियमों का उल्लंघन करती है, शुरू नहीं होगी। यही है, त्रुटियां संकलन चरण में होती हैं, और निष्पादन मंच पर नहीं, शाब्दिक रूप से।

निम्नलिखित वर्कफ़्लो को पुनर्स्थापित करने के लिए एक कोड है।

 public static void ResumeWorkflow<T>(int assignedDocumentInfoKey, T arg) where T: IAssignArgument { AssignedDocumentInfo assignedDocumentInfo = null; using (var store = new DataStore()) { //     assignedDocumentInfo = store.AssignedDocumentInfo .Where(aa => aa.AssignedDocumentInfoId=assignedDocumentInfoKey).First(); } var activity = (Activity) Activator.CreateInstance(Type.GetType(assignedDocumentInfo.WorkflowType)); WorkflowApplication wfApp = new WorkflowApplication(activity); wfApp.InstanceStore = new SqlWorkflowInstanceStore(ApplicationData.ConnectionString); wfApp.PersistableIdle = (e) => { return PersistableIdleAction.Unload; }; //    wfApp.Load(new Guid(assignedDocumentInfo.WorkflowInstanceId)); //           wfApp.ResumeBookmark(new Bookmark(assignedDocumentInfo.BookmarkName), arg); } 

मैं दो प्रकार की गतिविधि गुणों के बीच के अंतर को स्पष्ट करना चाहूंगा:

 public class MyActivity<T> : CodeActivity { public InArgument<int> UserId1 {get; set;} public int UserId2 {get; set;} } 

पहले मामले में, संपत्ति का वास्तविक मूल्य (यह OutArgument <T> और चर <T> पर भी लागू होता है) गतिविधि प्रक्रिया में एक भागीदार है, प्रक्रिया में मूल्य को बदल सकता है, भंडारण में अपने राज्य को बचा सकता है और पुनर्स्थापित कर सकता है: डिजाइनर में गतिविधि गुण तालिका का तत्व है। XAML में गतिविधि विशेषता है ।

दूसरे मामले में, मान एक स्थिर है - यह गतिविधि के दौरान नहीं बदलता है। एक्सएएमएल में अपरिवर्तनीय गतिविधि मापदंडों को बचाने के लिए इसका उपयोग करना सुविधाजनक है: डिजाइनर में गतिविधि गुण तालिका का एक तत्व - XAML में गतिविधि विशेषता है ।

अगला, हम भंडार में वस्तुओं को अपडेट करने के लिए गतिविधि का विश्लेषण करते हैं। वहाँ विकल्पों में से एक टन हो सकता है। उदाहरण के लिए, हम इसे बाल गतिविधियों की संरचना के रूप में लागू करते हैं। ऐसी गतिविधियों के लिए जिन्हें बाहर से डेटा की आवश्यकता नहीं होती है, आधार गतिविधि पुस्तकालय में एक विशेष कोडएक्टिविटी बेस क्लास भी लागू किया जाता है।

 /// <summary> ///         -  /// </summary> /// <typeparam name="T">  </typeparam> public abstract class ObjectSetPropertyActivity<T> : CodeActivity where T : class { public T Object { get; set; } } /// <summary> ///       -  /// </summary> /// <typeparam name="T">  </typeparam> /// <typeparam name="TProperty">  </typeparam> public class ObjectSetPropertyActivity<T, TProperty> : ObjectSetPropertyActivity<T> where T : class { /// <summary> ///   /// </summary> public string Property { get; set; } /// <summary> ///     ( ) /// </summary> [RequiredArgument] public InArgument<TProperty> Value { get; set; } protected override void Execute(CodeActivityContext context) { //   typeof(T).GetProperty(Property).SetValue(Object, Value.Get(context), null); } } /// <summary> /// ,      /// </summary> /// <typeparam name="T">   </typeparam> /// <typeparam name="TKey">  </typeparam> public class ObjectUpdateActivity<T, TKey> : CodeActivity where T : class { public ObjectUpdateActivity() { this.Activities = new Collection<ObjectSetPropertyActivity<T>>(); } /// <summary> ///     ( ) /// </summary> public InArgument<TKey> Key { get; set; } /// <summary> ///        /// </summary> public Collection<ObjectSetPropertyActivity<T>> Activities { get; set; } protected override void Execute(NativeActivityContext context) { if (this.Activities.Count > 0) { var store = new DocWorkflowDbContext(); var obj = store.LoadObject<T>(context.GetValue(Key)); var index = 0; CompletionCallback callback = (context1, activityInstance) => { index++; //    : //-  ; //-      . if (index < this.Activities.Count) { this.Activities[index].Object = obj; context1.ScheduleActivity(this.Activities[index], callback); } else { store.UpdateObject(obj); store.SaveChanges(); store.Dispose(); } }; //      this.Activities[index].Object = obj; //    context.ScheduleActivity(this.Activities[index], callback); } } } 

जैसा कि आप देख सकते हैं, मूल गतिविधि डेटाबेस से ऑब्जेक्ट को लोड करती है, ऑब्जेक्ट के गुणों को बदलने के लिए WF रनटाइम में सभी बाल गतिविधियों को लॉन्च करती है, और फिर रिपॉजिटरी में परिवर्तन को सहेजती है। गतिविधि प्रकारों की सार्वभौमिकता के कारण, हमारे पास डिज़ाइनर में ऑब्जेक्ट गुणों के लिए इनपुट नए मूल्यों का सत्यापन भी है।

तो यह गतिविधि डिजाइनर में दिख सकती है।

यह तकनीक का सबसे "चिपचिपा" हिस्सा है, अर्थात्, इस दायरे से परे थोड़ा सा एहसास करने के लिए, हमें "डांस और बीट टैम्बोरिन" की आवश्यकता है।

डिजाइनर को प्रौद्योगिकी WPF पर बनाया गया है।

यहां मुख्य तत्व वर्कफ़्लोडिजेनर है - ग्राफिक क्षेत्र जिसमें वर्कफ़्लो का निर्माण होता है।

प्रत्येक गतिविधि अपने स्वयं के डिजाइन ऑब्जेक्ट के साथ जुड़ी हो सकती है (वीएस में [डिजाइनर] विशेषता का उपयोग करके डब्ल्यूएफ तत्व - गतिविधि डिजाइनर लाइब्रेरी के डिजाइन को विकसित करने के लिए एक विशेष प्रकार की परियोजना भी है। वही गतिविधि के गुणों पर लागू होता है - [संपादक] विशेषता। यानी इस हिस्से में कुछ भी नया नहीं है, वास्तव में।

मैं कोड नहीं दूंगा, क्योंकि किसी ऐसी चीज की पहचान करना मुश्किल है जो बाहर खड़ी है और पर्याप्त रूप से कॉम्पैक्ट है। इसके लिए मैं कुछ लिंक दूंगा।

यहां एक डिजाइनर के कार्यान्वयन का एक शानदार उदाहरण है। यह एक मॉडल है कि कैसे XAML में एन्कोड की गई गतिविधियों को तुरंत नई गतिविधियों में बिल्डिंग ब्लॉक्स के रूप में इस्तेमाल किया जा सकता है। उदाहरण की ख़ासियत यह है कि प्रारंभिक गतिविधि में बदलाव से सभी गतिविधियों के एल्गोरिदम में बदलाव नहीं होता है, जहां शुरुआती एक का उपयोग किया जाता है। दुर्भाग्य से, यह "सुविधा" हमें पसंद नहीं आई।

और यहां उदाहरणों के साथ उत्कृष्ट WF पदों की एक श्रृंखला है (विशेष रूप से, आप डिजाइनर में एक सार्वभौमिक प्रकार के तर्कों को प्रतिस्थापित करके एक नमूना पा सकते हैं)। यदि आवश्यक हो, तो कम से कम "छलांग लगाना" आवश्यक होगा, लेकिन फिर भी करना होगा।

जैसा कि आप देख सकते हैं, विकास बहुत जटिल नहीं है, सिस्टम आसानी से विस्तार योग्य है। यदि वांछित है, तो हम एक गतिविधि को लागू कर सकते हैं जो परिवर्तन के लिए विशिष्ट दस्तावेज़ गुणों की उपलब्धता को नियंत्रित करता है, उदाहरण के लिए, और दस्तावेजों की सूची बनाए रखने के लिए मॉड्यूल में, इस कार्यक्षमता के लिए समर्थन करता है।

बहुत काम हुआ था? बड़ा एक। लेकिन क्या यह एक छोटी टीम के दांतों के लिए है? हां, यहां तक ​​कि 3 - 4 लोगों की टीम के लिए। और समय की उचित मात्रा में!

मुझे उम्मीद है कि इस पोस्ट की जानकारी आपके लिए उपयोगी होगी। अगर मुझे कुछ याद आया है, तो इसे सही ढंग से सेट नहीं किया गया है, या यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में आपका स्वागत है!