Kaynak:

https://melihtuna.wordpress.com/2011/09/28/c-datetime-islemleri/

C# DateTime İşlemleri

Yazım tarihi 28 Eylül 2011 tarafından Ahmet Melih Tuna

Bu bölümde tarih ve zaman bilgileri üzerinde nasıl işlem yapıldığı konusunda bilgi verilecektir. Tarih ve zaman bilgileri üzerinde işlem yapılırken DateTime yapısından(structure) yararlanılmaktadır. Alışkanlıktan DateTime’dan bazen sınıf diye söz edilmektedir.

Today Özelliği

Tarih ve zaman bilgileri DateTime tipindeki değişkenlerde saklanmakta ve tarihsel bilgiler üzerinde işlem yapılırken DateTime yapısının metotlarından ve özelliklerden yararlanılmaktadır. Sistem tarihini elde etmek istiyorsanız DateTime structure’ın Today özelliğine bakabilirsiniz.

textBox1.Text = DateTime.Today.ToString();

Bu satır sayesinde TextBox’a sistem tarihi aktarılır. Bu şekilde elde edilen sistem tarihine ayrıca zaman başlangıcı eklenmektedir. Aşağıda verilen ekran görüntüsünü bu satırı bir metoda yazıp işlettikten sonra aldık.

Todayözelliğinden okunan tarih bilgisini TextBox yerine DateTime tipindeki değişkene aktarabilirsiniz. Bu amaçla DateTime tipinde bir değişken tanımladık.

DateTime Tarih = DateTime.Today;

DateTime tipindeki değişkenin içeriğini istediğiniz gibi kullanabilirsiniz. TextBox’a yalnızca tarihin aktarılmasını sağlamak için String sınıfının Substring() metodunu kullandık.

DateTime Tarih = DateTime.Today;
string Tarih_str = Tarih.ToString();
textBox1.Text = Tarih_str.Substring(0, 10);

Today özelliği sayesinde elde edilen tarih ve zaman bilgisinin yalnızca tarih kısmı ile ilgileniyorsanız DateTime yapısının ToShortDateString() metodundan yararlanabilirsiniz.

DateTime Tarih = DateTime.Today;
textBox1.Text= Tarih.ToShortDateString();

DateTime yapısının Today özelliği ile elde edilen tarih bilgisinin uzun halini kullanmak istiyorsanız ToShortDateString() yerine ToLongDateString() metodunu kullanmalısınız. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Tarih = DateTime.Today;
textBox1.Text = Tarih.ToShortDateString();
textBox2.Text = Tarih.ToLongDateString();

ToShortDateString() ve ToLongDateString() metotları geriye string bilgi gönderdiği için bu bilgileri TextBox’a aktarmak için dönüştürme yapmaya gerek yoktur. Tarih bilgilerini string bilgiye dönüştürürken ToShortDateString ve ToLongDateString metotlarını kullandığınız gibi ToString() metodunu kullanabilirsiniz. DateTime nesnesinden kısa tarih bilgisini almak istiyorsanız “d” karakterini, uzun tarih elde etmek istiyorsanız “D” biçimleme karakterini ToString() metoduna parametre olarak vermelisiniz.

DateTime Tarih = DateTime.Today;
textBox1.Text = Tarih.ToString(“d”);
textBox2.Text = Tarih.ToString(“D”);
textBox3.Text = Tarih.ToString(“m”);
textBox4.Text = Tarih.ToString(“y”);

Benzer şekilde “m” format karakteri ile gün ve ay bilgisi, “y“ karakteri ile ay ve yıl bilgisi elde edilir. Bu satırlar bir metoda yazılıp işletilirse aşağıdaki gibi bir sonuç elde edilir.

Now Özelliği

Sistem saatinin hem tarih hem de zaman bilgisini elde etmek istiyorsanız DateTime yapısının Now özelliğine bakabilirsiniz. Now özelliğinin nasıl kullanıldığını anlatmak için aşağıda verilen satırı formun Load olayını temsil eden metoda yazdık.

textBox2.Text = DateTime.Now.ToString();

Bu satır sayesinde formdaki 2. TextBox’a hem sistem tarihi hem saati yazılır. Bu satırın işlevini aşağıda görebilirsiniz. Yukarıda yapıldığı gibi Substring() metodu ile DateTime tipindeki bilginin istediğiniz kısmını alıp başka amaçlarla kullanabilirsiniz.

Now özelliği sayesinde ile elde edilen sistem tarih ve saatinin yalnızca zaman kısmı ile ilgileniyorsanız DateTime tipindeki bilginin zaman kısmını ToShortTimeString() metodu ile elde edebilirsiniz. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Zaman = DateTime.Now;
textBox1.Text = Zaman.ToShortTimeString();

Bu metot işletildiğinde sistem saatinin zaman bilgisi TextBox’a aktarılır. ToShortTimeString metodu ile elde edilen zaman bilgisinde saniye olmaz. Zaman bilgisinin saniye kısmı ile ilgileniyorsanız ToLongTimeString metodunu kullanmalısınız.

DateTime Zaman = DateTime.Now;
textBox1.Text= Zaman.ToShortTimeString();
textBox2.Text= Zaman.ToLongTimeString();

String Bilgiyi DateTime Tipine Dönüştürmek

Yukarıda DateTime yapısının Today ve Now özelliklerinin içeriklerini DateTime tipindeki değişkenlere aktardık. TextBox’lara girilen bilgileri DateTime tipine dönüştürebilirsiniz. Bu işlemi yaparken Convert sınıfının ToDataTime() metodunu kullanabilirsiniz.

DateTime Tarih, Saat;
Tarih = Convert.ToDateTime(“30.12.2007”);
Saat = Convert.ToDateTime(“12:45”);

Zaman bilgilerini String bilgiye dönüştürürken ToLongTimeString ve ToShortTimeString metotlarını kullandığınız gibi ToString() metodunu kullanabilirsiniz. ToString() metoduna “t” karakterini parametre olarak verirseniz DateTime bilgisinden kısa saat elde edilir. Benzer şekilde “T” karakteri ile uzun zaman bilgisi elde edilir.

DateTime Zaman = DateTime.Now;
textBox1.Text = Zaman.ToString(“t”);
textBox2.Text = Zaman.ToString(“T”);
textBox3.Text = Zaman.ToString(“f”);
textBox4.Text = Zaman.ToString(“F”);
textBox5.Text = Zaman.ToString(“g”);

Bu satırlar bir metoda yazılıp işletilirse aşağıdaki gibi bir sonuç alınır. ToString() metodu ile tarih ve zaman bilgileri biçimlenirken Format() metodunun biçim kodları kullanılmaktadır.

DayOfWeek Özelliği

Sistem tarihinden veya tarihsel bir bilgiden yararlanarak haftanın gününü öğrenmek istiyorsanız bu özelliğe bakabilirsiniz. DayOfWeek özelliğinin nasıl kullanıldığını göstermek için aşağıda verilen kodu hazırladık. Bu kodda “Tarih” adında bir değişken tanımlayıp bu değişkene Today özelliğinden yararlanarak sistem tarihini aktardık.

DateTime Tarih = DateTime.Today;
int gun = Convert.ToInt32(Tarih.DayOfWeek);
textBox1.Text = Tarih.ToString().Substring(0, 10);
textBox2.Text = Convert.ToString(gun);

Bir sonraki satırda ise sistem tarihini formdaki ilk TextBox’a aktardık. En son olarak “Tarih” değişkenin veya nesnesinin DayOfWeek özelliğinin içeriğini okuyup 2. TextBox’a aktardık. Bu kod işletildiğinde aşağıdaki gibi bir sonuç alınır.

Bu şekilde haftanın günü öğrenildikten sonra kullanıcı günün Türkçe adı konusunda bilgilendirilebilinir. Bunun için Türkçe gün adlarından meydana gelen bir dizi değişken tanımlanır. Bu işlemin nasıl yapıldığını aşağıda görebilirsiniz.

string[] Gunler={ “Pazar”, “Pazartesi”, “Salı”, “Çarşamba”, “Perşembe”,”Cuma”, “Cumartesi” };
DateTime Tarih = DateTime.Today;
textBox1.Text = Tarih.ToString().Substring(0, 10);
int gun = Convert.ToInt32(Tarih.DayOfWeek);
textBox2.Text = Convert.ToString(gun);
textBox3.Text = Convert.ToString(Gunler[gun]);

DayOfYear Özelliği

Elinizdeki tarih bilgisinin yılın kaçıncı günü olduğunu öğrenmek istiyorsanız DayOfYear özelliğine bakabilirsiniz. Bu özelliğin nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Tarih = DateTime.Today;
int gun = Tarih.DayOfYear;
textBox1.Text = Tarih.ToShortDateString();
textBox2.Text = Convert.ToString(gun);

Bu kod işletildiğinde geçerli tarih bilgisi ilk TextBox’a, bu tarih bilgisinin gün kısmı ise 2. TextBox’a aktarılır. Aşağıda verilen ekran görüntüsünü bu kodu işlettikten sonra aldık.

Bu örnekte DayOfYear özelliğinin önüne DateTime tipindeki değişkenin adını yazdık. Dolayısıyla yılbaşından bu güne kadar geçen gün sayısını öğrendik. DateTime tipindeki değişkene başka bir tarihi aktarıp yılbaşından o tarihe kadar geçen gün sayısını öğrenebilirsiniz. Bu özellikten yararlanarak 2 tarih arasındaki gün sayısını öğrenebilirsiniz. Bu işlemin nasıl yapıldığını anlatmak için forma 3 TextBox yerleştirdik.

Formdaki ilk TextBox’a geçerli sistem tarihini, 2. TextBox’a ise en son ödeme tarihini yazacağız. Ödemenin kaç gün geç yapıldığını bulup 3. TextBox’a aktaracağız. Bu amaçla Form1’in Load olayını temsil eden metoda aşağıda verilen satırları yazıp proje çalıştırıldığı zaman geçerli tarihin ilk TextBox’a yazılmasını sağlayacağız.

private void Form1_Load(object sender, EventArgs e)
{
DateTime Tarih = DateTime.Today;
textBox1.Text = Tarih.ToShortDateString();
}

Kullanıcı projeyi çalıştırıp son ödeme tarihini 2. TextBox’a girip formu tıkladığında ödemenin kaç gün geciktiğini öğrenip ilgili TextBox’a yazmak için aşağıda verilen kodu hazırladık. Bu kodda DayOfYear özelliğine 2 kez bakılmaktadır. İlk kullanımda yılbaşından son ödemeye kadar gün sayısı öğrenilmektedir.

private void Form1_Click(object sender, EventArgs e)
{
DateTime Bugun = DateTime.Today;
textBox1.Text = Bugun.ToShortDateString();
DateTime Son_gun = Convert.ToDateTime(textBox2.Text);
int ilk = Bugun.DayOfYear;
int son = Son_gun.DayOfYear;
textBox3.Text = Convert.ToString(ilk-son);
}

DayOfYear özelliğinin 2. kez kullanıldığı satırda ise yılbaşından bugüne kadarki gün sayısı öğrenilmektedir. Bu 2 tarih arasındaki gün farkı gecikmedir.

Day, Month ve Year Özellikleri

Sistem tarihinin gün bilgisini öğrenmek için Day özelliğini kullanabilirsiniz. Geçerli tarihin ay bilgisini öğrenmek istiyorsanız Month özelliğini, yıl bilgisini öğrenmek için ise Year özelliğine bakabilirsiniz. Bu özelliklerin nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Tarih = DateTime.Today;
textBox1.Text = Tarih.ToString().Substring(0,10);
textBox2.Text = Tarih.Day.ToString();
textBox3.Text = Tarih.Month.ToString() ;
textBox4.Text = Tarih.Year.ToString();

Bu satırlar bir metoda yazılıp işletilirse aşağıdaki gibi bir sonuç elde edilir. Bu sayede tarih bilgisi gün, ay ve yıl şeklinde parçalanmış oldu. Tarih bilgisinden ay adını öğrenmek istiyorsanız Visual Basic kökenli MonthName() metodunu kullanabilirsiniz. Bu metot parametre olarak ay bilgisini alıp geriye ay adını göndermektedir.

DateTime Tarih = DateTime.Today;
int ay = Tarih.Month;
textBox4.Text = Microsoft.VisualBasic.DateAndTime.MonthName(ay, false);

MonthName() metoduna 2. parametre olarak true vermeniz halinde ay adının kısa hali elde edilir. Ayın Türkçe adını Visual Basic’in MonthName metodu sayesinde öğrenmek yerine Türkçe ay adlarını bir dizi değişkene aktarıp bu dizi değişkenden yararlanabilirsiniz.

DateSerial() Metodu

Gün, ay ve yıl bilgilerinden yola çıkıp tarih bilgisi oluşturmak istiyorsanız Visual Basic’in DateSerial() metodundan yararlanabilirsiniz. Bu metot yıl, ay ve gün bilgilerini parametre olarak alıp geriye tarih bilgisini göndermektedir.

DateSerial(Yıl, Ay, Gün)

int gun=24;
int ay =03;
int yil=2004;
DateTime Tarih;
Tarih = Microsoft.VisualBasic.DateAndTime.DateSerial(yil, ay, gun);
textBox1.Text = Convert.ToString(Tarih);

Visual Basic’in DateSerial() metodu sayesinde elde edilen tarih bilgisine C# derleyicisi otomatik olarak zaman başlangıcını eklemektedir. Bu nedenle bu satırlar bir metoda yazılıp işletilirse aşağıdaki gibi bir sonuç elde edilir.

Substring() veya ToShortDateString() metodundan yararlanıp tarihe eklenen zaman başlangıcını silebilirsiniz. Yukarıda verilen koddaki son satır aşağıdaki gibi değiştirilirse TextBox’a yalnızca tarih bilgisi aktarılır.

textBox1.Text = Convert.ToString(Tarih).Substring(0,10) ;

DateAdd() Metodu

Bazen geçerli tarihe belli sayıda gün, tarih veya yıl eklenmek istenir. Aynı şekilde zaman bilgisine saat, dakika eklemek gerekebilir. Visual Basic’in DateAdd() metodu bu işlemler yapılmak istendiğinde kullanılabilir.

DateAdd(Artım Tipi, Artım Miktarı, Tarih Bilgisi)

Bu metot 3 parametreye sahiptir. İlk parametre tarih veya zaman bilgisinin artım şekli belirtilmektedir. Tarih bilgisinin gün değeri arttırılmak isteniyorsa ilk parametrede Microsoft.VisualBasic.DateInterval.Day seçeneği kullanılmalıdır.

DateTime Tarih = DateTime.Now;
textBox1.Text = Tarih.ToShortDateString();
object Tarih1 = Microsoft.VisualBasic.DateAndTime.DateAdd(
Microsoft.VisualBasic.DateInterval.Day, 10, Tarih);
textBox2.Text = Convert.ToString(Tarih1).Substring(0, 10);

Bu satırlarda önce DateTime tipinde bir değişken tanımladık ve Now() metodu sayesinde sistem tarihi ve saatini bu değişkene aktardık. Formdaki ilk TextBox’a sistem tarihini, ardından DateAdd() metodu ile sistem tarihine 10 gün ekleyip 2. TextBox’a aktardık.

DateAdd() metoduna 3. parametre olarak verilen tarihsel bilgiye bir veya birden fazla ay eklemek istemiş olsaydık 1. parametrede DateInterval.Month seçeneğini kullanırdık.

AddDays(), AddMonths() ve AddYears() Metotları

Değişik şekilde elde edilmiş geçerli tarih bilgisine gün ekleyip veya çıkarıp başka bir tarih bilgisini elde ederken DateTime yapısının bu metotlarını kullanabilirsiniz. Bu metotlar gün, ay veya yıl eklenmek veya çıkarılmak istenen tarih bilgisinin yanına yazılmaktadır.

DateTime Bugun, Sonra, Once;
Bugun = DateTime.Now;
textBox1.Text = Convert.ToString(Bugun).Substring(0, 10);
Sonra = Bugun.AddDays(5);
textBox2.Text = Convert.ToString(Sonra).Substring(0, 10);
Once = Bugun.AddDays(-10);
textBox3.Text = Convert.ToString(Once).Substring(0, 10);

Bu kod işletilirse formdaki ilk TextBox’a geçerli sistem tarihi ve 2. TextBox’a ise 5 gün sonrasının tarihi yazılır. AddDays() metoduna eksi(-) bir değeri parametre olarak verirseniz tarih bilgisine gün eklenmeyip çıkarılır.

Tarih bilgisine ay eklemek veya çıkarmak istiyorsanız AddMonths(), yıl eklemek veya çıkarmak istiyorsanız AddYears() metotlarını kullanabilirsiniz. Bu metotların nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Bugun, Tarih1, Tarih2;
Bugun = DateTime.Now;
Tarih1 = Bugun.AddMonths(2);
Tarih2 = Bugun.AddYears(1);

DaysInMonth() ve IsLeapYear() Metotları

Herhangi bir yılın herhangi bir ayının kaç çektiğini öğrenmek istiyorsanız DaysInMonth() metodundan yararlanabilirsiniz. Bu metodun nasıl kullanıldığını anlatmak için forma 3 TextBox yerleştirip aşağıda verilen kodu hazırladık.

int yil = Convert.ToInt32(textBox1.Text);
int ay = Convert.ToInt32(textBox2.Text);
int gun = DateTime.DaysInMonth(yil, ay);
textBox3.Text = gun.ToString();

DaysInMonthmetodu 2 parametreye sahiptir. İlk parametrede yıl, 2. parametrede ise gün sayısı öğrenilmek istenen ay verilmektedir. Formdaki ilk TextBox’a yılı, 2. TextBox’a gün sayısını öğrenmek istediğimiz ayı yazıp bu kodu işletince aşağıdaki gibi bir sonuç elde ettik.

4 yılda bir şubat ayı 29 çekmekte ve dolayısıyla o yılda 366 gün olmaktadır. Belirtilen yılın 366 güne sahip olup olmadığını öğrenmek istiyorsanız IsLeapYear() metodunu kullanabilirsiniz. Bu metot parametre olarak aldığı tarih bilgisinin yılı 366 gün çekiyorsa geriye true, değilse false gönderir. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.

int yil = Convert.ToInt32(textBox1.Text);
bool artik = DateTime.IsLeapYear(yil);
if (artik == true)
MessageBox.Show(“Bu yıl şubat 29 çekiyor”);

Hour, Minute ve Second Özellikleri

Bu özelliklerden yararlanarak zaman bilgisinin saat, dakika ve saniye bileşenlerini öğrenebilirsiniz. Bu özellikler hakkında bilgi vermek için aşağıda verilen kodu hazırladık.

DateTime Zaman = DateTime.Now;
textBox1.Text = Zaman.ToString().Substring(11, 8);
textBox2.Text = Zaman.Hour.ToString();
textBox3.Text = Zaman.Minute.ToString();
textBox4.Text = Zaman.Second.ToString();

Bu metotta önce DateTime tipinde bir değişken tanımladık ve bu değişkene Now özelliğinden yararlanarak sistem tarih ve zaman bilgisini aktardık. Saat, dakika ve saniye bilgilerini Visual Basic’in TimeSerial() metoduna parametre olarak verip zaman bilgisi elde edebilirsiniz. Bu metodun nasıl kullanıldığını anlatmak için forma 4 TextBox yerleştirip aşağıda verilen kodu hazırladık.

int saat, dakika, saniye;
DateTime Zaman = DateTime.Now;
saat = Convert.ToInt32(textBox1.Text);
dakika = Convert.ToInt32(textBox2.Text);
saniye = Convert.ToInt32(textBox3.Text);
Zaman=Microsoft.VisualBasic.DateAndTime.TimeSerial(saat, dakika, saniye);
textBox4.Text = Convert.ToString(Zaman.ToLongTimeString());

Kullanıcı zaman bilgisini saat, dakika ve saniye cinsinden TextBox’lara girecek. Girilen bu bilgiler TimeSerial() metodu ile birleştirilip formdaki en son TextBox’a aktarılacaktır. Zaman bilgisinin mili saniye kısmını elde etmek istiyorsanız zaman nesnesinin Milisecond özelliğinden yararlanabilirsiniz.

AddHours(), AddMinutes() ve AddSeconds() Metotları

Zaman bilgisine saat, dakika veya saniye ekleme ve çıkarma gereğini duyduğunuzda bu metotları kullanabilirsiniz. Bu metotlar zaman bilgisini içeren değişken ile birlikte kullanılır ve eklenecek veya çıkarılacak saat, dakika ve saniyeyi parametre olarak alırlar.

Zaman Bilgisi.AddHours(Artım-Eksiltme Değeri)

Bu metotların nasıl kullanıldığını anlatmak için forma 3 TextBox yerleştirip aşağıda verilen satırları hazırladık. Bu satırlarda DateTime tipinde 3 değişken tanımlayıp ve Now özelliği ile sistem saatini “simdi” adını verilen değişkene aktardık. Sistem saatine saat eklemek için AddHours ve 30 dakika çıkarmak için AddMinutes metodunu kullandık.

DateTime Simdi, Zaman1, Zaman2;
Simdi = DateTime.Now;
Zaman1 = Simdi.AddHours(1);
Zaman2 = Simdi.AddMinutes(-30);

Format() Metodu İle Tarih ve Zaman Bilgilerini Biçimlemek

Tarih ve zaman bilgilerini biçimlerken Format() metodundan yararlanabilirsiniz. Aşağıda verilen kod işletilirse sistem tarihi belirlenen formata dönüştürülüp TextBox’lara aktarılır.

DateTime Tarih = DateTime.Today;
string str1 = String.Format(“{0:d}”, Tarih);
string str2 = String.Format(“{0:D}”, Tarih);
textBox1.Text = str1;
textBox2.Text = str2;

Format() metodu 2 parametreye gerek duymaktadır. İlk parametrede biçimleme yapılırken kullanılacak biçim kodu verilmektedir. 2. parametrede ise biçimlenecek veya dönüştürülecek tarih, zaman ve sayısal bilgi verilmektedir.

Bu örnekte DateTime tipinden kısa tarih elde etmek için d’yi, uzun tarihi elde etmek için ise D’yi kullandık. DateTime tipindeki değişkene tarih ile birlikte zaman bilgisini aktarırken “t” ve “T” biçim kodları ile zaman bilgisini kısa ve uzun olarak gösterebilirsiniz. “f” ve “F” biçim kodu ile hem tarih hem de zaman bilgisi elde edilmektedir.

DateTime Tarih = DateTime.Now;
string str1 = String.Format(“{0:t}”, Tarih);
string str2 = String.Format(“{0:T}”, Tarih);
string str3 = String.Format(“{0:F}”, Tarih);

Yalnızca sistem saatine gerek duyuyorsanız TimeOfDay() metodunu kullanabilirsiniz. Tarih ve zaman bilgilerini formatlarken kullanılan bazı kodlar aşağıda tablo halinde verildi.

 

Parse Metodu İle String Bilgileri Tarih ve Saate Çevirmek

Kullanıcının TextBox’a veya başka bir nesne aracılığıyla girmiş olduğu string bilgiyi tarih ve zaman olarak değerlendirmek istiyorsanız DateTime yapısının Parse() metodundan yararlanabilirsiniz. Bu metodun nasıl kullanıldığını aşağıda görebilirsiniz.

DateTime Tarih = DateTime.Parse(textBox1.Text);

TextBox’a girilen bilgi tarihsel değilse bu satır işletildiğinde hata meydana gelir. Geçersiz tarih girilip Parse() metodu ile dönüştürme yapılırken meydana gelecek hatalardan dolayı programın kırılmasını engellemek için aşağıdaki gibi try-catch bloğu hazırlanabilir.

DateTime Tarih;
try
{
Tarih = DateTime.Parse(textBox1.Text);
}
catch
{
MessageBox.Show(“Girilen tarih geçersiz”);
}

Bu satırları yazarken kullandığımız bilgisayarda mevcut bölgesel ayarlara göre tarih formatı gün-ay-yıl şeklindeydi. Dolayısıyla TextBox’a Ay-Gün-Yıl formatına uygun tarih girildiğinde Parse() metodu bu şekli ile kullanıldığında dönüştürme işlemini yapamaz. Parse() metoduna parametre olarak verilecek tarih bilgisinin formatını 2. parametrede belirtebilirsiniz. Bu konuda bilgi vermek için forma 2. bir TextBox yerleştirip aşağıda verilen kodu yazdık.

System.Globalization.CultureInfo ulke;
ulke = new System.Globalization.CultureInfo(“en-US”);
DateTime Tarih;
try
{
Tarih = DateTime.Parse(textBox1.Text, ulke);
textBox2.Text = Tarih.ToShortDateString();
}
catch
{
MessageBox.Show(“Girilen tarih geçersiz”);
}

Bu kod sayesinde formdaki ilk TextBox’a ay-gün-yıl formatında girilmiş tarih bilgisi DateTime yapısının Parse() metodu ile DateTime tipindeki değişkene aktarılır. Ardından bu değişkenin içeriği String’e çevrilip 2. TextBox’a aktarılmaktadır.

Ticks Özelliği

DateTime yapısının bu özelliğinden yararlanılarak bir işlemin ne kadar sürdüğünü öğrenebilirsiniz. Bu özellik hakkında bilgi vermek için aşağıda verilen kodu hazırladık.

long Tick_sayi = DateTime.Now.Ticks;
textBox1.Text = Tick_sayi.ToString();

Ticksözelliği 1 Ocak 0001’den içinde bulunulan ana kadar geçen süreyi tick sayısı cinsinden içermektedir. Bu özelliğin içeriği her 100 nano saniyede 1 artmaktadır.

Şimdi 1 Ocak 0001’den bu güne kadar geçen süreyi saniye, dakika, saat, gün ve yıl ile ifade edeceğiz. Bu amaçla forma 6 TextBox yerleştirip aşağıda verilen kodu hazırladık.

long Saniye, Dakika, Saat, Gun, Yil;
long Tick_sayi = DateTime.Now.Ticks;
textBox1.Text = Tick_sayi.ToString();
Saniye = Tick_sayi / 10000000;
textBox2.Text = Saniye.ToString();
Dakika = Saniye / 60;
textBox3.Text = Dakika.ToString();
Saat = Dakika / 60;
textBox4.Text = Saat.ToString();
Gun = Saat / 24;
textBox5.Text = Gun.ToString();
Yil = Gun / 365;
textBox6.Text = Yil.ToString();

Ticksözelliğinin içeriği her 100 nano saniyede bir arttığı için içeriğini 10.000.000’e bölerek 1 Ocak 0001’den bugüne kadar geçen süreyi saniye olarak ifade ettik. Devamında saniyeyi dakika, saat, gün ve yıla çevirdik. Bu kod işletildiğinde aşağıdaki gibi bir sonuç alınır.

Şimdi ise bir işlemin ne kadar sürdüğünü Ticks özelliğinden yararlanarak bulacağız. Bu amaçla bir for döngüsü hazırlayıp işlemin başında ve sonunda Ticks özelliğine bakıp geçen süreyi hesapladık. Kullandığımız bilgisayarda for döngüsünü 6 saniyede tamamlandı. Ticks özelliğinden yararlanıp bekleme durumları meydana getirebilirsiniz.

long Tick_ilk, Tick_son, Tick_fark;
long Sayi = 0;
Tick_ilk = DateTime.Now.Ticks;
for (int i = 0; i < 1000000000; i++)
{
Sayi = Sayi + i;
}
Tick_son = DateTime.Now.Ticks;
Tick_fark = Tick_son – Tick_ilk;
long Saniye = Tick_fark / 10000000;
textBox1.Text = Saniye.ToString();

TimeSpan Yapısı

Ticks özelliğinin içeriğini kullanırken ve tarihsel bilgiler üzerinde işlem yaparken TimeSpan adlı yapıdan yararlanabilirsiniz. Bu konuda bilgi vermek için aşağıda verilen kodu hazırladık. Bu örnek sayesinde 2 tarih arasındaki farkı gün birimi ile ifade edebileceğiz. Bu amaçla forma 2 TextBox yerleştirip aşağıda verilen odu hazırladık.

DateTime Tarih = DateTime.Parse(textBox1.Text);
DateTime Bugun = DateTime.Today;
textBox2.Text = Bugun.ToString(“d”);

Şimdi ise bir TimeSpan nesnesi hazırlayacağız. TimeSpan yapısının aşırı yüklenmiş 4 yapıcı metodu bulunmaktadır. İlk olarak Ticks bilgisini parametre olarak alan yapıcı metodu kullanacağız. Bu amaçla DateTime yapısının Ticks özelliğinden yararlanarak kullanıcının formdaki ilk TextBox’a girmiş olduğu tarihten yola çıkarak bir Tick değeri elde ettik.

DateTime Tarih, Bugun;
Tarih = DateTime.Parse(textBox1.Text);
Bugun = DateTime.Today;
textBox2.Text = Bugun.ToString(“d”);
long ilk_tick, Bugun_tick;
ilk_tick = Tarih.Ticks;
Bugun_tick = Bugun.Ticks;
System.TimeSpan Zaman;
Zaman = new TimeSpan(Bugun_tick -ilk_tick);
textBox3.Text = Zaman.Days.ToString();

DateTime sınıfının Now özelliğinden yararlanıp elde ettiğimiz geçerli tarihten de ikinci bir Tick değeri elde ettik. Bu 2 tick değerinin arasındaki farkı TimeSpan’ın yapıcı metoduna parametre olarak verip iki tarih arasındaki farkı TimeSpan olarak elde ettik. TimeSpan nesnesinden gün bilgisi elde ederken Days özelliğinden yararlandık. Formdaki ilk TextBox’a bilgi girilip bu kod işletildiğinde aşağıdaki gibi bir sonuç alınır.

Bu örneğe göre TimeSpan’dan yararlanarak tarih ve zaman bilgilerini değişik şekilde ifade etmek mümkündür. Bu 2 tarih arasındaki farkı saat birimi ile ifade etmek istemiş olsaydık TimeSpan nesnesinin TotalHours özelliğinden yararlanırdık. TimeSpan yapısı ayrıca TotalMinutes, TotalSeconds ve TotalMiliSeconds özelliklerine sahiptir.

Yukarıda verilen ve 2 tarih arasındaki gün sayısını bulma işleminde yararlandığımız TimeSpan nesnesini şimdi farklı bir teknikle hazırlayacağız. Yukarıda TimeSpan nesnesini hazırlarken parametre olarak iki tarih arasındaki zaman farkını Tick birimi ile vermiştik. Aşağıda ise TimeSpan nesnesini hazırlarken DateTime sınıfının Subtract() metodunu kullandık. Bu metot geriye TimeSpan nesnesini göndermektedir.

DateTime Tarih, Bugun;
Tarih = DateTime.Parse(textBox1.Text);
Bugun = DateTime.Today;
textBox2.Text = Bugun.ToString(“d”);
System.TimeSpan Zaman = Bugun.Subtract(Tarih);
textBox3.Text = Zaman.TotalDays.ToString();

Şimdi ise forma 3 TextBox ve 2 düğme yerleştirip kullanıcının “Baslat” adı verilen düğmeyi tıklaması ile “Durdur” düğmesini tıklaması arasında geçen süreyi mili saniye olarak hesaplayıp 3. TextBox’a aktaracağız. Baslat düğmesi için hazırlanan kodu aşağıda verdik.

private void Baslat_Click(object sender, EventArgs e)
{
DateTime Zaman = DateTime.Now;
textBox1.Text = Zaman.ToLongTimeString();
}

Bu kod sayesinde o anki zaman bilgisi ilk TextBox’a aktarılır. Kullanıcı “Durdur” adı verilen 2. düğmeyi tıklayıncaya kadar aradan geçen süreyi hesaplamak üzere aşağıdaki kodu yazdık.

private void Durdur_Click(object sender, EventArgs e)
{
DateTime Zaman = DateTime.Now;
textBox2.Text = Zaman.ToLongTimeString();
DateTime saat = DateTime.Parse(textBox1.Text);
DateTime simdi = DateTime.Now;
long ilk_tick, son_tick;
ilk_tick = saat.Ticks;
son_tick = simdi.Ticks;
System.TimeSpan fark;
fark = new TimeSpan(son_tick – ilk_tick);
textBox3.Text = fark.Milliseconds.ToString();
}

Tarihsel Bilgi Kontrolü

Daha önceki konulardan bildiğiniz gibi yıl, ay ve gün bilgileri birleştirilip tarihsel bilgi elde etmek mümkündür. Bazen kullanıcının girdiği bilgi tarihsel tipe uygun olmayabilir. Bu şartlarda programın kırılmasını engellemek için hata kontrolü yapılmalıdır.

Buradaki amacımız sizlere daha sonra sözü edilecek metotların işlevlerini hatırlatmak olduğu için tarihsel bilgi kontrolünü kendimiz yapacağız. Bu amaçla projeye bir CS dosyası ekledik ve bu CS dosyasında yandaki gibi bir Class hazırladık.

Öncelikle bu metotta kendisine parametre olarak verilen bilgiyi uzunluk açısından kontrol ettik. Bu metodu gönderilen bilgi 8 karakterden az veya 10 karakterden fazla ise kullanıcıya “Hata Var” mesajını verdik. Bu metodu çağırmak için “Aktar” adı verilen düğmenin Click olayını temsil eden metodu aşağıdaki gibi düzenledik.

private void Aktar_Click(object sender, EventArgs e)
{
Kontrol_sinifi nesne;
nesne = new Kontrol_sinifi();
textBox1.Text = nesne.Tarih_kontrol(textBox1.Text);
}

Ancak kullanıcı TextBox’a “111.1.2004” gibi bilgi yazarsa bu metot işe yaramaz ve “Tarih= Convert.ToDateTime(textBox1.Text)” satırı hata verir. Bu örnekte tarihsel bilgilerin uygunluğunu araştırırken .NET Framework ile gelen sınıfları kullanmak istemediğimiz için yukarıda verilen Tarih_kontrol() metodunu aşağıdaki gibi geliştirdik.

public string Tarih_kontrol(string tarih)
{
int uzunluk = tarih.Length;
if (uzunluk > 10 || uzunluk < 8)
return “Hata var”;
string gun = Microsoft.VisualBasic.Strings.Left(tarih, 2);
if (Convert.ToInt16(gun) > 31)
return “Hata var”;
return tarih;
}

Tarihsel bilginin gününü kontrol ederken sol taraftan 2 haneyi alıp 31’den büyük olup olmadığını araştırdık. Kullanıcı TextBox’a gün bilgisini 1 hane olarak girerse(1.12.2006 gibi) bu kodun işe yaramayacağını belirtmek isteriz. Şimdi ise tarih bilgisinin ay kısmını kontrol edeceğiz. Yukarıda verilen koda bu amaçla eklemeler yaptık. Kullanıcının gün, ay ve yıl bilgilerini “/” ile birbirinden ayırmak istemesi halinde bu kod hata verir.

public string Tarih_kontrol(string tarih)
{
int Konum1 = 0;
int Konum2 = 0;
int uzunluk = tarih.Length;
if (uzunluk > 10 || uzunluk < 8)
return “Hata var”;
string gun = Microsoft.VisualBasic.Strings.Left(tarih, 2);
if (Convert.ToInt16(gun) > 31)
return “Hata var”;
Konum1 = tarih.IndexOf(‘.’, 1) +1;
Konum2 = tarih.IndexOf(‘.’, Konum1 +1)+1;
if (Convert.ToInt16(tarih.Substring(Konum1, (Konum2-Konum1)-1)) > 12)
return “Hata Var”;
return tarih;
}

Format Kodu	İşlevi	Örnek
D	Kısa tarih	27.03.2006
D	Uzun tarih	27 Mart 2006 Pazartesi
F	Uzun tarih ve kısa zaman birlikte	27 Mart 2006 Pazartesi 15:24
F	Uzun tarih ve uzun zaman birlikte	27 Mart 2006Pazartesi 15:24:43
Dd	Sadece tarihin günü	27
Ddd	Günün kısa adı	Pzt
Dddd	Günün tam adı	Pazartesi
M	Ay bilgisi	27 Mart
MM	Ay tek basamaklı ise 01 şeklinde	03
MMM	Ayın kısa adı	Mar
MMMM	Ayın tam adı	Mart
Yy	Yıl bilgisi 2 haneli olarak gösterilir	06
Yyyy	Yıl bilgisi 4 haneli olarak gösterilir	2006
T	Zaman bilgisinin saati gösterilir	15:33
Mm	Zaman bilgisinin dakikası gösterilir	33