A Blatant Programming Question

Espen Harlinn

Espen Harlinn Principal Architect, Software - Goodtech Projects & Services AS Whenever methodologies become productized, objectivity is removed from the equation. -- Mike Myatt

Kenneth Haugland

Ah... Just call the garbage collecter afterword, and you would be fine. :laugh:

BillWoodruff

Hi Leppie, I have written a request to you to please give an example of use of anonymous classes here on the "Tuple" thread on the C# forum:[^]. I'd really appreciate hearing more about that ! best, Bill

"One of the few good things about modern times: If you die horribly on television, you will not have died in vain. You will have entertained us." Kurt Vonnegut

Roger Wright

While I completely disagree with your opinion, I highly respect it and accordingly, voted you a "5" as well. :-D It was a technical question - which is perfectly valid in the Lounge - about a concept, not a programming help request. It has broad application to multiple languages, and is entirely proper in the Lounge. I found the responses illuminating, but in no way instructive, which was exactly what I was seeking - a general perspective.

Will Rogers never met me.

leppie

I meant being influenced by the semantics of PHP ;p

IronScheme
((λ (x) `(,x ',x)) '(λ (x) `(,x ',x)))

Espen Harlinn

leppie wrote:

influenced by the semantics of PHP

Those being? Mind, I've got nothing against PHP, I just never use it ... ;)

Espen Harlinn Principal Architect, Software - Goodtech Projects & Services AS Whenever methodologies become productized, objectivity is removed from the equation. -- Mike Myatt

leppie

Espen Harlinn wrote:

Those being?

Dont really know, but none or horrible comes to mind ;p

IronScheme
((λ (x) `(,x ',x)) '(λ (x) `(,x ',x)))

RugbyLeague

I like your thinking

Jonathan C Dickinson

The concept of using arrays has been bought up - and why use them instead of arrays. It's because arrays have no type safety - leading to logical bugs at runtime. For example: Buggy code:

// I promise to return an array of length 2, with a String and Double.
public static object[] DoStuff()
{
return new object[] { "Hello", 123 }; // Did you mean 123.0?
}

public static void Main()
{
var ret = DoStuff();
var a = (string)ret[0]; // What happens if DoStuff() doesn't return the correct number of items?
var b = (double)ret[1]; // As above, as well as what if the type is wrong (which it is)?
}

Contrast this with:

// No comment required because this documents itself.
public static Tuple DoStuff()
{
return Tuple.Create("Hello", 123); // Compiler error, not runtime error! Wooo!
}

public static void Main()
{
var ret = DoStuff();
var a = ret.Item1; // Always succeeds.
var b = ret.Item2; // Always succeeds.
}

Finally consider the [internal, clearly] extension method magic you can do. So basically they are needed when you need an array of fixed length where each element in the array is a strong type. Remember that C# is [typically] a strongly-typed language and Tuple is a great citizen in the .Net type system for any language that is strongly-typed (and functional languages like F# too). You could write a class that represents your return type/whatever, but then again, why do you use Dictionary<TKey, TValue>? Shouldn't you write a specific type for that? Tuple is as much as a strongly-typed primitive as an array (it was just previously missing); it just needs to be used correctly (see above paragraph). Edit: Yes, I know that it originates from functional languages, but as always the .Net Framework team are showing us that at the end of the day all things are the same: and today the functional features in C# feel like natural parts of a imperative language (even though previously they were not). I strongly feel that the same principle applies to Tuple. Yes, I know that a runtime based on multiple return values (like Go) would be more 'correct'; but the Tuple is the biggest bang for 'risk buck' - in addition you can use it in places other than return types. Basically, learn to love that your cheese was moved into the fridge (where it belongs).

He who asks a question i

YvesDaoust

When defined at compile-time, a tuple is nothing else than a struct (a class if you prefer) and each member is referenced by a name. The .NET Tuples allow defining them at run-time, referencing the members by an index, to allow some form of run-time polymorphism. You will use a .NET Tuple when the composition of the items is unknown until run-time, for instance if it is input by the user.

Adriaan Davel

Agree with all, I sometimes use it to avoid writing a class and use it in my model only, if I want to construct a list of 'paired' types for a display for example

____________________________________________________________ Be brave little warrior, be VERY brave

Rob Grainger

Not sure if you actually got an answer here, but the 20 or so results I scanned seemed hopelessly misguided. Tuples are used enormously in functional programming and are extremely useful in LINQ. With LINQ queries, you may have an object of type person with Name, Age, Gender, etc. Now if you execute "from Persons where age > 20 select Age, Gender", what is the type of the result: answer a tuple type with the first item an integer and the 2nd an enum type. This is where they are useful. They avoid having to litter your code with classes that add no meaningful information and are pure data values. They are commonly useful as return types, e.g. a tuple where the first item indicates if the 2nd is applicable. Many more usages exist.

User 2788383

One of the best things tuples do is they allow you to return multiple values from a function instead of just one value as was the case in C# before C# 4.0.

Lost User

You seem a bit uptight to me. But you explained yourself so it's a wash, IMHO.

Gary Huck

Garth J Lancaster wrote:

I'd suggest Tuples were around before c++, c#, and 'class' related constructs

... as was Fortran, punch cards, ...

Dominic Amann

A map is essentially a collection of tuples, and I find maps incredibly useful. Often times I have a tuple in my code consisting of:

pair >

especially in database mapping.

Kenneth Haugland

Never even crossed my mind :thumbsup:

Fred Flams

Tuples exist in various functionnal languages, F# has been mentionned but older languages such as lisp / caml / ocaml and other similar flavours had them already. It can be useful if you want to have lists of associated items without having to handle a dictionnary. i.e.: Dictionnary<string, BlueToothDevice> could be replaced by List<Tuple<string, BlueToothDevice>>, you keep the flexibility of a List object (AddRange, RemoveRange, ForAll and so on) and the capability of a dictionnary and the system of keys... Another use I quite like is when you design an API method that would like to return multiple values at once, as it is not possible, you can use Tuples instead: public bool DoSomethingUseful(int someValue1, string someValue2, ref double someExport1, ref shot someExport2) could be written: public Tuple<bool, double, short> DoSomethingUseful(int someValue1, string someValue2) thus eliminating the need to pass parameters by reference because the return value of a method is already used... I hope this post can help you make your mind about Tuples and their possible usage.

mjohns07

I believe programming with tuples fits best with the functional programming paradigm or a mixed functional/OOP style. If your functions return values instead of changing the state of objects, then you might want to use tuples. On a side note, Erik Meijer, from Microsoft, will be talking at GOTO Night Chicago[^] on August 23rd. I'll be there. He'll be talking about embracing purely functional programming in order to tackle concurrency and complexity. I bet if we watch some of Erik Meijer's videos on Channel 9, we will better understand tuples: C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals, Chapter 1 of 13[^]

mgkr

"save you from creating a throwaway class" ^^This Ask yourself how many times you've (mis-)used the out param, to have method "return" two values. Sometimes you need two values back, and creating a class/struct for just that one method to be able to return the two values is.. annoying (and clutters the code) Using a Tuple instead is the "clean" way of doing this (and it can be expanded to more than just two objects)