.NET Framework içerisindeki enumerationların yapısına baktığımızda eminim ki bir çoğumuz her bir enum üyesinin tek bir değer taşıdığını biliyoruzdur. Örneğin aşağıdaki gibi yetkileri temsil eden bir enumeration’ımız olduğunu düşünelim.

public enum Yetki
{
    Ekleme,
    Silme,
    Degistirme
}

Buraya kadar herşey yolunda :) Şimdi diyelim ki bu enumerationı kullanarak yetkilerin atamasını yapan bir metot yazacağız ve bu metot içerisinde ilgili kullanıcıya birden fazla yetki ataması yapılmasına da olanak sağlayacağız.

Bu istekleri ilk olarak düşündüğümüzde aklımıza gelen en basit yöntem tabi ki metot parametresi olarakYetki tipini taşıyan bir list veya array almak. Öyleyse bu şekilde bir implemantasyon yapalım.

class Program
{
    static void Main(string[] args)
    {
        var list = new List()
            {
                Yetki.Degistirme,
                Yetki.Ekleme
            };
        YetkiAta(list.ToArray());
    }

    static void YetkiAta(Yetki[] yetkiler)
    {
        Console.WriteLine("Verilen Yetkiler: " + yetkiler.ToString());
        foreach (Yetki yetki in yetkiler)
        {
            Console.WriteLine(yetki.ToString());
        }
    }
}

Koda baktığımızda aslında her şey yolunda gibi. Kodu çalıştırıp bir de sonucu inceleyelim.

Çıkan sonuca baktığımızda aslında tek bir şey haricinde her şey yolunda gibi. Yolunda olmayan tek şey ise gelen yetkilerin tamamını doğru bir şekilde yazdıramamamız. Bunun yanında bir de metot kullanımına baktığımızda metodu kullanan developerın elindeki yetkileri toplayarak bir list veya array oluşturmasını sağlayarak aslında yazdığımız metodun kullanımını biraz da olsa zorlaştırmaktayız. Ayrıca ileride Admin veya modarator gibi içerisinde birden fazla yetkiyi barındıran üyeler tanımlamak istediğimizde bu üyelerin hangi yetkileri taşıdığını mecburen YetkiAta metodu içerisine gömeceğiz.

Peki başka çaremiz var mı ? :)

Flags Attribute

FlagsAttribute sınıfı System namespace’i altında bulunmakla beraber bizim tanımlamış olduğumuz enumerationlara çoklu değerler vermemizi sağlamakta. Bunu da yaparken aslında arka planda bit operasyonlarını kullanmakta. Peki Flags attribute’ünü nasıl kullanıyoruz ? Hemen o konuya gelelim. İlk olarak enumeration tanımımızın üzerine Flags attribute’ünü yerleştiriyoruz.

[Flags]
public enum Yetki
{
    Ekleme,
    Silme,
    Degistirme
}

Bir önceki paragrafı hatırlarsanız flags attribute’ünü eklediğimizde artık enum valueları üzerinde bit operasyonları gerçekleştirebileceğimizden bahsetmiştim. İşte bu bit operasyonlarından dolayı enum valuelarına da 2′nin üstleri (1,2,4,8,16…) değerler vermeliyiz ki runtime arka planda bu operasyonları kendisi handle edebilsin. Öyleyse Yetki enumını yukarıdaki kurallara göre değiştirelim.

[Flags]
public enum Yetki
{
    Ekleme=1,
    Silme=2,
    Degistirme=4
}

Bunları yaptıktan sonra peki metodumuz içerisindeki kullanım nasıl olacak ? Hemen enumeration’ın yeni durumuna göre kodu güncelleyelim.

class Program
{
    static void Main(string[] args)
    {
        YetkiAta(Yetki.Degistirme | Yetki.Ekleme);
    }

    static void YetkiAta(Yetki yetkiler)
    {
        Console.WriteLine("Verilen Yetkiler: " + yetkiler.ToString());

        if (yetkiler.HasFlag(Yetki.Ekleme))
        {
            Console.WriteLine("Ekleme yetkisi istendi");
        }
        if (yetkiler.HasFlag(Yetki.Silme))
        {
            Console.WriteLine("Silme yetkisi istendi");
        }
        if (yetkiler.HasFlag(Yetki.Degistirme))
        {
            Console.WriteLine("Degistirme yetkisi istendi");
        }
    }
}
[Flags]
public enum Yetki
{
    Ekleme = 1,
    Silme = 2,
    Degistirme = 4
}

Kodumuzun yeni haline baktığımızda aslında bazı farklılıklar olduğunu farketmişinizdir. Bu değişikliklerden ilki YetkiAta metodu içerisindeki if kontrolleri. Her ne kadar ilk baktığımızda bu kontroller kötü dursa da bu noktada aslında başka bir çaremiz yok gibi. Çünkü artık metot parametresine baktığımızda list veya array tipinde bir parametremiz yok. Sadece Yetki enumeration’ı alıyoruz parametre olarak. Haliyle bu enumeration içerisinde birden fazla değer taşıyabildiği için kontrollerimizi HasFlag metoduyla yapıyoruz. HasFlag metodu eğer elimizdeki enum değeri içerisinde, parametre olarak verdiğimiz enum değerini barındırıyorsa bize true değerini dönüyor.

Şimdi yazdığımız kodu çalıştıralım.

Ekran görüntüsünden de farkettiyseniz Flags attribute’ünü kullanmanın güzelliklerinden biri deToString metodunun çağrımında artık çoklu enum değeri içerisindeki tüm enum değerlerinin virgülle ayrılarak yazılması. Bunun yanında Flags attribute’ünü kullandığımızda Enum tipi içerisinde bulunan Parse metodu içerisinde çoklu enum isimlerini virgül ile ayırarak verdiğimizde ilgili değerlerin otomatik olarak Enum’a atanması mümkün. Örneğin,

class Program
{
    static void Main(string[] args)
    {
        Yetki yetki = (Yetki)Enum.Parse(typeof(Yetki), "Silme,Ekleme");
        Console.WriteLine(yetki.ToString());
    }
}

[Flags]
public enum Yetki
{
    Ekleme = 1,
    Silme = 2,
    Degistirme = 4
}

Kodu çalıştırdığımızda gördüğünüz gibi enumerationa Silme,Ekleme otomatik olarak atanıyor veToString metoduyla otomatik olarak ekrana yazılıyor.

Son olarak bahsedeceğim özellik ise enumlar içerisinde de Flags attribute’ü kullanarak birden fazla değeri içerisinde barındıran üyeler tanımlayabilmemiz. Örneğin yetkilere Admin ve Moderatör olarak 2 yeni kavram ekleyelim ve Admin’in tüm yetkileri olacağını, moderatörün ise sadece silme ve değiştirme yapabileceğini düşünelim. Bunun için enumeration içerisinde yapmamız gereken 2 yeni üye tanımlayıp bu üyelere gerekli yetkileri vermek.

class Program
{
    static void Main(string[] args)
    {
        Yetki yetki = Yetki.Admin;
        YetkiAta(yetki);
    }

    static void YetkiAta(Yetki yetkiler)
    {
        Console.WriteLine("Verilen Yetkiler: " + yetkiler.ToString());

        if (yetkiler.HasFlag(Yetki.Ekleme))
        {
            Console.WriteLine("Ekleme yetkisi istendi");
        }
        if (yetkiler.HasFlag(Yetki.Silme))
        {
            Console.WriteLine("Silme yetkisi istendi");
        }
        if (yetkiler.HasFlag(Yetki.Degistirme))
        {
            Console.WriteLine("Degistirme yetkisi istendi");
        }
    }
}

[Flags]
public enum Yetki
{
    Ekleme = 1,
    Silme = 2,
    Degistirme = 4,
    Admin = Ekleme | Silme | Degistirme,
    Moderator = Silme | Degistirme
}

Yukarıda gördüğünüz gibi “Verilen Yetkiler” kısmında enum Admin olarak gelirken YetkiAta metodu içerisinde Enum.HasFlag metodunu kullanarak yaptığımız yetki kontrollerinde Admin’in sahip olduğu esas yetkilere tek tek ulaşabildik.

Evet bu yazımızda Flags attribute’ü ile ilgili olarak bahsedeceklerimiz bu kadar. Aslında çok basit senaryolarda belki ilk olarak gördüğümüz list veya array üzerinden ilerleyebiliriz. Ancak Flags attribute’ü ile beraber gelen esneklikler de gözardı edilecek şeyler olmadığını düşünüyorum. Tabi yerine göre gelecek olan avantajları ve yükleri doğru olarak öngörmemiz lazım.

Hoşçakalın