Od dawna (chyba od początku) w C# do dyspozycji mieliśmy słowo kluczowe out, służące do przekazywania parametrów na wyjście. Standardem stało się pisanie metod typu TryParse, które zwracają bool oraz wartość za pomocą parametru out, np.:

         int number;
         bool result = Int32.TryParse(text, out number);
         if (result)
         {
            Console.WriteLine("Converted '{0}' to {1}.", text, number);         
         }
         else
         {
           // error
         }

Składnia bardzo niewygodna. Trzeba było osobno deklarować zmienną przekazywaną jako out. Ponadto, funkcje takie często akceptowały kilka parametrów out. W takich sytuacjach, musieliśmy deklarować puste “kontenery” ponieważ nie było możliwości przekazania NULL albo jakieś innej wartości. W skrajny sytuacjach wyglądało to tak:

int value;
// unnecessary variables
int container1,container2, container3;
DoSomething(out value, out container1, out container2, out container3);

// do something with value

W C# 7.0 nie musimy osobno deklarować takich zmiennych i powyższy kod można przepisać do:

            if (Int32.TryParse("4343", out int number))
            {
                Console.WriteLine(number);
            }
            else
            {
                // error
            }

Jak widzimy, deklaracja odbywa się w wewnątrz wywołania. Po kompilacji uzyskamy klasyczny kod:

    private static void Main(/*Parameter with token 08000001*/string[] args)
    {
      int result;
      if (!int.TryParse("4343", out result))
        return;
      Console.WriteLine(result);
    }

Ze względu, że sygnatura jest z góry znana, można skorzystać ze słowa “var” zamiast deklarować jawnie typ integer:

               
            if (Int32.TryParse("4343", out var number))
            {
                Console.WriteLine(number);
            }
            else
            {
                // error
            }

Możliwe, że będzie można korzystać z wildcards czyli (nie zostało to jeszcze zatwierdzone do finalnej wersji 7.0):

        static void Main(string[] args)
        {            
            if (Int32.TryParse("4343", out *))
            {
                Console.WriteLine("OK");
            }
            else
            {
                // error
            }
        }

Byłoby to bardzo przydatne w sytuacjach, gdzie zainteresowani jesteśmy tylko jedną wartością, a sygnatura wymaga od nas podania np. 5 innych zmiennych. Niestety na dzień dzisiejszy nie jest to zaimplementowane w najnowszej wersji VS (Visual Studio 15′ Preview 4).

Klasa (immutable) Tuple istniała aż od .NET Framework 4.0. W C# 7.0 mamy jednak wsparcie dla tuple od strony języka. Jednym z problemów klasy Tuple było, że każda właściwość nazywała się kolejno Item1, Item2 itp.

Przykład:

    class Program
    {
        private static void Main(string[] args)
        {
            var tuple = GetFirstAndLastName();

            Console.WriteLine(tuple.Item1);
            Console.WriteLine(tuple.Item2);
        }

        private static Tuple<string,string> GetFirstAndLastName()
        {
            var tuple = new Tuple<string, string>("Piotr", "Zielinski");

            return tuple;       
        }
    }

W wersji 7.0, powyższy kod możemy przepisać do:

    class Program
    {
        private static void Main(string[] args)
        {
            var tuple = GetFirstAndLastName();

            Console.WriteLine(tuple.firstName);
            Console.WriteLine(tuple.lastName);
        }

        private static (string firstName, string lastName) GetFirstAndLastName()
        {
            var fullName = (firstName: "Piotr", lastName: "Zielinski");

            return fullName;
        }
    }

Składnia dużo czytelniejsza ponieważ nie operujemy już na Item1 i Item2. Zobaczmy co się kryje za tym nowym “Tuple” po dekompilacji:

  internal class Program
  {
    // Method .ctor with token 06000003
    public Program()
    {
      base.\u002Ector();
    }

    // Method Main with token 06000001
    private static void Main(/*Parameter with token 08000001*/string[] args)
    {
      ValueTuple<string, string> firstAndLastName = Program.GetFirstAndLastName();
      Console.WriteLine(firstAndLastName.Item1);
      Console.WriteLine(firstAndLastName.Item2);
    }

    // Method GetFirstAndLastName with token 06000002
    private static ValueTuple<string, string> GetFirstAndLastName()
    {
      return new ValueTuple<string, string>("Piotr", "Zielinski");
    }
  }

Całość opiera się na zwykłej strukturze ValueTuple<string, string>. Wygląda to bardzo analogicznie do starego Tuple<T1,T2>. Zaglądając do źródeł ValueTuple, przekonamy się, że klasa jest immutable i  przeładowuje metody typu Equals oraz GetHashCode. Oznacza to, że typ doskonale nadaję się jako klucz do słowników.

Powyższy kod można przetestować używając Visual Studio ’15’ preview 3,  który jest dostępny tutaj.

Jakiś czas temu, pisałem o wizualizacji drzewa Roslyn.
Wtedy jeszcze nie była to oficjalna wersja i proces instalacji trochę zmienił się. Teraz rozszerzenie stanowi część “.Net Compiler Platform SDK”, które można zainstalować z poziomu Tools->Extensions and Updates:

Drzewo w oficjalnej wersji niewiele zmieniło się:

Ostatnio musiałem odczytać współrzędne geograficzne na podstawie nazwy lokalizacji.

Pierwszą opcją, którą sprawdziłem był pakiet “GoogleMaps.LocationServices”. Po instalacji NuGet, odczytanie współrzędnych było bardzo proste:

            var gls = new GoogleLocationService();
            var location = gls.GetLatLongFromAddress("Warsaw, Poland");

            Console.WriteLine("{0}, {1}", location.Latitude,location.Longitude);

Wynik:

Rozwiązanie bardzo proste. Biblioteka korzysta z Google Maps, ale niestety ma limity na liczbę zapytań w ciągu dnia. Co gorsza, nie istnieje możliwość zwiększenia tego limitu.

Z tego względu zdecydowałem się na bezpośrednie połączenie z Google API, a konkretnie z Geocoding API. Co prawda, rozwiązanie też ma limity dzienne, ale po darmowej rejestracji uzyskamy limit 100k dziennie, co w moim w wypadku było wystarczające. API jest w formie REST:
“https://maps.googleapis.com/maps/api/geocode/json?address=Warsaw,Poland&key=YOUR_API_KEY”

Oczywiście należy najpierw uzyskać klucz, rejestrując konto na Console Google. Przykładowa odpowiedź przychodzi w następującym formacie:

{
   "results" : [
      {
         "address_components" : [
            {
               "long_name" : "Warsaw",
               "short_name" : "Warsaw",
               "types" : [ "locality", "political" ]
            },
            {
               "long_name" : "Warszawa",
               "short_name" : "Warszawa",
               "types" : [ "administrative_area_level_3", "political" ]
            },
            {
               "long_name" : "Warszawa",
               "short_name" : "Warszawa",
               "types" : [ "administrative_area_level_2", "political" ]
            },
            {
               "long_name" : "Masovian Voivodeship",
               "short_name" : "Masovian Voivodeship",
               "types" : [ "administrative_area_level_1", "political" ]
            },
            {
               "long_name" : "Poland",
               "short_name" : "PL",
               "types" : [ "country", "political" ]
            }
         ],
         "formatted_address" : "Warsaw, Poland",
         "geometry" : {
            "bounds" : {
               "northeast" : {
                  "lat" : 52.3679992,
                  "lng" : 21.2710983
               },
               "southwest" : {
                  "lat" : 52.0978767,
                  "lng" : 20.8512898
               }
            },
            "location" : {
               "lat" : 52.2296756,
               "lng" : 21.0122287
            },
            "location_type" : "APPROXIMATE",
            "viewport" : {
               "northeast" : {
                  "lat" : 52.3679992,
                  "lng" : 21.2710983
               },
               "southwest" : {
                  "lat" : 52.0978767,
                  "lng" : 20.8512898
               }
            }
         },
         "place_id" : "ChIJAZ-GmmbMHkcR_NPqiCq-8HI",
         "types" : [ "locality", "political" ]
      }
   ],
   "status" : "OK"
}

Generując automatycznie klasy C# w Visual Studio na podstawie JSON uzyskamy:

  public class Rootobject
    {
        public Result[] results { get; set; }
        public string status { get; set; }
    }

    public class Result
    {
        public Address_Components[] address_components { get; set; }
        public string formatted_address { get; set; }
        public Geometry geometry { get; set; }
        public string place_id { get; set; }
        public string[] types { get; set; }
    }

    public class Geometry
    {
        public Bounds bounds { get; set; }
        public Location location { get; set; }
        public string location_type { get; set; }
        public Viewport viewport { get; set; }
    }

    public class Bounds
    {
        public Northeast northeast { get; set; }
        public Southwest southwest { get; set; }
    }

    public class Northeast
    {
        public float lat { get; set; }
        public float lng { get; set; }
    }

    public class Southwest
    {
        public float lat { get; set; }
        public float lng { get; set; }
    }

    public class Location
    {
        public float lat { get; set; }
        public float lng { get; set; }
    }

    public class Viewport
    {
        public Northeast1 northeast { get; set; }
        public Southwest1 southwest { get; set; }
    }

    public class Northeast1
    {
        public float lat { get; set; }
        public float lng { get; set; }
    }

    public class Southwest1
    {
        public float lat { get; set; }
        public float lng { get; set; }
    }

    public class Address_Components
    {
        public string long_name { get; set; }
        public string short_name { get; set; }
        public string[] types { get; set; }
    }

W przypadku usług REST, standardowo używam RestSharp+JSON.NET:

           var query = "https://maps.googleapis.com/maps/api/geocode/json?address=Warsaw,Poland&key=API_KEY";

            var client = new RestClient(query);
            var response = client.Get<dynamic>(new RestRequest());

            Rootobject data = JsonConvert.DeserializeObject<Rootobject>(response.Content);
            
            Console.WriteLine("{0}, {1}", data.results[0].geometry.location.lat, data.results[0].geometry.location.lng);

W praktyce, automatycznie wygenerowane klasy zostałyby zastąpione czytelniejszą strukturą. Tyle jednak wystarczy na szybkie sprawdzenie możliwości API.