none
c# e XML RRS feed

  • Pergunta

  • Estou usando o seguinte arquivo XML

    XML1:

    <?xml version="1.0" encoding="UTF-8"?>
    <security>	
    	<!--Apagar Arquivo-->	
    	<apagar>
    		<arq1	valor="D:\teste\j\"	 />
    		<arq2	valor="D:\teste\g.txt" />
    		<arq3	valor="D:\teste\k"	/>
    	</apagar>
    	<!--Restaurar backup-->
    	<backup>		
    		<arq1	valor1="D:\teste\b\" valor2="D:\teste\c\"/>
    		<arq2	valor1="D:\teste\a\" valor2="D:\teste\j\"/>	
    		<arq3	valor1="D:\teste\a\" valor2="D:\teste\a - Copia\"/>	
    		<arq4	valor1="D:\teste\e.txt" valor2="D:\teste\k\"/>			
    	</backup>
    </security>

    ou

    XML2:

    <?xml version="1.0" encoding="UTF-8"?>
    <security>	
    	<!--Restaurar backup-->
    	<backup>		
    		<arq1	valor1="D:\teste\b\" valor2="D:\teste\c\"/>
    		<arq2	valor1="D:\teste\a\" valor2="D:\teste\j\"/>	
    		<arq3	valor1="D:\teste\a\" valor2="D:\teste\a - Copia\"/>	
    		<arq4	valor1="D:\teste\e.txt" valor2="D:\teste\k\"/>			
    	</backup>
    	<!--Apagar Arquivo-->	
    	<apagar>
    		<arq1	valor="D:\teste\j\"	 />
    		<arq2	valor="D:\teste\g.txt" />
    		<arq3	valor="D:\teste\k"	/>
    	</apagar>
    </security>


    Um sistema de segurança para minhas maquinas que apaga certos arquivos e sobrescreve outros.

    O código e dividido em duas parte uma exclui os arquivo e a outra sobrescreve.

     Se eu usar meu arquivo XML como esta em XML1 ele só lê o elemento <apagar>, então ele somente exclui, o elemento <backup> retorna um valor vazio.

     Se eu usar meu arquivo XML como esta em XML2 ele só lê o elemento <backup>, então ele somente sobrescreve, o elemento <apagar> retorna um valor vazio.

     Não estou conseguindo achar nenhum erro que esteja bloqueando o segundo elemento.


    Faço a leitura do elementos assim:

    ex:

    xmlNode = xmlConfig.DocumentElement.SelectSingleNode("//security");
    
    1) xmlNode.SelectSingleNode("//backup").SelectSingleNode("//arq1").Attributes.GetNamedItem("valor1").InnerText.ToString(CultureInfo.CurrentCulture);
    
    2) xmlNode.SelectSingleNode("//apagar").SelectSingleNode("//arq1").Attributes.GetNamedItem("valor").InnerText.ToString(CultureInfo.CurrentCulture);


    • Editado Osvaldo1br segunda-feira, 9 de dezembro de 2019 23:57
    segunda-feira, 9 de dezembro de 2019 23:54

Todas as Respostas

  • Osvaldo1br,

       Estou tentando replicar o que você montou aqui, mas não estou conseguindo.
       Por favor, pode colocar mais detalhes do código?

    []'s,
    Fabio I.
    quarta-feira, 11 de dezembro de 2019 14:50
  • segue o código completo:

    using System;
    using System.Collections.Generic;
    using System.Globalization;
    using System.IO;
    using System.Linq;
    using System.Xml;
    
    namespace LimpardadosRestauracao
    {
        internal static class Program
        {
            private static void Main()
            {
                int i = 1;
                string[] valor;
                if (File.Exists(Path.Combine(Environment.CurrentDirectory,
                    @"config\seguranca.xml")))
                {
                    XmlFile xmlFile = new XmlFile(
                        Path.Combine(Environment.CurrentDirectory,
                        @"config\seguranca.xml"), "security");
    
                    //deletar
                    Log("testar erro1", xmlFile.ValueExists("valor", "apagar", "arq" + i.ToString(CultureInfo.CurrentCulture)).ToString()); // teste
                    while (xmlFile.ValueExists("valor", "apagar", "arq" + i.ToString(CultureInfo.CurrentCulture))) //***erro acontece aqui não passa aqui ou na posterior, conforme explicado
                    {
                        valor = Dividir(xmlFile.GetAllValueTag("apagar", "arq" + i.ToString(CultureInfo.CurrentCulture)).ToString(), ';');
                        for (int y = 0; y < valor.Length; y++)
                        {
                            Log("excluir", valor[y]); // teste
                            Excluir(valor[y]);
                        }
                        i++;
                    }
    
                    i = 1;
                    //restaurar
                    Log("testar erro2", xmlFile.ValueExists("valor1", "backup", "arq" + i.ToString(CultureInfo.CurrentCulture)).ToString()); // teste
                    while (xmlFile.ValueExists("valor1", "backup", "arq" + i.ToString(CultureInfo.CurrentCulture)))  //***erro acontece aqui não passa aqui ou na anterior, conforme explicado
                    {
                        valor = Dividir(xmlFile.GetAllValueTag("backup", "arq" + i.ToString(CultureInfo.CurrentCulture)), ';');
                        Log("restaurar", valor[0]); // teste
                        if (File.Exists(valor[0]))
                        {
                            RestaurarArquivos(valor[0], valor[1]);
                        }
                        else if (Directory.Exists(valor[0]))
                        {
                            RestaurarPasta(valor[0], valor[1]);
                        }
                        i++;
                    }
                    
                }
    
            }
    
             private static void RestaurarPasta(string pathOriginal, string pathVerificar)
            {
                try
                {
                    if (Directory.Exists(pathOriginal) && !Directory.Exists(pathVerificar))
                    {
                        Directory.CreateDirectory(pathVerificar);
                    }
                    if (Directory.Exists(pathOriginal) && Directory.Exists(pathVerificar))
                    {
                        // Create two identical or different temporary folders   
                        // on a local drive and change these file paths.  
                        DirectoryInfo dir1 = new DirectoryInfo(pathOriginal);
                        DirectoryInfo dir2 = new DirectoryInfo(pathVerificar);
    
                        // Take a snapshot of the file system.  
                        IEnumerable<FileInfo> list1 = dir1.GetFiles("*.*", SearchOption.AllDirectories);
                        IEnumerable<FileInfo> list2 = dir2.GetFiles("*.*", SearchOption.AllDirectories);
    
                        //A custom file comparer defined below  
                        FileCompare myFileCompare = new FileCompare();
    
                        // This query determines whether the two folders contain  
                        // identical file lists, based on the custom file comparer  
                        // that is defined in the FileCompare class.  
                        // The query executes immediately because it returns a bool.  
                        bool areIdentical = list1.SequenceEqual(list2, myFileCompare);
                        if (areIdentical == false)
                        {
                            // Deletar arquivos diferente em pathVerificar
                            if (File.Exists(pathVerificar) || Directory.Exists(pathVerificar))
                                Excluir(pathVerificar, false);
                            // Copiar arquivos diferente para pathVerificar
                            CopiarColar(PegarNomedoArquivo(pathOriginal), NomeDiretorio(pathOriginal),
                               pathVerificar);
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log("RestaurarPasta", ex.Message); // mensagem caso haja erro
                }
            }
    
            private static void RestaurarArquivos(string pathOriginal, string pathVerificar)
            {
                try
                {
                    FileInfo file1 = new FileInfo(pathOriginal);
                    FileInfo file2 = new FileInfo(pathVerificar);
    
                    List<FileInfo> listfile1 = new List<FileInfo>
                    {
                        file1
                    };
                    List<FileInfo> listfile2 = new List<FileInfo>
                    {
                        file2
                    };
                    // Take a snapshot of the file system.  
                    IEnumerable<FileInfo> list1 = listfile1;
                    IEnumerable<FileInfo> list2 = listfile2;
    
                    //A custom file comparer defined below  
                    FileCompare myFileCompare = new FileCompare();
    
                    // This query determines whether the two folders contain  
                    // identical file lists, based on the custom file comparer  
                    // that is defined in the FileCompare class.  
                    // The query executes immediately because it returns a bool.  
                    bool areIdentical = list1.SequenceEqual(list2, myFileCompare);
                    if (areIdentical == false)
                    {
                        // Deletar arquivos diferente em pathVerificar
                        if(File.Exists(pathVerificar) || Directory.Exists(pathVerificar))
                            Excluir(pathVerificar, false);
                        // Copiar arquivos diferente para pathVerificar
                        CopiarColar(PegarNomedoArquivo(pathOriginal), NomeDiretorio(pathOriginal),
                           pathVerificar);
                    }
    
                }
                catch (Exception ex)
                {
                    Log("RestaurarPasta", ex.Message); // mensagem caso haja erro
                   
                }
            }
    
    
            // ARQUIVO DE LOG
            public static String Log(string nome, String mensagem)
            {
                string arquivo = Path.Combine(Environment.CurrentDirectory, @"log\log.txt"); // caminho do arquivo
                try
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(arquivo)); // se o diretório não existir cria
                    File.AppendAllText(arquivo, DateTime.Now + " - Evento: " + nome + " - Mensagem: " + mensagem + "\r\n");// Acrescenta a cadeia de caracteres especificada ao arquivo, criando-o, caso ele ainda não exista.
                    return "";
                }
                catch (Exception ex)
                {
                    return ex.Message; // retorna mensagem caso haja erro
                }
            }
    
            //COPIAR / COLAR
            private static void CopiarColar(string fileName, string sourcePath, string targetPath)
            {
                // Usa a classe Path para manipular os caminhos de arquivos e diretórios.
                string sourceFile = Path.Combine(sourcePath, fileName);
                string destFile = Path.Combine(targetPath, fileName);
                try
                {
                    //string fileName = "test.txt";
                    //string sourcePath = @"C:\Users\Public\TestFolder";
                    //string targetPath = @"C:\Users\Public\TestFolder\SubDir";
    
    
    
                    // Para copiar o conteúdo de uma pasta para um novo local:
                    // Crie uma nova pasta de destino.
                    // Se o diretório já existir, este método não cria um novo diretório.
                    Directory.CreateDirectory(targetPath);
                    File.SetAttributes(sourcePath, FileAttributes.Normal);
                    File.SetAttributes(targetPath, FileAttributes.Normal);
                    // Verifica se o  arquivo de destino existe
                    // Converte o atributo do arquivo de destino para Normal
                    // Para copiar um arquivo para outro local e
                    // sobrescreve o arquivo de destino, se ele já existir.
                    if (File.Exists(sourceFile))
                    {
                        File.SetAttributes(sourceFile, FileAttributes.Normal);
                        File.Copy(sourceFile, destFile, true);
                    }
                    // Copia todos os arquivos em um diretório para outro diretório.
                    if (Directory.Exists(sourceFile))
                    {
                        // Cria todos os diretórios
                        foreach (string dirPath in Directory.GetDirectories(sourceFile, "*",
                            SearchOption.AllDirectories))
                        {
                            Directory.CreateDirectory(dirPath.Replace(sourceFile, destFile));
                        }
                            
    
    
                        // Copia todos os arquivos e substitui todos os arquivos com o mesmo nome
                        // Converte o atributo dos arquivos para Normal
                        foreach (string newPath in Directory.GetFiles(sourceFile, "*.*", SearchOption.AllDirectories))
                        {
                           File.SetAttributes(newPath, FileAttributes.Normal);
                            File.Copy(newPath, newPath.Replace(sourceFile, destFile), true);
                        }
                    }               
                }
                catch (Exception ex)
                {
                    Log("Copiar/Colar", ex.Message + ", " + sourceFile + ", " + destFile); // mensagem caso haja erro
                }
            }
    
            //DELETAR
            private static String Excluir(string arquivo, Boolean mens = true)
            {
               
                // Exclua um arquivo usando o método estático da classe File 
                if (File.Exists(arquivo))
                {
                    File.SetAttributes(arquivo, FileAttributes.Normal);
                    // Usa um bloco try para capturar Exceptions, para
                    // manipula o caso do arquivo que já está sendo
                    // aberto por outro processo.
                    try
                    {
                        FileInfo arquivo1 = new FileInfo(arquivo);
                        arquivo1.Delete();
                        if (mens)
                        {
                            return "Deletado com sucesso.";
                        }
                        else
                        {
                            return "";
                        }
                    }
                    catch (Exception ex)
                    {
                        Log("Excluir", ex.Message + " " + arquivo); // mensagem caso haja erro
                        return ex.Message + " " + arquivo;
                    }
                }
                // Exclua um diretório e todos os subdiretórios com o método estático Directory ...
                if (Directory.Exists(arquivo))
                {
                    try
                    {
                        Directory.Delete(arquivo, true);
                        if (mens)
                        {
                            return "Deletado com sucesso.";
                        }
                        else
                        {
                            return "";
                        }
                    }
    
                    catch (Exception ex)
                    {
                        Log("Excluir", ex.Message + " " + arquivo); // mensagem caso haja erro
                        return ex.Message + " " + arquivo;
                    }
                }
    
                if (mens && (Directory.Exists(arquivo) || File.Exists(arquivo)))
                {
                    return "Deletado com sucesso.";
                }
                else if ((!mens) && (Directory.Exists(arquivo) || File.Exists(arquivo)))
                {
                    return "";
                }
                else
                {
                    Log("Excluir", "Não foi possível deletar o arquivo: " + arquivo); // mensagem caso haja erro
                    return "Não foi possível deletar o arquivo: " + arquivo;
    
                }
            }
    
            private static string[] Dividir(string texto, char separador)
            {
                try
                {
                    if (!string.IsNullOrEmpty(texto))
                    {
                        string[] str = texto.Split(separador);
                        return str;
                    }
                    else
                    {
                        return new[] { "" };
                    }
                }
                catch (Exception ex)
                {
                    Log("Dividir String", ex.Message); // mensagem caso haja erro
                    return new[] { "" };
                }
            }
            // PEGA O NOME DO ARQUIVO
            private static string PegarNomedoArquivo(string arquivo)
            {
                try
                {
                    string nomeArquivo = Path.GetFileName(arquivo);
                    return nomeArquivo;
                }
                catch (Exception ex)
                {
                    Log("PegarNomedoArquivo", ex.Message + arquivo); // mensagem caso haja erro
                    return ex.Message + arquivo; // retorna mensagem caso haja erro
                }
            }
    
            // PEGA O DIRETÓRIO
            private static string NomeDiretorio(string arquivo)
            {
                try
                {
                    string pasta = Path.GetDirectoryName(arquivo);
                    return pasta;
                }
                catch (Exception ex)
                {
                    Log("NomeDiretorio", ex.Message + arquivo); // mensagem caso haja erro
                    return ex.Message + ", " + arquivo; // retorna mensagem caso haja erro
                }
            }
    
        }
    
        // This implementation defines a very simple comparison  
        // between two FileInfo objects. It only compares the name  
        // of the files being compared and their length in bytes.  
        public class FileCompare : IEqualityComparer<FileInfo>
        {
            public FileCompare() { }
    
            public bool Equals(FileInfo f1, FileInfo f2)
            {
                return f1.Name == f2.Name &&
                        f1.Length == f2.Length &&
                        f1.LastWriteTime == f2.LastWriteTime;
            }
    
            // Return a hash that reflects the comparison criteria. According to the   
            // rules for IEqualityComparer<T>, if Equals is true, then the hash codes must  
            // also be equal. Because equality as defined here is a simple value equality, not  
            // reference identity, it is possible that two or more objects will produce the same  
            // hash code.  
            public int GetHashCode(FileInfo fi)
            {
                string s = $"{fi.Name}{fi.Length}{fi.LastWriteTime}";
                return s.GetHashCode();
            }
        }
    
        //MANIPULAÇÃO DE xml//
        public class XmlFile
        {
            private readonly XmlNode xmlNode;
            public XmlFile(string xmlFile, string tagp)
            {
                XmlDocument xmlConfig = new XmlDocument()
                {
                    XmlResolver = null
                };
                xmlConfig.Load(xmlFile);
                xmlNode = xmlConfig.DocumentElement.SelectSingleNode("//" + tagp);
            }
    
            public string Read(string valor, string tag1 = null, string tag2 = null, string tag3 = null, string tag4 = null)
            {
                try
                {
                    if (tag1 == null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        Program.Log("Read XmlFile1", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
                        return xmlNode.Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);
                    }
                    else if (tag1 != null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        Program.Log("Read XmlFile2", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
                        return xmlNode.SelectSingleNode("//" + tag1).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);
                    }
                    else if (tag1 != null && tag2 != null && tag3 == null && tag4 == null)
                    {
                        Program.Log("Read XmlFile3", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
                        return xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 == null)
                    {
                        Program.Log("Read XmlFile4", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
                        return xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 != null)
                    {
                        Program.Log("Read XmlFile5", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
                        return xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).SelectSingleNode("//" + tag4).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);
                    }
                    else
                    {
                        Program.Log("Read XmlFile", "false, " + tag1 + ", " + tag2 + ", " + valor); // mensagem caso haja erro
                        return null;
                    }
                }
                catch (NullReferenceException)
                {
                    Program.Log("Read XmlFile", "false, " + tag1 + ", " + tag2 + ", " + valor);  // teste
                    return null;
                }
                catch (Exception ex)
                {
                    Program.Log("Read XmlFile", ex.Message); // mensagem caso haja erro
                    return null;
                }
            }
    
            public bool ValueExists(string valor, string tag1 = null, string tag2 = null, string tag3 = null, string tag4 = null)
            {
                try
                {
                    if (tag1 == null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        Program.Log("ValueExists XmlFile1", Read(valor, tag1, tag2) + ", " + tag1 + ", " + tag2 + ", " + valor); // teste
                        if (Read(valor).Length > 0)
                            return true;
                        else
                            return false;
                    }
                    else if (tag1 != null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        Program.Log("ValueExists XmlFile2", Read(valor, tag1, tag2) + ", " + tag1 + ", " + tag2 + ", " + valor); // teste
                        if (Read(valor, tag1).Length > 0)
                            return true;
                        else
                            return false;
                    }
                    else if (tag1 != null && tag2 != null && tag3 == null && tag4 == null)
                    {
                        Program.Log("ValueExists XmlFile3", Read(valor, tag1, tag2) + ", " + tag1 + ", " + tag2 + ", " + valor); // teste
                        if (Read(valor, tag1, tag2).Length > 0)
                        {
                            Program.Log("ValueExists XmlFile4", "false , " + tag1 + ", " + tag2 + ", " + valor); // teste
                            return true;
                        }                        
                        else
                        {
                            Program.Log("ValueExists XmlFile5", "true , " + tag1 + ", " + tag2 + ", " + valor); // teste
                            return false;
                        }
                           
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 == null)
                    {
                        Program.Log("ValueExists XmlFile6", Read(valor, tag1, tag2) + ", " + tag1 + ", " + tag2 + ", " + valor); // teste
                        if (Read(valor, tag1, tag2, tag3).Length > 0)
                            return true;
                        else
                            return false;
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 != null)
                    {
                        Program.Log("ValueExists XmlFile7", Read(valor, tag1, tag2) + ", " + tag1 + ", " + tag2 + ", " + valor); // teste
                        if (Read(valor, tag1, tag2, tag3, tag4).Length > 0)
                            return true;
                        else
                            return false;
                    }
                    else
                    {
                        
                        return false;
                    }
                }
                catch (NullReferenceException)
                {
                    return false;
                }
                catch (Exception ex)
                {
                    Program.Log("ValueExists XmlFile", ex.Message); // mensagem caso haja erro
                    return false; // retorna mensagem caso haja erro
                }
            }
    
            public string GetAllValueTag(string tag1 = null, string tag2 = null, string tag3 = null, string tag4 = null)
            {
                string temp = "";
                try
                {
                    if (tag1 == null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        for (int i = 0; i < xmlNode.Attributes.Count; i++)
                        {
                            temp += xmlNode.Attributes.Item(i).InnerText.ToString(CultureInfo.CurrentCulture) + ";";
                        }
                        return temp.TrimEnd(';');
                    }
                    else if (tag1 != null && tag2 == null && tag3 == null && tag4 == null)
                    {
                        for (int i = 0; i < xmlNode.SelectSingleNode("//" + tag1).Attributes.Count; i++)
                        {
                            temp += xmlNode.SelectSingleNode("//" + tag1).Attributes.Item(i).InnerText.ToString(CultureInfo.CurrentCulture) + ";";
                        }
                        return temp.TrimEnd(';');
                    }
                    else if (tag1 != null && tag2 != null && tag3 == null && tag4 == null)
                    {
                        for (int i = 0; i < xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.Count; i++)
                        {
                            temp += xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.Item(i).InnerText.ToString(CultureInfo.CurrentCulture) + ";";
                        }
                        return temp.TrimEnd(';');
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 == null)
                    {
                        for (int i = 0; i < xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).Attributes.Count; i++)
                        {
                            temp += xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).Attributes.Item(i).InnerText.ToString(CultureInfo.CurrentCulture) + ";";
                        }
                        return temp.TrimEnd(';');
                    }
                    else if (tag1 != null && tag2 != null && tag3 != null && tag4 != null)
                    {
                        for (int i = 0; i < xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).SelectSingleNode("//" + tag4).Attributes.Count; i++)
                        {
                            temp += xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).SelectSingleNode("//" + tag3).SelectSingleNode("//" + tag4).Attributes.Item(i).InnerText.ToString(CultureInfo.CurrentCulture) + ";";
                        }
                        return temp.TrimEnd(';');
                    }
                    else
                    {
                        return null;
                    }
                }
                catch (Exception ex)
                {
                    Program.Log("GetAllValueTag XmlFile", ex.Message); // mensagem caso haja erro
                    return null; // retorna mensagem caso haja erro
                }
            }
        }
    }

    quarta-feira, 11 de dezembro de 2019 17:16
  • Osvaldo1br,

       O erro está exatamente neste ponto (nestas duas linhas):

    // "Referência de objeto não definida para uma instância de um objeto."
    
    Program.Log("Read XmlFile3", xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
    
    return xmlNode.SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);

       Tente usar dessa forma:

    Program.Log("Read XmlFile3", xmlNode.SelectSingleNode("//" + tag1 + "//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture) + ", " + tag1 + ", " + tag2 + ", " + valor);  // teste
    
    return xmlNode.SelectSingleNode("//" + tag1 + "//" + tag2).Attributes.GetNamedItem(valor).InnerText.ToString(CultureInfo.CurrentCulture);

       Não testei muito, mas acho que é isso... 
       ... detalhe: Você precisará acertar todo o código para esse formato.


    []'s,
    Fabio I.

    quarta-feira, 11 de dezembro de 2019 18:32
  • Do jeito que me passou funcionou.

    O que há de diferença entre:

    SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2)
    e
    SelectSingleNode("//" + tag1 + "//" + tag2)

    pois uso o 1º em outro projeto e ele funciona normal.

    quarta-feira, 11 de dezembro de 2019 19:46
  • Osvaldo1br,

       Não achei uma explicação formal, mas acho que se você fizer isso (SelectSingleNode("//" + tag1).SelectSingleNode("//" + tag2)), vai ficar um dentro do outro ao invés de um do lado do outro ... acho que é isso, mas não tenho certeza.

    []'s,
    Fabio I.

    Por favor, se te ajudei, pode me pontuar? Agradecido.

    quarta-feira, 11 de dezembro de 2019 21:20