none
Validar un archivo de texto RRS feed

  • Pregunta

  • Buenas tardes!

    Alguien podria ayudarme a realizar una clase en c# para validar un archivo de texto,  algo asi como un analizador lexico, ya teniendo la clase le avanzo mas,  gracias x la atencion.....

    martes, 14 de diciembre de 2010 20:15

Respuestas

Todas las respuestas

  • hola

    pero ese archivo lo muestras en algun otro control ? por ahi en un RichTextBox

    por "analizador lexico" entiendo que debe interpretar cierta sintaxis por ejmeplo de codificacion

    no se si apuntas a algo como esto

    Enabling syntax highlighting in a RichTextBox

    CodeTextBox - another RichTextBox control with syntax highlightning and intellisense

    saludos


    Leandro Tuttini

    Blog
    Buenos Aires
    Argentina
    martes, 14 de diciembre de 2010 22:17
  • Que tal, esta es la primera vez que respondo, (así que espero que no me vaya tan mal jejeje)...

     

    Pues yo hice una clase muy sencilla para interpretar ciertas acciones en el orden que decía un archivo de texto...

    Ejemplo


    descargar http://www.microsoft.com/archivo.dat$nuevo_archivo.dat

     

    Donde la primera palabra era la acción a realizar y lo demás eran argumentos separados con el signo de moneda "$"..

    Esta clase es para cada una de las rutinas o acciones...

    public class ScriptRoutine
      {
        private string[] _arguments;
        private string _name = "";
        private string _raw_value = "";
    
        public ScriptRoutine()
        {
        
        }
    
        public ScriptRoutine(string line)
        {
          Parse(line);
        }
    
        public void Parse(string line)
        {
          _raw_value = line.Trim() ;
    
          if (_raw_value != "")
          {
            int argumentsStartCharacter = 0;
    
            argumentsStartCharacter = _raw_value.IndexOf(" ");
    
            if (argumentsStartCharacter > 0)
            {
              // Encontró argumentos en la línea
              _name = _raw_value.Substring(0, argumentsStartCharacter);
              string arguments_content = _raw_value.Substring(argumentsStartCharacter).Trim();
              _arguments = arguments_content.Split(new char[] { '$' });
            }
            else
            {
              _name = _raw_value.Trim();
            }
          }
        }
    
        public bool IsValid()
        {
          return (_name != "" ? true : false);
        }
      
        public string Name
        {
          get
          {
            return _name;
          }
          set
          {
            _name = value;
          }
        }
    
        public string[] Arguments
        {
          get
          {
            return _arguments;
          }
          set
          {
            _arguments = value;
          }
        }
    
      }
    

    Esta es para el que abre el archivo y carga las rutinas

     

    class ScriptParser
      {
        /// <summary>
        /// Lista de rutinas a ejecutar
        /// </summary>
        private RoutineCollection _routines = new RoutineCollection();
    
        /// <summary>
        /// Ubicación del directorio donde se encuentra la rutina actual
        /// </summary>
        private string _path;
    
        /// <summary>
        /// Nombre del archivo a analizar
        /// </summary>
        private string _filename = "";    
    
        private bool _savelog = false;
    
        public bool SaveLog
        {
          get
          {
            return _savelog;
          }
          set
          {
            _savelog = value;
          }
        }
    
    
        /// <summary>
        /// Versión de las rutinas
        /// </summary>
        public int Version
        {
          get
          {
            return 1;
          }
          set
          {
          }
        }
    
        /// <summary>
        /// Nombre del archivo a analizar
        /// </summary>
        public string Filename
        {
          get
          {
            return _filename;
          }
        }
    
        /// <summary>
        /// Ubicación del directorio donde se encuentra la rutina actual
        /// </summary>
        public string Path
        {
          get
          {
            return _path;
          }
        }
    
        /// <summary>
        /// Lista de rutinas a ejecutar
        /// </summary>
        public RoutineCollection Routines
        {
          get
          {
            return _routines;
          }
        }
    
    
        /// <summary>
        /// Analiza un archivo y devuelve todas las rutinas a ejecutar por el programa
        /// </summary>
        /// <param name="filename">Nombre del archivo a analizar</param>
        /// <returns>Verdadero si todo sale bien, de lo contrario devolverá falso</returns>
        public bool Parse(string filename)
        {
          // Determino si existe el archivo
          if (!System.IO.File.Exists(filename))
          {
            return false;
          }
    
          _filename = filename;
          _path = System.IO.Directory.GetParent(filename).ToString();
          
          // Abro el documento
          System.IO.StreamReader file = new System.IO.StreamReader(filename);
    
    
          string line;
    
          bool stopParse = false;
    
          while ((line = file.ReadLine()) != null)
          {
            if (line.Trim().Length > 1)
            {
    
              line = line.Trim();
    
              if (line.Substring(0, 2) == "/*")
              {
                stopParse = true;
              }
    
              if (line.Substring(0, 2) == "*/")
              {
                stopParse = false;
                line = "#";
              }
    
              if (line.Substring(0, 1) != "#" && !stopParse )
              {
    
                ScriptRoutine routineInfo = new ScriptRoutine();
    
    
                routineInfo.Parse(line);
                _routines.Add(routineInfo);
              }
            }
          }
    
          file.Close();
    
          return true;
    
        }
    
        
    
    
      }
    

    Y la siguiente es una colección..

     

      public class RoutineCollection: System.Collections.CollectionBase
      {
    
        public void Add( ScriptRoutine Routine )
        {
          List.Add( Routine );
        }
    
        public void Remove( int Index )
        {
          if (Index > 0 && Index < Count)
          {
            List.Remove(Index);
          }
        }
    
        public ScriptRoutine Item( int Index )
        {
          return (ScriptRoutine)List[Index];
        }
      }
    

     

    Espero te sirva.. saludos!

    • Marcado como respuesta Eduardo PorteschellerModerator jueves, 16 de diciembre de 2010 14:38
    • Desmarcado como respuesta Egipcia lunes, 20 de diciembre de 2010 19:02
    • Marcado como respuesta Egipcia lunes, 20 de diciembre de 2010 19:02
    • Desmarcado como respuesta Egipcia lunes, 20 de diciembre de 2010 21:44
    martes, 14 de diciembre de 2010 23:16
  • HolA!! muchas gracias por sus respuestas, explicare mejor

    La idea es que El listado de archivos sin validar se muestran en un listbox y al darle en el boton validar, lee uno por uno y te dice en otro cuadro de texto el status de la validacion, analizando... por ejemplo, y te muestra si tuvo algun error al leer... 

    los archivos txt tiene el sig. formato    |360|3165|RFCwjh7364|2010|12|  si no cumple con el formato te dice que es incorrecto..

     

    Gracias!!! XD

    sábado, 18 de diciembre de 2010 0:36
  • Para que utilizas la coleccion,?

    Saludos,

    lunes, 20 de diciembre de 2010 19:04