Czy używanie krotek .NET 4.0 w moim kodzie C # jest złą decyzją projektową?

Wraz z dodaniem klasy Tuple w .net 4, próbowałem zdecydować, czy użycie ich w moim projekcie jest złym wyborem, czy nie. Z mojego punktu widzenia krotka może być skrótem do napisania klasy wynikowej (jestem pewien, że są też inne zastosowania).

Więc to:

public class ResultType
{
    public string StringValue { get; set; }
    public int IntValue { get; set; }
}

public ResultType GetAClassedValue()
{
    //..Do Some Stuff
    ResultType result = new ResultType { StringValue = "A String", IntValue = 2 };
    return result;
}

Odpowiada temu:

public Tuple<string, int> GetATupledValue()
{
    //...Do Some stuff
    Tuple<string, int> result = new Tuple<string, int>("A String", 2);
    return result;
}

Pomijając więc możliwość, że brakuje mi sensu krotek, czy przykład z krotką jest złym wyborem projektowym? Wydaje mi się, że jest mniej bałaganu, ale nie tak samo dokumentujący się i czysty. Oznacza to, że w przypadku typu ResultTypejest później bardzo jasne, co oznacza każda część klasy, ale musisz zachować dodatkowy kod. Dzięki temu Tuple<string, int>będziesz musiał spojrzeć w górę i dowiedzieć się, co Itemreprezentuje każdy z nich , ale piszesz i utrzymujesz mniej kodu.

Będziemy bardzo wdzięczni za wszelkie doświadczenia związane z tym wyborem.

Krotki są świetne, jeśli kontrolujesz ich tworzenie i używanie - możesz zachować kontekst, który jest niezbędny do ich zrozumienia.

Jednak w publicznym interfejsie API są mniej skuteczne. Konsument (nie Ty) musi albo zgadywać, albo przeszukiwać dokumentację, zwłaszcza pod kątem takich rzeczy jak Tuple<int, int>.

Używałbym ich dla członków prywatnych / wewnętrznych, ale klas wyników dla członków publicznych / chronionych.

Ta odpowiedź zawiera również pewne informacje.

Z mojego punktu widzenia krotka jest skrótem do napisania klasy wynikowej (jestem pewien, że są też inne zastosowania).

Istnieją rzeczywiście inne cenne zastosowaniaTuple<> - większość z nich polega na abstrahowaniu od semantyki określonej grupy typów, które mają podobną strukturę, i traktowaniu ich po prostu jako uporządkowanego zbioru wartości. We wszystkich przypadkach zaletą krotek jest to, że pozwalają uniknąć zaśmiecania przestrzeni nazw klasami tylko do danych, które ujawniają właściwości, ale nie metody.

Oto przykład rozsądnego użycia Tuple<>:

var opponents = new Tuple<Player,Player>( playerBob, playerSam );

W powyższym przykładzie chcemy reprezentować parę przeciwników, krotka jest wygodnym sposobem parowania tych instancji bez konieczności tworzenia nowej klasy. Oto kolejny przykład:

var pokerHand = Tuple.Create( card1, card2, card3, card4, card5 );

Układ w pokera można traktować jako po prostu zestaw kart - a krotka (może być) rozsądnym sposobem wyrażenia tego pojęcia.

odkładając na bok możliwość, że brakuje mi sensu krotek, czy przykład z krotką jest złym wyborem projektowym?

Zwracanie silnie wpisanych Tuple<>wystąpień jako części publicznego interfejsu API dla typu publicznego rzadko jest dobrym pomysłem. Jak sam wiesz, krotki wymagają od zaangażowanych stron (autora biblioteki, użytkownika biblioteki) uzgodnienia z wyprzedzeniem celu i interpretacji używanych typów krotek. Tworzenie interfejsów API, które są intuicyjne i przejrzyste, a ich Tuple<>publiczne używanie jedynie przesłania intencje i zachowanie API, jest wystarczająco trudne .

Typy anonimowe są również rodzajem krotki - są jednak silnie wpisane i pozwalają określić jasne, informacyjne nazwy dla właściwości należących do typu. Ale typy anonimowe są trudne w użyciu w różnych metodach - zostały one głównie dodane do obsługi technologii, takich jak LINQ, w których projekcje tworzyłyby typy, do których normalnie nie chcielibyśmy przypisywać nazw. (Tak, wiem, że typy anonimowe o tych samych typach i nazwanych właściwościach są konsolidowane przez kompilator).

Moja praktyczna zasada brzmi: jeśli zwrócisz go z publicznego interfejsu - nadaj mu nazwany typ .

Moja druga praktyczna zasada dotycząca używania krotek to: nazwa argumenty metody i zmienne lokalne typu Tuple<>tak jasno, jak to tylko możliwe - spraw, aby nazwa przedstawiała znaczenie relacji między elementami krotki. Pomyśl o moim var opponents = ...przykładzie.

Oto przykład rzeczywistego przypadku, w którym Tuple<>unikałem deklarowania typu tylko do danych do użytku tylko w moim własnym zestawie . Sytuacja ta polega na tym, że przy używaniu słowników generycznych zawierających typy anonimowe trudno jest użyć TryGetValue()metody do wyszukiwania elementów w słowniku, ponieważ metoda wymaga outparametru, którego nie można nazwać:

public static class DictionaryExt 
{
    // helper method that allows compiler to provide type inference
    // when attempting to locate optionally existent items in a dictionary
    public static Tuple<TValue,bool> Find<TKey,TValue>( 
        this IDictionary<TKey,TValue> dict, TKey keyToFind ) 
    {
        TValue foundValue = default(TValue);
        bool wasFound = dict.TryGetValue( keyToFind, out foundValue );
        return Tuple.Create( foundValue, wasFound );
    }
}

public class Program
{
    public static void Main()
    {
        var people = new[] { new { LastName = "Smith", FirstName = "Joe" },
                             new { LastName = "Sanders", FirstName = "Bob" } };

        var peopleDict = people.ToDictionary( d => d.LastName );

        // ??? foundItem <= what type would you put here?
        // peopleDict.TryGetValue( "Smith", out ??? );

        // so instead, we use our Find() extension:
        var result = peopleDict.Find( "Smith" );
        if( result.First )
        {
            Console.WriteLine( result.Second );
        }
    }
}

PS Istnieje inny (prostszy) sposób na obejście problemów wynikających z anonimowych typów w słownikach, a jest to użycie varsłowa kluczowego, aby kompilator „wywnioskował” typ za Ciebie. Oto ta wersja:

var foundItem = peopleDict.FirstOrDefault().Value;
if( peopleDict.TryGetValue( "Smith", out foundItem ) )
{
   // use foundItem...
}

Krotki mogą być przydatne ... ale później mogą też być uciążliwe. Jeśli masz metodę, która zwraca, Tuple<int,string,string,int>skąd wiesz, jakie te wartości są później. Byli ID, FirstName, LastName, Ageczy byli UnitNumber, Street, City, ZipCode.

Krotki są dość rozczarowującym dodatkiem do środowiska CLR z punktu widzenia programisty C #. Jeśli masz kolekcję elementów o różnej długości, nie potrzebujesz, aby w czasie kompilacji miały unikalne nazwy statyczne.

Ale jeśli masz zbiór o stałej długości, oznacza to, że ustalone lokalizacje w kolekcji mają określone, wstępnie zdefiniowane znaczenie. I to jest zawsze lepiej, aby dać im odpowiednie nazwy statycznych w tym przypadku, zamiast pamiętać znaczenia Item1, Item2itp

Klasy anonimowe w C # już zapewniają doskonałe rozwiązanie dla najczęściej spotykanego prywatnego użycia krotek i nadają elementom znaczące nazwy, więc w rzeczywistości są pod tym względem lepsze. Jedynym problemem jest to, że nie mogą one wyciekać z nazwanych metod. Wolałbym, aby to ograniczenie zostało zniesione (być może tylko dla metod prywatnych), niż ma specyficzną obsługę krotek w C #:

private var GetDesserts()
{
    return _icecreams.Select(
        i => new { icecream = i, topping = new Topping(i) }
    );
}

public void Eat()
{
    foreach (var dessert in GetDesserts())
    {
        dessert.icecream.AddTopping(dessert.topping);
        dessert.Eat();
    }
}

Podobnie jak słowo kluczowe var, ma służyć wygodzie - ale jest równie łatwo nadużywane.

Moim najbardziej skromnym zdaniem nie wystawiaj się Tuplejako klasa powrotna. Używaj go prywatnie, jeśli wymaga tego struktura danych usługi lub komponentu, ale zwróć dobrze sformułowane dobrze znane klasy z metod publicznych.

// one possible use of tuple within a private context. would never
// return an opaque non-descript instance as a result, but useful
// when scope is known [ie private] and implementation intimacy is
// expected
public class WorkflowHost
{
    // a map of uri's to a workflow service definition 
    // and workflow service instance. By convention, first
    // element of tuple is definition, second element is
    // instance
    private Dictionary<Uri, Tuple<WorkflowService, WorkflowServiceHost>> _map = 
        new Dictionary<Uri, Tuple<WorkflowService, WorkflowServiceHost>> ();
}

Używanie klasy takiej jak ResultTypejest bardziej przejrzyste. Możesz nadać znaczące nazwy polom w klasie (podczas gdy w przypadku krotki będą one nazywane Item1i Item2). Jest to jeszcze ważniejsze, jeśli typy obu pól są takie same: nazwa wyraźnie je rozróżnia.

A co powiesz na użycie krotek we wzorcu dekoruj-sortuj-dekoruj? (Transformacja Schwartzian dla ludzi Perl). Oto wymyślony przykład, ale krotki wydają się być dobrym sposobem radzenia sobie z tego rodzaju problemami:

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] files = Directory.GetFiles("C:\\Windows")
                    .Select(x => new Tuple<string, string>(x, FirstLine(x)))
                    .OrderBy(x => x.Item2)
                    .Select(x => x.Item1).ToArray();
        }
        static string FirstLine(string path)
        {
            using (TextReader tr = new StreamReader(
                        File.Open(path, FileMode.Open)))
            {
                return tr.ReadLine();
            }
        }
    }
}

Teraz mogłem użyć Object [] dwóch elementów lub w tym konkretnym przykładzie łańcucha [] dwóch elementów. Chodzi o to, że mogłem użyć czegokolwiek jako drugiego elementu krotki, która jest używana wewnętrznie i jest dość łatwa do odczytania.

IMO te „krotki” to w zasadzie wszystkie structtypy anonimowe dostępu publicznego z nienazwanymi członkami .

Tylko umieścić użyłbym krotka jest, gdy trzeba szybko blob razem niektóre dane, w bardzo ograniczonym zakresie. Semantyka danych powinna być oczywista , więc kod nie jest trudny do odczytania. Więc użycie krotki ( int, int) dla (row, col) wydaje się rozsądne. Ale ciężko mi znaleźć przewagę nad structz nazwanymi członkami (więc nie popełnia się błędów, a wiersz / kolumna nie są przypadkowo zamieniane)

Jeśli wysyłasz dane z powrotem do dzwoniącego lub akceptujesz dane od dzwoniącego, naprawdę powinieneś używać structz nazwanymi członkami.

Weź prosty przykład:

struct Color{ float r,g,b,a ; }
public void setColor( Color color )
{
}

Wersja krotki

public void setColor( Tuple<float,float,float,float> color )
{
  // why?
}

Nie widzę żadnej korzyści z używania krotki zamiast struktury z nazwanymi członkami. Korzystanie z nienazwanych członków jest krokiem wstecz pod względem czytelności i zrozumiałości kodu.

Tuple wydaje mi się leniwy sposób na uniknięcie tworzenia structnazwanych członków. Nadużywanie krotki, gdzie naprawdę czujesz, że ty / lub ktoś inny napotykający twój kod potrzebowałby nazwanych członków, jest złą rzeczą ™, jeśli kiedykolwiek widziałem.

Nie oceniaj mnie, nie jestem ekspertem, ale dzięki nowym krotkom w C # 7.x możesz teraz zwrócić coś takiego:

return (string Name1, int Name2)

Przynajmniej teraz możesz go nazwać, a programiści mogą zobaczyć pewne informacje.

To oczywiście zależy! Jak już powiedziałeś, krotka może zaoszczędzić kod i czas, gdy chcesz zgrupować niektóre elementy do lokalnego spożycia. Możesz także użyć ich do stworzenia bardziej ogólnych algorytmów przetwarzania niż w przypadku przekazania konkretnej klasy. Nie pamiętam, ile razy żałowałem, że nie mam czegoś poza KeyValuePair lub DataRow, aby szybko przekazać jakąś datę z jednej metody do drugiej.

Z drugiej strony można z tym przesadzić i omijać krotki, w których można tylko zgadywać, co zawierają. Jeśli zamierzasz używać krotki między klasami, być może lepiej byłoby utworzyć jedną konkretną klasę.

Oczywiście używane z umiarem krotki mogą prowadzić do bardziej zwięzłego i czytelnego kodu. Możesz zajrzeć do C ++, STL i Boost, aby zobaczyć przykłady użycia krotek w innych językach, ale ostatecznie wszyscy będziemy musieli poeksperymentować, aby dowiedzieć się, jak najlepiej pasują do środowiska .NET.

Krotki są bezużyteczną funkcją frameworka w .NET 4. Myślę, że w C # 4.0 przegapiono świetną okazję. Bardzo chciałbym mieć krotki z wymienionych członków, więc można uzyskać dostęp do różnych dziedzinach krotki wg nazwy zamiast Wartość1 , wartość2 , etc ...

Wymagałoby to zmiany języka (składni), ale byłoby bardzo przydatne.

Osobiście nigdy nie użyłbym krotki jako typu zwracanego, ponieważ nie ma wskazania, co reprezentują wartości. Krotki mają kilka cennych zastosowań, ponieważ w przeciwieństwie do obiektów są typami wartości i dlatego rozumieją równość. Z tego powodu użyję ich jako kluczy słownikowych, jeśli potrzebuję klucza wieloczęściowego lub jako klucza do klauzuli GroupBy, jeśli chcę grupować według wielu zmiennych i nie chcę zagnieżdżonych grup (Kto kiedykolwiek chce zagnieżdżonych grup?). Aby rozwiązać problem z ekstremalną szczegółowością, możesz je utworzyć za pomocą metody pomocniczej. Pamiętaj, że jeśli często uzyskujesz dostęp do członków (poprzez Item1, Item2 itp.), Prawdopodobnie powinieneś użyć innej konstrukcji, takiej jak struktura lub klasa anonimowa.

Użyłem krotek, zarówno tych Tuplenowych , jak i nowych ValueTuple, w wielu różnych scenariuszach i doszedłem do następującego wniosku: nie używaj .

Za każdym razem napotykałem następujące problemy:

• kod stał się nieczytelny z powodu braku silnego nazewnictwa;
• nie można używać funkcji hierarchii klas, takich jak DTO klas bazowych i DTO klas potomnych itp .;
• jeśli są używane w więcej niż jednym miejscu, kopiujesz i wklejasz te brzydkie definicje zamiast czystej nazwy klasy.

Moim zdaniem krotki są szkodą, a nie funkcją języka C #.

Mam trochę podobną, ale dużo mniej surową krytykę Func<>i Action<>. Są one przydatne w wielu sytuacjach, szczególnie w prostych Actioni Func<type>wariantach, ale poza tym stwierdziłem, że tworzenie typu delegata jest bardziej eleganckie, czytelne, łatwe w utrzymaniu i zapewnia więcej funkcji, takich jak ref/ outparameters.