Blog Dla Młodszych Programistów C#/.NET

Od C# w wersji 3.0 programiści C#/.NET mają dostęp do tak zwanego typu domniemanego var. O tym, czym dokładnie jest var, kiedy i jak używać go w C# dowiesz się z tego artykułu.

Czym Jest VAR (Typ Domniemany) w C#?


W jakim celu używamy słowa kluczowego var?


Przygotowałem wcześniej kilka deklaracji wraz z inicjalizacją zmiennych w metodzie Main.

using System;

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            int number1 = 11;
            double number2 = 11.0;
            string name1 = "ModestProgrammer";
            bool isDeleted1 = false;
            DateTime dateTime1 = new DateTime(2021, 1, 1);
            AnExampleOfAVeryLongClassName anExampleOfAVeryLongClassName1 = 
                 new AnExampleOfAVeryLongClassName();
        }
    }
}

Jak widzisz, każda z tych zmiennych ma jawnie zdefiniowany typ (int, double, string, bool, DateTime oraz AnExampleOfAVeryLongClassName). Dzięki słowu kluczowej var, czyli typu domniemanemu możemy w każdym z tych przypadków zamienić właśnie wskazany typ na słowo var.

using System;

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            int number1 = 11;
            double number2 = 11.0;
            string name1 = "ModestProgrammer";
            bool isDeleted1 = false;
            DateTime dateTime1 = new DateTime(2021, 1, 1);
            AnExampleOfAVeryLongClassName anExampleOfAVeryLongClassName1 = 
                 new AnExampleOfAVeryLongClassName();

            var number3 = 11;
            var number4 = 11.0;
            var name2 = "ModestProgrammer";
            var isDeleted2 = false;
            var dateTime2 = new DateTime(2021, 1, 1);
            var anExampleOfAVeryLongClassName2 = 
                 new AnExampleOfAVeryLongClassName();
        }
    }
}

Jak widzisz, nie mamy w tym momencie żadnych błędów, a cały kod działa tak samo, jak wcześniej. Zadeklarowaliśmy nasze zmienne, jako typ domniemany var i kompilator w tym momencie wie niejawnie dzięki inicjalizacji, o jaki typ nam chodzi. Także taki zapis jest dopuszczalny i jeżeli teraz najedziesz wskaźnikiem myszy na słowo var, to wyświetli Ci się typ, który tak naprawdę zostanie w danym miejscu utworzony.

Typ domniemany var w C# - podgląd typu

Także akurat w naszym przypadku do zmiennej number3 przypisaliśmy 11 i jawnie jest to właśnie typ int. Dla number4 jest to double. Dla name2 string. Dla isDeleted2 bool. Dla dateTime2 DateTime, a dla anExampleOfAVeryLongClassName2 jest to oczywiście AnExampleOfAVeryLongClassName. Także te typy, gdzie zastosowaliśmy var są identyczne, jak te we wcześniejszym przykładzie, gdzie te typy zadeklarowaliśmy jawnie.

Dla mnie zapis drugi, czyli z użyciem var jest dużo bardziej czytelny, ale tutaj zgodzę się, że może to być kwestia sporna. Jasne, że niektórym osobom może bardziej odpowiadać forma pierwsza.

Także pierwsza kwestia to czytelność, ale druga bardziej kluczowa moim zdaniem jest kwestia długości typów. Jeżeli mamy jakieś dłuższe nazwy, to w takim przypadku napisanie słowa kluczowego var może być dużo szybsze. Możesz to zauważyć już w naszym przykładzie z tworzeniem instancji klasy AnExampleOfAVeryLongClassName. Co więcej, jeżeli będziemy chcieli skorzystać z LINQ i np. pobrać jeszcze kolekcję elementów to ten zapis będzie jeszcze dłuższy.

Zobacz na taki przykład:

using System.Collections.Generic;

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            List<AnExampleOfAVeryLongClassName> classess = 
                 new List<AnExampleOfAVeryLongClassName>();
        }
    }
}

Mamy tutaj listę elementów naszej klasy o długiej nazwie: AnExampleOfAVeryLongClassName. I teraz, jeżeli chciałbym pobrać jakieś elementy z tej listy np. za pomocą LINQ, to znowu ten przykład wyglądałby mniej więcej tak:

using System.Collections.Generic;
using System.Linq;

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            List<AnExampleOfAVeryLongClassName> classess = 
                 new List<AnExampleOfAVeryLongClassName>();

            IEnumerable<AnExampleOfAVeryLongClassName> myClassess =
                classess
                .Where(x => x.Id == 1)
                .OrderBy(x => x.Id);
        }
    }
}

Czyli stosuje tutaj IEnumerable, następnie znowu jako typ generyczny przekazuję tę długą nazwę klasy, nazwę zmiennej i następnie dopiero mogę tworzyć zapytanie LINQ.

I właśnie w takich przypadkach użycie typu domniemanego var będzie dużo lepszym rozwiązaniem:

using System.Collections.Generic;
using System.Linq;

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            var classess = 
                 new List<AnExampleOfAVeryLongClassName>();

            var myClassess = classess
                            .Where(x => x.Id == 1)
                            .OrderBy(x => x.Id);
        }
    }
}

Zobacz, jak w takim przypadku zmieniła się długość, a co za tym idzie czytelność naszego kodu. Dzięki użyciu var nasz przykład jest dużo bardziej czytelny.

Kiedy nie można użyć słowa var?


Na koniec chciałbym Ci jeszcze tylko zwrócić uwagę, że słowa var możemy użyć tylko w przypadku deklaracji wraz z inicjalizacją. Bez inicjalizacji kompilator nie domyśli się, o jaki typ nam chodzi, dlatego nie możemy wtedy zastosować var.

Dla takiego zapisu:

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
            var age; //błąd kompilacji
        }
    }
}

Zostanie zgłoszony błąd kompilacji, ponieważ mamy tutaj samą deklarację, bez inicjalizacji i kompilator nie wie jaki typ chcieliśmy tutaj niejawnie zadeklarować.

Słowa var możemy użyć tylko wewnątrz metod lub konstruktora. Nie możemy na przykład stworzyć pola, czy właściwości typu var.

namespace App
{
    class Program
    {
        private var number = 1; //błąd kompilacji
        public var MyProperty { get; set; } = 2; //błąd kompilacji

        static void Main(string[] args)
        {
        }
    }
}

W oby przypadkach zostanie zgłoszony błąd kompilacji.

To samo dotyczy sygnatury metod, tam słowo var nie jest dopuszczalne.

namespace App
{
    class Program
    {
        static void Main(string[] args)
        {
        }

        public static var MyMethod() //błąd kompilacji
        {
            return "1";
        }

        public static string MyMethod(var a = 1) //błąd kompilacji
        {
            return "1";
        }
    }
}

W obu powyższych metodach zostanie również zgłoszony błąd kompilacji.


PODSUMOWANIE


Podsumowując, moim zdaniem warto używać typu domniemanego var wszędzie, gdzie jest to możliwe, ale w szczególności przy połączeniu z LINQ, gdzie nazwy naszych zmiennych mogą być dość długie. Ja w swoich aplikacjach używam słowa var wszędzie, gdzie to jest możliwe i moim zdaniem zwiększa to znacząco czytelność mojego kodu.

Jeżeli taki artykuł Ci się spodobał, to koniecznie dołącz do mojej społeczności. Zapisz się na darmowy newsletter, gdzie co tydzień dzielę się wartościowymi materiałami w szczególności dotyczącymi C# i platformy .NET (darmowy zapis – newsletter).

To wszystko na dzisiaj, do zobaczenia w kolejnym artykule.

Poprzedni artykuł - Typ Wartościowy i Typ Referencyjny w C#.
Następny artykuł - 19 Najczęściej Używanych Metod String'a, Które Warto Znać.
Autor artykułu:
Kazimierz Szpin
Kazimierz Szpin
Programista C#/.NET. Specjalizuje się w ASP.NET Core, ASP.NET MVC, ASP.NET Web API, WPF oraz Windows Forms.
Autor bloga ModestProgrammer.pl
Dodaj komentarz

Wyszukiwarka

© Copyright 2021 modestprogrammer.pl. Wszelkie prawa zastrzeżone. Polityka prywatności. Design by Kazimierz Szpin