Bazen kısıtlı sayıda seçenek sözkonusudur ve bu seçeneklerin ifade edilmesi gerekmektedir. Bunun için yazıları kullanmak ( yani string kullanmak ) okunabilir olsa da iki dezavantajı vardır:
Yazılar yanlış yazılmaya müsaaittir ve yazı işlemleri göreli olarak yavaştır. Örneğin bir oyun programında bir şekle yukarı,sağ, aşağı ya da sola hareket ettiren move isimli bir metot yazacak olalım. metodun parametresi string olsun.
1 2 3 4 |
public void Move (string direction { //… } |
biz bu metodu şöyle yazabniliriz .string yerine int gibi tamsayılar kullanılabilir. Fakat bu durumda da koda bakan kişi ve hatta kofu yazan kişi şeklin hangi yöne gideceği yönde tereddüt yaşar.
1 2 3 4 5 6 7 8 |
public voidf Move(int direction) { //.. } //… Move(0); //… meve(2); |
Haftanın günleri, yılın ayları, renkler , ülkeler, şehirler hep kısıtlı sayıa seçeneğe sahip kümelerdir. O halde bizim yazıyla temsil edilen fakat gerçekte sayı belirten türlere gereksinimimiz vardır. İşte enum bunun için kullanılmaktadır. enum bildiriminin genel biçimi şöyledir.
1 2 3 4 |
enum <isim> { [sabit listesi] } |
Sabit listesi virgüllerle ayrılan isimlerden oluşur. Bunlara enum sabitleri denir.
1 2 3 4 |
enum Direction { Up, Right,Down,Left } |
Up, Right,Down,Left aslında yazı kılığına bürünmüş sayılardır.İlk enum sabitinin sayısal değeri sıfırdır sonrakiler de bir öncekinin bir fazlasıdır.Fakat istenirse bir enum sabitine = atomu ile bir değer verilebilir. Böylece sonrakiler onu izler. Örneğin;
1 2 3 4 |
enum Direction { up,right=3,down,left=-5 } |
Burada up =0 right =3 down =4 ve left =-5 tir.
Bir enum sabiti dışardan doğrudan kullanılamaz , enum ismi ve nokta operatörü ile kullanılr. Örneğin direction.up ve direction.down gibi. enum sabitleri erişim belirleyicilerine sabit değildir defaul publictir. Her enum türü farklı bir türdür.Aynı türden iki enum birbirine atanabilir.enum sabitleri de o enum türündendir .Örneğin;
1 2 3 4 5 6 7 |
enum Colors { Red, Green, } //… Colors c; c= Colors.Green; |
Burada c ve colors.Green aynı türdendir. enum türlerinden temel türleretemel türlerden de enum türlere doğrudan dönüştürme yoktur.
1 2 3 4 5 6 |
Colors c; //error! c=2; int a; //error! a=Colors .Green; |
Genellikle programcılaer özxel bir durum yoksa enum türnden sdabitlerini sayısaldeğerleriyle ilgilenmezler. Bu durumda onların sayısal değerleri tişleme sokulur.
1 2 3 4 5 |
enum Direction { Up,Right,Down,Left } //… |
Direction.Down > direction.up true değeri verir. enum değeri switch işlemine sokulabilir. Tabii bu durumda case ifadeleri de aynı türden enum olmak zorundadır.
Böylece yukarıda sözü edilen move metodu şöyle yazılabilir.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public void Move (Direction.d) { switch(d) { case Direction.Up; //… break; case Direction.Right; //… break; //… } } |
Bu durumda metodu şöyle çağırmalıyız.
1 2 3 |
Move (Direction.Up); //… Move(Direction.Right); |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
using System; namespace CSD { class App { public static void Main() { Move(Direction.Up); //... Move(Direction.Left); } public static void Move(Direction d) { switch (d) { case Direction.Up: Console.WriteLine("Move Up"); break; case Direction.Right: Console.WriteLine("Move Right"); break; case Direction.Down: Console.WriteLine("Move Down"); break; case Direction.Left: Console.WriteLine("Move Left"); break; } } } enum Direction { Up, Right, Down, Left } } |
Bir enum değerini Console sınıfının Write ve WriteLine metotlarıyla yazdırırsak onların sayısal karşılıkları değil yazısal karşılıkları ekrana basılır.
Örneğin Date Time yapısının DayOfWeek isimli property elemanı DayOfWeek türünden bir enum türündendir. DayOfWeek isimli enum türünün Sunday, Monay, Tuesday, Wednesday ,Thursday,Friday, ve Saturday elemanları vardır. Şüphesiz çok çeşitli enumlar da vardır.
Datetime isimli yapının “Dayofweek” isimli property elemanı “Dayofweek” isimli enum türündendir. Bu enum türünün haftanın günlerini belirten “Sunday, Monday, … “ isimli elemanları vardır.
***Anahtar Notlar: Bir sınıf yada yapının bir elemanının ismiyle onun türünün ismi aynı olabilir. Bu durumda bu isim dışarıdan niteliksiz olarak kullanıldığında tür ismi, nitelikli olarak kullanıldığında eleman ismi anlaşılır.
Örneğin:
1 2 3 4 5 6 7 8 9 10 |
enum Test { //... } class Sample { public Test Test; //... } |
1 2 3 4 5 6 7 8 9 10 |
class App { public static void Main() { //... Sample s = new Sample(); Test t; // Tür ismi t = s.Test; //Eleman ismi } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 |
class Sample { public Test Test; //... public void Foo() { Test t; t = Test.xx; } //... } |
Bir enum türü içerisinde aynı değere sahip birden fazla enum sabiti bulunabilir.
Örneğin:
1 2 3 4 5 6 7 8 9 |
enum Color { Red, Green, Blue = -1, Purple // Red = 0, // Green = 1, // Blue = -1, // Purple = 0 } |
Enum türleri Kategori olarak değer türlerindendir. Yani bir enum türünden bir değişken bildirdiğimizde biz değerin kendisini tutan bir değişken bildirmiş oluruz.
Her enum türünün ilişkin olduğu bir tam sayı türü vardır. (underlying integer type) İlişkin olduğu tam sayı türü enum isminden sonra “: “ syntax’ ı ile belirtilir. Eğer enum türünün ilişkin olduğu tam sayı türü belirtilmezse “: int” belirlemesi yapılmış gibi işlem görür.
Enum türünün ilişkin olduğu tam sayı türü o enum türünden değişkenin bellekte kaç byte yer kaplayacağını belirlemektedir.
Bir enum türünün enum sabitleri onun ilişkin olduğu tam sayı türünün sınırları dışında değer alamaz.
Örneğin:
1 2 3 4 5 6 |
enum Test : byte { XX = 254, YY, ZZ // Error! } |
1 2 3 4 5 |
enum Colors : sbyte { Red = 127, Green // Error! } |
1 2 3 4 5 |
enum Colors { Red = 127, Green // Geçerli! } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
using System; namespace CSD { class App { public static void Main() { Colors c; c = 100; } } enum Colors { Red = 100, Green = 200, Blue = 300 } } // Error! |
Enum türünden tam sayı türlerine tam sayı türlerinden de enum türlerine tür dönüştürme operatörleriyle dönüşüm yapılabilir.
Örneğin:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
using System; namespace CSD { class App { public static void Main() { Colors c; c = (Colors)100; // Geçerli! } } enum Colors { Red = 100, Green = 200, Blue = 300 } } |
Bir enum türünden değişkene atanacak değerin bir enum sabitiyle temsil edilmesi zorunlu değildir.
Örneğin:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
using System; namespace CSD { class App { public static void Main() { // Test t; t = (Test)10; // Geçerli! Console.WriteLine(t); } } enum Test { XX, YY, ZZ } } |
Anahtar Notlar: konsol sınıfının write ve writeline methodları ile bir enum değeri yazdırılırken eğer bu değer bir enum sabitiyle temsil ediliyorsa o sabitin yazısı yazdırılır. Temsil edilmiyorsa sabitin sayısal değeri yazdırılır.
Bir enum türünden de tamsayı türlerine tür dönüştürme operatörleriyle dönüşüm yapılabilir.
Örneğin:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
using System; namespace CSD { class App { public static void Main() { Test t = Test.YY; int result; result = t; // Error! result = (int)t; //Geçerli! Console.WriteLine(result); } } enum Test { XX, YY, ZZ } } |
Enum türleriyle temel türler arasında dönüşüm yapılırken, adeta enum türleri ilişkin olunan tam sayı türüymüş gibi işleme sokulur. Yani örneğin bir enum türünün ilişkin olduğu tam sayı türü “byte” türü olsun:
1 2 3 4 |
enum Test : byte { XX, YY, ZZ } |
İşte biz bu enum türüne farklı bir tam sayı türünü tür dönüştürerek atayabiliriz;
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
using System; namespace CSD { class App { public static void Main() { Test t; int i = 10000; t = (Test)i; Console.WriteLine(t); } } enum Test : byte { XX, YY, ZZ } } |
Burada int türünden byte türüne dönüşüm yapılıyormuş gibi işlem yapılır. Yani sayının yüksek anlamlı byteları kaybedilir. Aynı durumun terside söz konusudur:
1 2 3 4 |
enum Test : int { XX = 10000, YY, ZZ } |
1 2 3 4 5 6 7 |
public static void Main() { Test t = Test.XX; byte b; b = (byte)t; Console.WriteLine(b); } |
Farklı türlerden iki enum birbirine doğrudan atılamaz. Yani aralarında doğrudan dönüştürme yoktur. Fakat tür dönüştürme operatörüyle bir enum diğerine dönüştürülebilir.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
using System; namespace CSD { class App { public static void Main() { Colors c = Colors.Green; Weekend w = Weekend.Sunday; c = w; // Error! Sunday = 1 c = (Colors)w; // Geçerli! C = 1; Console.WriteLine(c); } } enum Colors { Red, Green, Blue } enum Weekend { Saturday, Sunday } } |
“E” bir enum türü, “T” bu enum türünün ilişkin olduğu tam sayı türü olsun. “e” “E” türünden, “x” de “T” türünden yada bu türe doğrudan dönüştürülebilen bir türden olsun.
1. Bir enum türüyle bir tam sayı türü toplanabilir. Sonuç enum türünden çıkar.Yani “e+x” geçerlidir. Bu işlemin sonucu ( E )(( T ) e + ( T ) x ) ifade biçimindedir.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
using System; namespace CSD { class App { public static void Main() { //... Colors c = Colors.Red; Colors result; result = c + 1; // Result = 1 // (Colors.Green) Console.WriteLine(result); } } enum Colors { Red, Green, Blue } } |
2. Bir enum türünden bir tam sayı türü çıkartılabilir. Sonuç enum türünden çıkar. Yani “e – x” işlemi geçerlidir. Bu işlemlin eş değeri ( E )(( T )e – ( T ) x) biçimindedir.
3. Bir enum türü “++” ve “—“ operatörleriyle işleme sokulabilir ve tam sayı türleriyle “+=” ve “-=” operatörleriyle işleme sokulabilir.
4. “e+x” işlemi “x+e” işlemiyle eşdeğerdir. Fakat “e-x” geçerli olduğu halde “x-e” geçerli değildir.
5. Aynı türden iki enum “-“ operatörüyle işleme sokulabilir. Sonuç ilişkin olunan tam sayı türünden çıkar yani; “e1” ve “e2” “E” türünden olmak üzere “e1-e2” ( T )e1 – ( T )e2 işlemiyle eşdeğerdir. Aynı türden iki enum birbirleriyle toplanamaz.
Kaynak:Kaan Aslan Hocanın Dersinde Tuttuğum Ders Notlarıdır.