tuple ออกแบบมาเพื่อแก้ข้อกำหนดอะไร

ฉันกำลังดูคุณสมบัติ C # ใหม่ของสิ่งทู ฉันอยากรู้ว่าทูเพิลออกแบบมาเพื่อแก้ปัญหาอะไร

คุณใช้ tuples ทำอะไรในแอพของคุณ?

อัปเดต

ขอบคุณสำหรับคำตอบที่ผ่านมาให้ฉันดูว่าฉันมีสิ่งที่ตรงใจ ตัวอย่างที่ดีของทูเปิลถูกชี้ให้เห็นเป็นพิกัด หน้าตาแบบนี้ใช่ไหม

var coords = Tuple.Create(geoLat,geoLong);

จากนั้นใช้ทูเพิลดังนี้:

var myLatlng = new google.maps.LatLng("+ coords.Item1 + ", "+ coords.Item2 + ");

ถูกต้องหรือไม่

เมื่อเขียนโปรแกรมเป็นเรื่องปกติมากที่จะต้องการรวมกลุ่มของค่าที่มีเหตุผลเข้าด้วยกันซึ่งไม่มีความคล้ายคลึงกันเพียงพอที่จะแสดงเหตุผลในการสร้างคลาส

ภาษาการเขียนโปรแกรมจำนวนมากช่วยให้คุณสามารถจัดกลุ่มชุดของค่าที่ไม่เกี่ยวข้องกันอย่างมีเหตุผลโดยไม่ต้องสร้างประเภทด้วยวิธีเดียว:

void M(int foo, string bar, double blah)

ตรรกะนี้เหมือนกับเมธอด M ที่รับหนึ่งอาร์กิวเมนต์ซึ่งเป็น 3-tuple ของ int, string, double แต่ฉันหวังว่าคุณจะไม่ทำ:

class MArguments
{
   public int Foo { get; private set; } 
   ... etc

เว้นแต่ว่า MArguments จะมีความหมายอื่นในตรรกะทางธุรกิจ

แนวคิดของ "รวมกลุ่มข้อมูลที่ไม่เกี่ยวข้องกันไว้ด้วยกันในโครงสร้างบางส่วนที่มีน้ำหนักเบากว่าคลาส" มีประโยชน์ในหลาย ๆ ที่ไม่ใช่เฉพาะสำหรับรายการพารามิเตอร์ที่เป็นทางการ จะมีประโยชน์เมื่อเมธอดมีสองสิ่งที่ต้องส่งคืนหรือเมื่อคุณต้องการคีย์พจนานุกรมจากข้อมูลสองข้อมูลแทนที่จะเป็นหนึ่งข้อมูลและอื่น ๆ

ภาษาเช่น F # ซึ่งรองรับประเภททูเปิลให้ความยืดหยุ่นแก่ผู้ใช้เป็นอย่างมาก เป็นชุดข้อมูลที่มีประโยชน์อย่างยิ่ง ทีม BCL ตัดสินใจที่จะทำงานร่วมกับทีม F # เพื่อสร้างมาตรฐานของทูเพิลประเภทเดียวสำหรับเฟรมเวิร์กเพื่อให้ทุกภาษาได้รับประโยชน์จากพวกเขา

อย่างไรก็ตาม ณ จุดนี้ยังไม่มีการรองรับภาษาสำหรับทูเปิลใน C # Tuples เป็นเพียงประเภทข้อมูลอื่นเช่นเดียวกับคลาส Framework อื่น ๆ ไม่มีอะไรพิเศษเกี่ยวกับพวกเขา เรากำลังพิจารณาเพิ่มการสนับสนุนที่ดีขึ้นสำหรับสิ่งที่เพิ่มขึ้นใน C # เวอร์ชันสมมุติในอนาคต หากใครมีความคิดเห็นเกี่ยวกับคุณสมบัติที่เกี่ยวข้องกับสิ่งที่คุณต้องการดูเรายินดีที่จะส่งต่อให้กับทีมออกแบบ สถานการณ์ที่เป็นจริงมีความน่าเชื่อมากกว่าเนื้อหาทางทฤษฎี

Tuples นำเสนอการใช้งานคอลเลกชันที่ไม่เปลี่ยนรูป

นอกเหนือจากการใช้ทูเปิลทั่วไป:

• เพื่อจัดกลุ่มค่าส่วนกลางเข้าด้วยกันโดยไม่ต้องสร้างคลาส
• เพื่อคืนค่าหลายค่าจากฟังก์ชัน / วิธีการ
• ฯลฯ ...

วัตถุที่ไม่เปลี่ยนรูปเป็นด้ายที่ปลอดภัยโดยเนื้อแท้:

วัตถุที่ไม่เปลี่ยนรูปจะมีประโยชน์ในการใช้งานแบบมัลติเธรด เธรดหลายเธรดสามารถดำเนินการกับข้อมูลที่แสดงโดยอ็อบเจ็กต์ที่ไม่เปลี่ยนรูปได้โดยไม่ต้องกังวลว่าเธรดอื่นจะเปลี่ยนแปลงข้อมูล ดังนั้นวัตถุที่ไม่เปลี่ยนรูปจึงถูกพิจารณาว่ามีความปลอดภัยต่อเธรดมากกว่าวัตถุที่เปลี่ยนแปลงไม่ได้

จาก"Immutable Object"บนวิกิพีเดีย

มีทางเลือกให้refหรือoutถ้าคุณมีวิธีการที่ต้องการส่งคืนอ็อบเจ็กต์ใหม่หลายรายการเป็นส่วนหนึ่งของการตอบสนอง

นอกจากนี้ยังช่วยให้คุณสามารถใช้ประเภทในตัวเป็นประเภทส่งคืนได้หากสิ่งที่คุณต้องทำคือการผสมสองหรือสามประเภทที่มีอยู่และคุณไม่ต้องการเพิ่มคลาส / โครงสร้างสำหรับชุดค่าผสมนี้เท่านั้น (เคยต้องการให้ฟังก์ชันส่งคืนประเภทที่ไม่ระบุตัวตนหรือไม่นี่คือคำตอบบางส่วนสำหรับสถานการณ์นั้น)

การมีประเภท "คู่" มักจะเป็นประโยชน์ซึ่งใช้ในสถานการณ์ที่รวดเร็ว (เช่นการคืนค่าสองค่าจากวิธีการ) Tuples เป็นส่วนสำคัญของภาษาที่ใช้งานได้เช่น F # และ C # จะเลือกภาษาเหล่านี้

มีประโยชน์มากสำหรับการคืนค่าสองค่าจากฟังก์ชัน

โดยส่วนตัวแล้วฉันพบว่าทูเปิลเป็นส่วนหนึ่งของการพัฒนาเมื่อคุณอยู่ในวงจรการสืบสวนหรือแค่ "เล่น" เนื่องจาก Tuple เป็นแบบทั่วไปฉันมักจะนึกถึงเมื่อทำงานกับพารามิเตอร์ทั่วไปโดยเฉพาะอย่างยิ่งเมื่อต้องการพัฒนาโค้ดทั่วไปและฉันเริ่มต้นที่ส่วนท้ายรหัสแทนที่จะถามตัวเองว่า "ฉันจะเรียกสิ่งนี้อย่างไร มอง?".

บ่อยครั้งที่ฉันตระหนักดีว่าคอลเลกชันที่รูปแบบทูเพิลกลายเป็นส่วนหนึ่งของรายการและการดูรายการ> ไม่ได้แสดงถึงเจตนาของรายการหรือวิธีการทำงาน ฉันมักจะ "ใช้ชีวิต" กับมัน แต่พบว่าตัวเองต้องการจัดการรายการและเปลี่ยนค่า - ณ จุดนั้นฉันไม่จำเป็นต้องสร้าง Tuple ใหม่สำหรับสิ่งนั้นดังนั้นฉันต้องสร้างคลาสหรือโครงสร้างของตัวเอง เพื่อเก็บไว้ฉันจะได้เพิ่มรหัสการจัดการ

แน่นอนว่ามีวิธีการขยายอยู่เสมอ แต่บ่อยครั้งที่คุณไม่ต้องการขยายโค้ดพิเศษนั้นไปยังการใช้งานทั่วไป

มีหลายครั้งที่ฉันต้องการแสดงข้อมูลเป็นทูเพิล แต่ไม่มีทูเปิล (VS2008) ซึ่งในกรณีนี้ฉันเพิ่งสร้างคลาส Tuple ของตัวเอง - และฉันไม่ทำให้เธรดปลอดภัย (ไม่เปลี่ยนรูป)

ดังนั้นฉันเดาว่าฉันมีความเห็นว่า Tuples เป็นโปรแกรมที่ขี้เกียจเนื่องจากเสียชื่อประเภทที่อธิบายวัตถุประสงค์ ค่าใช้จ่ายอื่น ๆ คือคุณต้องประกาศลายเซ็นของ Tuple ไม่ว่าจะใช้เป็นพารามิเตอร์ หลังจากวิธีการหลายอย่างที่เริ่มดูบวมคุณอาจรู้สึกเหมือนฉันว่ามันคุ้มค่าที่จะสร้างคลาสเพราะมันจะล้างลายเซ็นของวิธีการ

ฉันมักจะเริ่มต้นด้วยการให้ชั้นเรียนเป็นสมาชิกสาธารณะของชั้นเรียนที่คุณทำงานอยู่แล้ว แต่ในขณะที่มันขยายออกไปไกลกว่าการรวบรวมค่าเพียงอย่างเดียวมันก็กลายเป็นไฟล์ของตัวเองและฉันย้ายมันออกจากชั้นเรียนที่มี

ดังนั้นเมื่อมองย้อนกลับไปฉันเชื่อว่าฉันใช้ Tuples เมื่อฉันไม่ต้องการที่จะออกไปเขียนชั้นเรียนและแค่อยากคิดเกี่ยวกับสิ่งที่ฉันเขียนในตอนนี้ ซึ่งหมายความว่าลายเซ็นของ Tuple อาจมีการเปลี่ยนแปลงค่อนข้างมากในข้อความครึ่งชั่วโมงในขณะที่ฉันคิดว่าฉันต้องการข้อมูลใดสำหรับวิธีนี้และวิธีการคืนค่าที่เคยจะคืนค่า

ถ้าฉันมีโอกาส refactor code ฉันมักจะตั้งคำถามกับสถานที่ของ Tuple ในนั้น

คำถามเก่าตั้งแต่ปี 2010 และตอนนี้ในปี 2017 Dotnet มีการเปลี่ยนแปลงและฉลาดขึ้น

C # 7 แนะนำการรองรับภาษาสำหรับทูเปิลซึ่งเปิดใช้งานชื่อความหมายสำหรับฟิลด์ของทูเพิลโดยใช้ทูเพิลชนิดใหม่ที่มีประสิทธิภาพมากขึ้น

ในเทียบกับ 2017 และ. Net 4.7 (หรือติดตั้ง nuget package System.ValueTuple) คุณสามารถสร้าง / ใช้ทูเพิลได้อย่างมีประสิทธิภาพและง่ายดาย:

     var person = (Id:"123", Name:"john"); //create tuble with two items
     Console.WriteLine($"{person.Id} name:{person.Name}") //access its fields

การส่งคืนค่ามากกว่าหนึ่งค่าจากวิธีการ:

    public (double sum, double average) ComputeSumAndAverage(List<double> list)
    {
       var sum= list.Sum();
        var average = sum/list.Count;
        return (sum, average);
    }

    How to use:

        var list=new List<double>{1,2,3};
        var result = ComputeSumAndAverage(list);
        Console.WriteLine($"Sum={result.sum} Average={result.average}");    

สำหรับรายละเอียดเพิ่มเติมโปรดอ่าน: https://docs.microsoft.com/en-us/dotnet/csharp/tuples

Tuple มักใช้เพื่อส่งคืนค่าหลายค่าจากฟังก์ชันเมื่อคุณไม่ต้องการสร้างประเภทเฉพาะ หากคุณคุ้นเคยกับ Python Python มีมานานแล้ว

ส่งคืนค่ามากกว่าหนึ่งค่าจากฟังก์ชัน getCoordinates () ไม่มีประโยชน์มากนักหากส่งคืนค่า x หรือ y หรือ z แต่การสร้างคลาสและอ็อบเจ็กต์แบบเต็มเพื่อเก็บสาม ints ก็ดูเหมือนจะมีน้ำหนักมาก

การใช้งานทั่วไปอาจเป็นการหลีกเลี่ยงการสร้างคลาส / โครงสร้างที่มีเพียง 2 ฟิลด์แทนที่จะสร้าง Tuple (หรือ KeyValuePair ในตอนนี้) มีประโยชน์เป็นค่าส่งคืนหลีกเลี่ยงการส่ง N out params ...

ฉันพบว่า KeyValuePair กำลังรีเฟรชใน C # เพื่อวนซ้ำคู่ค่าคีย์ในพจนานุกรม

มันมีประโยชน์มากในขณะที่คืนค่าจากฟังก์ชัน เราสามารถมีค่าย้อนกลับได้หลายค่าและนี่ก็ค่อนข้างประหยัดในบางสถานการณ์

ฉันสะดุดกับเกณฑ์มาตรฐานประสิทธิภาพระหว่างคู่ทูเปิลและคีย์ - ค่าและคุณอาจคิดว่ามันน่าสนใจ โดยสรุปกล่าวว่าทูเปิลมีข้อได้เปรียบเนื่องจากเป็นคลาสดังนั้นจึงถูกเก็บไว้ในฮีปไม่ใช่ในสแต็กและเมื่อส่งผ่านไปรอบ ๆ เนื่องจากอาร์กิวเมนต์ตัวชี้เป็นสิ่งเดียวที่จะเกิดขึ้น แต่ KeyValuePair เป็นโครงสร้างดังนั้นจึงจัดสรรได้เร็วกว่า แต่จะช้ากว่าเมื่อใช้

http://www.dotnetperls.com/tuple-keyvaluepair