"आइटम 1", "आइटम 2" की तुलना में टुपल कक्षाओं में बेहतर नामकरण


204

क्या एक ट्यूपल वर्ग का उपयोग करने का एक तरीका है, लेकिन इसमें वस्तुओं के नाम की आपूर्ति करें?

उदाहरण के लिए:

public Tuple<int, int, int int> GetOrderRelatedIds()

वह ऑर्डरग्रेगआईड, ऑर्डरटाइपआईडी, ऑर्डरसुबटाइपआईडी और ऑर्डररिएपरइयरआईड के लिए आईडी लौटाता है।

मेरे तरीके के उपयोगकर्ताओं को यह बताना अच्छा होगा कि कौन सा है। (जब आप विधि कहते हैं, तो परिणाम result.Item1, result.Item2, result.Item3, result.Item4 हैं। यह स्पष्ट नहीं है कि कौन सा है।)

(मुझे पता है कि मैं इन सभी Ids को रखने के लिए सिर्फ एक वर्ग बना सकता हूं, लेकिन यह इन Ids के पास पहले से ही उनकी अपनी कक्षाएं हैं जो वे रहते हैं और इस एक विधि के वापसी मूल्य के लिए एक वर्ग बनाना मूर्खतापूर्ण लगता है।)


1
आप अपना रोल करने जा रहे हैं - Tupleबहुत ही सामान्य है, इसलिए आपको बस इतना ही मिलेगा
BrokenGlass

नहीं आप ऐसा नहीं कर सकते, अधिक जानकारी के लिए इस लिंक को देखें msdn.microsoft.com/en-us/vcsharp/ee957397
Enigma State

1
मैं यह कहने के लिए उद्यम करूंगा कि आपके एपी के लिए एक सार्वजनिक रूप से डेटाटाइप के रूप में टपल का उपयोग करने की सिफारिश नहीं की जा सकती है। मैं आमतौर पर Tuple का उपयोग अल्पकालिक आंतरिक चीजों के लिए करता हूं जो किसी API के रिटर्न वैल्यू के रूप में नहीं है।
माइक बर्डिक

1
इस सुविधा के लिए वोट करें: visualstudio.uservoice.com/forums/121579-visual-studio-2015/…
John

4
यह C # 7 की वर्किंग लिस्ट में है github.com/dotnet/roslyn/issues/347
फिलिप डिंग

जवाबों:


277

C # 7.0 (Visual Studio 2017) में ऐसा करने के लिए एक नया निर्माण है:

(string first, string middle, string last) LookupName(long id)

68
वाक्य-विन्यास है List<(int first, int second)>। मुझे Visual Studio 2017 में काम करने के लिए NuGet से System.ValueTuple पैकेज डाउनलोड करना था।
मैट डेविस

14
मान बनाने के लिएreturn (first: first, middle: middle, last: last);
fiat

4
या केवल: return (first, middle, last);.NET 4.7.1 में (4.7.0 के लिए निश्चित नहीं)
वाटबाइबरीफ

1
आदेश में इसका इस्तेमाल करने के लिए आपको System.ValueTuple nuget package
Alex G

11
यह ध्यान दिया जाना चाहिए कि C # 7's ValueTuple, जबकि आमतौर पर महान है, एक उत्परिवर्तनीय मूल्य प्रकार (संरचना) है, जबकि Tupleएक अपरिवर्तनीय संदर्भ प्रकार (वर्ग) है। जहाँ तक मुझे पता है, Tupleदोस्ताना आइटम नामों के साथ एक संदर्भ प्रकार प्राप्त करने का कोई तरीका नहीं है ।
dx_over_dt

51

C # 7.0 तक, अपने स्वयं के प्रकार को परिभाषित करने की इस कमी को करने का कोई तरीका नहीं था।


13
मुझे विश्वास नहीं हो रहा है कि यह उत्तर 40 के स्कोर के साथ स्वीकार किया जाएगा। आप कम से कम यह दिखा सकते थे कि एक उचित कंस्ट्रक्टर के साथ एक वर्ग इसे कैसे स्थानापन्न कर सकता है।
bytecode77

1
@ bytecode77 खैर, बहुत जल्द यह जवाब गलत होने वाला है: github.com/dotnet/roslyn/issues/347
MarkPflug

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

3
C # 7 जारी होने के बाद, ऐसा करना संभव होगा: msdn.microsoft.com/en-us/magazine/mt595758.aspx
बुरक

11
क्यू 'में टैग के रूप में c # 4 है, इसलिए यद्यपि यह उत्तर संक्षिप्त है, फिर भी यह सही है।
स्टीव ड्रेक

33

यहाँ एक अति जटिल संस्करण है जो आप पूछ रहे हैं:

class MyTuple : Tuple<int, int>
{
    public MyTuple(int one, int two)
        :base(one, two)
    {

    }

    public int OrderGroupId { get{ return this.Item1; } }
    public int OrderTypeId { get{ return this.Item2; } }

}

सिर्फ क्लास क्यों नहीं बनाते?


2
क्या क्लास के बजाय इस मामले में स्ट्रक्चर बेहतर होगा?
मृत्यु

5
इसका जो मामूली लाभ मुझे दिखाई देता है, वह यह है कि यह स्वचालित रूप से बराबर ऑपरेटर को लागू करता है, यह जाँचता है कि 2 उदाहरण समान हैं यदि आइटम सभी समान हैं।
JSoet

8
इस दृष्टिकोण के लिए एक और दोष यह है कि आइटम 1 और आइटम 2 अभी भी MyTuple पर सार्वजनिक गुण हैं
RJFalconer

3
@ डुप्रेस्रेस टुप्ले स्वयं कक्षाएं हैं, इसलिए यदि आप सीधे से विरासत में प्राप्त करना चाहते हैं तो आप Tuple<T, T2>एक संरचना नहीं हो सकते।
Chakrava

3
मैं गलत हो सकता हूं, लेकिन मैं जहां भी किसी वस्तु को वापस करना चाहता हूं, वहां ज्यादातर टपल का इस्तेमाल करता हूं, लेकिन एक विशिष्ट वर्ग को परिभाषित नहीं करना चाहता हूं ..
जे।

12

.Net 4 के साथ, आप शायद इसे देख सकते हैं ExpandoObject, हालांकि, इस सरल मामले के लिए इसका उपयोग न करें क्योंकि संकलन-समय की त्रुटियां रन-टाइम त्रुटियाँ बन जाती हैं।

class Program
{
    static void Main(string[] args)
    {
        dynamic employee, manager;

        employee = new ExpandoObject();
        employee.Name = "John Smith";
        employee.Age = 33;

        manager = new ExpandoObject();
        manager.Name = "Allison Brown";
        manager.Age = 42;
        manager.TeamSize = 10;

        WritePerson(manager);
        WritePerson(employee);
    }
    private static void WritePerson(dynamic person)
    {
        Console.WriteLine("{0} is {1} years old.",
                          person.Name, person.Age);
        // The following statement causes an exception
        // if you pass the employee object.
        // Console.WriteLine("Manages {0} people", person.TeamSize);
    }
}
// This code example produces the following output:
// John Smith is 33 years old.
// Allison Brown is 42 years old.

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

var MyStuff = new
    {
        PropertyName1 = 10,
        PropertyName2 = "string data",
        PropertyName3 = new ComplexType()
    };

10

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

C # v7.0 शुरू करते हुए, अब टपल गुणों को नाम देना संभव है, जो पहले पूर्वनिर्धारित नामों को डिफ़ॉल्ट रूप से उपयोग करते थे Item1, Item2और इसी तरह।

टपल साहित्य के गुणों का नामकरण :

var myDetails = (MyName: "RBT_Yoga", MyAge: 22, MyFavoriteFood: "Dosa");
Console.WriteLine($"Name - {myDetails.MyName}, Age - {myDetails.MyAge}, Passion - {myDetails.MyFavoriteFood}");

कंसोल पर आउटपुट:

नाम - RBT_Yoga, आयु - 22, जुनून - डोसा

रिटर्निंग टपल एक विधि से (नाम गुण) :

static void Main(string[] args)
{
    var empInfo = GetEmpInfo();
    Console.WriteLine($"Employee Details: {empInfo.firstName}, {empInfo.lastName}, {empInfo.computerName}, {empInfo.Salary}");
}

static (string firstName, string lastName, string computerName, int Salary) GetEmpInfo()
{
    //This is hardcoded just for the demonstration. Ideally this data might be coming from some DB or web service call
    return ("Rasik", "Bihari", "Rasik-PC", 1000);
}

कंसोल पर आउटपुट:

कर्मचारी विवरण: रसिक, बिहारी, रसिक-पीसी, 1000

नाम वाले गुणों वाले Tuples की सूची बनाना

var tupleList = new List<(int Index, string Name)>
{
    (1, "cow"),
    (5, "chickens"),
    (1, "airplane")
};

foreach (var tuple in tupleList)
    Console.WriteLine($"{tuple.Index} - {tuple.Name}");

कंसोल पर आउटपुट:

1 - गाय 5 - मुर्गियां 1 - हवाई जहाज

मुझे उम्मीद है कि मैंने सब कुछ कवर कर लिया है। मामले में, कुछ भी है जो मैंने याद किया है तो कृपया मुझे टिप्पणियों में प्रतिक्रिया दें।

नोट : मेरा कोड स्निपेट यहां विस्तृत रूप से C # v7 के स्ट्रिंग इंटरपोलेशन सुविधा का उपयोग कर रहा है


3

MichaelMocko उत्तर दिया महान है,

लेकिन मैं कुछ चीजें जोड़ना चाहता हूं, जो मुझे समझनी थी

(string first, string middle, string last) LookupName(long id)

यदि आप उपयोग कर रहे हैं तो ऊपर दी गई लाइन आपको संकलित समय त्रुटि देगी .net फ्रेमवर्क

तो अगर आप एक परियोजना है कि उपयोग कर रहा है है .नेट फ्रेमवर्क <4.7 और अभी भी आप वैकल्पिक हल से ValueTuple उपयोग करना चाहते हैं स्थापित करने होगा इस nuget पैकेज


2

नहीं, आप टपल सदस्यों का नाम नहीं दे सकते।

इन-टू-बीच का उपयोग टुपल के बजाय एक्सपेंडेओबजेक्ट के लिए किया जाएगा।


2

यदि आपके आइटम के प्रकार सभी अलग-अलग हैं, तो यहां एक वर्ग है जिसे मैंने उन्हें अधिक सहजता से प्राप्त करने के लिए बनाया है।

इस वर्ग का उपयोग:

var t = TypedTuple.Create("hello", 1, new MyClass());
var s = t.Get<string>();
var i = t.Get<int>();
var c = t.Get<MyClass>();

सोर्स कोड:

public static class TypedTuple
{
    public static TypedTuple<T1> Create<T1>(T1 t1)
    {
        return new TypedTuple<T1>(t1);
    }

    public static TypedTuple<T1, T2> Create<T1, T2>(T1 t1, T2 t2)
    {
        return new TypedTuple<T1, T2>(t1, t2);
    }

    public static TypedTuple<T1, T2, T3> Create<T1, T2, T3>(T1 t1, T2 t2, T3 t3)
    {
        return new TypedTuple<T1, T2, T3>(t1, t2, t3);
    }

    public static TypedTuple<T1, T2, T3, T4> Create<T1, T2, T3, T4>(T1 t1, T2 t2, T3 t3, T4 t4)
    {
        return new TypedTuple<T1, T2, T3, T4>(t1, t2, t3, t4);
    }

    public static TypedTuple<T1, T2, T3, T4, T5> Create<T1, T2, T3, T4, T5>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
    {
        return new TypedTuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6> Create<T1, T2, T3, T4, T5, T6>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6, T7> Create<T1, T2, T3, T4, T5, T6, T7>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
    }

    public static TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8> Create<T1, T2, T3, T4, T5, T6, T7, T8>(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
    {
        return new TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
    }

}

public class TypedTuple<T>
{
    protected Dictionary<Type, object> items = new Dictionary<Type, object>();

    public TypedTuple(T item1)
    {
        Item1 = item1;
    }

    public TSource Get<TSource>()
    {
        object value;
        if (this.items.TryGetValue(typeof(TSource), out value))
        {
            return (TSource)value;
        }
        else
            return default(TSource);
    }

    private T item1;
    public T Item1 { get { return this.item1; } set { this.item1 = value; this.items[typeof(T)] = value; } }
}

public class TypedTuple<T1, T2> : TypedTuple<T1>
{
    public TypedTuple(T1 item1, T2 item2)
        : base(item1)
    {
        Item2 = item2;
    }

    private T2 item2;
    public T2 Item2 { get { return this.item2; } set { this.item2 = value; this.items[typeof(T2)] = value; } }
}

public class TypedTuple<T1, T2, T3> : TypedTuple<T1, T2>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3)
        : base(item1, item2)
    {
        Item3 = item3;
    }

    private T3 item3;
    public T3 Item3 { get { return this.item3; } set { this.item3 = value; this.items[typeof(T3)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4> : TypedTuple<T1, T2, T3>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4)
        : base(item1, item2, item3)
    {
        Item4 = item4;
    }

    private T4 item4;
    public T4 Item4 { get { return this.item4; } set { this.item4 = value; this.items[typeof(T4)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5> : TypedTuple<T1, T2, T3, T4>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5)
        : base(item1, item2, item3, item4)
    {
        Item5 = item5;
    }

    private T5 item5;
    public T5 Item5 { get { return this.item5; } set { this.item5 = value; this.items[typeof(T5)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6> : TypedTuple<T1, T2, T3, T4, T5>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6)
        : base(item1, item2, item3, item4, item5)
    {
        Item6 = item6;
    }

    private T6 item6;
    public T6 Item6 { get { return this.item6; } set { this.item6 = value; this.items[typeof(T6)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6, T7> : TypedTuple<T1, T2, T3, T4, T5, T6>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7)
        : base(item1, item2, item3, item4, item5, item6)
    {
        Item7 = item7;
    }

    private T7 item7;
    public T7 Item7 { get { return this.item7; } set { this.item7 = value; this.items[typeof(T7)] = value; } }
}

public class TypedTuple<T1, T2, T3, T4, T5, T6, T7, T8> : TypedTuple<T1, T2, T3, T4, T5, T6, T7>
{
    public TypedTuple(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, T8 item8)
        : base(item1, item2, item3, item4, item5, item6, item7)
    {
        Item8 = item8;
    }

    private T8 item8;
    public T8 Item8 { get { return this.item8; } set { this.item8 = value; this.items[typeof(T8)] = value; } }
}

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

और भगवान आपकी आत्मा पर दया कर सकते हैं।
जेमी एम।

1

यह बहुत कष्टप्रद है और मुझे उम्मीद है कि C # के भविष्य के संस्करण इस आवश्यकता को संबोधित करेंगे। मुझे लगता है कि आस-पास सबसे आसान काम एक अलग डेटा संरचना प्रकार का उपयोग करना है या अपनी पवित्रता के लिए और अपने कोड को पढ़ने वाले दूसरों की पवित्रता के लिए "आइटम" का नाम बदलना है।

Tuple<ApiResource, JSendResponseStatus> result = await SendApiRequest();
ApiResource apiResource = result.Item1;
JSendResponseStatus jSendStatus = result.Item2;

0

मुझे लगता है कि मैं एक वर्ग बनाऊंगा लेकिन दूसरा विकल्प आउटपुट पैरामीटर है।

public void GetOrderRelatedIds(out int OrderGroupId, out int OrderTypeId, out int OrderSubTypeId, out int OrderRequirementId)

चूँकि आपके Tuple में केवल पूर्णांक होते हैं, इसलिए आप इसका प्रतिनिधित्व कर सकते हैं a Dictionary<string,int>

var orderIds = new Dictionary<string, int> {
    {"OrderGroupId", 1},
    {"OrderTypeId", 2},
    {"OrderSubTypeId", 3},
    {"OrderRequirementId", 4}.
};

लेकिन मैं यह भी सलाह नहीं देता हूं।


0

हर कोई जीवन को इतना कठिन क्यों बना रहा है। Tuples बल्कि अस्थायी डाटा प्रोसेसिंग के लिए हैं। हर समय टुपल्स के साथ काम करने से कोड को किसी बिंदु पर समझने में बहुत मुश्किल होगी। हर चीज के लिए कक्षाएं बनाना अंततः आपकी परियोजना को धुंधला कर सकता है।

हालांकि यह संतुलन के बारे में है ...

आपकी समस्या कुछ ऐसी लगती है जिसके लिए आप एक वर्ग चाहते हैं। और सिर्फ पूर्णता के लिए, नीचे इस वर्ग में निर्माता भी हैं।


इसके लिए उचित पैटर्न है

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

public class OrderRelatedIds
{
    public int OrderGroupId { get; set; }
    public int OrderTypeId { get; set; }
    public int OrderSubTypeId { get; set; }
    public int OrderRequirementId { get; set; }

    public OrderRelatedIds()
    {
    }
    public OrderRelatedIds(int orderGroupId)
        : this()
    {
        OrderGroupId = orderGroupId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId)
        : this(orderGroupId)
    {
        OrderTypeId = orderTypeId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId, int orderSubTypeId)
        : this(orderGroupId, orderTypeId)
    {
        OrderSubTypeId = orderSubTypeId;
    }
    public OrderRelatedIds(int orderGroupId, int orderTypeId, int orderSubTypeId, int orderRequirementId)
        : this(orderGroupId, orderTypeId, orderSubTypeId)
    {
        OrderRequirementId = orderRequirementId;
    }
}

या, यदि आप इसे वास्तव में सरल चाहते हैं: आप टाइप इनिशियलाइज़र का भी उपयोग कर सकते हैं:

OrderRelatedIds orders = new OrderRelatedIds
{
    OrderGroupId = 1,
    OrderTypeId = 2,
    OrderSubTypeId = 3,
    OrderRequirementId = 4
};

public class OrderRelatedIds
{
    public int OrderGroupId;
    public int OrderTypeId;
    public int OrderSubTypeId;
    public int OrderRequirementId;
}

0

मैं सारांश में आइटम के नाम लिखूंगा .. इसलिए फंक्शन हेलोवर्ल्ड () पाठ पर मंडराते हुए हैलो कहेंगे = आइटम 1 और दुनिया = आइटम 2

 helloworld("Hi1,Hi2");

/// <summary>
/// Return hello = Item1 and world Item2
/// </summary>
/// <param name="input">string to split</param>
/// <returns></returns>
private static Tuple<bool, bool> helloworld(string input)
{
    bool hello = false;
    bool world = false;
    foreach (var hw in input.Split(','))
    {
        switch (hw)
        {
            case "Hi1":
                hello= true;
                break;
            case "Hi2":
                world= true;
                break;
        }

    }
    return new Tuple<bool, bool>(hello, world);
}

0

बस @MichaelMocko जवाब में जोड़ने के लिए। ट्यूपल्स के पास इस समय कुछ जोड़े हैं:

आप उन्हें EF अभिव्यक्ति पेड़ों में उपयोग नहीं कर सकते

उदाहरण:

public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        // Selecting as Tuple
        .Select(person => (person.Name, person.Surname))
        .First();
}

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

अपडेट के लिए इस मुद्दे को ट्रैक (और अपवोट) करें: https://github.com/dotnet/roslyn/issues/12897

समस्या को हल करने के लिए, आप इसे पहले गुमनाम प्रकार में डाल सकते हैं और फिर मान को टुपल में बदल सकते हैं:

// Will work
public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => new { person.Name, person.Surname })
        .ToList()
        .Select(person => (person.Name, person.Surname))
        .First();
}

एक अन्य विकल्प ValueTuple.Create का उपयोग करना है:

// Will work
public static (string name, string surname) GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => ValueTuple.Create(person.Name, person.Surname))
        .First();
}

संदर्भ:

आप उन्हें मेमनों में नहीं बदल सकते

समर्थन जोड़ने का प्रस्ताव है: https://github.com/dotnet/csharplang/issues/258

उदाहरण:

public static IQueryable<(string name, string surname)> GetPersonName(this PersonContext ctx, int id)
{
    return ctx.Persons
        .Where(person => person.Id == id)
        .Select(person => ValueTuple.Create(person.Name, person.Surname));
}

// This won't work
ctx.GetPersonName(id).Select((name, surname) => { return name + surname; })

// But this will
ctx.GetPersonName(id).Select(t => { return t.name + t.surname; })

संदर्भ:

वे अच्छी तरह से धारावाहिक नहीं करेंगे

using System;
using Newtonsoft.Json;

public class Program
{
    public static void Main() {
        var me = (age: 21, favoriteFood: "Custard");
        string json = JsonConvert.SerializeObject(me);

        // Will output {"Item1":21,"Item2":"Custard"}
        Console.WriteLine(json); 
    }
}

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

संदर्भ:


-1

आप एक वर्ग लिख सकते हैं जिसमें टपल शामिल है।

आपको समान और GetHashCode फ़ंक्शन को ओवरराइड करने की आवश्यकता है

और == और = = ऑपरेटर।

class Program
{
    public class MyTuple
    {
        private Tuple<int, int> t;

        public MyTuple(int a, int b)
        {
            t = new Tuple<int, int>(a, b);
        }

        public int A
        {
            get
            {
                return t.Item1;
            }
        }

        public int B
        {
            get
            {
                return t.Item2;
            }
        }

        public override bool Equals(object obj)
        {
            return t.Equals(((MyTuple)obj).t);
        }

        public override int GetHashCode()
        {
            return t.GetHashCode();
        }

        public static bool operator ==(MyTuple m1, MyTuple m2)
        {
            return m1.Equals(m2);
        }

        public static bool operator !=(MyTuple m1, MyTuple m2)
        {
            return !m1.Equals(m2);
        }
    }

    static void Main(string[] args)
    {
        var v1 = new MyTuple(1, 2);
        var v2 = new MyTuple(1, 2);

        Console.WriteLine(v1 == v2);

        Dictionary<MyTuple, int> d = new Dictionary<MyTuple, int>();
        d.Add(v1, 1);

        Console.WriteLine(d.ContainsKey(v2));
    }
}

वापस होगा:

सच

सच


2
यदि आपने पहले से ही इस डेटा प्रकार के लिए एक वर्ग लागू किया है, तो आप केवल गुणों के बजाय अंतर्निहित डेटा के लिए एक टपल क्यों घोषित करते हैं?
bytecode77

मैं tuple विशेषता का उपयोग करना चाहता हूं कि यह समतुल्य फ़ंक्शन
ss

वह बोनस हो सकता है। लेकिन दूसरी ओर आपने मूल रूप से गुण 1 से लेकर आइटम X तक की श्रेणी बनाई। मैं एक ट्यूपल का उपयोग करके उचित नामकरण और बराबरी () में अधिक कोड चुनूंगा।
bytecode77

-1

C # 7 टपल उदाहरण

var tuple = TupleExample(key, value);

     private (string key1, long value1) ValidateAPIKeyOwnerId(string key, string value)
            {
                return (key, value);
            }
      if (!string.IsNullOrEmpty(tuple.key1) && tuple.value1 > 0)
          {
                    //your code

                }     
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.