Ana içeriğe atla

C# ile Temel I/O İşlemleri – Dosya, Dizin

Bu makalemizde C#  dili ile temel Girdi/Çıktı (Input/Output) işlemlerini nasıl yapabileceğimizi inceleyeceğiz.  Bilgisayar ile yaptığımız her işlem aslında bir girdi/çıktı işlemidir. Klavyeden veri girişi, fare ile program açmak, ekrana veya yazıcıya belge yazdırmak, dosya kaydetmek I/O işlemlerine birer örnektir.  Bizim burada inceleyeceğimiz I/O işlemleri ise .Net  System.IO isim alanı altındaki sınıflarla yapabileceğimiz dosya, dizin okuma/yazma işlemleridir.
Directory
Directory sınıfı klasör oluşturma, silme, yeniden adlandırma ve taşıma gibi klasör işlemleri yapabilmemizi sağlayan statik metotları barındıran ve hiçbir özelliği olmayan bir sınıftır. Eğer bir klasör üzerinde sadece bir işlem yapmak istiyorsanız, instance alınmadan kullanıldığı ve aşırı yüklenmeden kaçındığı için bu sınıfı kullanmanız daha faydalı olacaktır. Şimdi ufak bir uygulama ile bu metotların kullanımına bir göz atalım.

class DirectoryTest
    {
        public static void Main()
        {
            // Gerekli dosya konumlarını tanımlıyoruz.
            string path = @"C:\Test\TestDizini";
            string target = @"C:\Test\HedefDizini";
             try
           {
                // Exist Static Metodu ile dizinin var olup olmadığının kontrolü.
                if (!Directory.Exists(path))
                {
                    // CreateDirectory metodu ile dizin oluşturma işlemi.
                    Directory.CreateDirectory(path);
                    Console.WriteLine("Oluşturulma Tarihi: " + Directory.GetCreationTime(path));
                    Console.WriteLine("Son Erişim Tarihi: " + Directory.GetLastAccessTime(path));
                    Console.WriteLine("Son Değiştirilme Tarihi: " + Directory.GetLastWriteTime(path));
                    Console.WriteLine("Bulunduğu Dizinin Adı: " + Directory.GetParent(path));
                    Console.ReadLine();
                } 
                if (Directory.Exists(target))
                {
                    // Delete metodu ile dizin silme işlemi
                    Directory.Delete(target, true);
                }
                //Move metodu ile dizini taşıma işlemi.
                Directory.Move(path, target);
                //GetDirectories ile dizindeki klasörlerin seçimi.
                string[] directories = Directory.GetDirectories(@"C:\Test\");
                foreach (string dir in directories)
                {
                    Console.WriteLine(dir);
                }
                // Yeni bir Metin Belgesi oluşturma.
                File.CreateText(target + @"\NewFile.txt");
                // GetFiles ile dizindeki dosyaların seçimi.
                Console.WriteLine("{0} dizinindeki dosya sayısı: {1}", target, Directory.GetFiles(target).Length);
                Console.ReadLine();
            }
            catch (Exception e)
            {
                Console.WriteLine("İşlem Başarısız: {0}", e.ToString());
            }
            finally { }
        }
    } 
DirectoryInfo 
DirectoryInfo, Directory sınıfına benzer metotları olan ve yine klasör işlemlerinde kullandığımız instance alınabilir bir sınıf olup bir çok özelliği vardır. Bir objeyi birden fazla kullanacağımız durumlarda, DirectoryInfo ile instance alıp çalışmamız performans açısından daha etkilidir. Uygulama içerisinde bu özellikleri kullanarak inceleyelim.
class DirectoryInfoTest
    {
        public static void Main()
        {
            // Kullanılacak dizini tanımlama.
            DirectoryInfo NewDir = new DirectoryInfo(@"C:\Test\TestDizini");
            try
            {
                // Dizinin var olup olmadığının kontrolü.
                if (NewDir.Exists)
                {
                    Console.WriteLine("Dizin Mevcut.");
                    // Dizin silme işlemi.
                    NewDir.Delete();
                    Console.WriteLine("Dizin Silindi..");
                }
                 // Yeni dizin oluşturma.
                NewDir.Create();
                Console.WriteLine("Klasör oluşturuldu.");
               
Console.WriteLine("Oluşturulma Tarihi: " + NewDir.CreationTime);
                Console.WriteLine("Bulundugu Dizinin Adı: " + NewDir.Parent);
 
               Console.WriteLine("Dizinin Adı: " + NewDir.Name);
                Console.WriteLine("Dizinin Tam Adı : " + NewDir.FullName);
                Console.WriteLine("Son Erişim Tarihi : " + NewDir.LastAccessTime);
                Console.WriteLine("Son Değiştirilme Tarihi : " + NewDir.LastWriteTime);
                Console.ReadLine(); 
                //Dizin içerisinde alt dizin oluşturma.
                DirectoryInfo SubDir = NewDir.CreateSubdirectory("AltDizin");
                //Alt Dizin içerisinde alt dizin oluşturma.
                SubDir.CreateSubdirectory("AltDizin2");
                 // GetFiles ile dizindeki dosyaların seçimi.
                Console.WriteLine("{0} dizinindeki dosya sayısı: {1}",
                NewDir.FullName, NewDir.GetFiles().Length);
                // GetDirectories ile dizindeki klasörlerin seçimi.
                Console.WriteLine("{0} dizinindeki klasör sayısı: {1}", NewDir.FullName, NewDir.GetDirectories().Length);
                Console.ReadLine();
            }
            catch (Exception e)
            {
                Console.WriteLine("İşlem Başarısız: {0}", e.ToString());
            }
            finally { }
        }
    }


File
File sınıfı ve Directory sınıfının bazı metotları aynıdır ve tek farkı klasörler yerine dosyalar üzerinde işlem yapmasıdır. Bu metotlar şunlardır: Exists(), Delete(), GetCreationTime(), GetLastAccessTime(), GetLastWriteTime(), Move(), SetCreationTime(), SetLastAccessTime(), SetLastWriteTime(). Ortak metotların yanı sıra dosyalar üzerinde farklı işlemler yapabilmesi için farklı metotları mevcuttur. Bu metotlar da FileInfo sınıfı instance metotları ile aynıdır.
FileInfo
File sınıfı gibi dosyalar üzerinde işlem yapabilen ve de benzer metotları bulunan bir sınıftır. File sınıfı ile işlem yaparken her daim dosya yolunu girmek gerekirken, FileInfo ile instance alındıktan sonra tekrar kullanımı daha efektiftir.
 class FileInfoTest
    {
        public static void Main()
        {
            FileInfo NewFile = new FileInfo(@"C:\Test\HedefDizini\NewFile.txt");
            if (NewFile.Exists) // File sınıfı:  if(File.Exists(@"C:\Test\NewFile.txt"))
            {
                // Dosya silme işlemi.
                NewFile.Delete();   // File sınıfı: File.Delete(@"C:\Test\NewFile.txt"))
            } 
            // Dosya oluşturma.
            NewFile.CreateText(); // File sınıfı: File.CreateText(@"C:\Test\NewFile.txt"))
            Console.WriteLine("Oluşturulma Tarihi: " + NewFile.CreationTime);
            Console.WriteLine("Son Erişim Tarihi : " + NewFile.LastAccessTime);
            Console.WriteLine("Son Değiştirilme Tarihi : " + NewFile.LastWriteTime);
            Console.WriteLine("Bulundugu Dizinin Adı: " + NewFile.DirectoryName);
            Console.WriteLine("Dosyanın Adı: " + NewFile.Name);
            Console.WriteLine("Dosyanın Tam Adı: " + NewFile.FullName);
            Console.WriteLine("Dosyanın Uzantısı: " + NewFile.Extension);
            // Dosya Kopyalama
            NewFile.CopyTo(@"C:\Test\");
            Console.ReadLine();
        }
    }
Buraya kadar dosyaların oluşturulması, kopyalanması ve silinmesi gibi işlemlerin File ve FileInfo sınıfları ile nasıl yapılacağınız gördük. Dosyalar ile okuma ve yazma işlemleri yapabilmek için Stream(Akım) sınıflarından yararlanacağız.
FileStream 
Okuma ve yazma işlemlerinde dosya açarken kullandığımız bir sınıftır. Bu sınıf ile Byte düzeyinde okuma ve yazma işlemleri de yapılabilir fakat bu işlemleri etkin olarak StreamReader ve StreamWriter sınıfları ile metin düzeyinde yapmamız daha efektif olacaktır. Bir FileStream nesnesi oluşturulurken FileMode, FileAccess ve FileShare enumları ile değişik yollarda yaratılabilir. Örnek:
class FileStreamTest
    {
        public static void Main()
        {
            string adres = @"C:\TestDizini\NewFile.txt";
            FileStream fs = new FileStream(adres, FileMode.OpenOrCreate);
            FileStream fs2 = new FileStream(adres, FileMode.Append, FileAccess.Write);
            FileStream fs3 = new FileStream(adres, FileMode.Truncate, FileAccess.Write, FileShare.None); 
            // FileStream akımının tamponu temizlenir
            fs.Flush();
            // FileStream tarafından kullanılan kaynaklar boşaltılır.
            fs.Close();
        }
    } 
FileMode enum
Append: Açılan dosyanın sonuna ekleme yapmak için kullanılır. Eğer dosya bulunmazsa oluşturulur.
Create: Yeni dosya oluşturmak için kullanılır. Zaten dosya varsa üzerine yazılır.
CreateNew: Yeni dosya oluşturmak için kullanılır, belirtilen dosya mevcutsa çalışma zamanı hatası verdirir.
Open:  Dosyayı açmak için kullanılır.
OpenOrCreate: Belirtilen dosya varsa açılır, yoksa yenisi oluşturulur.
Truncate: Belirtilen dosya açılır ve içi tamamen silinir.
FileAccess enum
Read: Dosya okumak için kullanılır.
ReadWrite: Dosya okunmak ve yazılmak üzere açılır.
Write: Dosya sadece yazılmak için açılır.
FileShare enum
Inheritable: Dosyanın child (yavru) işlemler tarafından türetilebilmesini sağlar.
None: Dosyanın aynı anda başka işlemler tarafından açılmasını engeller.
Read: Dosyanın aynı anda başka işlemlerce de açılabilmesini sağlar.
ReadWrite: Dosyanın aynı anda başka işlemlerce de açılıp, okunup, yazılabilmesini sağlar.
Write: Dosyaya aynı anda başka işlemlerce yazılabilmesini sağlar.
Cihan DEMİREL

Yorumlar

Bu blogdaki popüler yayınlar

UML ve Modelleme – Bölüm 4 (Class (Sınıf) Diyagramları)

Bir önceki makalemizde UML modellemede kullanılan ilk diyagram olan Use Case diyagramını incelemiştik. Bu makalemizde nesne tabanlı programlamada kullanılan sınıflar ve sınıfların arasındaki ilişkileri modelleyebileceğimiz diyagramlar olan Class(Sınıf) diyagramlarını inceleyeceğiz. UML’de sınıflar, nesne tabanlı programlama mantığı ile tasarlanmıştır. Sınıf diyagramının amacı bir model içerisinde sınıfların tasvir edilmesidir. Nesne tabanlı uygulamada, sınıfların kendi özellikleri (üye değişkenler), işlevleri (üye fonksiyonlar) ve diğer sınıflarla ilişkileri bulunmaktadır. UML’de sınıf diyagramlarının genel gösterimi aşağıdaki gibidir. Şekil 1. Class Diyagram Şekil1’de görüldüğü üzere bir dikdörtgeni 3 parçaya bölüyoruz. En üst bölüm sınıf adını, orta kısım özellik listesini (üye değişkenler) ve en son kısım, işlev listesini (üye fonksiyonlar) göstermektedir. Çoğu diyagramlarda alt iki bölüm çıkarılır. Genelde tüm özellik ve işlevler gösterilmemektedir. Ama

Yazılım Maliyet Tahmineleme Tecrübeleri

Yazılım mühendisliğinde maliyet hesabı her zaman problem olmuştur. "Bu iş kaç Adam/Gün tutar?" sorusuyla sıkça karşılaşıyoruz. Adam/gün veya Adam/ay ölçütleri bir kaynağın/kişinin belirtilen zaman dilimindeki iş gücü anlamına gelir. Tabi bu noktada yine kafa karışıklıkları başlar. 6 A/G'lik bir işi hızlandıralım diye 2 kişi ile yapmaya çalışsak ve kaynak/kod, modül, altyapı, insan vb. her bir şeyi bir kenara bıraksak, matematiksel basit formülle 6/2=3 A/G'de biter? Gerçek hayat böyle değil, öncelikle bunu anlamamız lazım. Hep şu örnek verilir; "Aynı bebeği 2 kadın birlikte daha kısa sürede doğurur mu?" Eğer bunun cevabı "Evet" ise (veya bir gün böyle bir durum ortaya çıkarsa), yazımı değiştirmem gerekecek:) Mevzu gerçekten derin...Maliyet hesabı; bulunduğunuz firmanın yazılım süreçlerini hangi methodlarla uyguladığına, ilgili işin o dönemdeki aciliyetine, (şirket yönetiminin baskısına:)) vb. bir çok duruma bağlı olabilir. Örneğin; bizim firmada e

UML ve Modelleme – Bölüm 3 (Use Case Diyagramlar)

Önceki iki makalemizde ( 1 , 2 ) UML’e genel olarak değinip ve modellemede kullanacağımız dokuz diyagram hakkında bilgiler vermiştik. Bu makalemizde Use Case diyagramından detaylı bahsedeceğiz. Öncelikle, genel Use case diyagramının tanımını hatırlayalım. “Bir kullanıcı ve bir sistem arasındaki etkileşimi anlatan senaryo topluluğudur.” Ivar Jacobson Senaryo tanımı için der ki: “Aktörle sistem arasında gerçekleştirilen, sonucunda aktöre farkedilir getirisi/ faydası oluşan etkileşimli diyalogdur. ” UML Use Case Diyagramları  sistemin işlevselliğini açıklamak amacıyla kullanılır. Sistemin birbirinden ayrı özelliklerinin detaylarını göstermekten ziyade, Use Case Diyagramlar, tüm mevcut işlevselliği göstermek için kullanılabilir. Buradaki en önemli noktalardan biri,   Use Case Diyagramlar temelde sequence diyagram ve akış diyagramlarından farklıdır. Use Case diyagramlar dört ana elemandan oluşmaktadır. Aktörler , Sistem (Proje kapsamını belirtir) , Use Caseler ve bunlar ara