Dzisiaj przyszedł czas na wzorzec agregujący w pewien sposób wszystkie poprzednie, a mianowicie wzorzec rekurencyjny. Załóżmy, że mamy następującą hierarchię klas, np.:

    public class Employee
    {
        public string Name { get; set; }
        public object Salary { get; set; }
    }

    public class Manager : Employee
    {
        public object DirectReports { get; set; }
    }

W poprzednich wersjach C#, było możliwe jedynie sprawdzenie czy obiekt jest typu “Manager” czy innej implementacji. W wersji 7.0 możemy:

            object employee = new Manager()
            {
                Salary = 53,
                DirectReports = new Employee[5]
            };

            if (employee is Manager { Salary is int salary,DirectReports is Employee[] directReports})
            {
                Console.WriteLine("It's a manager with salary {0} and direct reports {1}", salary, directReports.Length);
            }

Widzimy tutaj wzorzec rekurencyjny składający się z:

• type pattern – sprawdzamy czy obiekt jest typu Manager
• zagnieżdżonego type pattern – sprawdzamy czy Salary jest liczbą całkowitą
• zagnieżdżonego type pattern – sprawdzamy czy DirectReports jest tablicą.

Jeśli któryś z warunków jest nieprawdziwy, całość zwróci false. Jeśli np. zamienimy tablicę na kolekcję, wtedy na ekranie nic się nie wyświetli:

        private static void Main(string[] args)
        {
            object employee = new Manager()
            {
                Salary = 53,
                DirectReports = new List<Employee>()
            };

            if (employee is Manager { Salary is int salary,DirectReports is Employee[] directReports})
            {
                Console.WriteLine("It's manager with salary {0} and direct reports {1}", salary, directReports.Length);
            }
        }

Można również umieścić “constant pattern”, o którym pisałem w poprzednim poście:

            object employee = new Manager()
            {
                Name="Piotr"
            };

            if (employee is Manager { Name is "Piotr"})
            {
                Console.WriteLine("Name: Piotr");
            }

W tym przypadku, instrukcja zwróci true, gdy właściwość Name ma wartość “Piotr”. Constant pattern, nie wyodrębnia zawartości, jedynie sprawdza czy zmienna jest równa danej stałej.

Zmieńmy teraz trochę strukturę klas na:

    public class Employee
    {
        public string Name { get; set; }
    }

    public class Manager : Employee
    {
        public object DirectReport { get; set; }
    }

Za pomocą wzorca możemy rekurencyjnie sprawdzać właściwości o dowolnym zagnieżdżeniu, tzn.:

            object employee = new Manager()
            {
                DirectReport = new Employee { Name = "Piotr" }
            };

            if (employee is Manager { DirectReport is Employee { Name is string name}})
            {
                Console.WriteLine(name);
            }

Rekurencyjna jest zatem przerywana, gdy jakiś warunek zwraca false. Jeśli zwraca true, wtedy kolejne warunki będą sprawdzane, przeglądając graf obiektów o dowolnej głębokości. W powyższym przykładzie, zatem musimy mieć obiekt typu Manager, w którym DirectReport jest typu Employee, a właściwość Name jest napisem.

Tak jak zwykle, na zakończenie zobaczmy kod po kompilacji:

		private static void Main(string[] args)
		{
			object employee = new Manager
			{
				Salary = 53,
				DirectReports = new List<Employee>()
			};
			Manager manager = employee as Manager;
			int salary;
			Employee[] directReports;
			bool arg_65_0;
			if (manager != null)
			{
				int? num = manager.Salary as int?;
				salary = num.GetValueOrDefault();
				if (num.HasValue)
				{
					directReports = (manager.DirectReports as Employee[]);
					arg_65_0 = (directReports != null);
					goto IL_65;
				}
			}
			arg_65_0 = false;
			IL_65:
			bool flag = arg_65_0;
			if (flag)
			{
				Console.WriteLine("It's manager with salary {0} and direct reports {1}", salary, directReports.Length);
			}
		}

Wyraźnie widzimy, że wszystkie warunki muszą zostać spełnione tzn.:

• Employee musi być typu Manager
• Salary jest liczbą całkowitą
• DirectReports jest tablicą Employee

Ponadto, jak widzimy z powyższego kodu, typy proste mogą być nullable, o ile mają w sobie jakąś wartość. Zatem salary mogłaby być typu int?, o ile wartość nie jest NULL.

Ostatnio przyjrzeliśmy się pierwszemu usprawnieniu operatora IS. Tak naprawdę jest to część dużo większej zmiany, a mianowicie dopasowywania wzorców (pattern matching). Celem jest filtracja i wyodrębnianie konkretnych danych z obiektu. Dla osób znających programowanie funkcyjne,  nie stanowi to prawdopodobnie wielkiej zmiany. Język C# zawiera coraz więcej elementów programowania funkcyjnego,  przy tym samym zachowując swój styl zaczerpnięty  z CPP i klasycznych języków obiektowych.

W ostatnim poście opisałem tzw. “type pattern” ponieważ wydobywaliśmy dane na podstawie typu. Operator zwracał “true”, gdy typ był zgodny z naszymi oczekiwaniami:

object test = 5;
 
if(test is int integerValue)
{
    Console.WriteLine(integerValue.GetType());
    Console.WriteLine(integerValue * 5);
}

Kolejnym rodzajem wzorca jest “var pattern”:

            object test = 5;

            if (test is var x)
            {
                Console.WriteLine(x.GetType());
            }

Wzorzec “var” zwraca zawsze true. Oznacza to, że instrukcja IF zawsze wykona się. Na ekranie w powyższym przypadku wyświetli się “System.Int32”. Zmienna x jednak jest typu System.Object, zatem nie możemy wykonać na niej bezpośrednio operacji arytmetycznych. Po kompilacji, powyższa konstrukcja wygląda następująco:

                        object test = 5;
			object x = test;
			bool flag = true;
			if (flag)
			{
				Console.WriteLine(x.GetType());
			}

Wiem, że na razie wygląda to bezużytecznie, ale w przyszłym poście zajmiemy się rekurencyjnymi wzorcami i wtedy znajduje to zastosowanie.

Kolejny wzorzec to “wildcard pattern”:

             object test = 5;

            if (test is *)
            {
                Console.WriteLine(test.GetType());
            }

Na ekranie oczywiście znów wyświetli się System.Int32. Analogicznie jak wzorzec var, zawsze zwraca true. Jedyna różnica to fakt, że w przypadku wildcard, nie wydobywamy żadnych danych. Po dekompilacji zobaczymy po prostu:

object test = 5;
Console.WriteLine(test.GetType());

Następny wzorzec to “const pattern”, czyli dopasowywanie stałych. Przydaje się np. w instrukcji switch. Przykład:

            object test = 3;

            switch (test)
            {
                case int integerValue when integerValue <= 5:
                    Console.WriteLine(integerValue );
                    break;

                case int integerValue:
                    Console.WriteLine(integerValue * 5);
                    break;
                case string text:
                    Console.WriteLine(text.ToLower());
                    break;
                case *:
                    Console.WriteLine("All");
                    break;
            }

W powyższym przykładzie, dopasowywanie zostało umieszczone w instrukcjach warunkowych CASE. Normalnie, switch porównuje dane za pomocą operatora ==. W c# 7.0 wspiera on dopasowywanie wzorców i w powyższym kodzie skorzystaliśmy ze wzorca “Type” oraz “wildcard”. Ponadto dodano klauzule “when”, gdzie możemy filtrować dodatkowo wartości. Powyższy kod, pokazuje również, że w pewnych sytuacjach, zarówno “wildcard” jak i “var pattern” są przydatne. Oczywiście nie korzystamy z nich jak mamy pojedynczą instrukcję warunkową, ale w przypadku switch jest już to realny przykład użycia.

Po dekompilacji otrzymamy:

	internal class Program
	{
		private static void Main(string[] args)
		{
			object test = 3;
			object obj = test;
			int? num = obj as int?;
			int integerValue = num.GetValueOrDefault();
			if (num.HasValue && integerValue <= 5)
			{
				Console.WriteLine(integerValue);
			}
			else
			{
				num = (obj as int?);
				int integerValue2 = num.GetValueOrDefault();
				if (num.HasValue)
				{
					Console.WriteLine(integerValue2 * 5);
				}
				else
				{
					string text = obj as string;
					if (text != null)
					{
						Console.WriteLine(text.ToLower());
					}
					else
					{
						Console.WriteLine("All");
					}
				}
			}
		}
	}

W przyszłym poście przyjrzymy się rekurencyjnemu dopasowywaniu, które stanowi agregację przedstawionych wzorców.

W C# 7.0 operator Is, a konkretniej dopasowywanie typów, zostało ulepszone. We wcześniejszych wersjach, byliśmy zmuszeni do pisania następującego kodu:

object test = 5;

if(test is int)
{
int integerValue = (int)test;

Console.WriteLine(integerValue.GetType());
Console.WriteLine(integerValue * 5);
}

W wersji C#, możliwa jest uproszczona konstrukcja:

            object test = 5;

            if(test is int integerValue)
            {
                Console.WriteLine(integerValue.GetType());
                Console.WriteLine(integerValue * 5);
            }

Jeśli zmienna jest danego typu, automatycznie zostanie zrzutowana. Innymi słowy, za pomocą jednego operatora wykonujemy 3 operacje: sprawdzenie typu, zrzutowanie oraz wykonanie instrukcji warunkowej. W poprzednich wersjach, możliwe było zrobienie czegoś podobnego, ale powstały kod zwykłe był mniej przejrzysty.
Po skompilowaniu, kod jest skonwertowany do postaci z operatorem “as”:

			object test = 5;
			int? num = test as int?;
			int integerValue = num.GetValueOrDefault();
			bool hasValue = num.HasValue;
			if (hasValue)
			{
				Console.WriteLine(integerValue.GetType());
				Console.WriteLine(integerValue * 5);
			}

W następnym wpisie, pokażę kilka kolejnych zmian, które pojawiły się w w obrębie dopasowywania typów.

Kolejną ciekawostką z wersji 7.0 są literały binarne. Od dawna w c# możliwe było prezentowanie wartości w systemie szesnastkowym np.:

   int a = 0xF;
   Console.WriteLine(a);

Na ekranie wyświetli się liczba w systemie dziesiętnym czyli 15. Analogicznie w 7.0 możemy napisać kod z liczbami binarnymi:

    int a = 0b1111;
    Console.WriteLine(a);

Powyższy kod we wcześniejszych wersjach nie skompilowałby się. Literały binarne zaczynamy od prefiksu 0b. Dla większości użytkowników jest to raczej ciekawostka, przydatna jedynie w nauce podstawowych algorytmów.

Kolejną ciekawostką, która aczkolwiek może być ciekawsza dla większej grupy programistów, jest możliwość separacji cyfr w literałach. Załóżmy, że mamy bardzo długą stałą, np.:

   int a = 7676242;
   Console.WriteLine(a);

Liczba nie jest zbyt czytelna. Za pomocą znaku podkreślenia, w C# 7.0 możemy:

  int a = 7_676_242;
  Console.WriteLine(a);

Oczywiście można korzystać z dowolnej liczby podkreśleń, np.:

int a = 7______676______242;
Console.WriteLine(a);

Wygląda to bardziej przejrzyście. Nic wielkiego, ale czasami przydatne.

Od następnego wpisu będzie już o C# 7.0. Wersję 6.0 niejednokrotnie już opisywałem, włączając wersje community review. Pomyślałem zatem, że warto napisać jeden wpis agregujący nowości z C# 6.0, zanim przejdziemy do 7.0.

• Primary constructors (usunięte z finalnej wersji c# 6.0)
• Inicjalizacja słowników i automatycznych właściwości
• Filtrowanie wyjątków
• Propagacja NULL, operator nameof
• Bezparametrowe konstruktory w strukturach, inicjalizacja właściwości bez setter’ow
• Definiowanie metod za pomocą lambda
• Using i klasy statyczne oraz metody asynchroniczne w catch\finally
• Interpolacja string

Dzisiaj podstawy, ale wcześniej nie miałem potrzeby skorzystania z  funkcji GroupJoin. Myślę, że prosty przykład jest najlepszą dokumentacją.

Dosyć częstą używaną funkcją jest GroupBy. Jeśli mamy np. listę zamówień w postaci (IdCustomer, Name), wykonując GroupBy na IdCustomer otrzymamy słownik, gdzie kluczem jest identyfikator zamówienia, a wartością lista zamówień danego klienta.

GroupJoin, jak sama nazwa sugeruje jest połączeniem Join z GroupBy. Załóżmy, że mamy następujące encje:

    class CustomerInfo
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    class Order
    {
        public int IdCustomer { get; set; }
        public string Name { get; set; }
    }

Następnie przykładowe dane, definiujące relacje wyglądają następująco:

            var customers = new CustomerInfo[3];
            customers[0] = new CustomerInfo() { Id = 1, Name = "Piotr" };
            customers[1] = new CustomerInfo() { Id = 2, Name = "Pawel" };
            customers[2] = new CustomerInfo() { Id = 3, Name = "tertert" };

            var orderList = new Order[5];
            orderList[0] = new Order() { IdCustomer = 1, Name = "Zamowienie 1" };
            orderList[1] = new Order() { IdCustomer = 1, Name = "Zamowienie 1 a" };
            orderList[2] = new Order() { IdCustomer = 2, Name = "Zamowienie 2 a" };
            orderList[3] = new Order() { IdCustomer = 2, Name = "Zamowienie 2 b" };
            orderList[4] = new Order() { IdCustomer = 3, Name = "Zamowienie 3" };

W celu uzyskania zamówień dla konkretnego klienta wystarczy:

            var customerOrders = customers.GroupJoin(orderList, x => x.Id, x => x.IdCustomer, (customer, orders) => new
            {
                CustomerName = customer.Name,
                Orders = orders.ToArray()
            });

            foreach (var customerOrder in customerOrders)
            {
                Console.WriteLine(customerOrder.CustomerName);

                foreach (var order in customerOrder.Orders)
                {
                    Console.WriteLine("\t{0}", order.Name);
                }
            }

Wynikiem będzie lista klientów wraz z zamówieniami: