C # में एक और पैटर्न मिलान

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

• आमतौर पर "सामान्य" के करीब एफ # / स्काला के रूप में निर्माण करता है
• यदि संभव हो तो कोड के जितना संभव हो उतना करीब से पास करें / और यदि संभव हो तो / और

जो हुआ - उसके लिए मैं कट मांगता हूं

दिखावट

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



यहाँ का उपयोग करते समय यह कैसा दिखता है:

Func<string, int> match = new Matcher<string, int> { {s => string.IsNullOrEmpty(s), s => 0}, {s => true, s => s.Length} }; int len1 = match(null); // 0 int len2 = match("abc"); // 3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कार्यान्वयन

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

 public class ExprMatcher<TIn, TOut> : IEnumerable<Pair<Expression<Predicate<TIn>>, Expression<Func<TIn, TOut>>>> { private Func<TIn, TOut> _matcher; private Func<TIn, TOut> Matcher { get { return _matcher ?? (_matcher = CompileMatcher()); } } private readonly List<Pair<Expression<Predicate<TIn>>, Expression<Func<TIn, TOut>>>> _caseList = new List<Pair<Expression<Predicate<TIn>>, Expression<Func<TIn, TOut>>>>(); public void Add(Expression<Predicate<TIn>> predicate, Expression<Func<TIn, TOut>> function) { _caseList.Add(new Pair<Expression<Predicate<TIn>>, Expression<Func<TIn, TOut>>>(predicate, function)); } private Func<TIn, TOut> CompileMatcher() { var reverted = Enumerable.Reverse(_caseList).ToList(); var arg = Expression.Parameter(typeof(TIn)); var retVal = Expression.Label(typeof(TOut)); var matcher = Expression.Block( Expression.Throw(Expression.Constant(new MatchException("Provided value was not matched with any case"))), Expression.Label(retVal, Expression.Constant(default(TOut))) ); foreach (var pair in reverted) { retVal = Expression.Label(typeof(TOut)); var condition = Expression.Invoke(pair.First, arg); var action = Expression.Return(retVal, Expression.Invoke(pair.Second, arg)); matcher = Expression.Block( Expression.IfThenElse(condition, action, Expression.Return(retVal, matcher)), Expression.Label(retVal, Expression.Constant(default(TOut))) ); } return Expression.Lambda<Func<TIn, TOut>>(matcher, arg).Compile(); } public TOut Match(TIn value) { return Matcher(value); } public static implicit operator Func<TIn, TOut>(ExprMatcher<TIn, TOut> matcher) { return matcher.Match; } public IEnumerator<Pair<Expression<Predicate<TIn>>, Expression<Func<TIn, TOut>>>> GetEnumerator() { return _caseList.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

बीजगणितीय प्रकार

मेरे लिए C # का उपयोग करने का एक और नुकसान इसमें यूनियन प्रकारों की कमी थी। मैं उन्हें जोड़ना चाहता था, लेकिन साथ ही उनका उपयोग यथासंभव सुरक्षित (एनपीई के लिए) कर रहा था।

शुरुआत के लिए, दो प्रकारों का संयोजन लागू किया गया था:

 public sealed class Union<T1, T2> { public object Value { get; private set; } public T1 Value1 { get; private set; } public T2 Value2 { get; private set; } public Union(T1 value) { Value1 = value; Value = value; } public Union(T2 value) { Value2 = value; Value = value; } public static explicit operator T1(Union<T1, T2> value) { return value.Value1; } public static explicit operator T2(Union<T1, T2> value) { return value.Value2; } public static implicit operator Union<T1, T2>(T1 value) { return new Union<T1, T2>(value); } public static implicit operator Union<T1, T2>(T2 value) { return new Union<T1, T2>(value); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कंस्ट्रक्टर को दिए गए पैरामीटर के आधार पर, या तो Value1 या Value2 को उदाहरण में आरंभीकृत किया जाता है, और मूल्य को भी आरंभीकृत किया जाता है। यह आपको इसकी मदद से विधेय के प्रकार की जांच करने की तुलना करने की अनुमति देता है, इस बात की चिंता किए बिना कि मूल्य T1 और T2 के अलावा किसी अन्य प्रकार पर ले जाएगा। T4 टेम्पलेट इंजन का उपयोग करके, 17 प्रकार तक के यूनियन अधिभार उत्पन्न किए गए थे।

इसके अलावा, मिलानकर्ताओं के प्रारंभिककरण को आसान बनाने के लिए, मैचर और एक्सप्रैमर के वारिस लिखे गए:

 public class ExprMatcher<T1, T2, T3> : ExprMatcher<T1, Union<T2, T3>> {}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

तस्वीर को पूरा करने के लिए, बल्कि एक तुच्छ विकल्प भी लिखा गया था।



आशा है कि मेरा मिलान किसी के लिए उपयोगी होगा:

Bitbucket प्रोजेक्ट

नगेट पैकेज



आपका ध्यान के लिए धन्यवाद!