21 Mayıs 2012 Pazartesi

C# ile XML Kullanımı

Merhaba değerli Webkolog.net takipçileri, bugünkü yazımızda C# .NET Framework 4 ile XML dosyalarını nasıl okuyup yazabileceğimizi, XML verilerini nasıl işleyebileceğimizi ve farklı XML işleme yöntemlerini yakından inceleyeceğiz. XML (eXtensible Markup Language), veri depolama ve transferi için yaygın olarak kullanılan bir formattır. C# .NET Framework, XML verileriyle çalışmak için zengin araçlar sunar.

XML Nedir?

XML, yapılandırılmış veriyi temsil etmek için kullanılan bir metin biçimidir. XML, etiketler (tags) kullanarak veriyi hiyerarşik bir yapıda saklar. XML, insanlar ve makineler tarafından kolayca okunabilir ve işlenebilir.

C# ile XML İşleme Yöntemleri

C# .NET Framework, XML verileriyle çalışmak için çeşitli sınıflar ve yöntemler sunar. Başlıca XML işleme yöntemleri şunlardır:

  • XmlReader ve XmlWriter: XML verilerini okumak ve yazmak için kullanılan hızlı ve bellek açısından verimli yöntemlerdir.
  • XmlDocument: XML verilerini bir ağaç yapısında temsil eden ve üzerinde gezinme, düzenleme ve sorgulama gibi işlemleri yapmamızı sağlayan bir sınıftır.
  • LINQ to XML: LINQ (Language Integrated Query) kullanarak XML verilerini sorgulamak ve işlemek için kullanılan modern ve kullanımı kolay bir yöntemdir (C# 3.0 ve .NET Framework 3.5 ile gelmiştir, .NET 4.0'da mevcuttur).

XML Verilerini SQL Veritabanına Aktarma ve SQL Veritabanından XML'e Aktarma

XML verilerini bir SQL Server veritabanına aktarmak veya SQL Server veritabanından XML'e aktarmak için DataSet ve SqlDataAdapter sınıflarını kullanabiliriz:

XML'den SQL'e Aktarma
using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms; // Application.StartupPath için

class XmlToSql
{
    static void Main()
    {
        // XML dosyasından DataSet'e veri okuma
        DataSet ds = new DataSet();
        try
        {
            // Application.StartupPath, uygulamanın çalıştığı dizini verir
            ds.ReadXml(Application.StartupPath + "\\SqlDenGelen.xml");
            Console.WriteLine("XML dosyası başarıyla okundu.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML dosyası okunurken hata oluştu: " + ex.Message);
            return;
        }

        // SQL Server bağlantısı oluşturma
        // Kendi bağlantı dizenizi ve veritabanı adınızı buraya yazın
        SqlConnection cnn = new SqlConnection("server=.; Database=KuzeyRuzgari; trusted_connection=true");

        // Veri adaptörü ve komut oluşturucu oluşturma
        SqlDataAdapter adp = new SqlDataAdapter("SELECT * FROM Urunler", cnn);
        SqlCommandBuilder sc = new SqlCommandBuilder(adp); // Update, Insert, Delete komutlarını otomatik oluşturur

        try
        {
            // DataSet'teki verileri veritabanına aktarma (Urunler tablosuna)
            adp.Update(ds.Tables[0]);
            Console.WriteLine("Veriler veritabanına başarıyla aktarıldı.");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Veritabanına veri aktarılırken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}
SQL'den XML'e Aktırma
using System;
using System.Data;
using System.Data.SqlClient;
using System.Windows.Forms; // Application.StartupPath için

class SqlToXml
{
    static void Main()
    {
        // SQL Server bağlantısı oluşturma
        // Kendi bağlantı dizenizi ve veritabanı adınızı buraya yazın
        SqlConnection cnn = new SqlConnection("server=.; Database=KuzeyRuzgari; trusted_connection=true");

        // Veri adaptörü oluşturma
        SqlDataAdapter adp = new SqlDataAdapter("SELECT * FROM Urunler", cnn);

        // DataSet ve DataTable oluşturma
        DataSet ds = new DataSet("UrunlerDataSet"); // DataSet'e bir isim verilebilir
        DataTable dt = new DataTable("Urun"); // DataTable'a bir isim verilebilir

        try
        {
            // Verileri DataTable'a doldurma
            adp.Fill(dt);
            ds.Tables.Add(dt); // DataTable'ı DataSet'e ekle

            // DataSet'teki verileri XML dosyasına yazma
            ds.Tables[0].WriteXml(Application.StartupPath + "\\SqlDenGelen.xml");
            Console.WriteLine("Veriler XML dosyasına başarıyla yazıldı: " + Application.StartupPath + "\\SqlDenGelen.xml");
        }
        catch (Exception ex)
        {
            Console.WriteLine("Veritabanından XML'e veri aktarılırken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}

LINQ to XML Kullanımı

LINQ to XML, XML verilerini sorgulamak ve işlemek için LINQ sorgularını kullanmamızı sağlar. Bu yöntem, XML verileriyle çalışmayı daha kolay ve sezgisel hale getirir. System.Xml.Linq namespace'ini kullanır.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq; // LINQ to XML için

// Örnek veri sınıfları
class Satislar
{
    public DateTime Tarih { get; set; }
    public List<Urun> Urunler { get; set; }
}

class Urun
{
    public int Miktar { get; set; }
}

class LinqToXmlOrnek
{
    static void Main()
    {
        // Örnek satış verileri oluşturma
        List<Satislar> satislar = new List<Satislar>()
        {
            new Satislar { Tarih = new DateTime(2025, 4, 15), Urunler = new List<Urun> { new Urun { Miktar = 10 }, new Urun { Miktar = 20 } } },
            new Satislar { Tarih = new DateTime(2025, 4, 16), Urunler = new List<Urun> { new Urun { Miktar = 5 }, new Urun { Miktar = 15 } } }
        };

        // LINQ to XML sorgusu ile XML oluşturma
        var satisXML = new XElement("Satislar", // Kök element
            from s in satislar
            select new XElement("Satis", // Her bir satış için "Satis" elementi
                new XAttribute("SatisTarih", s.Tarih.ToString("yyyy-MM-dd")), // Öznitelik
                new XAttribute("ToplamMiktar", s.Urunler.Sum(i => i.Miktar)) // Öznitelik
            )
        );

        // Oluşturulan XML'i konsola yazdırma
        Console.WriteLine(satisXML.ToString());
        Console.ReadLine();
    }
}

XmlReader Kullanımı (XML Okuma)

XmlReader sınıfı, XML verilerini hızlı ve bellek açısından verimli bir şekilde okumamızı sağlar. XmlReader, sadece ileri yönlü okuma (forward-only) yapar, yani sadece ileriye doğru hareket edebilir ve okunan veriyi geri alamaz. System.Xml namespace'ini kullanır.

using System;
using System.Xml;

class XmlReaderOrnek
{
    static void Main()
    {
        // XML dosyasını okumak için XmlTextReader oluşturma
        XmlTextReader rdr = null;
        try
        {
            rdr = new XmlTextReader("C:\\dosya.xml"); // Kendi dosya yolunuzu belirtin

            // XML dosyasını okuma
            while (rdr.Read())
            {
                if (rdr.NodeType == XmlNodeType.Element)
                {
                    // Element adını ve değerini yazdırma
                    Console.WriteLine("Element: " + rdr.Name);
                    Console.WriteLine("Değer: " + rdr.Value); // Elementin değeri (iç metni)
                    Console.WriteLine("Derinlik: " + rdr.Depth); // XML hiyerarşisindeki derinliği

                    // Elementin öznitelikleri varsa, ilk özniteliği yazdırma
                    if (rdr.HasAttributes)
                    {
                        Console.WriteLine("İlk Öznitelik: " + rdr.GetAttribute(0));
                    }
                }
                // Diğer NodeType değerleri için de kontrol yapılabilir
                // if (rdr.NodeType == XmlNodeType.Text) { Console.WriteLine("Metin: " + rdr.Value); }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML okunurken hata oluştu: " + ex.Message);
        }
        finally
        {
            if (rdr != null)
            {
                rdr.Close(); // Okuyucuyu kapat
            }
        }
        Console.ReadLine();
    }
}

XmlNodeType Değerleri:

XmlReader sınıfının NodeType özelliği, o anki düğümün türünü belirtir. Başlıca XmlNodeType değerleri şunlardır:

  • Attribute: Öznitelik
  • CDATA: CDATA bölümü
  • Comment: Yorum
  • Document: Belge (XML belgesinin kendisi)
  • DocumentType: Belge türü tanımı (DOCTYPE)
  • Element: Element (etiket)
  • EndElement: Elementin bitiş etiketi (örneğin </element>)
  • EntityReference: Varlık referansı
  • None: Düğüm yok
  • ProcessingInstruction: İşleme yönergesi
  • Text: Metin
  • XmlDeclaration: XML bildirimi (örneğin <?xml version="1.0"?>)

XmlValidatingReader Kullanımı (Doğrulamalı Okuma)

XmlValidatingReader sınıfı, XML verilerini okurken belirli bir şemaya (örneğin, DTD veya XSD) göre doğrulamak için kullanılır. System.Xml.Schema namespace'ini kullanır.

using System;
using System.Xml;
using System.Xml.Schema; // Doğrulama için

class XmlValidatingReaderOrnek
{
    static void Main()
    {
        XmlTextReader rdr = null;
        XmlValidatingReader dogrula = null;
        try
        {
            rdr = new XmlTextReader("C:\\dosya.xml"); // Doğrulanacak XML dosyası
            dogrula = new XmlValidatingReader(rdr);

            // Doğrulama türünü ayarlama (örneğin DTD veya Schemas)
            dogrula.ValidationType = ValidationType.DTD; // DTD'ye göre doğrulama

            // Doğrulama hatalarını yakalamak için olay işleyici ekle
            dogrula.ValidationEventHandler += new ValidationEventHandler(HataYakala);

            // XML dosyasını okuma ve doğrulama
            while (dogrula.Read())
            {
                // Kodlar (normal XmlReader gibi okunabilir)
                if (dogrula.NodeType == XmlNodeType.Element)
                {
                    Console.WriteLine("Doğrulanan Element: " + dogrula.Name);
                }
            }
            Console.WriteLine("XML dosyası doğrulandı (hatalar yukarıda gösterildi).");
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML doğrulanırken genel hata oluştu: " + ex.Message);
        }
        finally
        {
            if (dogrula != null) dogrula.Close();
            if (rdr != null) rdr.Close();
        }
        Console.ReadLine();
    }

    // Hata yakalama metodu (ValidationEventHandler delegate'ine uygun olmalı)
    static void HataYakala(object sender, ValidationEventArgs e)
    {
        Console.WriteLine("Doğrulama Hatası: " + e.Message);
        // Hata türüne göre (e.Severity) farklı işlemler yapılabilir
    }
}

ValidationType Değerleri:

  • Auto: Otomatik olarak şema türünü algıla (DTD veya XSD).
  • DTD: DTD'ye göre doğrulama yap.
  • None: Doğrulama yapma.
  • Schemas: XSD şemasına göre doğrulama yap.
  • XDR: XDR şemasına göre doğrulama yap (kullanımı önerilmez, eski bir standarttır).

XmlTextWriter Kullanımı (XML Dosyası Oluşturma)

XmlTextWriter sınıfı, XML dosyaları oluşturmak için kullanılır. Bu sınıf, XML verilerini bir dosyaya veya başka bir akıma (stream) yazmamızı sağlar. System.Xml ve System.Text namespace'lerini kullanır.

using System;
using System.Xml;
using System.Text; // Encoding için

class XmlTextWriterOrnek
{
    static void Main()
    {
        XmlTextWriter yaz = null;
        try
        {
            // XML dosyası oluşturmak için XmlTextWriter oluşturma
            yaz = new XmlTextWriter("C:\\yeni_dosya.xml", Encoding.UTF8); // Kendi dosya yolunuzu belirtin

            // Yazma ayarları
            yaz.Formatting = Formatting.Indented; // XML çıktısını girintili yap
            yaz.Indentation = 5; // Her girinti için 5 boşluk kullan

            // XML belgesini yazma
            yaz.WriteStartDocument(); // 
            yaz.WriteComment("Bu bir örnek XML dosyasıdır."); // Yorum ekle

            // "insan" elementini başlat
            yaz.WriteStartElement("insan");
            // "insan" elementine "tc" özniteliği ekle
            yaz.WriteAttributeString("tc", "12345678901");

            // "isim" elementini ve değerini yaz
            yaz.WriteElementString("isim", "Ali");
            // "yas" elementini ve değerini yaz
            yaz.WriteElementString("yas", "30");

            // "insan" elementini bitir
            yaz.WriteFullEndElement(); // 

            // XML belgesini bitir
            yaz.WriteEndDocument();

            Console.WriteLine("XML dosyası başarıyla oluşturuldu: C:\\yeni_dosya.xml");
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML dosyası oluşturulurken hata oluştu: " + ex.Message);
        }
        finally
        {
            if (yaz != null)
            {
                yaz.Close(); // Yazıcıyı kapat ve kaynakları serbest bırak
            }
        }
        Console.ReadLine();
    }
}

XmlTextWriter Özellikleri:

  • Formatting: Çıktının formatını belirler (Formatting.None veya Formatting.Indented).
  • Indentation: Formatting Indented ise, her girinti seviyesi için kullanılacak boşluk veya karakter sayısını belirtir.
  • IndentChar: Formatting Indented ise, girinti için kullanılacak karakteri belirtir (varsayılan: boşluk).
  • Namespaces: Namespace kullanımını etkinleştirir veya devre dışı bırakır.
  • QuoteChar: Öznitelik değerlerini çevreleyen tırnak karakterini belirtir.

XmlTextWriter Metotları:

  • .WriteStartDocument(): XML bildirimi (<?xml ...?>) satırını yazar.
  • .WriteEndDocument(): XML belgesini sonlandırır.
  • .WriteStartElement(string name): Bir elementin başlangıç etiketini yazar.
  • .WriteEndElement(): En son açılan elementin bitiş etiketini yazar.
  • .WriteStartAttribute(string name): Bir özniteliğin başlangıcını yazar.
  • .WriteEndAttribute(): Bir özniteliğin bitişini yazar.
  • .WriteElementString(string name, string value): Bir elementin başlangıç ve bitiş etiketlerini ve içindeki metin değerini yazar.
  • .WriteAttributeString(string name, string value): Bir özniteliğin adını ve değerini yazar.
  • .WriteDocType(string name, string publicId, string systemId, string subset): DOCTYPE bildirimini yazar.
  • .WriteComment(string text): Yorum yazar.
  • .WriteFullEndElement(): Bir elementin tam bitiş etiketini yazar (örneğin, </element>). Boş elementler için <element/> yerine kullanılır.
  • .Close(): Yazıcıyı kapatır ve kullanılan kaynakları serbest bırakır.

XmlDocument Kullanımı (XML Okuma ve Yazma/Düzenleme/Silme)

XmlDocument sınıfı, XML verilerini bir ağaç yapısında (DOM - Document Object Model) temsil eder ve hem okuma hem de yazma işlemlerini yapmamızı sağlar. Bu sınıf, XML verilerini düzenlemek, silmek ve üzerinde ileri-geri gezinmek için de kullanılabilir. System.Xml namespace'ini kullanır.

Örnek 1: Dosyadan Okuma
using System;
using System.Xml;

class XmlDocumentOkumaOrnek
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load("c:\\dosya.xml"); // Kendi dosya yolunuzu belirtin
            Console.WriteLine("XML dosyası yüklendi.");
            // XML içeriğini konsola yazdır
            Console.WriteLine(doc.OuterXml);
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML dosyası yüklenirken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}
Örnek 2: Stringden Okuma
using System;
using System.Xml;

class XmlDocumentStringOkumaOrnek
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        string veriXML = "<root><item>Değer</item></root>"; // XML verisi içeren string
        try
        {
            doc.LoadXml(veriXML);
            Console.WriteLine("XML stringi yüklendi.");
            Console.WriteLine(doc.OuterXml);
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML stringi yüklenirken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}
Örnek 3: Dosyaya Yazma ve Element Ekleme
using System;
using System.Xml;

class XmlDocumentYazmaOrnek
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        // Yeni bir XML belgesi oluştur veya var olanı yükle
        // doc.Load("dosya.xml"); // Var olanı yüklemek için
        // Ya da yeni bir belge oluştur:
        XmlDeclaration xmlDeclaration = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
        doc.AppendChild(xmlDeclaration);
        XmlElement root = doc.CreateElement("Root");
        doc.AppendChild(root);

        // Yeni bir "insan" elementi oluştur
        XmlElement insan = doc.CreateElement("insan");
        // "tc" özniteliği ekle
        insan.SetAttribute("tc", "12345678901");

        // "isim" elementi ve değeri
        XmlElement isim = doc.CreateElement("isim");
        isim.InnerText = "Ali";
        insan.AppendChild(isim); // "isim" elementini "insan" elementine ekle

        // "yas" elementi ve değeri
        XmlElement yas = doc.CreateElement("yas");
        yas.InnerText = "30";
        insan.AppendChild(yas); // "yas" elementini "insan" elementine ekle

        root.AppendChild(insan); // "insan" elementini kök elemente ekle

        try
        {
            doc.Save("yeni_dosya_doc.xml"); // Değişiklikleri dosyaya kaydet
            Console.WriteLine("XML dosyası başarıyla oluşturuldu/güncellendi: yeni_dosya_doc.xml");
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML dosyası kaydedilirken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}
Örnek 4: Değiştirme
using System;
using System.Xml;

class XmlDocumentDegistirmeOrnek
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load("yeni_dosya_doc.xml"); // Önceki örnekten oluşturulan dosyayı yükle

            // Kök elementi al
            XmlElement root = doc.DocumentElement;

            // İlk "insan" elementinin ilk alt düğümünü (yani "isim" elementini) seç
            // XPath kullanarak daha spesifik seçimler de yapılabilir: root.SelectSingleNode("insan/isim")
            XmlNode nodeToChange = root.SelectSingleNode("insan/isim");

            if (nodeToChange != null)
            {
                nodeToChange.InnerText = "Burak"; // İç metni değiştir
                doc.Save("yeni_dosya_doc.xml"); // Değişiklikleri kaydet
                Console.WriteLine("İsim başarıyla 'Burak' olarak değiştirildi.");
            }
            else
            {
                Console.WriteLine("Değiştirilecek 'isim' elementi bulunamadı.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML değiştirilirken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}
Örnek 5: Silme
using System;
using System.Xml;

class XmlDocumentSilmeOrnek
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        try
        {
            doc.Load("yeni_dosya_doc.xml"); // Önceki örnekten oluşturulan dosyayı yükle

            XmlElement root = doc.DocumentElement;
            // İlk "insan" elementini seç
            XmlElement insanElement = (XmlElement)root.SelectSingleNode("insan");

            if (insanElement != null)
            {
                // "isim" alt elementini sil
                XmlNode isimElement = insanElement.SelectSingleNode("isim");
                if (isimElement != null)
                {
                    insanElement.RemoveChild(isimElement);
                    Console.WriteLine("'isim' elementi silindi.");
                }

                // Tüm alt düğümleri silmek için (örneğin "insan" elementinin içini boşaltmak)
                // insanElement.RemoveAll();
                // Console.WriteLine("'insan' elementinin tüm içeriği silindi.");

                doc.Save("yeni_dosya_doc.xml"); // Değişiklikleri kaydet
                Console.WriteLine("XML dosyası başarıyla güncellendi.");
            }
            else
            {
                Console.WriteLine("Silinecek 'insan' elementi bulunamadı.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML silinirken hata oluştu: " + ex.Message);
        }
        Console.ReadLine();
    }
}

XmlElement Özellikleri:

  • Name: Elementin adını alır.
  • InnerText: Elementin içindeki metni alır (sadece metin düğümleri, alt elementleri içermez).
  • InnerXml: Elementin içindeki XML'i alır (alt elementler ve metin dahil).
  • OuterXml: Elementin kendisi de dahil olmak üzere, elementin tüm XML'ini alır.
  • ChildNodes: Elementin alt düğümlerinin bir listesini (XmlNodeList) alır.
  • FirstChild: Elementin ilk alt düğümünü alır (XmlNode döndürür).
  • LastChild: Elementin son alt düğümünü alır (XmlNode döndürür).
  • NextSibling: Elementin bir sonraki kardeş düğümünü alır (XmlNode döndürür).
  • PreviousSibling: Elementin bir önceki kardeş düğümünü alır (XmlNode döndürür).

XmlNodeList Özellikleri:

  • Count: Listedeki düğüm sayısını alır.
  • Item(int index) veya [int index]: Belirtilen dizindeki düğümü alır.

XmlDocument, XmlNode, XmlReaderSettings, XmlWriterSettings, XmlWriter Sınıfları

Aşağıdaki tabloda, sık kullanılan XML sınıfları ve metotları özetlenmiştir:

XmlDocument
  • .Load(string yol): XML dosyasını yükler.
  • .Save(string yol): XML dosyasını kaydeder.
  • .AppendChild(XmlNode node): Bir düğümü sona ekler.
  • .ChildNodes[index]: Belirtilen dizindeki alt düğümü alır.
  • .ChildNodes[index].InnerText: Bir etiketin içindeki değeri alır.
  • .SelectNodes(string xpath): Belirtilen XPath ifadesine uyan düğümleri seçer.
  • .SelectSingleNode(string xpath): Belirtilen XPath ifadesine uyan ilk düğümü seçer.
  • .DocumentElement: XML belgesinin kök elementini alır.
  • .DocumentElement.InsertAfter(XmlNode yeniNode, XmlNode referansNode): Yeni bir düğümü belirtilen düğümün sonrasına ekler.
  • .DocumentElement.InsertBefore(XmlNode yeniNode, XmlNode referansNode): Yeni bir düğümü belirtilen düğümün öncesine ekler.
  • .DocumentElement.RemoveChild(XmlNode node): Bir alt düğümü siler.
  • .CreateElement(string name): Yeni bir element oluşturur.
  • .CreateAttribute(string name): Yeni bir öznitelik oluşturur.
  • .CreateTextNode(string text): Yeni bir metin düğümü oluşturur.
XmlNode
  • .Attributes["attr_adi"].Value: Bir özniteliğin değerini alır.
  • .ChildNodes[index]: Belirtilen dizindeki alt düğümü alır.
  • .ChildNodes[index].InnerText: Bir etiketin içindeki değeri alır.
XmlReaderSettings
  • .Schemas.Add(string namespaceURI, string schemaUrl): Bir şema ekler.
  • .ValidationType: Doğrulama türünü belirtir.
  • .ValidationEventHandler: Doğrulama hatalarını işlemek için bir olay işleyicisi belirtir.
XmlWriterSettings
  • .Encoding: Kullanılacak kodlamayı belirtir.
  • .Indent: Girintileme yapılıp yapılmayacağını belirtir (true veya false).
XmlWriter
  • .WriteStartDocument(): XML belgesinin başlangıcını yazar.
  • .WriteStartElement(): Bir elementin başlangıç etiketini yazar.
  • .WriteAttributeString(): Bir öznitelik yazar.
  • .WriteEndElement(): Bir elementin bitiş etiketini yazar.
  • .WriteEndDocument(): XML belgesinin bitişini yazar.
  • .Close(): XmlWriter'ı kapatır ve kaynakları serbest bırakır.

XPath ile Sorgulama

XPath, XML belgelerinde düğümleri seçmek için kullanılan bir sorgulama dilidir. XmlDocument sınıfının SelectNodes() ve SelectSingleNode() metotları ile XPath ifadeleri kullanarak XML verilerini sorgulayabiliriz.

Örnek XPath İfadesi:

root/node/element[fiyat >= 5 and fiyat <= 10]

Bu ifade, root elementinin altındaki node elementinin altındaki element elementlerinden fiyat özniteliği 5 ile 10 arasında olanları seçer.

  • Her şeyi saran kısım: root
  • Altı: node
  • Node'un altı: childNode
  • Parametre olan kısım: attribute

Örnek: XML Dosyasından Veri Okuma ve MessageBox'ta Gösterme

using System;
using System.Xml;
using System.IO;
using System.Windows.Forms; // MessageBox ve Application.StartupPath için

class ProductXmlReader
{
    static void Main()
    {
        // Uygulamanın çalıştığı dizinde "product.xml" dosyasının olduğunu varsayalım
        // Visual Studio'da bu dosyanın "Copy to Output Directory" özelliğini "Copy Always" yapın.
        string xmlFilePath = Application.StartupPath + "\\product.xml";

        // Örnek bir product.xml dosyası oluştur (eğer yoksa)
        if (!File.Exists(xmlFilePath))
        {
            string sampleXml = @"<Products>
    <Product>
        <Name>Laptop</Name>
        <Price>1200</Price>
        <Category>Electronics</Category>
    </Product>
    <Product>
        <Name>Mouse</Name>
        <Price>25</Price>
        <Category>Peripherals</Category>
    </Product>
</Products>";
            File.WriteAllText(xmlFilePath, sampleXml);
            Console.WriteLine("Örnek 'product.xml' dosyası oluşturuldu.");
        }


        XmlDataDocument xmldoc = new XmlDataDocument();
        XmlNodeList xmlnode;
        string str = null;
        FileStream fs = null;

        try
        {
            fs = new FileStream(xmlFilePath, FileMode.Open, FileAccess.Read);
            xmldoc.Load(fs); // XML dosyasını yükle

            xmlnode = xmldoc.GetElementsByTagName("Product"); // "Product" etiketli tüm elementleri al

            for (int i = 0; i <= xmlnode.Count - 1; i++)
            {
                // Her bir Product elementinin altındaki Name, Price, Category elementlerine erişim
                string productName = xmlnode[i].ChildNodes.Item(0).InnerText.Trim();
                string productPrice = xmlnode[i].ChildNodes.Item(1).InnerText.Trim();
                string productCategory = xmlnode[i].ChildNodes.Item(2).InnerText.Trim();

                str = "Ürün Adı: " + productName + Environment.NewLine +
                      "Fiyat: " + productPrice + Environment.NewLine +
                      "Kategori: " + productCategory;

                MessageBox.Show(str, "Ürün Bilgisi", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show("XML okunurken veya işlenirken bir hata oluştu: " + ex.Message, "Hata", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
        finally
        {
            if (fs != null)
            {
                fs.Close(); // Dosya akışını kapat
            }
        }
        Console.ReadLine();
    }
}
---

Evet sevgili Webkolog.net okurları, bu yazımızda C# .NET Framework 4 ile XML kullanımının temel prensiplerini ve yöntemlerini detaylı bir şekilde ele aldık. XML, veri alışverişi ve depolama için önemli bir araçtır ve C# .NET Framework, XML verileriyle çalışmak için zengin özellikler sunar. Umarım bu bilgiler, C# projelerinizde XML'i etkili bir şekilde kullanmanıza yardımcı olur. Bir sonraki yazımda, C# dilinin diğer önemli yapı taşlarını keşfetmeye devam edeceğiz. Webkolog.net'i takipte kalın!

Hepinize yapılandırılmış verilerle dolu ve başarılı geliştirme süreçleri dilerim!

0 yorum:

Yorum Gönder