व्यावहारिक उदाहरण जहां .net 4.0 में Tuple का उपयोग किया जा सकता है?

Question

मैंने .net 4 में टुपल को देखा है लेकिन मैं कल्पना नहीं कर पा रहा हूं कि इसका उपयोग कहां किया जा सकता है। हम हमेशा एक कस्टम वर्ग या संरचना बना सकते हैं।

Comments

शायद यह नोट करने के लिए एक अच्छी जगह है कि यह विषय बहुत पुराना है। देखिए C # 7 में क्या हुआ !

— माफ़-शीतल

Answer 1

वह बिंदु है - कस्टम क्लास या स्ट्रक्चर को हर समय नहीं बनाना अधिक सुविधाजनक है । यह एक सुधार जैसा है Actionया Func... आप इस प्रकार को स्वयं बना सकते हैं, लेकिन यह सुविधाजनक है कि वे ढांचे में मौजूद हैं।

Comments

संभवतः MSDN से इंगित करने के लायक है : "इस प्रकार का कोई भी सार्वजनिक स्थैतिक सदस्य थ्रेड सुरक्षित हैं। किसी भी उदाहरण के सदस्यों को थ्रेड सुरक्षित होने की गारंटी नहीं है। "

— मैट बोरजा

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

— थॉमस आइड

@ThomasEyde जो पिछले 15 सालों से वही कर रहे हैं। इस तरह अभिव्यक्ति बॉडिड सदस्यों को जोड़ा गया, और अब टुपल्स को महत्व देते हैं। C # 7 के इस संस्करण के लिए रिकॉर्ड-शैली की कक्षाएं अगस्त में (इस टिप्पणी से 9 महीने पहले) कटौती से चूक गईं, और संभवतः C # 8 में सामने आ रही हैं। ध्यान दें कि मूल्य टुपल्स मूल्य समानता की पेशकश करते हैं जहां सादे-पुराने वर्ग नहीं करते हैं । 2002 में यह सब वापस पेश करने की आवश्यकता होगी

— Panagiotis Kanavos

आप से क्या मतलब है convenient not to make a custom class। क्या आप का उपयोग कर कस्टम वर्ग उदाहरण बनाने का मतलब है =new..()?

— एलेक्स

Answer 2

ट्यूपल्स के साथ आप दो आयामी शब्दकोश (या उस मामले के लिए एन-आयामी) को आसानी से लागू कर सकते हैं। उदाहरण के लिए, मुद्रा विनिमय मानचित्रण को लागू करने के लिए आप इस तरह के शब्दकोश का उपयोग कर सकते हैं:

var forex = new Dictionary<Tuple<string, string>, decimal>();
forex.Add(Tuple.Create("USD", "EUR"), 0.74850m); // 1 USD = 0.74850 EUR
forex.Add(Tuple.Create("USD", "GBP"), 0.64128m);
forex.Add(Tuple.Create("EUR", "USD"), 1.33635m);
forex.Add(Tuple.Create("EUR", "GBP"), 0.85677m);
forex.Add(Tuple.Create("GBP", "USD"), 1.55938m);
forex.Add(Tuple.Create("GBP", "EUR"), 1.16717m);
forex.Add(Tuple.Create("USD", "USD"), 1.00000m);
forex.Add(Tuple.Create("EUR", "EUR"), 1.00000m);
forex.Add(Tuple.Create("GBP", "GBP"), 1.00000m);

decimal result;
result = 35.0m * forex[Tuple.Create("USD", "EUR")]; // USD 35.00 = EUR 26.20
result = 35.0m * forex[Tuple.Create("EUR", "GBP")]; // EUR 35.00 = GBP 29.99
result = 35.0m * forex[Tuple.Create("GBP", "USD")]; // GBP 35.00 = USD 54.58

Comments

मैं देश के संक्षिप्त विवरण के लिए Enum का उपयोग करूंगा। क्या यह संभव है?

— ज़ैक

यकीन है, यह समस्याओं के बिना काम करना चाहिए क्योंकि enums मूल्य प्रकार हैं।

— मारियोवी

@MarioVW इसे बहुआयामी सरणी का उपयोग करके भी पूरा किया जा सकता है। कैसे टपल को कोई फर्क पड़ता है?

— एलेक्स

Answer 3

वहाँ एक है उत्कृष्ट लेख हैMSDN पत्रिका में है जो पेट-दर्द और डिजाइन के विचारों के बारे में बात करता है जो TCL को BCL में जोड़ने में चला गया। एक मूल्य प्रकार और एक संदर्भ प्रकार के बीच चयन करना विशेष रूप से दिलचस्प है।

जैसा कि लेख स्पष्ट करता है, टपल के पीछे ड्राइविंग बल माइक्रोसॉफ्ट के अंदर बहुत सारे समूह थे, इसका उपयोग करने के लिए, एफ # टीम सामने। हालांकि उल्लेख नहीं किया गया है, मुझे लगता है कि C # (और VB.NET) में नए "डायनामिक" कीवर्ड के साथ कुछ ऐसा करना था, साथ ही ट्यूपल्स गतिशील भाषाओं में बहुत आम हैं।

यह अन्यथा अपने स्वयं के पोको बनाने के लिए विशेष रूप से बेहतर नहीं है, कम से कम आप सदस्यों को एक बेहतर नाम दे सकते हैं।

---

अद्यतन: C # संस्करण 7 में एक बड़े संशोधन के कारण, अब बहुत अधिक वाक्यविन्यास प्यार मिल रहा है। इस ब्लॉग पोस्ट में प्रारंभिक घोषणा ।

Answer 4

यहां एक छोटा सा उदाहरण है - मान लीजिए कि आपके पास एक ऐसा तरीका है जो उपयोगकर्ता आईडी को देखते हुए उपयोगकर्ता के हैंडल और ईमेल पते को देखने की आवश्यकता है। आप हमेशा एक कस्टम क्लास बना सकते हैं, जिसमें वह डेटा हो, या उस डेटा के लिए रेफ / आउट पैरामीटर का उपयोग कर सकते हैं, या आप केवल एक Tuple वापस कर सकते हैं और एक नया POCO बनाने के बिना एक अच्छी विधि हस्ताक्षर कर सकते हैं।

public static void Main(string[] args)
{
    int userId = 0;
    Tuple<string, string> userData = GetUserData(userId);
}

public static Tuple<string, string> GetUserData(int userId)
{
    return new Tuple<string, string>("Hello", "World");
}

Comments

यह एक अच्छा उदाहरण है, हालांकि टुपल के उपयोग को सही नहीं ठहराता है।

— अमिताभ

जब आप अलग-अलग मान लौटा रहे हैं, तो टुपल यहां एक सभ्य है; लेकिन एक टपल अधिक चमकता है जब आप अलग से एक से अधिक मान लौट रहे हैं प्रकार के ।

— मार्क रसखॉफ़

एक और अच्छा उदाहरण int.TryParse होगा, जैसा कि आप आउटपुट पैरामीटर को खत्म कर सकते हैं और इसके बजाय एक Tuple का उपयोग कर सकते हैं। तो आपके पास Tuple<bool, T> TryParse<T>(string input)आउटपुट पैरामीटर का उपयोग करने के बजाय हो सकता है , आपको एक टपल में दोनों मान वापस मिलें।

— तेजस

वास्तव में, ऐसा ही होता है जब आप F # से किसी भी TryParse विधि को कॉल करते हैं।

— जोएल म्यूलर

Answer 5

मैंने प्रोजेक्ट यूलर की समस्या 11 को हल करने के लिए एक टपल का उपयोग किया :

class Grid
{
    public static int[,] Cells = { { 08, 02, 22, // whole grid omitted

    public static IEnumerable<Tuple<int, int, int, int>> ToList()
    {
        // code converts grid to enumeration every possible set of 4 per rules
        // code omitted
    }
}

अब मैं पूरी समस्या को हल कर सकता हूं:

class Program
{
    static void Main(string[] args)
    {
        int product = Grid.ToList().Max(t => t.Item1 * t.Item2 * t.Item3 * t.Item4);
        Console.WriteLine("Maximum product is {0}", product);
    }
}

मैं इसके लिए एक कस्टम प्रकार का उपयोग कर सकता था, लेकिन यह बिल्कुल टुपल जैसा दिखता था ।

Answer 6

सी # टुपल सिंटैक्स हास्यास्पद रूप से भारी है, इसलिए ट्यूपल्स को घोषित करने के लिए दर्दनाक है। और इसका पैटर्न मिलान नहीं है, इसलिए वे उपयोग करने के लिए दर्दनाक हैं।

लेकिन कभी-कभी, आप बस इसके लिए एक वर्ग बनाए बिना वस्तुओं का एक तदर्थ समूह बनाना चाहते हैं। उदाहरण के लिए, मान लें कि मैं एक सूची एकत्र करना चाहता था, लेकिन मैं एक के बजाय दो मान चाहता था:

// sum and sum of squares at the same time
var x =
    Enumerable.Range(1, 100)
    .Aggregate((acc, x) => Tuple.Create(acc.Item1 + x, acc.Item2 + x * x));

मानों के संग्रह को एकल परिणाम में संयोजित करने के बजाय, आइए एकल परिणाम को मानों के संग्रह में विस्तारित करते हैं। इस फ़ंक्शन को लिखने का सबसे आसान तरीका है:

static IEnumerable<T> Unfold<T, State>(State seed, Func<State, Tuple<T, State>> f)
{
    Tuple<T, State> res;
    while ((res = f(seed)) != null)
    {
        yield return res.Item1;
        seed = res.Item2;
    }
}

fकुछ अवस्था को टुपल में परिवर्तित करता है। हम टुपल से पहला मान वापस करते हैं और अपना नया राज्य दूसरे मूल्य पर सेट करते हैं। यह हमें गणना के दौरान राज्य को बनाए रखने की अनुमति देता है।

आप इसे इस प्रकार उपयोग करते हैं:

// return 0, 2, 3, 6, 8
var evens =
    Unfold(0, state => state < 10 ? Tuple.Create(state, state + 2) : null)
    .ToList();

// returns 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
var fibs =
    Unfold(Tuple.Create(0, 1), state => Tuple.Create(state.Item1, Tuple.Create(state.Item2, state.Item1 + state.Item2)))
    .Take(10).ToList();

evensकाफी सीधा है, लेकिन fibsथोड़ा अधिक चतुर है। यह stateवास्तव में एक नलिका है जो क्रमशः फ़ाइबर (n-2) और फ़ाइबर (n-1) रखती है।

Comments

+1 टपल। क्रेटा के लिए शॉर्टहैंड हैnew Tuple<Guid,string,...>

— एरोनएलएस

@ जूलियट स्टेट कीवर्ड का क्या उपयोग

— irfandar

Answer 7

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

और वे अपने सभी वस्तुओं के हैशकोड को आंतरिक रूप से जोड़ते हैं; उदाहरण के लिए, यहां टपल का गेटहैशकोड (ILSpy से लिया गया है):

    int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
    {
        return Tuple.CombineHashCodes(comparer.GetHashCode(this.m_Item1), comparer.GetHashCode(this.m_Item2), comparer.GetHashCode(this.m_Item3));
    }

Answer 8

Tuples एक बार में कई async IO ऑपरेशन करने और सभी मानों को एक साथ वापस करने के लिए महान हैं। टपल के साथ और इसके बिना करने के उदाहरण यहां दिए गए हैं। Tuples वास्तव में आपके कोड को स्पष्ट कर सकता है!

बिना (गंदा घोंसले के शिकार!):

Task.Factory.StartNew(() => data.RetrieveServerNames())
    .ContinueWith(antecedent1 =>
        {
            if (!antecedent1.IsFaulted)
            {
                ServerNames = KeepExistingFilter(ServerNames, antecedent1.Result);
                Task.Factory.StartNew(() => data.RetrieveLogNames())
                    .ContinueWith(antecedent2 =>
                        {
                            if (antecedent2.IsFaulted)
                            {
                                LogNames = KeepExistingFilter(LogNames, antecedent2.Result);
                                Task.Factory.StartNew(() => data.RetrieveEntryTypes())
                                    .ContinueWith(antecedent3 =>
                                        {
                                            if (!antecedent3.IsFaulted)
                                            {
                                                EntryTypes = KeepExistingFilter(EntryTypes, antecedent3.Result);
                                            }
                                        });
                            }
                        });
            }
        });

टपल के साथ

Task.Factory.StartNew(() =>
    {
        List<string> serverNames = data.RetrieveServerNames();
        List<string> logNames = data.RetrieveLogNames();
        List<string> entryTypes = data.RetrieveEntryTypes();
        return Tuple.Create(serverNames, logNames, entryTypes);
    }).ContinueWith(antecedent =>
        {
            if (!antecedent.IsFaulted)
            {
                ServerNames = KeepExistingFilter(ServerNames, antecedent.Result.Item1);
                LogNames = KeepExistingFilter(LogNames, antecedent.Result.Item2);
                EntryTypes = KeepExistingFilter(EntryTypes, antecedent.Result.Item3);
            }
        });

यदि आप किसी भी तरह से एक निहित फ़ंक्शन के साथ एक अनाम फ़ंक्शन का उपयोग कर रहे थे, तो आप Tuple का उपयोग करके कोड को कम स्पष्ट नहीं कर रहे हैं। एक विधि से एक ट्यूपल को फिर से बनाना? कोड स्पष्टता का उपयोग करें जब मेरे विनम्र राय में कोड स्पष्टता महत्वपूर्ण है। मुझे पता है कि C # में कार्यात्मक प्रोग्रामिंग का विरोध करना कठिन है, लेकिन हमें उन सभी पुराने क्लूनी "ऑब्जेक्ट ओरिएंटेड" C # प्रोग्रामर्स पर विचार करना होगा।

Answer 9

टुपल्स का उपयोग कार्यात्मक भाषाओं में बहुत अधिक किया जाता है जो उनके साथ और अधिक कार्य कर सकती हैं, अब F # एक 'आधिकारिक' .net भाषा है जिसे आप C # से इसके साथ जोड़ना चाहते हैं और दो भाषाओं में लिखे कोड के बीच इन्हें पास कर सकते हैं।

Comments

कुछ लोकप्रिय स्क्रिप्टिंग भाषाओं जैसे पाइथन और रूबी के लिए टुपल्स भी बनाए गए हैं (जिसमें इंटरोप के लिए .Net कार्यान्वयन भी हैं ... आयरनपाइथन / रूबी)।

— मटनटिन्जाकोडोडेन्की

Answer 10

मैं Tupleज्यादातर परिदृश्यों से बचने की कोशिश करता हूं क्योंकि यह पठनीयता को नुकसान पहुंचाता है। तथापि,Tuple उपयोगी है जब आप असंबंधित डेटा समूह के लिए की जरूरत है।

उदाहरण के लिए, मान लीजिए कि आपके पास उन कारों और शहरों की सूची है, जिनमें उन्हें खरीदा गया था:

Mercedes, Seattle
Mustang, Denver
Mercedes, Seattle
Porsche, Seattle
Tesla, Seattle
Mercedes, Seattle

आप प्रत्येक शहर के लिए प्रत्येक कार के लिए कुल योग करना चाहते हैं:

Mercedes, Seattle [3]
Mustang, Denver [1]
Porsche, Seattle [1]
Tesla, Seattle [1]

ऐसा करने के लिए, आप एक बनाते हैं Dictionary। आपके पास कुछ विकल्प हैं:

1. एक बनाएँ Dictionary<string, Dictionary<string, int>>।
2. एक बनाएँ Dictionary<CarAndCity, int>।
3. एक बनाएँ Dictionary<Tuple<string, string>, int>।

पहले विकल्प के साथ पठनीयता खो जाती है। इसके लिए आपको बहुत अधिक कोड लिखना होगा।

दूसरा विकल्प काम करता है और रसीला है, लेकिन कार और शहर वास्तव में संबंधित नहीं हैं और शायद एक साथ एक वर्ग में नहीं हैं।

तीसरा विकल्प सुसाइड और क्लीन है। इसका अच्छा उपयोग है Tuple।

Answer 11

मेरे सिर के ऊपर से कुछ उदाहरण:

• एक X और Y स्थान (और यदि आपको पसंद है तो Z)
• एक चौड़ाई और ऊँचाई
• समय के साथ कुछ भी मापा जाता है

उदाहरण के लिए, आप केवल प्वाइंट / पॉइंटएफ और साइज़ / साइज़ एफआरएफ का उपयोग करने के लिए एक वेब एप्लिकेशन में System.Drawing को शामिल नहीं करना चाहेंगे।

Comments

Tupleग्राफिक परिचालनों को करते समय महत्वपूर्ण परिस्थितियों में उपयोगी है Pointया SomeVectorउपयोगी हो सकता है। यह दो मूल्यों पर प्रकाश डालता है जो एक-दूसरे से बहुत जुड़े होते हैं। मैंने अक्सर कोड पढ़ते समय StartTime और EndTime नाम की संपत्तियाँ देखी हैं, लेकिन एक दिनांक समय और एक अवधि से भी बेहतर, एक टपल आपको दोनों मानों पर विचार करने के लिए मजबूर करता है जो आप अपने व्यवसाय तर्क के इस क्षेत्र में काम कर रहे हैं। या "हे, डेटा बदल गया है (बूल) लौटा, यहाँ गहन बाइंडिंग के माध्यम से जाने के बजाय भारी संसाधित में डेटा (अन्य प्रकार) है।"

— लेओन पेलेटियर

Answer 12

आपको उपयोग करने में बहुत सावधानी बरतनी चाहिए Tupleऔर शायद ऐसा करने से पहले दो बार सोचें। मेरे पिछले अनुभव से मुझे पता चला कि Tupleकोड का उपयोग करना भविष्य में पढ़ना और समर्थन करना बहुत मुश्किल है। कुछ समय पहले, मुझे कुछ कोड ठीक करने थे, जहाँ लगभग हर जगह टुपल्स का उपयोग किया जाता था। उचित वस्तु मॉडल के बारे में सोचने के बजाय, उन्होंने सिर्फ टुपल्स का उपयोग किया। वह बुरा सपना था ... कभी-कभी मैं उस आदमी को मारना चाहता था जिसने कोड लिखा था ...

यह नहीं कहना चाहते कि आप का उपयोग नहीं करना चाहिए Tupleऔर यह बुराई या कुछ है और मुझे शत प्रतिशत यकीन है कि कुछ कार्य ऐसे हैं जहां Tupleसबसे अच्छा उम्मीदवार का उपयोग किया जाना है, लेकिन शायद आपको फिर से सोचना चाहिए, क्या आपको वास्तव में इसकी आवश्यकता है ?

Answer 13

तुपल्स के लिए सबसे अच्छा उपयोग मैंने पाया है जब एक विधि से 1 से अधिक प्रकार की वस्तु को वापस करने की आवश्यकता होती है, तो आप जानते हैं कि वे किस प्रकार की वस्तु और संख्या होगी, और यह एक लंबी सूची नहीं है।

अन्य सरल विकल्प एक 'आउट' पैरामीटर का उपयोग करेंगे

private string MyMethod(out object)

या एक शब्दकोश बना रही है

Dictionary<objectType1, objectType2>

हालांकि, टपल का उपयोग करने से या तो 'आउट' ऑब्जेक्ट बन जाता है या अनिवार्य रूप से डिक्शनरी में एंट्री दिखती है;

Answer 14

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

कार्य LINQ से बिना किसी अतिरिक्त वर्ग के JSON प्रतिक्रिया लिखना है:

 //I select some roles from my ORM my with subrequest and save results to Tuple list
 var rolesWithUsers = (from role in roles
                       select new Tuple<string, int, int>(
                         role.RoleName, 
                         role.RoleId, 
                         usersInRoles.Where(ur => ur.RoleId == role.RoleId).Count()
                      ));

 //Then I add some new element required element to this collection
 var tempResult = rolesWithUsers.ToList();
 tempResult.Add(new Tuple<string, int, int>(
                        "Empty", 
                         -1,
                         emptyRoleUsers.Count()
                      ));

 //And create a new anonimous class collection, based on my Tuple list
 tempResult.Select(item => new
            {
                GroupName = item.Item1,
                GroupId = item.Item2,
                Count = item.Item3
            });


 //And return it in JSON
 return new JavaScriptSerializer().Serialize(rolesWithUsers);

निस्संदेह हम अपने समूहों के लिए एक नई कक्षा की घोषणा के साथ ऐसा कर सकते थे, लेकिन नए वर्गों की घोषणा किए बिना इस तरह के अनूठे संग्रह बनाने का विचार था।

Answer 15

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

नीचे नमूना कोड।

...
...
// calling code.
var userDetails = await GetUserDetails(userId);
Console.WriteLine("Username : {0}", userDetails.Item1);
Console.WriteLine("User Region Id : {0}", userDetails.Item2);
...
...

private async Tuple<string,int> GetUserDetails(int userId)
{
    return new Tuple<string,int>("Amogh",105);
    // Note that I can also use the existing helper method (Tuple.Create).
}

टपल के बारे में और अधिक पढ़ें । उम्मीद है की यह मदद करेगा।

Comments

मुझे लगता है कि आप एक अनाम प्रकार या ऐरे (या डायनामिक सामग्री) को वापस नहीं करना चाहते थे

— ozzy432836

Answer 16

वस्तुओं के आकार बदलने पर जब आपको उन्हें तार के पार भेजने की आवश्यकता हो या आवेदन की विभिन्न परत को पास करना हो और कई वस्तुओं को एक में विलय कर दिया जाए:

उदाहरण:

var customerDetails = new Tuple<Customer, List<Address>>(mainCustomer, new List<Address> {mainCustomerAddress}).ToCustomerDetails();

ExtensionMethod:

public static CustomerDetails ToCustomerDetails(this Tuple<Website.Customer, List<Website.Address>> customerAndAddress)
    {
        var mainAddress = customerAndAddress.Item2 != null ? customerAndAddress.Item2.SingleOrDefault(o => o.Type == "Main") : null;
        var customerDetails = new CustomerDetails
        {
            FirstName = customerAndAddress.Item1.Name,
            LastName = customerAndAddress.Item1.Surname,
            Title = customerAndAddress.Item1.Title,
            Dob = customerAndAddress.Item1.Dob,
            EmailAddress = customerAndAddress.Item1.Email,
            Gender = customerAndAddress.Item1.Gender,
            PrimaryPhoneNo = string.Format("{0}", customerAndAddress.Item1.Phone)
        };

        if (mainAddress != null)
        {
            customerDetails.AddressLine1 =
                !string.IsNullOrWhiteSpace(mainAddress.HouseName)
                    ? mainAddress.HouseName
                    : mainAddress.HouseNumber;
            customerDetails.AddressLine2 =
                !string.IsNullOrWhiteSpace(mainAddress.Street)
                    ? mainAddress.Street
                    : null;
            customerDetails.AddressLine3 =
                !string.IsNullOrWhiteSpace(mainAddress.Town) ? mainAddress.Town : null;
            customerDetails.AddressLine4 =
                !string.IsNullOrWhiteSpace(mainAddress.County)
                    ? mainAddress.County
                    : null;
            customerDetails.PostCode = mainAddress.PostCode;
        }
...
        return customerDetails;
    }

Answer 17

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

मूल्यों को वापस करने के लिए एक वर्ग / संरचना का उपयोग करते हुए पहला विकल्प सीधा है। बस प्रकार बनाएं (इस उदाहरण में यह एक संरचना है) जैसे:

public struct Dimensions
{
public int Height;
public int Width;
public int Depth;
}

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

var values = new Tuple<int, int, int, int, int, int, int, Tuple<int, int, int>> (
1, 2, 3, 4, 5, 6, 7, new Tuple<int, int, int> (8, 9, 10));

बेशक, आप प्रत्येक एम्बेडेड Tuple के अंत में अधिक Tuples जोड़ना जारी रख सकते हैं, जिससे आपको किसी भी आकार के Tuple की आवश्यकता होगी।

Answer 18

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

यह लिखना आसान है, पढ़ना मुश्किल है। वर्गों, आंतरिक वर्गों, अनाम कक्षाओं आदि पर इसका कोई दृश्यमान लाभ नहीं है।

Answer 19

वैसे मैंने C # 7 में एक ही समस्या को हल करने के लिए 3 तरीके आजमाए और मुझे Tuples के लिए एक उपयोग का मामला मिला।

वेब परियोजनाओं में गतिशील डेटा के साथ काम करना कभी-कभी मैपिंग आदि के दौरान दर्द हो सकता है।

मैं जिस तरह से Tuple सिर्फ auto1 को आइटम 1, आइटम 2, आइटमएन पर मैप करता हूं, जो मुझे सरणी इंडेक्स का उपयोग करने की तुलना में अधिक मजबूत लगता है, जहां आप इंडेक्स आइटम से बाहर निकल सकते हैं या गुमनाम प्रकार का उपयोग कर सकते हैं जहां आप एक संपत्ति का नाम छोड़ सकते हैं।

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

using System;

namespace Playground
{
    class Program
    {
        static void Main(string[] args)
        {
            var tuple = GetTuple();
            Console.WriteLine(tuple.Item1);
            Console.WriteLine(tuple.Item2);
            Console.WriteLine(tuple.Item3);
            Console.WriteLine(tuple);

            Console.WriteLine("---");

            var dyn = GetDynamic();
            Console.WriteLine(dyn.First);
            Console.WriteLine(dyn.Last);
            Console.WriteLine(dyn.Age);
            Console.WriteLine(dyn);

            Console.WriteLine("---");

            var arr = GetArray();
            Console.WriteLine(arr[0]);
            Console.WriteLine(arr[1]);
            Console.WriteLine(arr[2]);
            Console.WriteLine(arr);

            Console.Read();

            (string, string, int) GetTuple()
            {
                return ("John", "Connor", 1);
            }

            dynamic GetDynamic()
            {
                return new { First = "John", Last = "Connor", Age = 1 };
            }

            dynamic[] GetArray()
            {
                return new dynamic[] { "John", "Connor", 1 };
            }
        }
    }
}