C# 7.0 - Tuples To The Extreme!

public class Location
{
    // Properties to store city and state information
    public string City { get; set; }
    public string State { get; set; }
    // Constructor to initialize city and state
    public Location(string city, string state)
    {
        City = city;
        State = state;
    }
}
// Example usage
var location = new Location("Lake Charles", "LA");
// Print out the address using the properties of the Location class
var address = $"{location.City}, {location.State}";
// Alternatively, you can use Tuple for a concise representation
var locationTuple = new Tuple<string, string>("Lake Charles", "LA");
// Print out the address using Tuple's Item1 and Item2 properties
var addressTuple = $"{locationTuple.Item1}, {locationTuple.Item2}";

public (string city, string state) GetCityAndState()
{
    // Return a tuple representing city and state information
    return ("Lake Charles", "Louisiana");
}

This would allow you to make a call to a single method and access each of the return values by their defined names as seen below.

public (string city, string state) GetCityAndState()
{
    // Return a tuple representing city and state information
    return ("Lake Charles", "Louisiana");
}

The results of these multiple return value methods can also be deconstructed in a variety of ways based on your needs.

// Using tuple deconstruction to get values from the function
(string city, string state) = GetCityAndState();
// Using var for type inference in tuple deconstruction
(var city, var state) = GetCityAndState();
// Using a single var declaration for multiple variables in tuple deconstruction
var (city, state) = GetCityAndState();
// Using existing variables in tuple deconstruction
(city, state) = GetCityAndState();

As you might imagine, initialization is going to take a similar syntactic approach roughly.

// Creating a tuple representing location information (city, state)
var location = ("Lake Charles", "Louisiana");

This is a feature that a few other popular programming languages like Python, Scala, Ruby, Go, and others have had for quite a while, so hopefully, it will be a nice addition to C#.

Cool. Anything else?

In addition to straightforward examples like those provided, these new ValueTuple objects can use things like type inference to match up the signature of the return type and ensure it is valid, like the following example.

public (string city, int population) FindBiggestCityWithPopulation(string state)
{
    // Create a tuple to store city and population information, initialized with default values
    var result = (city: "", population: 0);
    // Retrieve the biggest city in the specified state using _someService
    result.city = _someService.GetBiggestCity(state);
    // Get the population of the retrieved city
    result.population = _someService.GetPopulation(result.city);
    // Return the tuple containing city and population information
    return result;
}

Likewise, these new tuples also support the async/await pattern out of the box.

public async Task<(string bird, string flower)> GetStateBirdAndFlowerAsync(string state)
{
    // Retrieve the state bird asynchronously using _someService
    var bird = await _someService.GetStateBirdAsync(state);
    // Retrieve the state flower asynchronously using _someService
    var flower = await _someService.GetStateFlower(state);
    // Return a tuple containing state bird and flower information
    return (bird, flower);
}

How did this come to be?

One of the wonderful things about the "new" Microsoft development ecosystem is just how open it is. No longer are important development decisions made in dark, smoke-filled rooms but rather in transparent issues on GitHub.

If you want to take a look at the conversation that lead up to this feature, you can visit the proposal for multiple return values here. You may also want to consider looking around through the other active issues to see what other features might be coming soon.