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

.NET के लिए कई तैयार समाधान हैं, लेकिन सबसे अधिक प्रासंगिक है ClickOnce। इस तकनीक को अब नया नहीं कहा जा सकता है, हालांकि, मेरी राय में, इसे बहुत पहले न तो गंभीर विकास प्राप्त हुआ, और न ही संपूर्ण कार्यक्षमता है।
यदि आप पहिया को फिर से स्थापित नहीं करना चाहते हैं, तो मैं आपको ClickOnce की क्षमताओं की बारीकी से जांच करने की सलाह देता हूं, और यदि आपके पास पर्याप्त कार्यक्षमता है, तो यह निश्चित रूप से आपकी पसंद है। हालाँकि, ClickOnce एक रामबाण नहीं है और यह हमेशा इसके साथ करना संभव नहीं है।

अब मैं ऑटो-अपडेट तंत्र के बारे में अपनी दृष्टि के बारे में बात करना चाहता हूं। मैं अंतिम सत्य होने का दावा नहीं करता, इसलिए रचनात्मक आलोचना और टिप्पणियों में सुझावों का स्वागत है।

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

इसलिए कार्य

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

कार्यान्वयन

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

मेरी ऑटो-अपडेट सेवा में 3 मॉड्यूल हैं:
1) अपडेट के साथ एक वेब सेवा, संस्करण वाले संस्करण, सभी समर्थित अनुप्रयोगों का डेटाबेस और बाकी सब कुछ जो यहां लाया जा सकता है (उदाहरण के लिए, एक विशिष्ट एप्लिकेशन को अपडेट करने की प्रक्रिया के लिए कुछ "दूरस्थ" सेटिंग्स)।
2) एक विंडोज सेवा जो एक वेब सेवा से कनेक्ट होगी और सभी हस्ताक्षरित एप्लिकेशन के अपडेट टाइमर और ऑन डिमांड के लिए चेक करेगी।
3) क्लाइंट-लाइब्रेरी, जो विंडोज-सर्विस अपडेटेटर से कनेक्ट करने का तरीका जानेंगे, साथ ही कॉलबैक इंटरफ़ेस के साथ एप्लिकेशन प्रदान करेगा।

मैंने इसे सभी 3 विधानसभाओं में रखा और उनके अनुसार नाम दिया।

Updater.Online - वेब सेवा
Updater.Service - विंडोज़ सेवा
Updater.Client - क्लाइंट मॉड्यूल

मैंने सामान्य अमूर्त के लिए एक और असेंबली भी चुनी - अपडेटर.डोमैन ।

अपडेटर ऑनलाइन

वेब सेवा के साथ शुरू करते हैं। यहां सब कुछ सरल है, सब कुछ एक CheckForUpdates पद्धति में धकेल दिया जा सकता है, जो ApplicationID और CurrentVersion को स्वीकार करता है, डेटाबेस में देखता है कि क्या इस एप्लिकेशन के लिए वर्तमान अपडेट हैं, और यदि वहाँ है, तो यह अपडेट या शून्य के साथ .z फ़ाइल को पथ देता है यदि कोई अद्यतन नहीं है। यह सबसे सरल मामला है, सामान्य तौर पर, क्वेरी परिणामों के साथ-साथ अधिक क्वेरी पैरामीटर भी हो सकते हैं।
सेवा अतिरिक्त जानकारी लौटा सकती है जो अद्यतन प्रक्रिया के दौरान काम आ सकती है। उदाहरण के लिए, एक सेवा पर आप यह संकेत दे सकते हैं कि किसी दिए गए एप्लिकेशन के लिए साइलेंट-मोड में अपडेट करना संभव है, अपडेट कैसे डाउनलोड करें, यह किस प्रारूप में है, इसका आकार क्या है, आदि।

अपडेटर सेवा

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

[ServiceContract(CallbackContract = typeof(IUpdateServiceCallback))] public interface IUpdaterService { #region Callback subsctibe/unsibscribe methods [OperationContract(IsOneWay = true)] void Subscribe(SubscribeRequest request); [OperationContract(IsOneWay = true)] void Unsubscribe(UnsubscribeRequest request); #endregion [OperationContract(IsOneWay = true)] void InstallAvalibleUpdates(InstallAvalibleUpdatesRequst request); [OperationContract(IsOneWay = true)] void DownloadUpdate(Guid applicationId); [OperationContract(IsOneWay = true)] void CheckForUpdates(Guid applicationId); } [ServiceContract] public interface IUpdateServiceCallback { [OperationContract(IsOneWay = true)] void OnUpdateDetected(UpdateDetectedEventArgs eventArgs); [OperationContract(IsOneWay = true)] void OnUpdateDownloaded(UpdateDownloadedEventArgs updateDetectedEventArgs); [OperationContract(IsOneWay = true)] void OnUpdateInstalled(UpdateInstalledEventArgs eventArgs); } 

सदस्यता की विधि में, मैं क्लाइंट से स्थिर शब्दकोश <TAppID, CallbackList> में आया एक कॉलबैक जोड़ता हूं, जहां TAPID एप्लिकेशन पहचानकर्ता है (मेरे पास मार्गदर्शन है), प्रत्येक एप्लिकेशन के लिए कॉलबैक की एक अलग सूची है।
यहां सदस्यता विधि का कार्यान्वयन है

 public void Subscribe(SubscribeRequest request) { //    calback   IUpdateServiceCallback callback = OperationContext.Current.GetCallbackChannel<IUpdateServiceCallback>(); // lock,       lock (sync) { //      Application   ID.   , //   . /     var app = applicationService.Get(request.ApplicationId); if (app == null) { app = new Application() { Id = request.ApplicationId }; applicationService.Add(app); } app.CurrentVersion = request.Version ?? app.CurrentVersion; app.RootFolderPath = request.RootFolder ?? app.RootFolderPath; app.Name = request.ApplicationName ?? app.Name; } //   callback'      , //     var list = GetEventList(request.ApplicationId) ?? new CallbacksList(); list.OnUpdateDetected += callback.OnUpdateDetected; list.OnUpdateDownloaded += callback.OnUpdateDownloaded; if (registredCallbacks.ContainsKey(request.ApplicationId)) { registredCallbacks[request.ApplicationId] = list; } else { registredCallbacks.Add(request.ApplicationId, list); } //     ,   //       ( //    ) ICommunicationObject obj = (ICommunicationObject)callback; obj.Closing += ClientClosing; obj.Closed += ClientClosed; applicationService.SaveChanges(); } 

साथ ही अपडेटर सर्विस में, मैंने कॉलबैक को कॉल करने के लिए स्टैटिक मेथड्स को जोड़ा है ताकि उनके कॉल के वास्तविक कार्यान्वयन को थोड़ा छुपाया जा सके। इन तरीकों को अपडेटर सेवा की तरफ बुलाया जाता है जब क्लाइंट पक्ष पर उचित घटनाओं को ट्रिगर करना आवश्यक होता है।

 private static Dictionary<Guid, CallbacksList> registredCallbacks; //      callback'   null     private static CallbacksList GetEventList(Guid appId) { CallbacksList result; return registredCallbacks.TryGetValue(appId, out result) ? result : null; } //   callback'    private static void PerformCallback(Guid applicationId, Action<CallbacksList> func) { try { var list = GetEventList(applicationId); if (list != null) { func(list); } } catch { } } //    OnUpdateDetected     //   ApplicatioId public static void OnUpdateDetected(UpdateDetectedEventArgs args) { PerformCallback(args.ApplicationId, callbacks => callbacks.OnUpdateDetected(args)); } 

सेवा पर भी, मैं एक "टाइमर" लॉन्च करता हूं, जो एक निर्दिष्ट अवधि के बाद सभी हस्ताक्षरित अनुप्रयोगों के अपडेट की जांच करता है।
ApplicationService मेरे कोड में दिखाई देती है, हालांकि मैंने इसे एक सेवा कहा है, यह हस्ताक्षरित अनुप्रयोगों और उनके लिए अपडेट के बारे में जानकारी के भंडार की तरह दिखता है।
यहां एप्लिकेशन क्लासेस और अपडेट हैं।

 public class Application { public Guid Id { get; set; } public String Name { get; set; } public Version CurrentVersion { get; set; } public String RootFolderPath { get; set; } public List<Update> Updates { get; set; } } public class Update { public String UpdateUrl { get; set; } public Version Version { get; set; } public bool IsInstalled { get; set; } public bool IsDownloaded { get; set; } public string UpdateLocalPath { get; set; } } 

अपडेटर क्लाइंट

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

 public interface IUpdatble { Guid ApplicationId { get; } String ApplicationName { get; } String RootFolder { get; } } public class UpdaterClient { private IUpdaterService client; private IUpdateble settings; private DuplexChannelFactory<IUpdaterService> factory; public UpdaterClient(IUpdateServiceCallback callback, IUpdateble settings) { this.settings = settings; var context = new InstanceContext(callback); var binding = new NetTcpBinding(); //     ,    //      , //    IUpdateServiceCallback factory = new DuplexChannelFactory<IUpdaterService>(context, binding, new EndpointAddress(UpdaterSettings.Default.UpdaterServiceUrl)); client = factory.CreateChannel(); } //    ,   //     Iupdateble , //      public void Subscribe() { client.Subscribe(new SubscribeRequest() { ApplicationId = settings.ApplicationId, RootFolder = settings.RootFolder, Version = settings.Version, ApplicationName = settings.ApplicationName }); } public void Unsubscribe() { client.Unsubscribe(new UnsubscribeRequest() { ApplicationId = settings.ApplicationId }); } public void InstallUpdates(bool reopenOnComplete) { InstallUpdates(reopenOnComplete); } public void DownloadUpdate() { client.DownloadUpdate(new DownloadUpdateRequest() { ApplicationId = settings.ApplicationId }); } public void CheckForUpdates() { client.CheckForUpdates(settings.ApplicationId); } public void InstallUpdates(bool reopenOnComplete) { client.InstallAvalibleUpdates(new InstallAvalibleUpdatesRequst() { ApplicationId = settings.ApplicationId, RestartOnComplete = reopenOnComplete }); } } 

खैर, बस इतना ही। इसका उपयोग क्लाइंट साइड पर निम्नानुसार किया जाता है - हम अपडेटर को कनेक्ट करते हैं। क्लाइंट असेंबली को कनेक्ट करते हैं, प्रकार का एक ऑब्जेक्ट बनाते हैं अपडेटरक्लाइंट, सदस्यता विधि को कॉल करें, और हमारा एप्लिकेशन नए अपडेट के बारे में सेवा से संदेश प्राप्त करना शुरू कर देता है।