🛑 👆🏻 🐛 डेल्फी में इंटरफ़ेस ट्रिक्स 🚱 🗄️ 😂

नमस्ते।

आज ही, मैंने एक सहयोगी के साथ इंटरफेस पर चर्चा की। उसने मुझे अपनी दिलचस्प चाल के बारे में बताया, मैंने उसे अपने बारे में बताया, लेकिन घर पर ही मुझे इन चालों की पूरी ताकत का एहसास हुआ, खासकर अगर आप उन्हें एक साथ जोड़ते हैं।

सुविधाजनक स्वचालन और एमवीसी पैटर्न के प्रशंसक - कृपया, बिल्ली के नीचे।

ट्रिक 1. स्मार्ट कमजोर लिंक्स

उन लोगों के लिए जो नहीं जानते हैं - कमजोर (कमजोर) लिंक - लिंक जो काउंटर में वृद्धि नहीं करते हैं। मान लीजिए कि हमारे पास एक पेड़ है:

INode = interface function GetParent: INode; function ChildCount: Integer; function GetChild(Index: Integer): INode; end;

यदि एक वर्ग के अंदर जो कि इनकोड इंटरफ़ेस को लागू करता है, तो अभिभावक और बच्चे इस तरह संग्रहीत होंगे:

 TNode = class(TInterfacedObject, INode) private FParent: INode; FChild: array of INode; end;

वह पेड़ कभी नष्ट नहीं होगा। माता-पिता बच्चों को लिंक देते रहते हैं (और इस तरह उनका काउंटर बढ़ता है), और बच्चे माता-पिता के लिए। यह एक क्लासिक परिपत्र लिंक समस्या है, और इस मामले में कमजोर लिंक का सहारा लेते हैं। नई XE डेल्फी में, आप इसे लिख सकते हैं:

 TNode = class(TInterfacedObject, INode) private [weak] FParent: INode; FChild: array of INode; end;

और पुराने में - वे पॉइंटर को स्टोर करते हैं:

 TNode = class(TInterfacedObject, INode) private FParent: Pointer; FChild: array of INode; end;

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

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

लेकिन एक बहुत ही सुंदर समाधान है। और इस तरह से यह काम करता है। हम एक कमजोर लिंक इंटरफ़ेस और एक वर्ग लिखते हैं जो इसे लागू करता है:

  IWeakRef = interface function IsAlive: Boolean; function Get: IUnknown; end; TWeakRef = class(TInterfacedObject, IWeakRef) private FOwner: Pointer; public procedure _Clean; function IsAlive: Boolean; function Get: IUnknown; end; procedure TWeakRef._Clean; begin FOwner := nil; end; function TWeakRef.Get: IUnknown; begin Result := IUnknown(FOwner); end; function TWeakRef.IsAlive: Boolean; begin Result := Assigned(FOwner); end;

यहाँ सूचक के लिए सामान्य टाइपकास्ट है। यह वह कमजोर कड़ी है जिसके बारे में मैंने ऊपर बात की थी। लेकिन प्रमुख विधि IsAlive है , जो सही रिटर्न देता है - यदि वस्तु कमजोर संदर्भ द्वारा संदर्भित है - अभी भी मौजूद है। यह केवल समझने के लिए रहता है कि सुंदर तरीके से फॉनर को कैसे साफ किया जाए ।

हम इंटरफ़ेस लिखते हैं:

  IWeakly = interface ['{F1DFE67A-B796-4B95-ADE1-8AA030A7546D}'] function WeakRef: IWeakRef; end;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     }']  IWeakly = interface ['{F1DFE67A-B796-4B95-ADE1-8AA030A7546D}'] function WeakRef: IWeakRef; end;

जो एक कमजोर लिंक देता है और एक वर्ग लिखता है जो इस इंटरफ़ेस को लागू करता है:

  TWeaklyInterfacedObject = class(TInterfacedObject, IWeakly) private FWeakRef: IWeakRef; public function WeakRef: IWeakRef; destructor Destroy; override; end; destructor TWeaklyInterfacedObject.Destroy; begin inherited; FWeakRef._Clean; end; function TWeaklyInterfacedObject.WeakRef: IWeakRef; var obj: TWeakRef; begin if FWeakRef = nil then begin obj := TWeakRef.Create; obj.FOwner := Self; FWeakRef := obj; end; Result := FWeakRef; end;

हमने सिर्फ एक तरीका जोड़ा है जो सभी को एक कमजोर कड़ी देता है। और चूँकि वस्तु हमेशा अपने कमजोर लिंक के बारे में जानती है, इसलिए वह इसे अपने विध्वंसक में साफ कर देती है। अब जो कुछ है वह TInterfacedObject के बजाय TWeaklyInterfacedObject से प्राप्त करना है , बस इतना ही। कोई और अधिक असुरक्षित जातियां, पैर में शॉट्स और बेईमानी नहीं।

ट्रिक 2. सब्सक्राइबर्स मैकेनिज्म

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

इंटरफ़ेस-आधारित ईवेंट आमतौर पर इसे लागू करते हैं। उदाहरण के लिए, एक अलग ईवेंट इंटरफ़ेस बनाएं:

 IMouseEvents = interface procedure OnMouseMove(...); procedure OnMouseDown(...); procedure OnMouseUp(...); end;

और वस्तु की क्लासिक प्रक्रिया के बजाय इसे पास करें; उदाहरण के लिए, सदस्यता / सदस्यता समाप्त करने के तरीकों की एक जोड़ी में:

 IForm = interface procedure SubscribeMouse(const subscriber: IMouseEvents); procedure UnsubscribeMouse(const subscriber: IMouseEvents); end;

जब कोड बढ़ता है, और IMouseEvents इंटरफ़ेस थोड़ा बदलता है (उदाहरण के लिए, एक विधि जोड़ा जाता है), तो रिफैक्टरिंग बहुत अधिक तनाव करना शुरू कर देता है। उदाहरण के लिए, समान IMouseEvents का उपयोग IForm , IButton , IImage और अन्य बुरी आत्माओं में किया जाता है। हर जगह आपको सदस्यता को सही ढंग से सही करने की आवश्यकता है, ग्राहकों के लिए क्रॉल जोड़ें, आदि।

मैं निम्नलिखित चाल का उपयोग कर रहा हूँ। हम इंटरफ़ेस लिखते हैं:

  IPublisher = interface ['{CDE9EE5C-021F-4942-A92A-39FC74395B4B}'] procedure Subscribe (const ASubscriber: IUnknown); procedure Unsubscribe(const ASubscriber: IUnknown); end;

वह वर्ग जो इस इंटरफ़ेस को लागू करेगा (इसे TBasePublisher होने दें ) केवल सूची में से कुछ इंटरफेस जोड़ और हटा सकता है। भविष्य में, हम उन कक्षाओं को लिखते हैं जिन्हें मैं ब्रॉडकास्टर कहता हूं। यहां हमारे पास ईवेंट इंटरफ़ेस है:

  IGraphEvents = interface ['{2C7EF06A-2D63-4F25-80BC-7BA747463DB6}'] procedure OnAddItem(const ASender: IGraphList; const AItem: TGraphItem); procedure OnClear(const ASender: IGraphList); end;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     }']  IGraphEvents = interface ['{2C7EF06A-2D63-4F25-80BC-7BA747463DB6}'] procedure OnAddItem(const ASender: IGraphList; const AItem: TGraphItem); procedure OnClear(const ASender: IGraphList); end;

हम TBasePublisher से विरासत में प्राप्त करते हैं और निम्नलिखित ब्रोकेस्टर को लागू करते हैं:

  TGraphEventsBroadcaster = class(TBasePublisher, IGraphEvents) private procedure OnAddItem(const ASender: IGraphList; const AItem: TGraphItem); procedure OnClear(const ASender: IGraphList); end; procedure TGraphEventsBroadcaster.OnAddItem(const ASender: IGraphList; const AItem: TGraphItem); var arr: TInterfacesArray; i: Integer; ev: IGraphEvents; begin arr := GetItems; for i := 0 to Length(arr) - 1 do if Supports(arr[i], IGraphEvents, ev) then ev.OnAddItem(ASender, AItem); end; procedure TGraphEventsBroadcaster.OnClear(const ASender: IGraphList); var arr: TInterfacesArray; i: Integer; ev: IGraphEvents; begin arr := GetItems; for i := 0 to Length(arr) - 1 do if Supports(arr[i], IGraphEvents, ev) then ev.OnClear(ASender); end;

यही है, प्रसारक स्वयं ईवेंट इंटरफ़ेस लागू करता है, और कार्यान्वयन में यह सभी ग्राहकों के लिए समान ईवेंट भेजता है। फायदा यह है कि सब कुछ एक ही स्थान पर लागू किया जाता है, यदि आप IGraphEvents को कम से कम थोड़ा बदलते हैं तो यह संकलन नहीं करेगा। अब IForm , IButton , IImage zoo केवल TGraphEventsBroadcaster को अपने अंदर बनाते हैं और इसके तरीकों को कहते हैं, जैसे कि IForm के केवल एक ग्राहक हैं।

ट्रिक 3. स्मार्ट कमजोर लिंक + ग्राहक तंत्र

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

  IPublisher = interface ['{CDE9EE5C-021F-4942-A92A-39FC74395B4B}'] procedure Subscribe (const ASubscriber: IWeakly); procedure Unsubscribe(const ASubscriber: IWeakly); end;

अंदर ही, TBasePublisher प्रकाशक कमजोर लिंक TWeakRefArr = सरणी IWeakRef की एक सरणी संग्रहीत करता है;

  TBasePublisher = class(TInterfacedObject, IPublisher) private FItems: TWeakRefArr; protected function GetItems: TWeakRefArr; public procedure Subscribe (const ASubscriber: IWeakly); procedure Unsubscribe(const ASubscriber: IWeakly); end;

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

 procedure TGraphEventsBroadcaster.OnAddItem(const ASender: IGraphList; const AItem: TGraphItem); var arr: TWeakRefArr; i: Integer; ev: IGraphEvents; begin arr := GetItems; for i := 0 to Length(arr) - 1 do if IsAlive(arr[i]) then if Supports(arr[i].Get, IGraphEvents, ev) then ev.OnAddItem(ASender, AItem); end; procedure TGraphEventsBroadcaster.OnClear(const ASender: IGraphList); var arr: TWeakRefArr; i: Integer; ev: IGraphEvents; begin arr := GetItems; for i := 0 to Length(arr) - 1 do if IsAlive(arr[i]) then if Supports(arr[i].Get, IGraphEvents, ev) then ev.OnClear(ASender); end;

अब हम अनसब्सक्राइबिंग ऑर्डर के बारे में बिल्कुल चिंतित नहीं हैं। यदि हम सदस्यता समाप्त करना भूल गए - यह ठीक है। सब कुछ पारदर्शी हो गया, जैसा कि होना चाहिए।

चाल 4. मदद करने के लिए पुनः लोड करना

अंतिम स्पर्श:

  TAutoPublisher = packed record Publisher: IPublisher; class operator Add(const APublisher: TAutoPublisher; const ASubscriber: IWeakly): Boolean; class operator Subtract(const APublisher: TAutoPublisher; const ASubscriber: IWeakly): Boolean; end; class operator TAutoPublisher.Add(const APublisher: TAutoPublisher; const ASubscriber: IWeakly): Boolean; begin APublisher.Publisher.Subscribe(ASubscriber); Result := True; end; class operator TAutoPublisher.Subtract(const APublisher: TAutoPublisher; const ASubscriber: IWeakly): Boolean; begin APublisher.Publisher.Unsubscribe(ASubscriber); Result := True; end;

मुझे लगता है कि यह बिना शब्दों के स्पष्ट है। हम सिर्फ MyForm.MyEvents + MySubscriber करते हैं ; - हमने साइन अप किया। घटाया: MyForm.MyEvents - MySubscriber ; - सदस्यता समाप्त।

यदि यह कैसे काम करता है इसका उदाहरण नहीं दिया तो लेख पूरा नहीं होगा। इसलिए, यहां एक उदाहरण है । संक्षेप में:

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

IntfEx.pas - स्मार्ट कमजोर लिंक के कार्यान्वयन, कमजोर लिंक पर प्रकाशक TBasePublisher का आधार वर्ग + TAutoPublisher संरचना के माध्यम से अधिभार

Datas.pas - इस सूची को बदलते समय खींची गई वस्तुओं + घटना इंटरफ़ेस की सूची

DrawForm.pas - एक ऐसा वर्ग जो एक फार्म लागू करता है जिस पर आप आकर्षित कर सकते हैं। घटनाओं के लिए एक सदस्यता है।

HiddenForm.pas - छिपा हुआ मुख्य रूप (केवल विंडो लूप स्पिन करने के लिए आवेदन के लिए आवश्यक)

ठीक है, परियोजना फ़ाइल थोड़ा संशोधित है (प्रपत्र बनाए जाते हैं, जिस पर आप आकर्षित कर सकते हैं)

कमजोर लिंक का विचार मैक्सिडिक्स सरो के दिमित्री इलिंस द्वारा आविष्कार किया गया था और मेरे द्वारा अंतिम रूप दिया गया था।

युपीडी। रिलीज के साथ शुरू, डेल्फी 10.1 ने पूर्ण-विकसित [कमजोर] लिंक पेश किए। हुड के तहत, वे ऊपर वर्णित कमजोर लिंक के साथ सादृश्य द्वारा कार्यान्वित किए जाते हैं, और इंटरफ़ेस विलय होने पर स्वचालित रूप से शून्य में बदल जाता है। यहां पढ़ें: habr.com/en/post/282035

डेल्फी में इंटरफ़ेस ट्रिक्स

ट्रिक 1. स्मार्ट कमजोर लिंक्स

ट्रिक 2. सब्सक्राइबर्स मैकेनिज्म

ट्रिक 3. स्मार्ट कमजोर लिंक + ग्राहक तंत्र

चाल 4. मदद करने के लिए पुनः लोड करना

More articles: