क्या async एक्सपोज़र करने वाला इंटरफ़ेस एक टपका हुआ अमूर्त कार्य है?


13

मैं पुस्तक डिपेंडेंसी इंजेक्शन सिद्धांत, अभ्यास और पैटर्न पढ़ रहा हूं और मैंने टपकी अमूर्तता की अवधारणा के बारे में पढ़ा है जो पुस्तक में अच्छी तरह वर्णित है।

इन दिनों मैं निर्भरता इंजेक्शन का उपयोग करते हुए C # कोड बेस को रिफ्लेक्ट कर रहा हूं, ताकि ब्लॉक करने के बजाय async कॉल का उपयोग किया जाए। ऐसा करने से मैं कुछ इंटरफेस पर विचार कर रहा हूं जो मेरे कोड बेस में अमूर्तता का प्रतिनिधित्व करते हैं और जिसे फिर से डिजाइन करने की आवश्यकता है ताकि एसिंक्स कॉल का उपयोग किया जा सके।

एक उदाहरण के रूप में, अनुप्रयोग उपयोगकर्ताओं के लिए भंडार का प्रतिनिधित्व करने वाले निम्नलिखित इंटरफ़ेस पर विचार करें:

public interface IUserRepository 
{
  Task<IEnumerable<User>> GetAllAsync();
}

पुस्तक की परिभाषा के अनुसार एक टपकी अमूर्तता एक अमूर्तता है जिसे एक विशिष्ट कार्यान्वयन को ध्यान में रखते हुए बनाया गया है, ताकि कुछ कार्यान्वयन विवरण "अमूर्त" के माध्यम से ही "लीक" हो जाएं।

मेरा प्रश्न निम्नलिखित है: क्या हम एक ऐसे इंटरफ़ेस को ध्यान में रख सकते हैं, जो IUserRepository के रूप में, एक Leaky Abstraction का उदाहरण है?

बेशक सभी संभावित कार्यान्वयन में अतुल्यकालिकता के साथ कुछ करना नहीं है: केवल प्रक्रिया कार्यान्वयन से बाहर (जैसे कि एसक्यूएल कार्यान्वयन) करते हैं, लेकिन मेमोरी रिपॉजिटरी में अतुल्यकालिक की आवश्यकता नहीं होती है (वास्तव में इंटरफ़ेस के मेमोरी संस्करण में कार्यान्वयन संभवतः अधिक होता है यदि इंटरफ़ेस async मेथड्स को उजागर करता है, उदाहरण के लिए, आपको संभवतः टास्क की तरह कुछ वापस करना होगा।

तुम उसके बारे में क्या सोचते हो ?


@ नील मुझे शायद बात समझ में आ गई। टास्क या टास्क <T> लौटाने वाला एक इंटरफ़ेस एक्सपोज़िंग प्रति सेकेड एब्सट्रैक्ट नहीं है, बस एक हस्ताक्षर युक्त कार्य है। टास्क या टास्क <T> को वापस करने का एक तरीका एक async कार्यान्वयन नहीं है (उदाहरण के लिए यदि मैं कार्य को पूरा करके कार्य बनाता हूँ। इसके विपरीत, C # में async कार्यान्वयन की आवश्यकता है कि एक async विधि का रिटर्न प्रकार टास्क या टास्क <T> का होना चाहिए। मेरे इंटरफेस का एकमात्र "टपका हुआ" पहलू एक और तरीका है, जो कि नाम में
एसिंक्स

@ नील वास्तव में एक नामकरण दिशानिर्देश है, जिसमें कहा गया है कि सभी async विधियों का एक नाम "Async" समाप्त होना चाहिए। लेकिन इसका मतलब यह नहीं है कि टास्क या टास्क <T> लौटाने वाली विधि को Async प्रत्यय के साथ नामित किया जाना चाहिए क्योंकि इसे async कॉल का उपयोग करके लागू किया जा सकता है।
एनरिको मासोन

6
मैं तर्क करूँगा कि 'asyncness' एक विधि का संकेत इस तथ्य से है कि यह एक रिटर्न देता है Task। Async शब्द के साथ async मेथड प्रत्यय करने के लिए दिशा-निर्देश अलग-अलग API कॉल्स (रिटर्न प्रकार के आधार पर C # केंट प्रेषण) के बीच अंतर करना था। हमारी कंपनी में हमने यह सब एक साथ गिरा दिया है।
रिचज़िला

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

2
:-) -> "कार्यात्मक प्रोग्रामिंग लोग" हा। Async तुल्यकालिक से अधिक लीक नहीं है, यह सिर्फ इसलिए लगता है क्योंकि हम डिफ़ॉल्ट रूप से सिंक कोड लिखने के लिए उपयोग किए जाते हैं। यदि हम सभी डिफ़ॉल्ट रूप से async कोडित करते हैं, तो एक तुल्यकालिक फ़ंक्शन लीक हो सकता है।
StarTrekRedneck

जवाबों:


8

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

कपोल-कल्पना

सार की मेरी पसंदीदा परिभाषा रॉबर्ट सी। मार्टिन के एपीपीपी से ली गई है :

"एक अमूर्त आवश्यक और अप्रासंगिक के उन्मूलन का प्रवर्धन है।"

इस प्रकार, इंटरफेस, अपने आप में, सार नहीं हैं । वे केवल सार हैं यदि वे सतह पर लाते हैं जो मायने रखता है, और बाकी को छुपाता है।

टपका हुआ

पुस्तक निर्भरता इंजेक्शन सिद्धांत, पैटर्न, और अभ्यास निर्भरता इंजेक्शन (DI) के संदर्भ में टपका हुआ अमूर्त शब्द को परिभाषित करता है । इस संदर्भ में बहुरूपता और ठोस सिद्धांत एक बड़ी भूमिका निभाते हैं।

से निर्भरता उलट सिद्धांत (DIP) यह मानता है, इस प्रकार फिर से APPP के हवाले से, कि:

"क्लाइंट [...] अमूर्त इंटरफेस के मालिक हैं"

इसका मतलब यह है कि ग्राहक (कॉलिंग कोड) उन अमूर्तताओं को परिभाषित करते हैं जिनकी उन्हें आवश्यकता होती है, और फिर आप उस अमूर्त को लागू करते हैं।

मेरे विचार में एक टपका हुआ अमूर्त , एक अमूर्तता है जो डीआईपी का उल्लंघन किसी तरह से कुछ कार्यक्षमता सहित करता है जिसकी क्लाइंट को आवश्यकता नहीं है

तुल्यकालिक निर्भरताएँ

एक ग्राहक जो व्यावसायिक तर्क का एक टुकड़ा लागू करता है, आमतौर पर DI को कुछ कार्यान्वयन विवरणों, जैसे कि, आमतौर पर, डेटाबेस से स्वयं को हटाने के लिए उपयोग करेगा।

एक डोमेन ऑब्जेक्ट पर विचार करें जो एक रेस्तरां आरक्षण के लिए अनुरोध को संभालता है:

public class MaîtreD : IMaîtreD
{
    public MaîtreD(int capacity, IReservationsRepository repository)
    {
        Capacity = capacity;
        Repository = repository;
    }

    public int Capacity { get; }
    public IReservationsRepository Repository { get; }

    public int? TryAccept(Reservation reservation)
    {
        var reservations = Repository.ReadReservations(reservation.Date);
        int reservedSeats = reservations.Sum(r => r.Quantity);

        if (Capacity < reservedSeats + reservation.Quantity)
            return null;

        reservation.IsAccepted = true;
        return Repository.Create(reservation);
    }
}

यहाँ, ग्राहक, वर्ग द्वारा IReservationsRepositoryनिर्भरता का निर्धारण विशेष रूप से किया जाता है MaîtreD:

public interface IReservationsRepository
{
    Reservation[] ReadReservations(DateTimeOffset date);
    int Create(Reservation reservation);
}

यह इंटरफ़ेस पूरी तरह से सिंक्रोनस है क्योंकि MaîtreDक्लास को एसिंक्रोनस होने की आवश्यकता नहीं है

अतुल्यकालिक निर्भरताएँ

आप आसानी से अतुल्यकालिक होने के लिए इंटरफ़ेस बदल सकते हैं:

public interface IReservationsRepository
{
    Task<Reservation[]> ReadReservations(DateTimeOffset date);
    Task<int> Create(Reservation reservation);
}

MaîtreDवर्ग, हालांकि, यह नहीं है की जरूरत है उन तरीकों अतुल्यकालिक होने की, तो अब DIP का उल्लंघन किया है। मैं इसे एक टपका हुआ अमूर्त मानता हूं, क्योंकि एक कार्यान्वयन विवरण क्लाइंट को बदलने के लिए मजबूर करता है। TryAcceptविधि अब भी अतुल्यकालिक बनना पड़ता है:

public async Task<int?> TryAccept(Reservation reservation)
{
    var reservations =
        await Repository.ReadReservations(reservation.Date);
    int reservedSeats = reservations.Sum(r => r.Quantity);

    if (Capacity < reservedSeats + reservation.Quantity)
        return null;

    reservation.IsAccepted = true;
    return await Repository.Create(reservation);
}

डोमेन तर्क के लिए अतुल्यकालिक होने के लिए कोई अंतर्निहित तर्क नहीं है, लेकिन कार्यान्वयन की अतुल्यकालिकता का समर्थन करने के लिए, अब यह आवश्यक है।

बेहतर विकल्प

एनडीसी सिडनी 2018 में मैंने इस विषय पर बात की । इसमें, मैं एक विकल्प को भी रेखांकित करता हूं जो लीक नहीं करता है। मैं 2019 में भी कई सम्मेलनों में यह बात दे रहा हूं, लेकिन अब Async इंजेक्शन के नए शीर्षक के साथ फिर से लिखा गया है

मैं भी बात करने के लिए ब्लॉग पोस्ट की एक श्रृंखला प्रकाशित करने की योजना बना रहा हूं। ये लेख पहले से ही मेरे लेख कतार में बैठे हैं, प्रकाशित होने की प्रतीक्षा में हैं, इसलिए बने रहें।


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

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

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

11

यह बिलकुल नहीं है।

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

यदि फ़ंक्शन उजागर हुआ कि फ़ंक्शन को अतुल्यकालिक कैसे बनाया गया था, तो यह टपका होगा। यह कैसे कार्यान्वित किया जाता है, इसकी देखभाल आपको (नहीं / नहीं) करनी चाहिए।


5

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

यदि, इसके बजाय, आपकी लाइब्रेरी ने अपने भीतर सभी अतुल्यकालिक गतिविधि को ठीक से प्रबंधित किया है, तो आप asyncएपीआई से "लीक ' नहीं होने दे सकते हैं ।

सॉफ्टवेयर में कठिनाई के चार आयाम हैं: डेटा, नियंत्रण, स्थान और समय। अतुल्यकालिक संचालन सभी चार आयामों को फैलाते हैं, इस प्रकार, सबसे अधिक देखभाल की आवश्यकता होती है।


मैं आपकी भावना से सहमत हूं, लेकिन "लीक" का मतलब कुछ बुरा है, जो कि "लीक एब्स्ट्रैक्शन" शब्द का आशय है - अमूर्त में अवांछनीय कुछ। Async बनाम सिंक के मामले में, कुछ भी लीक नहीं हो रहा है।
StarTrekRedneck

2

एक टपका हुआ अमूर्त एक अमूर्तता है जिसे मन में एक विशिष्ट कार्यान्वयन के साथ डिज़ाइन किया गया है, ताकि कुछ कार्यान्वयन विवरण "अमूर्त" के माध्यम से "रिसाव" हो।

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

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

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


2

निम्नलिखित उदाहरणों पर विचार करें:

यह एक विधि है जो नाम को लौटने से पहले सेट करती है:

public void SetName(string name)
{
    _dataLayer.SetName(name);
}

यह एक विधि है जो नाम सेट करती है। जब तक लौटा कार्य पूरा नहीं हो जाता है, तब तक कॉलर यह नहीं मान सकता है कि नाम सेट है ( IsCompleted= true):

public Task SetName(string name)
{
    return _dataLayer.SetNameAsync(name);
}

यह एक विधि है जो नाम सेट करती है। जब तक लौटा कार्य पूरा नहीं हो जाता है, तब तक कॉलर यह नहीं मान सकता है कि नाम सेट है ( IsCompleted= true):

public async Task SetName(string name)
{
    await _dataLayer.SetNameAsync(name);
}

प्रश्न: कौन सा अन्य दो के साथ संबंध नहीं रखता है?

A: Async विधि वह नहीं है जो अकेले खड़ी हो। वह जो अकेला खड़ा है वह विधि है जो शून्य है।

मेरे लिए, "रिसाव" यहां asyncकीवर्ड नहीं है ; यह तथ्य है कि विधि एक टास्क लौटाती है। और वह रिसाव नहीं है; यह प्रोटोटाइप का हिस्सा है, और अमूर्त का हिस्सा है। एक async विधि जो किसी कार्य को लौटाती है वह समकालिक विधि द्वारा किए गए सटीक वादे को पूरा करती है जो किसी कार्य को देता है।

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


0

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

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


0

यहाँ एक विरोधी दृष्टिकोण है।

हम लौटने से लौटने के Fooलिए नहीं गए Task<Foo>क्योंकि हम Taskसिर्फ के बजाय चाहते थे Foo। दी, कभी-कभी हम बातचीत करते हैं Taskलेकिन सबसे वास्तविक दुनिया के कोड में हम इसे अनदेखा करते हैं और बस उपयोग करते हैं Foo

क्या अधिक है, हम अक्सर एस्सेन्स व्यवहार का समर्थन करने के लिए इंटरफेस को परिभाषित करते हैं, भले ही कार्यान्वयन एसिंक्रोनस नहीं हो सकता है या नहीं।

वास्तव में एक इंटरफ़ेस जो Task<Foo>आपको बताता है कि कार्यान्वयन संभवतः अतुल्यकालिक है कि क्या यह वास्तव में है या नहीं, भले ही आप देखभाल कर सकते हैं या नहीं। यदि एक अमूर्त हमें इसके कार्यान्वयन के बारे में जानने की आवश्यकता से अधिक बताता है, तो यह टपका हुआ है।

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

यह कोई निर्णय नहीं है। जैसा कि अन्य ने बताया है, सभी अमूर्त रिसाव। यह एक अधिक प्रभाव पड़ता है क्योंकि यह हमारे कोड में async / प्रतीक्षा के एक लहर प्रभाव की आवश्यकता है क्योंकि कहीं न कहीं इसके अंत में कुछ ऐसा हो सकता है जो वास्तव में अतुल्यकालिक है।

क्या वह ध्वनि एक शिकायत की तरह है? यह मेरा इरादा नहीं है, लेकिन मुझे लगता है कि यह एक सटीक अवलोकन है।

एक संबंधित बिंदु यह दावा है कि "एक इंटरफ़ेस एक अमूर्त नहीं है।" मार्क सेमैन ने जो कुछ कहा है, उसका थोड़ा बहुत दुरुपयोग किया गया है।

"अमूर्त" की परिभाषा "इंटरफ़ेस" नहीं है, यहां तक ​​कि .NET में भी। अंश कई अन्य रूप ले सकते हैं। एक इंटरफ़ेस खराब अमूर्त हो सकता है या इसके कार्यान्वयन को इतनी बारीकी से दिखा सकता है कि एक अर्थ में यह शायद ही एक अमूर्त है।

लेकिन हम पूरी तरह से अमूर्त बनाने के लिए इंटरफेस का उपयोग करते हैं। इसलिए "इंटरफेस एब्स्ट्रैक्ट नहीं हैं" क्योंकि टॉस में एक सवाल इंटरफेस का उल्लेख करता है और एब्सट्रैक्ट ज्ञानवर्धक नहीं है।


-2

है GetAllAsync()वास्तव में async? मेरा मतलब है कि "async" नाम में है, लेकिन इसे हटाया जा सकता है। तो मैं फिर से पूछता हूं ... क्या एक फ़ंक्शन को लागू करना असंभव है जो रिटर्न देता है Task<IEnumerable<User>>जिसे सिंक्रोनाइज़ किया जाता है?

मुझे .Net के Taskप्रकार की बारीकियों का पता नहीं है , लेकिन यदि यह फ़ंक्शन को सिंक्रोनाइज़ करना असंभव है, तो सुनिश्चित करें कि यह एक टपका हुआ अमूर्त है (इस तरह से) लेकिन अन्यथा नहीं। मैं करना जानते हैं कि अगर यह एक था IObservableएक टास्क के बजाय, यह हो सकता है या तो सिंक्रोनस रूप से या async तो कुछ भी नहीं समारोह के बाहर जानता लागू किया है और इसलिए यह है कि विशेष तथ्य लीक नहीं है।


Task<T> async का मतलब है । आपको कार्य ऑब्जेक्ट तुरंत मिल जाता है, लेकिन उपयोगकर्ताओं के अनुक्रम के लिए इंतजार करना पड़ सकता है
कैलथ

मई प्रतीक्षा करने के लिए यह जरूरी async है इसका मतलब यह नहीं है। शल वेट का मतलब होगा async। संभवतः, यदि अंतर्निहित कार्य पहले ही चल चुका है, तो आपको प्रतीक्षा करने की आवश्यकता नहीं है।
डैनियल टी।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.