WPF - Realizando as operações CRUD em uma fonte de dados XML

WPF - Realizando as operações CRUD em uma fonte de dados XML (C#)

Neste artigo vou mostrar como criar uma aplicação WPF realiza a manutenção de uma fonte de dados XML através das CRUD : incluir, excluir e atualizar.

Este artigo foi adaptado do original em : CRUD Operation on XML

O objetivo é mostrar como usar os recursos da WPF para tratar arquivos XML em uma aplicação simples mas funcional.

Recursos usados:

Visual C# 2010 Express Edition
Arquivo XML

A nossa fonte de dados será o arquivo XML matricula.xml cuja estrutura podemos ver a seguir:

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<Alunos>
<Aluno>
    <Nome>Macoratti</Nome>
    <Curso>Quimica</Curso>
    <Email>macoratti@yahoo.com</Email>
    <Matricula>2011</Idade>
</Aluno>
<Aluno>
    <Nome>Marcia Soares</Nome>
    <Curso>Biologia</Curso>
    <Email>marciasoraes@ig.com.br</Email>
    <Matricula>2011</Idade>
</Aluno>
</Alunos>

O nosso arquivo matricula.xml estará localizado na pasta c:\dados

(você pode colocá-lo em qualquer outro local (como a pasta bin) desde que altere o
caminho do arquivo no código)

Criando o projeto WPF

Abra o Visual C# 2010 Express Edition e crie um novo projeto (File-> New Project) do tipo WPF Application com o nome CRUDXmlDBWPF;

Vamos iniciar definido uma classe com o nome Alunos.cs (Project->Add Class) com o seguinte conteúdo:

namespace CRUDXmlDbWPF
{
    class Alunos
    {
        public string Nome { get; set; }
        public string Curso { get; set; }
        public string Email { get; set; }
        public string Matricula { get; set; }
    }
}

Esta classe representa o nosso domínio e possui 4 propriedades que refletem as tags do arquivo matricula.xml.

Vamos iniciar definindo a interface da aplicação, para isso abra o arquivo Window1.xaml e inclua um controle TabControl a partir da ToolBox definindo 3 TabItens : Ver Todos, Incluir Novo e Atualizar conforme o leiaute da figura abaixo (à direita):

A seguir inclua os seguintes controles em cada TabItem:

Ver Todos - DataGrid (Name=ViewDataGrid)
Incluir Novo - Grid com 2 colunas e 7 linhas
Atualizar - Grid com 2 colunas e 7 linhas

Conforme o leiaute das figuras a seguir

	No Grid deste TabItem usamos os seguintes controles: DataGrid - ViewDataGrid No controle DataGrid definimos: IsReadOnly="True" AutoGenerateColumns="False"
	No Grid deste TabItem usamos os seguintes controles: TextBox - txtNome TextBox - txtCurso (TextWrapping="Wrap") TextBox - txtEmail (TextWrapping="Wrap") ComboBox - cmbMatricula Button - btnIncluir
	No Grid deste TabItem usamos os seguintes controles: TextBox - txtNomeAtualiza TextBox - txtCursoAtualiza (TextWrapping="Wrap") TextBox - txtEmailAtualiza (TextWrapping="Wrap") ComboBox - cmbMatriculaAtualiza Button - btnAtualizar Button - btnDeletar ListBox - lbAlunos
Leiaute

O código XAML do arquivo Window1.xaml é visto a seguir:

Definindo o código da aplicação

No arquivo Window1.xaml.cs vamos definir o código usado pela nossa aplicação.

Iniciamos com a declaração dos namespaces das classes usadas pela aplicação no início do arquivo:

using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Xml.Linq;
using System.Collections.ObjectModel;
using System.IO;
using System.Xml;

A seguir, logo após a declaração da janela Window definimos as variáveis globais usadas pela aplicação:

ObservableCollection<Alunos> selectedList = new ObservableCollection<Alunos>();
List<Alunos> listaAlunos;
List<string> listaAnos;
Alunos alunosDel;
string caminhoArquivoXML = @"c:\dados\Matricula.xml";

A classe ObservableCollection<T> que fica no namespace System.Collections.ObjectModel, que fornece notificações, quando a coleção é modificada, incluindo, alterando ou mesmo excluindo algum item.

Logo a seguir temos a inicialização das variáveis , a definição dos dados da combobox e a carga dos dados:

public Window1()
        {
            InitializeComponent();
            btnAtualizar.IsEnabled = false;
            btnDeletar.IsEnabled = false;
            listaAnos = new List<string> { "2005", "2006", "2007", "2008", "2009", "2010", "2011" };
            cmbMatricula.ItemsSource = listaAnos;
            cmbMatriculaAtualiza.ItemsSource = listaAnos;
           carregaDados();
        }

A rotina carregaDados() tem o seguinte código:

        void carregaDados()
        {
            try
            {
                XDocument doc = XDocument.Load(caminhoArquivoXML);
              listaAlunos = (from aluno in doc.Descendants("Aluno")
                                    orderby aluno.Element("Nome").Value
                                    select new Alunos
                                   {
                                       Nome = aluno.Element("Nome").Value,
                                       Curso = aluno.Element("Curso").Value,
                                       Email = aluno.Element("Email").Value,
                                       Matricula = aluno.Element("Matricula").Value,
                                   }).ToList();
                lbAlunos.ItemsSource = listaAlunos;
                ViewDataGrid.ItemsSource = listaAlunos;
            }
            catch
            {
                MessageBox.Show("Erro ao acessar dados");
            }
        }

Neste código usamos uma consulta para obter os valores do arquivo XML e exibi-los no controle ListBox e no DataGrid via propriedade ItemsSource.

No evento Click do botão Incluir temos o código que inclui uma informação no arquivo XML:

   private void btnIncluir_Click(object sender, RoutedEventArgs e)
        {
            string nome = txtNome.Text.Trim();
            string matricula;
            if (cmbMatricula.SelectedIndex != -1)
            {
                matricula = cmbMatricula.SelectedValue.ToString();
            }
            else
            {
                matricula = "2010";
            }
            string curso = txtCurso.Text.Trim();
            string email = txtEmail.Text.Trim();

           bool isUpdate = false;

            if (nome.Equals(string.Empty))
                nome = "não informado";
            if (matricula.Equals(string.Empty))
                matricula = "2011";
            if (curso.Equals(string.Empty))
                curso = "indefinido";
            if (email.Equals(string.Empty))
                email = "não informado";

            Alunos novoAluno = new Alunos
            {
                Nome = nome,
                Curso = curso,
                Email = email,
                Matricula = matricula,
            };

            WriteToXmlFile(novoAluno, isUpdate);
            txtNome.Text = string.Empty;
            txtCurso.Text = string.Empty;
            txtEmail.Text = string.Empty;
            cmbMatricula.SelectedIndex = -1;
            carregaDados();
        }

Neste código atribuímos os valores para as propriedades do objeto novoAluno que é uma instância da classe Alunos e chamamos o método WriteToXmlFIle passando o objeto novoAluno para ser persistido no arquivo XML e em seguida limpamos os controles e carregamos os dados novamente.

No evento Click do botão Atualizar temos o código que permite alterar uma informação no arquivo XML:

      private void btnAtualizar_Click(object sender, RoutedEventArgs e)
        {
            if (lbAlunos.SelectedIndex != -1)
            {
                string nome = txtNomeAtualiza.Text;
                string curso = txtCursoAtualiza.Text;
                string email = txtEmailAtualiza.Text;
                string matricula = cmbMatriculaAtualiza.SelectedValue.ToString();

              bool isUpdate = true;

                if (nome.Equals(string.Empty))
                    nome = "não informado";
                if (matricula.Equals(string.Empty))
                    matricula = "2009";
                if (curso.Equals(string.Empty))
                    curso = "indefinido";
                if (email.Equals(string.Empty))
                    email = "não informado";

                Alunos atualizaAluno = new Alunos
                {
                    Nome = nome,
                    Curso = curso,
                    Email = email,
                    Matricula = matricula,
                };

               WriteToXmlFile(atualizaAluno, isUpdate);
                lbAlunos.SelectedIndex = -1;
                btnAtualizar.IsEnabled = false;
                btnDeletar.IsEnabled = false;
                carregaDados();
            }
        }

O procedimento é o mesmo do código anterior, a diferença é que definimos a variável IsUpdate como false para realizar uma atualização nos dados.

No evento Click do botão Deletar temos o código que exclui uma informação do arquivo XML:

     private void btnDeletar_Click(object sender, RoutedEventArgs e)
        {
            if (alunosDel != null)
            {
                if (System.Windows.MessageBox.Show("Deseja excluir este aluno ?", "Confirmar Exclusão",
MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                   XDocument doc = XDocument.Load(caminhoArquivoXML);

                   foreach (var item in doc.Descendants("Aluno"))
                    {
                        if (item.Element("Nome").Value == alunosDel.Nome)
                        {
                            ((XElement)item.Element("Nome")).Parent.Remove();
                            doc.Save(caminhoArquivoXML);
                            break;
                        }
                    }
                    carregaDados();
                    alunosDel = null;
                    lbAlunos.SelectedIndex = -1;
                    btnDeletar.IsEnabled = false;
                }
                else
                {
                    alunosDel = null;
                    lbAlunos.SelectedIndex = -1;
                    btnDeletar.IsEnabled = false;
                }
            }
        }

A rotina WriteToXmlFile é quem realiza a persistência das operações no arquivo XML e tem o seguinte código:

   void WriteToXmlFile(Alunos alunos, bool isUpdate)
        {
           if (!isUpdate)
            {
                FileStream fs = new FileStream(caminhoArquivoXML, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.Load(fs);
                fs.Close();

               XmlElement novoAluno = xmlDoc.CreateElement("Aluno");
                XmlElement nome = xmlDoc.CreateElement("Nome");
                nome.InnerText = alunos.Nome;
                novoAluno.AppendChild(nome);

              XmlElement curso = xmlDoc.CreateElement("Curso");
                curso.InnerText = alunos.Curso;
                novoAluno.AppendChild(curso);

              XmlElement email = xmlDoc.CreateElement("Email");
                email.InnerText = alunos.Email;
                novoAluno.AppendChild(email);

              XmlElement matricula = xmlDoc.CreateElement("Matricula");
                matricula.InnerText = alunos.Matricula;
                novoAluno.AppendChild(matricula);

                xmlDoc.DocumentElement.InsertAfter(novoAluno,xmlDoc.DocumentElement.LastChild);

              FileStream fsxml = new FileStream(caminhoArquivoXML, FileMode.Truncate,
                                      FileAccess.Write,
                                      FileShare.ReadWrite);

                xmlDoc.Save(fsxml);
                fsxml.Close();
            }
            else
            {
                XDocument doc = XDocument.Load(caminhoArquivoXML);

               foreach (var item in doc.Descendants("Aluno"))
                {
                    if (item.Element("Nome").Value == alunosDel.Nome)
                    {
                        item.Element("Nome").SetValue(alunos.Nome);
                        item.Element("Curso").SetValue(alunos.Curso);
                        item.Element("Email").SetValue(alunos.Email);
                        item.Element("Matricula").SetValue(alunos.Matricula);
                        doc.Save(caminhoArquivoXML);
                        break;
                    }
                }
            }
        }

O evento SelectionChanged do controle ListBox é exibido a seguir:

private void lbAlunos_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            selectedList.Clear();
            if (this.lbAlunos.SelectedItem is Alunos)
            {
                selectedList.Add(((Alunos)this.lbAlunos.SelectedItem));
                alunosDel = (Alunos)this.lbAlunos.SelectedItem;
            }
            foreach (var item in selectedList)
            {
                txtNomeAtualiza.Text = item.Nome;
                txtCursoAtualiza.Text = item.Curso;
                txtEmailAtualiza.Text = item.Email;
                cmbMatriculaAtualiza.SelectedValue = item.Matricula;
            }
            btnAtualizar.IsEnabled = true;
            btnDeletar.IsEnabled = true;
        }

Ele limpa a lista e a seguir preenche a lista com os dados do aluno.

Executando o projeto podemos ver nas figuras abaixo cada uma das opções sendo usada na aplicação:

1- Exibição dos dados no DataGrid:

2- Inclusão de dados

3- Alteração de dados

E assim vimos que a WPF possui poderosos recursos para tratar arquivo XML usando o recurso do DataBinding.

Pegue o projeto completo aqui: CRUDXmlDbWPF.zip

Eu sei é apenas WPF, mas eu gosto...

"Passará o céu e a terra, mas as minhas palavras jamais passarão." (Mateus 24:35)

Referências:

Super DVD .NET - A sua porta de entrada na plataforma .NET

Super DVD Vídeo Aulas - Vídeo Aula sobre VB .NET, ASP .NET e C#

José Carlos Macoratti

WPF - Apresentando o DataBinding-