Napisz to krócej czyli jak uprościć swój kod

Podczas pisania aplikacji czasem zdarza się, że potrzebujemy zrealizować jakąś prostą operację. W niektóre z takich przypadków wymagają jednak nie dodania jednej linii kodu, lecz np.: całej pętli. W .NET, szczególnie od wersji 3.5, możemy wspomóc się składnią i udostępnianymi mechanizmami, które pozwalają skrócić zapis nawet dla dość skomplikowanych operacji.

Na wstępie chcę zaznaczyć, że żadnych wielkich odkryć tu nie będzie :P. Celem tego artykułu jest natomiast zebranie w jednym miejscu kilku sposobów, którymi można się wspomóc w prostych zadaniach programistycznych. Dzięki temu możemy skupić się na ważnych częściach kodu zamiast tracić czas na klepanie fragmentów pomocniczych ;).

Operator ? Pierwszy sposób jest znany pewnie każdemu, kto napisał chociaż kilka programów w języku C++ lub C#. Mowa o operatorze ?, zwanym też operatorem trójargumentowym lub operatorem warunkowym.

Pozwala on zastąpić kod:

<i>
int v;
if (condition)
v = value_for_true();
else
v = value_for_false();
</i>

jedną linią:

<i>
v = condition ? value_for_true() : value_for false();
</i>

Operator ?? Jest to kolejny operator, którym możemy się posłużyć w celu uniknięcia dodatkowego, niepotrzebnego kodu.

Jego działanie polega na zwróceniu wartości po lewej stronie operatora jeśli nie jest ona nullem lub zwróceniu wartości po prawej stronie w przeciwnym przypadku.

Tak więc kod

<i>
object my_object;
object default_object;
...
object other_object = my_object != null ? my_object : default_object;

</i>

możemy zapisać jako

<i>
object my_object;
object default_object;
...
object other_object = my_object ?? default_object;
</i>

Trochę krócej. Jest to również bardziej czytelne, ponieważ używając operatora ? w tym przypadku ktoś może posłużyć się raz warunkiem == lub !=, co sprawia, że kod czyta się nieco trudniej. Użycie operatora ?? określa tą kolejność.

Słowo kluczowe var

To słówko pojawiło się w składni języka w .NET3.5. Jest to udogodnienie dla programistów, pozwalające nie podawać jawnie typu tam, gdzie kompilator sam może go określić. Zamiast pisać:

<i>
Dictionary<String, List<int>> dictionary;
...
foreach (KeyValuePair<String, List<int>> item in dictionary)
{
...
}
</i>

możemy napisać

<i>
Dictionary<String, List<int>> dictionary;
...
foreach (var item in dictionary)
{
...
}
</i>

LINQ

LINQ również pojawiło się w .NET3.5 i służy do wydobywania informacji o elementach z pewnej kolekcji. Składnią przypomina trochę SQL, więc jeśli ktoś miał styczność z bazami danych szybko przyzwyczai się do wykorzystania LINQ we własnym kodzie :).

Prostym przykładem na zastosowanie może być wybranie z listy elementów, które spełniają pewną własność. Bez LINQ można to zaimplementować np. tak, jak pokazano poniżej:

<i>
List<Shape> triangles = new List<Shape>();
foreach (var item in shapes)
{
   if (item.Vertices.Count == 3)
      triangles.Add(item);
}
</i>

Składnia LINQ pozwala jednak na trochę inny zapis

<i>
List<Shape> triangles = (from item in shapes where item.Vertices.Count == 3 select item).ToList();
</i>

Wywołanie .ToList() na końcu wymusza utworzenie nowej kolekcji, ponieważ obiekt IEnumerable<Shape> zwrócony bezpośrednio przez nasze zapytanie można chyba określić jako enumerator po wybranych obiektach z kolekcji źródłowej shapes. Więcej o LINQ możecie poczytać na Wikipedii :).

Wyrażenia lambda

Wersja .NET3.5 wprowadziła również wsparcie dla tego mechanizmu :). Pozwala on na definiowanie anonimowych funkcji, co jest przydatne częściej niż może się wydawać na pierwszy rzut oka. Zaprezentuję tylko jak mógłby wyglądać kod przedstawiony przy okazji omawiania LINQ.

<i>
List<Shape> triangles = shapes.TakeWhile(item => item.Vertices == 3).ToList();
</i>

Wyrażenia lambda pozwalają na znacznie więcej. Jeśli chcecie poznać ich inne możliwości, możecie zacząć od informacji na MSDNie.

W tym artykule przedstawiłem pokrótce jedynie kilka wybranych metod, pozwalających skrócić i uprościć swój kod, co może także korzystnie wpłynąć na jego czytelność :). Jeśli chcecie dowiedzieć się więcej, w internecie znajdziecie artykuły zawierające bardziej obszerne opisy każdej z nich.

Pamiętajcie jednak, że nadużywając sposobów skracających zapis kodu, można go również bardzo skutecznie uczynić zupełne nieczytelnym. Należy więc znaleźć pewne optimum pomiędzy krótkim kodem i jego klarownością tak, aby przy ponownym czytaniu kodu własnego programu nie było dla nas zagadką jaką funkcjonalność dana część kodu właściwie realizuje ;).

Mam nadzieję, że dla kogoś informacje te będą przydatne :). Jeśli dopatrzycie się błędów lub macie pytania związane z tematem, piszcie.

Pozdrawiam,

Łukasz

P.S.

Słusznie zwrócono mi uwagę, że warto także wspomnieć o spadku wydajności, który może być spowodowany używaniem LINQ, wyrażeń lambda oraz pętli typu foreach. Często jednak kolekcje, na których operujemy mają kilkanaście do kilkudziesięciu elementów, więc wydłużenie czasu wykonania nie powinno być zbyt duże :). Jeśli pomimo tego zależy nam na wydajności lub takie są wymagania projektu, warto o tym pamiętać.