Inicio |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Creada el 24/11/2011 Última actualización 22/12/2012 por http://hardsoftweb.es and http://openwifizone.es - También estamos en Facebook https://www.facebook.com/ProgramacionVisualBasic
Manual VB.NET 1-Introducción a la plataforma Microsoft.NET Manual VB.NET 2-Introducción a VS.NET Manual VB.NET 3-Elementos del lenguaje, variables y estructuras de datos Manual VB.NET 4-Funciones, subrutinas y procedimientos Manual VB.NET 5-Bucles y estructuras de desición Manual VB.NET 7-Trabajando con controles Manual VB.NET 8-Manejo de errores y excepciones Manual VB.NET 9-Streams y ficheros Manual VB.NET 9.10-Streams y ficheros (extendido) Manual VB.NET 10-Programación orientada a objetos Manual VB.NET 11-Desarrollo de componentes Manual VB.NET 12-Acceso a datos con ADO.NET Manual VB.NET 13-Informes e impresión en aplicaciones Windows Form Manual VB.NET 14-Distribucion de aplicaciones Consultas, dudas, aportaciones, correcciones de texto, etc openwifizone@gmail.com Colaboradores: www.ematech2010.es - Mantenimientos y automatizaciones industriales http://openwifizone.es - Localización y documentación zonas wifi gratis mundiales http://android.webcindario.com - Programación Android y mundo Android http://manualphp.webcindario.com - Manual de programación php y utilidades Creador: http://hardsoftweb.es - Innovaciones Tecnológicas y telecomunicaciones
1-Introducción a la plataforma Microsoft.NET La plataforma .NET es un conjunto de tecnologias diseñadas para transformar Internet en una plataforma informática distribuida a escala completa. Proporciona nuevas formas de desarrollar aplicaciones apartir de colecciones de servicios web. Y soporta totalmente la infraestructura existente de Internet, Http, Xml y Soap. Proporciona: -Un modelo de programación coherente e independiente del lenguaje para todas las capas y niveles de una aplicación. -Una interoperabilidad transparente entre tecnologias. -Una fácil migración desde tecnologias existentes. -Un completo soporte de tecnologias de internet. Tecnologias intrinsecas de la plataforma .Net. El .Net Framework se basa en un nuevo entorno de ejecución del lenguaje comun (CLR, Common Languaje Runtime). Este motor de ejecución proporciona un conjunto de servicios comunes para los proyectos generados con Visual Studio.Net. Con independencia del lenguaje. Gracias al CLR todos los lenguajes .Net utilizan lso mismos archivos del entorno de ejecución. Servicios .Net Building Blocks: Son servicios programables distribuidos que están disponibles tanto en modo conectado como desconectado y pueden utilizarse desde qualquier plataforma que soporte el protocolo Soap. Servidores .Net Enterprise Servers: Proporcionan escalavilidad, fiabilidad, gestión e integración dentro de la empresa y entre organizaciones. ¿Que es el .Net Framework? El .NET Framework proporciona todos los servicios comunes necesarios para ejecutar las aplicaciones Visual Basic .NET. Crear componentes en el .Net Framework Al utilizar COM, es posible integrar componentes dentro de una aplicación y entre aplicaciones exponiendo una serie de interfaces comunes. En el .Net Framework, los componentes se construllen sobre una base comun. El .Net Framework soporta totanmente clases, herencia, métodos, propiedades, eventos, poliformismo, constructores y otras construcciones orientadas a objetos. Common Languaje Specification. CLS. Define los minimos estandares que deven satisfacer los lenguajes y desarrolladores, si desean que sus componentes y aplicaciones sean ampliamente utilizados por otros lenguajes compatibles con .Net. Componetes del .Net Framework: -Common Languaje Runtime. (CLR) -Biblioteca de clases del .Net Framework -ADO.Net: Datos y Xml -ASP.Net: Formularios web y servicios web -Interface de usuario El CLR simplifica el desarrollo de aplicaciones, proporciona un entorno de ejecución robusto y seguro, soporta multiples lenguajes, simplifica la implantación y administración de aplicaciones y proporciona un entorno gestionado. ¿Que es un entorno gestionado? Un entorno gestionado es aquel que proporciona servicios comunes de forma automatica. Algunos de los tipos de servicios que proporciona son el recolector de basura y la seguridad. Componentes del CLR: -Cargador de clases: Carga la implementación de un tipo en memória y lo prepara para la ejecución. -MSIL a compilador nativo: Convierte lenguaje intermedio MSIL a código nativo(Just in Time). -Gestor de código: Gestiona la ejecución del código. -Recolector de basura: Gestiona automaticamente la vida de todos sus objetos. -Motor de seguridad: Proporciona seguridad basada en evidencias en función del origen del código y del usuario. -Motor de depuración: Permite depurar la aplicación y trazar la ejecución del código. -Verificador de tipos: No permitira casts inseguros ni variables no inicializadas -Gestor de excepciones: Proporciona una gestión de excepciones estructuada e integrada con Windows Structured Exception Handling -Soporte de hilos (Threads): Proporciona clases e interfaces que permiten programación multi-hilo. -Com Marshaler: Proporciona Marshaling hacia y desde COM. -Soporte de la biblioteca de clases del .Net Framework: Integra el código con el entorno de ejecución que soporta la biblioteca de clases del .Net Framework. Biblioteca de clases del .Net Framework. La biblioteca de clases del .Net Framework expone características del entorno de ejecución y proporciona en una jerarquia de objetos otros servicios de alto nivel, los espacios de nombres. Espacios de nombres System. El espacio de nombres System contiene clases fundamentales y clases base que definen tipos de datos valor y referencia comunmente utilizados, eventos y descriptores de eventos, interfaces, atributos y procesamiento de excepciones. ADO.Net: Datos y Xml. ADO.Net es la siguiente generación de la tecnologia ActiveX, proporciona un soporte mejorado para el modelo de programación desconectado. También ofrece un completo soporte Xml. ASP.Net: Formularios web y servicios web. ASP.Net es un marco de trabajo de programación basado en el CLR y que puede ser utilizado en un servidor para crear potentes aplicaciones web. El CLR proporciona un soporte nativo para crear y exponer servicios web utilizando una abstracción de programación coherente y familiar para desarrolladores tanto de ASP como Visual Basic. ¿Cuales son las mejoras de VB.Net? -Soporte orientado a objetos mejorado: Permite a los desarrolladores de VB.Net utilizar herencia de clases, constructores, destructores, sobrecarga, interfaces y poliformismo. -Gesstión de excepciones estructurada: Simplifica el control de excepciones y permite utilizar potentes caracteristicas como las excepciones anidadas. -Nuevas obciones de manejo de hilos: Permite crear aplicaciones que utilizan capacidades con multiples hilos de ejecución. -Recolector de basura: Garantiza que las aplicaciones creadas con VB.Net no acedan a posiciones de memória sin referencia. -Crear formularios web facilmente: Es tan facil como crear formularios windows utilizando la tecnica de escrivir código tras el evento de un control. -Crear servicios web rapidamente: Es posible crear servicios web rapidamente de modo similar a como se creaban componentes en las versiones anteriores de Visual Basic. Descripción de los espacios de nombres. El .Net Framework incluye un gran conjunto de ensamblados que forman las bibliotecas de clases, que conjuntamente contienen cientos de tipos. Los espacios de nombres utilizan un esquema nombres con una sintaxis basada en un punto. Para agrupar logicamente clases relacionadas de modo que puedan buscarse y referenciarse facilmente. El espacio de nombres System: Es el espacio de nombres raiz para los tipos en el .Net Framework. Tambien contiene tipos para la gestión de excepciones, recolector de basura, E/S de consola, varios tipos de herramientas, tipos de datos de formato, generadores de números aleatorios y funciones matemáticas. La plataforma .Net proporciona la base de la siguiente generación de software que permite conectar sistemas, información, dispositivos y usuarios distintos de un modo mas unificado y personalizado. Incorpora servicios web XML como medio para permitir la interoperadibilidad entre tecnologias diferentes. Proporciona a los desarrolladores de software las herramientas y tecnologia para crear rapida y eficazmente soluciones de negocio que abarcan multiples aplicaciones y multiples dispositivos cliente entre diversas organizaciones. Permite a los usuarios controlar que información y como y cuando se les entrega. La plataforma .Net incluye una completa familia de productos creados para trabajar con los estandares XML e internet. -Herramientas para desarrollar soluciones. -Servidores para gestionar, crear e implantar soluciones. -Servicios para integrar, conectar y reutilizar soluciones. -Clientes hardware y software para proporcionar experiencias sin precedentes a los usuarios.
¿Como funciona el .Net Framework? El .Net Framework es un conjunto de servicios de programación diseñados para simplificar el desarrollo de aplicaciones sobre el entorno distribuido de intenet. Tiene dos componentes principales: El Common Language Runtime (CLR) y la biblioteca de clases. Cuando creamos una nueva aplicacion windows en Visual Basic.Net se nos proporciona un código inicial que incluye el espacio de nombres System.Windows.Forms y la clase Form. Cuando compilamos la aplicación, el código se traduce al lenguaje comun del entorno de ejecución Microsoft Intermiediate Language (MSIL). El entorno de ejecución incluye una caracteristica denominada compilación just-in-time (JIT), que traduce código MSIL al lenguaje maquina del sistema en que la aplicacción se ejecutará. Para entender como funciona el .Net Framework devemos estar familiarizados con la siguiente terminologia: -Clase: Es una entidad de programación con nombre que consta de un conjunto comun de metodos, propiedades y atributos. -Espacio de nombres: Identifica una colección de clases relacionadas y/u otros espacios de nombres del .Net Framework, algunos ejemplos el System y System.Windows.Forms. -Biblioteca de clases: Es una colecion completa orientada a objetos de clases reutilizables y organizadas en espacios de nombres jerarquicos en base de su funcionabilidad. -Common Language Runtime (CLR): Es la base del .Net Framework. En el entorno .Net, los programadores desarrollan aplicaciones en el lenguaje compatible con .Net que elijan; el codigo se compila en MSIL, y el entorno de ejecución gestiona y ejecuta el código compilado. ¿Que es Visual Studio.Net? Es un entorno de desarrollo integrado que nos ayuda a diseñar, desarrollar, depurar e implantar con rapidez soluciones basadas en el .Net Framework. Visual Studio.Net incluye las caracteristicas de programación siguientes:
¿Que es una plantilla de aplicación? Una plantilla de aplicación proporciona archivos de inicio y una estructura de proyecto, y contiene los objetos básicos del proyecto y la configuración del entorno que necesitamos para crear el tipo de aplicación que deseamos. El proceso de desarrollo Crear una aplicación en Visual Basic.Net implica 7 pasos basicos: 1-crear una especificacion o organigrama de diseño, 2-crear el interface de usuario, 3-establecer las propiedades de los objetos del interface de usuario, 4-Escrivir código, 5-provar y depurar, 6-generar un ejecutable, 7-crear una aplicacion de instalación. 3-Elementos del lenguaje, variables y estructuras de datos Introducción a los tipos de datos. El tipo de datos de un elemento de programación hace referencia a la clase de datos que puede contener y a como se almacenan los datos. El sistema de tipos comunes (Common Type System - CTS) define el tipo de datos que soporta el CLR. ¿Que es el sistema de tipos comunes? Define como se declaran, utilizan y gestionan los tipos en el CLR. El sistema de tipos comunes hace posible que un desarrollador pueda crear un proyecto en Visual Basic.Net e integrarlo con un componente creado en otro lenguaje. Todas estas piezas pueden integrarse en una única solución. Los compiladores y herramientas de Microsoft Visual Studio.Net y el CLR dependen del sistema de tipos comunes para proporcionar: -Integración entre lenguajes. -Código con seguridad de tipos. -Las herramientas que permiten y gestionan una ejecución del código de alto rendimiento. Tipos por valor y tipos por referencia: Una variable de tipo valor contiene directamente sus datos. Cada variable de tipo valor tiene su copia de datos, de modo que las operaciones en dicha variable no pueden afectar a otra variable. Una variable de tipo referencia contiene una referencia o puntero al valor de un objeto. Dos variables de tipo referencia pueden referirse al mismo objeto.
Si usted declara las variables sin tipo de datos se les otorga de forma predeterminada el tipo de datos Object. Por eso es recomendable declarar las variables con su tipo de datos correspondiente, porque: -Minimiza la cantidad de memoria que utiliza la aplicación. -Permite al compilador realizar la conversión de tipos. -La ejecución del código es mas rapìda. Uso de variables. Elementos de las variables
Como nombrar las variables. Cuando declaramos una variable, es importante desarrollar una estrategia de asignación de nombres. Debemos tener en cuenta las siguientes reglas: -Iniciar cada nombre de variable con un carácter alfabético o guión bajo. -No utilizar espacios ni símbolos. -No utilizar palabras clave. Se recomienda seguir las siguientes directrices: -Proporcione nombres descriptivos. -Empiece cada palabra del nombre de una variable publica con letra mayúscula como CuentaNumeros. -Evite el uso de abreviaturas. -Utilice un nombre único dentro del ámbito de la variable. -Cuando declare variables locales y privadas, inicie la primera palabra en minúsculas como cuentaNumeros. Como declarar una variable: Declaramos una variable para especificar su nombre y caracteristicas. Con la instrucción Dim. Dim nombreVariable As Tipo Como asignar valores a las variables: Para asignar un valor a una variable utilize el signo igual (=) Dim variableNum As Integer = 10 Como utilizar variables: Despues de nombrar y declarar variables y asignarles un valor. Podemos empezar a utilizarlas en la aplicacion. Podemos utilizar variables para almacenar datos orijinados por una expresión. newMessage = "¡Tiene un email!" unreadMail = totalMail - readMail Podemos utilizar variables para almacenar la entrada de información por parte del usuario. userName = nameTextBox.Text applicationDate = appDateTextBox.Text Podemos utilizar variables para almacenar objetos. myForm = mainForm Constantes. Las constantes almacenan valores, que como su nombre indica, permanecerán constantes a lo largo del programa. Ventajas de utilizar constantes: -Hacen que el código sea mas fácil de leer. -Utilizan menos memoria que las variables. -Hacen que los cambios a nivel de aplicación sean mas fáciles de implementar. Para declarar una constante usaremos la palabra clave Const. Const nombreconstante As Tipo Ejemplo: Dim area, radio, circunferencia As Double Const Pi As Double = 3.1415 area = Pi * radio ^2 circumferencia = 2 * Pi * radio Ambito de una variable: Para estudiar el modo de trabajo del ambito con variables, devemos estar familiarizados con los terminos y deffiniciones siguientes:
Asignamos el ámbito de una variable al declararla. Existen tres factores fundamentales que afectan al ámbito de una variable: -Donde la declaramos: Dentro de un bloque, procedimiento, modulo, clase o estructura. -El nivel de acceso (Public, Friend, Private) del modulo, clase o estructura en que se declara. -La sintaxis que utilizamos para declarar la variable (Dim, Private, Friend o Public) Niveles de ambito:
Como declarar variables locales. Cuando declaramos variables en un bloque o procedimiento nos referimos a variables locales, ya que estan limitadas por el bloque o procedimiento. Ejemplo de variable a nivel de bloque: If x <> 0 then Dim variable As Integer variable= 1/x End If Ejemplo de variable a nivel de procedimiento: Sub btnmensage_click () Dim name as String name = nameTextBox.Text MessageBox.Show("Bienbenido" & name & "!")End Sub Como declarar variables estaticas: La vida de una variable local empieza cuando un procedimiento la invoca y acaba cuando el procedimiento finaliza. Cuando acaba la vida de una variable local, la instancia de la variable se destruye y su valor se pierde. En ocasiones, es posible que deseemos que la vida de una variable local sea más larga que la vida del procedimiento. Por ejemplo, podemos desear que un procedimiento realice una acción específica la primera vez que sea invocado y que no haga nada en las siguientes llamadas. Podemos declarar una variable estática para conseguir esta funcionalidad. Una variable estática perdurará mientras la aplicación siga ejecutándose. Para declarar una variable estatica local: Static variable As Tipo Las variables estaticas resultan utiles para mantener contadores dentro del procedimiento. El sigiente ejemplo la variable estatica realiza un seguimiento de cada vez que se ejecute AddItemm y se incrementa en 1. Sub AddItem_Click( ) Static items As Integer ' Añadir 1 al contador items += 1 ' Usar ampersand(&) para combinar una cadena y una variable Messagebox.Show("El contador es ahora " & items) End Sub Como declarar variables a nivel de modulo: Las variables declaradas en un módulo, clase o estructura pero dentro de un procedimiento se denominan variables de módulo.Para declarar una variable de modulo: AccessModifier nombrevariable As Tipo
Ejemplo de ámbito a nivel de módulo ' Ponga la declaración siguiente al nivel del módulo ' (no en cualquier procedimiento) Private myModuleMessage As String ' ... Sub InitializeModuleVariable( ) myModuleMessage = "This variable has module-level scope." End Sub ' ... Sub UseModuleVariable( ) MessageBox.Show(myModuleMessage) End Sub Ejemplo de ámbito a nivel de proyecto ' Put the following declaration at module level ' (not in any procedure) Friend MyProjectMessage As String ' ... Sub InitializeProjectVariable( ) MyProjectMessage = "This variable has project-level scope." End Sub ' ... Sub UseProjectVariable( ) MessageBox.Show(MyProjectMessage) End Sub Ejemplo de ámbito a nivel de solución ' Put the following declaration at module level ' (not in any procedure) Public MySolutionMessage As String ' ... Sub InitializeSolutionVariable( ) MySolutionMessage = _ "This variable has solution-level scope." End Sub ' ... Sub UseSolutionVariable( ) MessageBox.Show(MySolutionMessage) End Sub Convertir tipos de datos: El proceso de convertir el valor de un tipo en otro se denomina conversión o casting. Podemos convertir valores e un tipo a otro antes de que sean utilizados.
Private Sub Button1_Click(...) ' Use string conversion on Integer Dim myVariable As Integer myVariable = 1234 MessageBox.Show(myVariable) MessageBox.Show(CStr(myVariable) & "1") End Sub Private Sub Button2_Click(...) ' Use integer conversion on Double Dim myVariable As Double myVariable = 567.9894 MessageBox.Show(myVariable) MessageBox.Show(CInt(myVariable)) End Sub Private Sub Button3_Click(...) ' Use date conversion on String Dim myVariable As String myVariable = "February 12, 1992" MessageBox.Show(myVariable) MessageBox.Show(CDate(myVariable)) End Sub Convertir explicitamente tipos de datos: Se recomienda el uso de funciones de conversión para convertir valores explicitamente antes de que sean utilizados, las conversiones explicitas se ejecutan mas rápido variableName = CFunction(Expresion) El siguiente ejemplo muestra como usar las funciones de conversion CStr y CDbl. Para convertir pies y pulgadas a metros. Private Sub Calculate_Click(...) Dim feet As Double, inches As Double Dim millimeters As Double, meters As Double 'First, extract feet and inches from the text boxes. 'The Text property returns a string, but we need a double, 'so CDbl( ) is used to perform the conversion. feet = CDbl(FeetTextBox.Text) inches = CDbl(InchesTextBox.Text) 'Next, convert feet and inches to millimeters. millimeters = (inches * MillimetersPerInch) + _ (feet * MillimetersPerInch * InchesPerFoot) 'Convert millimeters to meters. meters = millimeters / 1000 'Display the result in a label. Because the Text property 'is a string, use CStr( ) to convert the double. MeterResult.Text = CStr(meters) End Sub El siguiente ejemplo muestra cómo utilizar la función CInt para convertir un valor Double en un Integer: Dim myDouble As Double Dim myInt As Integer myDouble = 2345.5678 ' Set myInt to 2346 myInt = CInt(myDouble) Crear y utilizar estructuras. En Visual Basic.Net, podemos combinar variables de varios tipos de datos diferentes para crear un tipo definido por el usuario denominado estructura. ¿Que son las estructuras? Una estructura es una convinación de tipos de datos que se crea convinando otros tipos de datos. Las estructuras pueden tener datos, propiedades, métodos y procedimientos y pueden invocar y manipular eventos. El uso mas simple y havitual de las estructuras es encapsular variables relacionadas, creando un tipo de datos definido por el usuario. Por ejemplo es posible que deseemos guardar juntos el nombre, fecha de contratación, cargo y salario de un empleado. Podriamos utilizar varias variables o definimos una estructura y la utilizamos como la variable de un único empleado. Public Structure Employee Public FirstName As String Public LastName As String Public HireDate As Date Public JobTitle As String Private Salary As Decimal End Structure Como declarar estructuras. Iniciamos la declaración con la palabra clave Structure y la finalizamos con la instrucción End Structure. Devemos declarar cada miembro de los datos de una estructura y especificar un nivel de acceso. No podemos inicializar ninguno de los miembros de datos en la declaración de la estructura. Puede accederse a las estructuras desde cualquier lugar del archivo, módulo o clase en que estén declaradas. Podemos especificar el nivel de acceso como sigue: -Public: Accesible desde cualquier lugar de la solución o desde cualquier lugar que haga referencia al proyecto. -Protected: Accesible unicamente desde dentro de su propia clase. -Friend: Accesible desde la aplicación en que esta declarada o desde cualquier otro lugar del ensamblado. -Private: Accesible unicamente desde el modulo, archivo u otro elemento de programación en que este declarada, incluyendo desde miembros de cualquier tipo anidado como procedimientos. Public Structure Employee ' Public members, accessible throughout declaration region Public FirstName As String Public MiddleName As String Public LastName As String ' Friend members, accessible anywhere in the same assembly Friend EmployeeNumber As Integer Friend BusinessPhone As Long ' Private members, accessible only in the structure itself Private HomePhone As Long Private Salary As Double Private Bonus As Double End Structure Cómo utilizar las estructuras Una vez creada la estructura podemos declarar variables a nivel de procedimiento y a nivel de módulo como ese tipo de estructura. Podemos asignar valores a los miembros de datos de la estructura de la variable y escribir código para utilizar los miembros de la estructura. Generalmente, los pasos para utilizar las estructuras son los siguientes: 1-Declarar una estructura. Private Structure computerInfo Public processor As String Public memory As Long Public purchaseDate As Date End Estructure 2-Declarar una variable de tipo de estructura declarado Dim mySystem As computerInfo 3-Asignar valores a los miembros de datos mySystem.processor = "x86" mySystem.purchaseDate = #1/1/2003# mySystem.memory = TextBox1.Text 4-Escrivir código para utilizar los miembros de la estructura if mySystem.memory < 64000 Then NotEnoughMemory = True ¿Que es una matriz? Una matriz es un tipo de datos fundamental en Visual Basic, podemos utilizar matrices para crear menos código y mas sencillo, porque podemos utilizar estructuras y bucles de decisión para recuperar y modificar cualquier elemento de una matriz. Una matriz es una secuencia de datos del mismo tipo. Podemos acceder a los elementos individuales de una matriz utilizando el nombre de la matriz y un índice o indices ( empezando por 0) para especificar la posición del elemento en la matriz. Una matriz tiene una o mas dimensiones con uno o mas elementos en cada dimensión. Como declarar una matriz unidimensional Declaramos una matriz unidimensional especificando su nombre, tamaño, tipo de datos de los elementos y su nivel de acceso. Podemos declarar matrices locales utilizando la instrucción Dim. Sub InitializeArray () Dim currentExpense (30) As Decimal Dim number As Integer For number = 0 To 30 currentExpense(number) = 100 Next number End Sub Para declarar una matriz pública utilizaremos la palabra clave Public. Como utilizar matrices multidimensionales Para declarar una variable de matriz multidimensional, añada un par de parentesis detras del nombre de la variable y coloque comas dentro del parentesis para separar las dimensiones. Dim My4DArray (2, 6, 4, 1) As Integer Matriz de 2 dimensiones 4 filas y 3 columnas. Dim storageNumber (3, 2) As Double Para asignar un valor a un elemento especifico de la matriz, haga referencia a los números de indice del elemento. storageNumber (2, 1) = 24 Como canviar el tamaño de una matriz Modificar el tamaño de matrices nos ayuda a gestionar la memoria eficazmente. Por ejemplo, podemos utilizar una matriz grande durante un corto período de tiempo y canviar su tamaño por otro mas pequeño liberando asi la memoria. ReDim matrizExistente (nuevo tamaño) Ejemplo: Dim number, miMatriz () As Integer ReDim miMatriz (5) For number = 0 To 5 miMatriz (number) = number Next number Cuando utilizamos la instrucción ReDim los valores de la matriz se pierden, podemos conservarlos incluyendo la palabra clave Preserve. ReDim Preserve miMatriz (10) 4-Funciones, subrutinas y procedimientos El desarroyo de una aplicación, especialmente si es un proyecto muy grande, es mas facil si se divide en trozos mas pequeños. ¿Que es un procedimiento? Los procedimientos son las sentencias de codigo ejecutable de un programa Tipos de procedimientos: -Sub: Realizan acciones pero no devuelven ningun valor. al procedimiento que izo la llamada. -Function: Pueden devolver un valor al procedimiento que izo la llamada. -Property: Devuelven y asignan valores de propiedades de clases estructuras o modulos. Uso de procedimientos: Un procedimiento puede ser invocado desde otro, cuando un procedimiento llama a otro este recive el control asta que finaliza el procedimiento Accesibilidad del procedimiento: Public: Ninguna restricción Friend: Accesible desde el programa que contiene la declaración y desde cualquier otro lugar del ensamblado. Private: Accesible unicamente en el modulo que contiene la declaración. Como crear procedimientos Sub Un procedimiento sub es una serie de instrucciones delimitadas por Sub y End Sub Private Sub Hola() MessageBox.Show("Mi programa") End Sub Como crear procedimientos Function. Un procedimiento function es una serie de instrucciones delimitadas por Function y End Function, son similares a los sub, pero las funciones pueden devolver un valor. Function Square (SquareValue As Integer)As Integer Square = ScuareValue * SquareValue End Function El valor que devuelve se llama valor de retorno, La función puede devolver un valor de las dos siguientes formas: -Asigna un valor al nombre de su propia función en una o mas instrucciones dentro del procedimiento. El control no se devuelve al programa que realiza la llamada asta que se ejecuta Exid Function o End Function. -Utilizar una instrucción return para especificar el valor devuelto, y devuelve el control inmediatamente al código llamador. Ejemplo de asignación del valor de retorno, el siguiente ejemplo asigna el valor de retorno al nombre de la función DoubleTheValue. Function DoubleTheValue (ByVal j As Integer)As Double DoubleTheValue = j * 2 Exid Function End Function Ejemplo de uso de la instrucción return, La instruccion return asigna simultaneamente el valor devuelto y sale de la función. Function DoubleTheValue(ByVal j As Integer)As Double Return j * 2 End Function Como declarar argumentos en procedimientos. Un procedimiento que realiza tareas repetidas o compartidas utiliza distinta información en cada llamada. Esta información puede estar formada por variables, constantes y expresiones que se pasan al procedimiento por el procedimiento que realiza la llamada. Cada valor que se pasa a un procedimiento se denomina argumento. Los elementos definidos en el procedimiento se denominan parametros. Cuando definimos un procedimiento, definimos el modo en que otros procedimientos pueden pasar argumentos al procedimiento. Podemos escoger pasarle argumentos por referencia (ByRef) o por valor (ByVal)
El elemento de programación que subyace en un argumento puede ser un elemento variable, cuyo valor puede ser canviado, o un elemento no variable.
Utilizamos la misma sintaxis para declarar los argumentos para procedimientos Sub y procedimientos Function. Declaramos cada argumento de un procedimiento del mismo modo en que declaramos una variable, especificando el nombre del argumento y el tipo de datos. Tambien podemos especificar el mecanismo de paso y si el argumento es obcional. ([ByVal | ByRef] [ParamArray] nombreargumento As datatype) Si el argumento es opcional, devemos incluir tambien la palabra clave Optional y proporcionar un valor predeterminado en la declaración. Optional [ByVal | ByRef] nombreargumento As datatype = defaultvalue En el siguiente ejemplo, el procedimiento Sub Hello esta diseñado para tomar un argumento Name de tipo String por valor desde un procedimiento de llamada. Public Sub Hello (ByVal Name As String) MessageBox.Show ("Hello, " & Name & "!") End Sub Como utilizar argumentos opcionales Los argumentos opcionales estan indicados por la palabra clave Opcional en la definición del procedimiento. Además, cuando declaramos un argumento opcional, se aplican las siguientes reglas. -Debe especificarse un valor predeterminado para todos los argumentos opcionales -El valor predeterminado de un argumento opcional debe ser una expresion constante -Todos los argumentos que sigan a un argumento opcional en la definicion del procedimiento también deben ser opcionales Function Add (ByVal value1 As Integer, ByVal value2 As Integer, Optional ByVal value3 As Integer = 0)_ As Integer Reutilización de código tema 4 pag 15 5-Bucles y estructuras de desición Utilizamos estructuras de decisión para comparar valores y a continuación, ejecutar una determinada sección de código en base al resultado. Utilizamos estructuras de bucle para ejecutar una serie de instrucciones repetidamente asta que se satisface una condición. ¿Que son las expresiones condicionales? Cuando desarrollamos aplicaciones en Visual Basic.net necesitamos escribir expresiones que el equipo pueda evaluar. Las expresiones que evaluan True o False se denominan expresiones condicionales. Como utilizar operadores aritméticos Los operadores aritméticos se utilizan para realizar muchas de las operaciones aritméticas familiares que implican el cálculo de valores numéricos representados por literales, variables, otras expresiones, llamadas de funciones y propiedades, y constantes. Ejemplo de utilización de operadores aritméticos: Dim x As Integer x = 52 * 17 x = 120 / 4 x = 67 + 34 x = 32 - 12 x = 23 ^ 3 Como utilizar operadores de comparación tema 5 pag 7 8-Manejo de errores y excepciones El espacio de nombres System.IO contiene tipos que permiten la lectura/escritura sincrona y asincrona desde/a streams de datos y archivos. Streams. Los streams proporcionan una forma de leer y escribir bytes desde y hacia un repositorio de seguridad. Un repositorio de seguridad es un medio de almacenamiento, como un diskete o memoria. Principales operaciones de stream: -Podemos leer de streams: La lectura es la transferencia de datos desde un stream a una estrucctura de datos (como una matriz de bytes) -Podemos escribir a streams: La escritura es la transferencia de datos desde una estructura de datos a un stream. -Los streams pueden soportar busqueda: La busqueda es la consulta y modificación de la posicion actual en un stream. La capacidad de busqueda depende del tipo de repositorio de seguridad que tenga un stream. Soporte de Buffering: Algunas implementaciones de streams realizan un proceso de buffering local de los datos subyacentes para mejorar el rendimiento. Para estos streams podemos utilizar el metodo Flush, tanto para eliminar buffers internos como para asegurar que todos los datos se han escrito en la fuente de datos subyacente o el repositorio. El metodo Close tambien libera recursos del sistema, como descriptores de archivos, conexiones a redes o memoria utilizada. Las clases Stream proporcionadas por el .Net Framework. -Clase BufferedStream: Se utiliza para invocar el proceso de lectura de buffer desde otro stream, y escritura de buffer a otro stream. Un buffer es un bloque de bytes en memoria que se utiliza para almacenar datos en cache, reduciendo así el numero de llamadas al sistema operativo. -Clase MemoryStream: Proporciona un metodo de creación de streams que utiliza la memoria como repositorio de seguridad. La clase MemoryStream crea un stream desde una matriz de bytes. -Clase FileStream: Se utiliza tanto para leer de archivos como para escribir a ellos. De forma predeterminada abre archivos sincronamente, pero tambien proporciona un constructor para abrirlos asincronamente. Instancia de un stream Null. En ocasiones, una aplicación simplemente necesita que un stream elimine su salida y no devuelva ninguna entrada. Podemos obtener este tipo de stream que no tiene repositorio de seguridad y que no consumira ningun recurso operativo, del campo estatico publico de la clase stream denominado Null. Readers y Writers. La clase stream esta diseñada para la entrada/salida de bytes. Podemos utilizar las clases Reader y Writer para extraer e introducir a stream y cadenas que usan otros tipos.
El siguiente ejemplo muestra cómo escribir datos de tipo Integer y leer datos desde un nuevo stream de archivos vacío denominado Test.data. Una vez creado el archivo de datos en el directorio actual, la clase BinaryWriter se utiliza para escribir enteros de 0 a 10 en Test.data. A continuación, la clase BinaryReader lee el archivo y muestra el contenido del archivo en la consola. Imports System Imports System.IO Class MyStream Private Const FILE_NAME As String = "Test.data" Shared Sub Main() ' Create the new, empty data file. If (File.Exists(FILE_NAME)) Then Console.WriteLine("{0} already exists!", FILE_NAME) Exit Sub End If Dim fs As New FileStream(FILE_NAME, FileMode.CreateNew) ' Create the writer for data. Dim w As New BinaryWriter(fs) ' Write data to Test.data. Dim i As Integer For i = 0 To 10 w.Write(i) Next w.Close() fs.Close() ' Create the reader for data. fs = New FileStream(FILE_NAME, FileMode.Open, _ FileAccess.Read) Dim r As New BinaryReader(fs) ' Read data from Test.data. For i = 0 To 10 Console.WriteLine(r.ReadInt32()) Next w.Close() End Sub End Class En el siguiente ejemplo, el código define una cadena y la convierte en una matriz de caracteres. Esta matriz puede leerse utilizando el método StringReader.Read adecuado: Imports System Imports System.IO Class CharsFromStr Shared Sub Main() ' Create a string to read characters from. Dim str As String = "Some number of characters" ' Size the array to hold all the characters of the ' string, so that they are all accessible. Dim b(24) As Char ' Create a StringReader and attach it to the string. Dim sr As New StringReader(str) ' Read 13 characters from the array that holds ' the string, starting from the first array member. sr.Read(b, 0, 13) ' Display the output. Console.WriteLine(b) ' Close the StringReader. sr.Close() End Sub End Class System.Text.Encoding. El entorno de ejecución representa todos los caracteres en formato Unicode, pero el .Net Framework proporciona varios tipos derivados que pueden codificar/decodificar caracteres Unicode a ASCII, UTF-7, UTF-8. La codificación predeterminada es UTF-8 E/S Basica de archivos. -La clase FileStream: Se utiliza para leer y escrivir de/a archivos. Los tipos FileMode, FileAccess y FileShare se utilizan como parametros en algunos constructores FileStream -Los parametros FileMode: Controlan si un archivo se a sobreescrito, creado o abierto, o sometido a cualquiera de estas operaciones.
-La enumeración FileAccess: Define constantes para el acceso en modo lectura, escritura o lectura/escritura a un archivo. Esta enumeración tiene un atributo FlagsAttribute que permite una convinación de bits de sus valores miembro. -La enumeración FileShare: Contiene constantes para controlar el tipo de acceso que otros objetos FileStream pueden tener al mismo archivo. Esta enumeración tiene un atributo FlagsAttribute que permite una convinación de bits de sus valores miembro. Se utiliza tipicamente para definir si varios procesos pueden leer simultaneamente desde el mismo archivo. En el siguiente ejemplo, un constructor FileStream abre un archivo exsistente para aceder en modo lectura y permite a otros usuarios leer el archivo simultaneamente. Dim f As New FileStream(name, FileMode.Open, FileAccess.Read, FileShare.Read) Uso del metodo Seek para el acceso aleatorio de archivos. Los objetos FileStream soportan el acceso aleatorio a archivos utilizando el metodo Seek. El metodo permite mover la posicion de lectura/escritura del Stream de archivos a cualquier posición del archivo.
La clases File y FileInfo. Son clases utiles que contienen metodos que se utilizan principalmente para crear, copiar, eliminar, mover y abrir archivos. Todos los metodos de la clase File son compartidos y, por tanto, pueden invocarse sin crear una instancia de la clase. Por ejemplo, para crear un archivo denominado MyFile.txt y devolver un objeto FileStream utilice el siguiente código: Dim aStream As FileStream = File.Create("MyFile.txt") Para crear un archivo y devolver un objeto StreamWriter. Dim sw As StreamWriter = File.CreateText("MyFile.txt") Para crear un archivo y devolver un objeto StreamReader. Dim sr As StreamReader = File.OpenText("MyFile.txt") Ejemplo de lectura de texto: Imports System Imports System.IO Class TextFromFile Private Const FILE_NAME As String = "MyFile.txt" Shared Sub Main() ' Create the new, empty data file. If (File.Exists(FILE_NAME) = False) Then Console.WriteLine("{0} does not exist!", FILE_NAME) Exit Sub End If Dim sr As StreamReader = File.OpenText(FILE_NAME) Dim Line As String = sr.ReadLine() While Not(Line Is Nothing) Console.WriteLine(Line) Line = sr.ReadLine() End While Console.WriteLine( _ "The end of the stream has been reached.") sr.Close() End Sub End Class Este código crea un objeto StreamReader que apunta a un archivo denominado MyFile.txt utilizando una llamada a File.OpenText. StreamReader.ReadLine devuelve cada línea como una cadena. Cuando no hay más caracteres para leer, se muestra un mensaje a tal efecto, y el stream se cierra. Ejemplo de escritura de texto: El siguiente ejemplo crea un nuevo archivo de texto denominado MyFile.txt, escribe una cadena, entero y un número de coma flotante en él y, finalmente, cierra el archivo. Imports System Imports System.IO Class TextToFile Private Const FILE_NAME As String = "MyFile.txt" Shared Sub Main() If (File.Exists(FILE_NAME)) Then Console.WriteLine("{0} already exists!", FILE_NAME) Exit Sub End If Dim sw As StreamWriter = File.CreateText("MyFile.txt") sw.WriteLine("This is my file") sw.WriteLine( _ "I can write ints {0} or floats {1}, and so on.", 1, 4.2) sw.Close() End Sub End Class Las clases Directory y DirectoryInfo. Contienen rutinas para crear, mover y enumerar a traves de directorios y subdirectorios. La clase DirectoryInfo contiene todos los metodos de instancia. El siguiente ejemplo muestra el uso de la clase DirectoryInfo para crear un listado de directorio. Imports System Imports System.IO Class DirectoryLister Shared Sub Main() Dim dir As New DirectoryInfo(".") Dim f As FileInfo Dim name As String, size As Long, creationTime As DateTime For Each f In dir.GetFiles("*.vb") name = f.FullName size = f.Length creationTime = f.CreationTime Console.WriteLine("{0,-12:N0} {1,-20:g} {2}", _ size, creationTime, name) Next End Sub End Class Rutas: Utilice la clase Path para procesar cadenas de directorios de modo multiplataforma. Los miembros de la clase Path permiten realizar rapida y facilmente las operaciones mas habituales, como averiguar si una extensión de archivo forma parte de una ruta, y convinar dos cadenas en un nombre de ruta. FileSystemWatcher. Utilizamos el componente para monitorizar un sistema de archivos y para reaccionar cuando se producen canvios en dicho sistema, podemos lanzar rapida y facilmente procesos de negocio cuando se creen, modifiquen o eliminen directorios o archivos especificos. Podemos configurar el componente para monotorizar un directorio completo y su contenido o para buscar unicamente un archivo especifico o un conjunto de archivos de un determinado directorio. Para monitorizar canvios en todos los archivos, estableceremos la propiedad Filter en una cadena vacia (""). Para un archivo determinado estableceremos la propiedad Filter en el nombre del archivo. Podemos buscar canvios en atributos (Attribute), en fecha y hora (LastWrite), o en el tamaño (Size). Creación de un componente FileSystemWatcher El siguiente ejemplo crea un componente FileSystemWatcher para monitorizar el directorio que se especifica en tiempo de ejecución. El componente se establece para monitorizar cambios en los instantes LastWrite y LastAccess, y la creación, borrado o renombrado de los archivos de texto del directorio. Si se cambia, crea o borra un archivo, se imprime la ruta al archivo en la consola. Cuando se cambia el nombre de un archivo, se imprimen las rutas antigua y nueva en la consola. Imports System Imports System.IO Imports Microsoft.VisualBasic Class Watcher Shared Sub Main() ' If a directory is not specified, exit program. Dim args() As String = Split(Command()) If Command().Length = 0 Or args.Length<>1 Then ' Display the proper way to call the program. Console.WriteLine("Usage: Watcher.exe (directory)") Exit Sub End If ' Create a new FileSystemWatcher ' and set its properties. Dim watcher As New FileSystemWatcher() watcher.Path = args(0) ' Watch for changes in LastAccess and LastWrite ' times, and the renaming of files or directories watcher.NotifyFilter = NotifyFilters.LastAccess + _ NotifyFilters.LastWrite + NotifyFilters.FileName + _ NotifyFilters.DirectoryName ' Only watch text files. watcher.Filter = "*.txt" ' Add event handlers. ' The Changed event occurs when changes are made to ' the size, system attributes, last write time, last ' access time, or security permissions in a file or ' directory in the specified Path of a ' FileSystemWatcher. AddHandler watcher.Changed, AddressOf OnChanged ' The Created event occurs when a file or directory ' in the specified Path of a FileSystemWatcher is ' created. AddHandler watcher.Created, AddressOf OnChanged ' The Deleted event occurs when a file or directory ' in the specified Path of a FileSystemWatcher is ' deleted. AddHandler watcher.Deleted, AddressOf OnChanged ' The Renamed event occurs when a file or directory ' in the specified Path of a FileSystemWatcher is ' renamed. AddHandler watcher.Renamed, AddressOf OnRenamed ' Begin watching. watcher.EnableRaisingEvents = True ' Wait for the user to quit the program. Console.WriteLine("Press 'q' to quit the sample.") While (Console.ReadLine() <> "q") 'do nothing End While End Sub ' Define the event handlers. Public Shared Sub OnChanged(ByVal sender As Object, _ ByVal e As FileSystemEventArgs) ' Specify what is done when a file is changed, ' created, or deleted. Console.WriteLine("File: " & e.FullPath & " " _ & e.ChangeType) End Sub Public Shared Sub OnRenamed(ByVal sender As Object, _ ByVal e As RenamedEventArgs) ' Specify what is done when a file is renamed. Console.WriteLine("File: {0} renamed to {1}", _ e.OldFullPath, e.FullPath) End Sub End Class 9.1-Streams y ficheros (extendido) La remodelación del viejo esquema de entrada y salida Desde las primeras versiones del lenguaje, el programador de Visual Basic ha dispuesto de un conjunto de instrucciones y funciones para el manejo de las operaciones de lectura/escritura con archivos, y la gestión de los mismos dentro del sistema operativo, en cuanto a su creación, borrado copia, etc., entre directorios y unidades. Si bien este modo de trabajo ha sido válido durante mucho tiempo, la incorporación de las técnicas OOP a los lenguajes de programación, hacían necesario una renovación en este aspecto de VB. Las instrucciones Open, Input, Write, Put, etc., a pesar de resolver su cometido, no proporcionan un entorno de trabajo cómodo, en un mundo en el que cada vez prima más el trabajo con objetos. La jerarquía de objetos FileSystemObject, introducida recientemente, vino a paliar en parte esta carencia, aportando un conjunto de clases que ya nos permitían, desde un prisma orienta a objeto, trabajar con todos los aspectos del sistema de archivos, en cuanto a su lectura, escritura, manejo de directorios, unidades, etc. La evolución de este conjunto de objetos se halla en la plataforma .NET. System.IO, el punto de partida Con la llegada de la tecnología .NET, el acceso al sistema de archivos, es un aspecto que ya no forma parte de un lenguaje determinado, como ocurría en las anteriores versiones de VB, sino que ha sido integrado dentro de la jerarquía de clases de la plataforma, en el espacio de nombres IO de System. Con ello, todos los lenguajes compatibles con .NET podrán utilizar este conjunto de objetos. Las clases incluidas en System.IO, nos van a permitir realizar labores de lectura y escritura en archivos de texto, binarios, etc., así como la creación y manipulación de los archivos y directorios que contienen la información. Objetos Stream Un objeto Stream representa un flujo o corriente de datos, es decir, un conjunto de información guardada en formato de texto o binario, que podremos leer y escribir sobre un soporte físico, también denominado en la plataforma .NET, almacén de respaldo (backing store). Algunos tipos de Stream, para optimizar el flujo de transferencia de datos entre el objeto y su medio físico de almacenamiento, disponen de una característica denominada almacenamiento intermedio (buffering), que consiste en mantener un búfer intermedio con los datos. En el caso, por ejemplo, de tareas de escritura, todas las operaciones se realizarían en el búfer, mientras este dispusiera de capacidad. Una vez terminado el proceso de escritura, o cuando el búfer estuviera lleno, su contenido pasaría al archivo físico. Podemos también, alterar el comportamiento por defecto del búfer a través de diversas propiedades y métodos del objeto Stream correspondiente. Las clases TextReader y TextWriter Estas clases contienen los miembros genéricos para realizar lectura y escritura de caracteres. Se trata de clases abstractas, por lo que deberemos utilizar las clases derivadas StreamReader, StreamWriter, StringReader y StringWriter, comentadas a continuación. La clase StreamWriter Un objeto StreamWriter realiza operaciones de escritura de texto sobre un archivo. El proceso típico de escritura de datos mediante un StreamWriter, comprende los siguientes pasos: • Instanciar un objeto de esta clase mediante alguno de los constructores disponibles. Aquí creamos un nuevo archivo para escribir datos sobre él, o abrimos uno existente. • Escritura de texto mediante los métodos WriteLine( ) y Write( ). El primero escribe el texto pasado como parámetro, y añade los caracteres especiales de retorno de carro y nueva línea. El segundo escribe el texto pasado y deja el puntero de escritura a partir del último carácter escrito, con lo que no produce un cambio automático de línea. Deberemos utilizar la propiedad NewLine para introducir manualmente un salto de línea. • Cierre del Stream con el método Close( ). Esta acción vuelca el contenido del búfer del objeto en el archivo. Imports System.IO Module Module1 Sub Main() Dim swEscritor As StreamWriter ' creamos un stream de escritura, y al mismo tiempo un ' nuevo archivo para escribir texto sobre él swEscritor = New StreamWriter("\pruebas\NOTAS.txt") ' escribir líneas swEscritor.WriteLine("esta es la primera línea") swEscritor.WriteLine("segunda línea de texto") ' ahora escribimos texto pero sin provocar un salto de línea swEscritor.Write("Juan y Luna ") swEscritor.Write("van de paseo") swEscritor.Write(swEscritor.NewLine) ' esto introduce el salto de línea swEscritor.WriteLine("con esta línea cerramos") ' cerrar el stream y el archivo asociado swEscritor.Close() End Sub End Module Algunas de las clases de tipo Stream de escritura disponen del campo compartido Null, que permite realizar una operación de escritura que no será volcada en el medio físico de almacenamiento, con lo que se perderán los datos escritos. ' escribir a un medio inexistente (nulo) swEscritor.Null.WriteLine("este texto no llegará al archivo") En el caso de que el archivo sobre el que vamos a escribir ya exista, podemos utilizar un constructor de StreamWriter que nos permite especificar si vamos a añadir texto al archivo o vamos a sobrescribir, perdiendo el texto que hubiera. ' abre el archivo y se sitúa al final del texto para añadir swEscritor = New StreamWriter("\pruebas\NOTAS.txt", True) ' se elimina el contenido previo del archivo swEscritor = New StreamWriter("\pruebas\NOTAS.txt", False) Después de crear un objeto de este tipo, y escribir algunas líneas de texto sin cerrar el Stream, si abrimos su archivo de texto correspondiente, nos encontraremos con que no hay texto dentro del archivo. Ello es debido a que todavía no se ha volcado el contenido del búfer del objeto sobre el archivo. Para forzar dicho volcado, deberemos llamar al método Flush( ), que se encarga de traspasar el búfer al archivo asociado al Stream. Dim swEscritor As StreamWriter ' creamos un stream de escritura swEscritor = New StreamWriter("\pruebas\NOTAS.txt", False) ' escribir líneas swEscritor.WriteLine("la primera línea") swEscritor.WriteLine("un poco más de texto") ' si abrimos el archivo antes de la siguiente, estará vacío swEscritor.Flush() ' ahora el archivo ya contendrá texto ' cerrar el stream y el archivo asociado swEscritor.Close() La clase StreamReader Un objeto StreamReader realiza operaciones de lectura de texto sobre un archivo. El proceso que debemos llevar a cabo para leer el contenido de un Stream de lectura es muy similar al de escritura: instanciar el objeto con uno de sus constructores, abriendo un archivo para leer; ejecutar alguno de los métodos de lectura del StreamReader, y cerrar el objeto con Close( ). Entre los métodos de lectura de este objeto, tenemos ReadLine( ), que devuelve una línea del archivo; y ReadToEnd( ), que devuelve el resto del contenido del archivo, desde el punto en el que se encontrara el Stream al realizar la última lectura. Dim srLector As StreamReader = New StreamReader("\pruebas\NOTAS.txt") Console.WriteLine("**Leer una primera línea**") Dim Linea As String Linea = srLector.ReadLine() Console.WriteLine("La línea contiene --> {0}", Linea) Console.WriteLine() Console.WriteLine("**Ahora leemos el resto del archivo**") Dim Texto As String Texto = srLector.ReadToEnd() Console.WriteLine("El texto restante contiene --> {0}", Texto) srLector.Close() ' *********************************************** ' leer línea a línea mediante un bucle Dim srLector As StreamReader = New StreamReader("\pruebas\Datos.txt") Dim Linea As String Dim ContadorLin As Integer = 1 Linea = srLector.ReadLine() Do While Not (Linea Is Nothing) Console.WriteLine("Línea: {0} - Contenido: {1}", ContadorLin, Linea) ContadorLin += 1 Linea = srLector.ReadLine() Loop Otro de los métodos de lectura es ReadBlock( ), que recibe como parámetro un array de tipo Char, sobre el que se depositarán una cierta cantidad de caracteres leídos del archivo. En el segundo parámetro de este método indicamos la posición del array desde la que se comenzarán a guardar los caracteres. En el tercer parámetro, el número de caracteres a leer. El método Read( ), también permite realizar una lectura igual que ReadBlock( ), pero en el caso de no utilizar parámetros, devuelve un valor numérico, correspondiente al código del carácter que acaba de leer. Cuando llega al final del Stream, devuelve –1. Para convertir de nuevo a carácter los valores que devuelve Read( ), debemos pasar estos valores a un array de tipo Byte, y después, utilizando un objeto ASCIIEncoding, mediante su método GetString( ), pasaríamos el array a una cadena. Imports System.IO Imports System.Text Module Module1 Sub Main() ' crear un Stream de lectura Dim srLector As StreamReader = New StreamReader("\pruebas\NOTAS.txt") ' obtener valores del Stream con el método ReadBlock() ' ---------------------------------------------------- ' crear un array Char que contendrá los caracteres leídos Dim Caracteres(15) As Char ' leemos 16 caracteres del archivo y los pasamos al array ' comenzando a grabarlos a partir de su posición 0 srLector.ReadBlock(Caracteres, 0, 16) ' pasamos el array de valores Char a String mediante ' el constructor de la clase String que recibe como ' parámetro un array Char Dim Parte1 As String = New String(Caracteres) Console.WriteLine("Resultado de la lectura con ReadBlock()") Console.WriteLine(Parte1) Console.WriteLine() ' obtener valores del stream con el método Read() ' ----------------------------------------------- Dim Valor As Integer Dim Codigos() As Byte ' vamos a ir volcando en un bucle los códigos de carácter ' leidos desde el archivo a un array Byte Valor = srLector.Read() While (Valor <> -1) ' cuando lleguemos al final, obtendremos -1 If Codigos Is Nothing Then ReDim Codigos(0) Else ReDim Preserve Codigos(Codigos.GetUpperBound(0) + 1) End If Codigos(Codigos.GetUpperBound(0)) = Valor Valor = srLector.Read() End While Dim Codificador As New ASCIIEncoding() Dim Parte2 As String ' con el objeto ASCIIEncoding, método GetString(), ' obtenemos una cadena, pasando como parámetro un array ' de tipos Byte Parte2 = Codificador.GetString(Codigos) Console.WriteLine("Resultado de la lectura con ReadBlock()") Console.WriteLine(Parte2) Console.ReadLine() End Sub End Module Finalmente, el método Peek( ), al igual que Read( ), devuelve el siguiente valor disponible del Stream, pero sin extraerlo del búfer, con lo que deberemos utilizar alguno de los métodos anteriormente descritos para realizar una lectura real. Las clases StringWriter y StringReader Estas clases proporcionan la misma funcionalidad que StreamWriter y StreamReader, con la diferencia de que StringWriter trabaja con un objeto StringBuilder como almacén de datos, mientras que StringReader utiliza un String para leer su contenido. La clase Stream (flujo de datos) La clase Stream representa un flujo o corriente de datos, es decir, un conjunto secuencial de bytes, como puede ser un archivo, un dispositivo de entrada/salida, memoria, un conector TCP/IP, etc. Se trata de una clase abstracta, por lo que si queremos hacer uso de un stream concreto, tenemos que acudir a alguna de sus clases derivadas como son FileStream, MemoryStream, BufferedStream, etc. La clase FileStream Realiza escritura y lectura de bytes sobre un archivo; en el caso de que el archivo no exista, lo crearíamos al mismo tiempo que instanciamos este objeto. Uno de los constructores de esta clase, nos permite especificar una cadena con la ruta del archivo a utilizar, mientras que en el segundo parámetro utilizaremos un valor de la enumeración FileMode, mediante la que indicamos el modo de trabajo sobre el archivo: añadir, abrir, crear, etc. Las propiedades CanRead, CanWrite y CanSeek, devuelven un valor lógico que nos informa de si en el objeto podemos realizar operaciones de lectura, escritura y desplazamiento por los bytes que contiene. Para escribir datos, disponemos del método WriteByte( ), que escribe un byte en el archivo; y también tenemos el método Write( ), que escribe de un array de bytes pasado como parámetro, una cantidad de elementos determinada empezando por una de las posiciones de dicho array. ' escrituras con Filestream Dim oFileStream As FileStream oFileStream = New FileStream("\pruebas\apuntes.dtt", FileMode.CreateNew) oFileStream.Write(New Byte() {15, 160, 88, 40, 67, 24, 37, 50, 21}, 0, 6) oFileStream.WriteByte(75) Console.WriteLine("Opciones en el FileStream") Console.WriteLine("Podemos leer: {0}", IIf(oFileStream.CanRead, "SI", "NO")) Console.WriteLine("Podemos escribir: {0}", IIf(oFileStream.CanWrite, "SI", "NO")) Console.WriteLine("Podemos movernos: {0}", IIf(oFileStream.CanSeek, "SI", "NO")) oFileStream.Close() oFileStream = Nothing Para las operaciones de lectura, tenemos ReadByte( ), que devuelve el valor sobre el que esté posicionado el objeto en ese momento. También disponemos del método Read( ), que traspasa valores a un array de bytes. Si queremos desplazarnos por los elementos del Stream, podemos utilizar el método Seek( ), pasando la cantidad de posiciones a movernos, y el punto desde el que queremos realizar dicho desplazamiento, mediante los valores de la enumeración SeekOrigin. Para averiguar el elemento del Stream en el que estamos situados, disponemos de la propiedad Position. ' lectura con FileStream Dim oFileStream As FileStream oFileStream = New FileStream("\pruebas\apuntes.dtt", FileMode.Open) Dim Valor As Byte Valor = oFileStream.ReadByte() ' obtener un valor Console.WriteLine("Se ha leido el valor: {0}", Valor) Console.WriteLine("Nos desplazamos dos bytes en el stream") oFileStream.Seek(2, SeekOrigin.Begin) Valor = oFileStream.ReadByte() Console.WriteLine("Se ha leido el valor: {0}", Valor) Console.WriteLine("La posición actual del stream es: {0}", _ oFileStream.Position) ' leer varios valores, pasándolos a un array ' previamente dimensionado Dim VariosValores(3) As Byte oFileStream.Read(VariosValores, 0, 4) Console.WriteLine("Leer bloque de valores del stream") Dim Enumerador As IEnumerator Enumerador = VariosValores.GetEnumerator() While Enumerador.MoveNext Console.WriteLine("Valor: {0}", Enumerador.Current) End While Console.ReadLine() Las clases BufferedStream y MemoryStream, que también heredan de Stream, disponen de los mismos miembros que FileStream, teniendo como principal diferencia el que utilizan la memoria de la máquina como almacén de respaldo. Manejo de datos binarios Las clases BinaryWriter y BinaryReader, tal y como podemos anticipar por sus nombres, nos permiten escribir y leer respectivamente, datos binarios en archivos, utilizando los métodos ya vistos en clases anteriores. ' escritura binaria Dim oBin As New BinaryWriter(New FileStream("\pruebas\info.bin", FileMode.CreateNew)) oBin.Write("H"c) oBin.Write("D"c) oBin.Write("U"c) oBin.Close() oBin = Nothing ' lectura binaria Dim oBinLector As BinaryReader oBinLector = New BinaryReader(New FileStream("\pruebas\info.bin", FileMode.Open)) Console.WriteLine("Valor 1 del lector: {0}", oBinLector.ReadChar()) Console.WriteLine("Valor 2 del lector: {0}", oBinLector.ReadChar()) Console.WriteLine("Valor 3 del lector: {0}", oBinLector.ReadChar()) oBinLector.Close() Console.ReadLine() Manipulación de archivos mediante File y FileInfo Las clases File y FileInfo, proporcionan a través de sus miembros, el conjunto de operaciones comunes que podemos realizar con archivos en cuanto a su creación, copia, borrado, etc. La diferencia principal entre ambas radica en que los miembros de File son todos compartidos, con lo cual se facilita en gran medida su uso, al no tener que crear una instancia previa de la clase; mientras que en FileInfo deberemos crear un objeto para poder utilizarla, ya que sus miembros son de instancia. FileInfo dispone de algunos métodos adicionales que no se encuentran en File. Comenzando por la clase File, los métodos CreateText( ) y OpenText( ), devuelven respectivamente un objeto StreamWriter y StreamReader, que utilizaremos para escribir y leer en el archivo pasado como parámetro a estos métodos. Con el método Exists( ), comprobamos si existe un determinado archivo. Dim sNombreFich As String Dim srLector As StreamReader Dim swEscritor As StreamWriter Console.WriteLine("Introducir ruta y archivo") sNombreFich = Console.ReadLine() If File.Exists(sNombreFich) Then srLector = File.OpenText(sNombreFich) Console.WriteLine("El archivo contiene:{0}{1}", _ ControlChars.CrLf, srLector.ReadToEnd()) srLector.Close() Else swEscritor = File.CreateText(sNombreFich) swEscritor.WriteLine("este es") swEscritor.WriteLine("un nuevo archivo") swEscritor.Close() End If Console.WriteLine("Proceso finalizado") Console.ReadLine() Para obtener los atributos de un archivo, disponemos del método GetAttributes( ), al que pasamos la ruta de un archivo, y devuelve un valor de la enumeración FileAttributes con la información sobre los atributos. En el caso de que al intentar acceder a un archivo, este no exista, se producirá una excepción de tipo FileNotFoundException, que podemos tratar en una estructura de manejo de excepciones. Dim sNombreFich As String Dim oAtributos As FileAttributes Try Console.WriteLine("Introducir ruta y archivo") sNombreFich = Console.ReadLine() oAtributos = File.GetAttributes(sNombreFich) Console.WriteLine("Atributos del archivo: {0}", oAtributos.ToString()) Catch oExcep As FileNotFoundException Console.WriteLine("Se ha producido un error {0}{1}", _ ControlChars.CrLf, oExcep.Message) Finally Console.WriteLine("Proceso finalizado") Console.ReadLine() End Try Además de esta excepción, el espacio de nombres IO proporciona algunas clases de excepción adicionales para tratar otras diversas circunstancias de error. Los métodos Copy( ), Move( ) y Delete( ), nos permiten copiar, mover y borrar respectivamente el nombre de archivo que pasemos como parámetro. El método GetCreationTime( ) nos devuelve un tipo Date con la fecha de creación del archivo. Por otro lado, si queremos obtener información adicional sobre un archivo, como su nombre, extensión, ruta, etc., instanciaremos un objeto FileInfo( ), pasando al constructor una cadena con el nombre del archivo, y utilizaremos algunas de sus propiedades como Name, Extensión, DirectoryName. Dim sNombreFich As String Dim iOperacion As Integer Dim oFInfo As FileInfo Console.WriteLine("Introducir ruta y archivo") sNombreFich = Console.ReadLine() Console.WriteLine("Fecha creación archivo: {0}", _ File.GetCreationTime(sNombreFich)) oFInfo = New FileInfo(sNombreFich) Console.WriteLine("Introducir el número de operación a realizar:") Console.WriteLine("1 - Copiar") Console.WriteLine("2 - Mover") Console.WriteLine("3 - Borrar") iOperacion = Console.ReadLine() Select Case iOperacion Case 1 File.Copy(sNombreFich, "\pruebas\distinto" & oFInfo.Extension) Case 2 Console.WriteLine("Vamos a mover el archivo {0}", oFInfo.Name) Console.WriteLine("que está en la ruta {0}", oFInfo.DirectoryName) File.Move(sNombreFich, "\pruebas\" & oFInfo.Name) Console.WriteLine("Completado") Console.ReadLine() Case 3 File.Delete(sNombreFich) End Select Manipulación de archivos mediante Directory y DirectoryInfo Las clases Directory y DirectoryInfo contienen métodos y propiedades para crear, borrar, copiar y mover directorios, así como otra serie de tareas para su manejo y obtención de información. Al igual que sucedía con las clases del anterior apartado, los miembros de Directory son compartidos, mientras que los de DirectoryInfo son de instancia; esta es su principal diferencia. En el ejemplo, el método Exists( ) comprueba la existencia de un directorio, y en caso afirmativo, obtenemos su última fecha de uso mediante GetLastAccessTime( ). Seguidamente obtenemos un array String con su lista de archivos mediante GetFiles( ), y creamos un subdirectorio de respaldo con CreateSubdirectory( ). En caso de que el directorio no exista, lo creamos con CreateDirectory( ). Dim sNombreDir As String Dim Archivos() As String Dim Archivo As String Dim oDirInfo As DirectoryInfo Console.WriteLine("Introducir un nombre de directorio") sNombreDir = Console.ReadLine() If Directory.Exists(sNombreDir) Then Console.WriteLine("Fecha último acceso: {0}", _ Directory.GetLastAccessTime(sNombreDir)) Console.WriteLine("Archivos del directorio {0}", sNombreDir) Archivos = Directory.GetFiles(sNombreDir) For Each Archivo In Archivos Console.WriteLine(Archivo) Next oDirInfo = New DirectoryInfo(sNombreDir) oDirInfo.CreateSubdirectory("bak") Else Directory.CreateDirectory(sNombreDir) Console.WriteLine("No existía el directorio, se acaba de crear") End If Para obtener el directorio actual de ejecución, disponemos del método GetCurrentDirectory( ), mientras que si queremos subir al directorio de nivel superior, tenemos el método GetParent( ), que devuelve un tipo DirectoryInfo, con el que podemos, por ejemplo, mostrar su nombre completo mediante la propiedad FullName, y fecha de creación con CreationTime. Dim sNombreDir As String Dim oDirInfo As DirectoryInfo ' obtenemos el directorio actual de ejecución sNombreDir = Directory.GetCurrentDirectory() Console.WriteLine("Directorio actual: {0}", sNombreDir) ' obtenemos el directorio padre del actual, ' y mostramos información de dicha directorio oDirInfo = Directory.GetParent(sNombreDir) Console.WriteLine("Directorio padre y fecha de creación {0}{1}{2}{3}", _ ControlChars.CrLf, oDirInfo.FullName, _ ControlChars.CrLf, oDirInfo.CreationTime) En el siguiente ejemplo, el método GetDirectories( ) devuelve un array de cadenas, con los nombres de los subdirectorios que se encuentran dentro del directorio pasado como parámetro a este método. A continuación, mediante el método Move( ), cambiamos de lugar un directorio; con Delete( ) borramos otro de los directorios. Observe el lector, cómo utilizando de forma combinada CType( ), Directory.GetFiles( ), y un elemento del array que contiene la lista de directorios, creamos una expresión que nos permite averiguar, si en un determinado directorio hay o no archivos. Dim sNombreDir As String Dim oDirInfo As DirectoryInfo Dim sDirectorios() As String Dim sDirectorio As String Console.WriteLine("Introducir un nombre de directorio") sNombreDir = Console.ReadLine() ' obtener directorios del directorio especificado sDirectorios = Directory.GetDirectories(sNombreDir) ' comprobar que el directorio contiene a su vez ' varios directorios; en caso negativo, finalizar If Not (sDirectorios.Length > 1) Then Console.WriteLine("El directorio especificado debe contener al menos dos subdirectorios") Console.ReadLine() Exit Sub End If ' mostrar nombres de directorios For Each sDirectorio In sDirectorios Console.WriteLine(sDirectorio) Next ' mover uno de los directorios a otra ubicación del disco actual Directory.Move(sDirectorios(0), "\temp\BIS") ' borrar otro de los directorios; ' el directorio a borrar debe estar vacío; ' comprobar con la siguiente expresión si dicho ' directorio contiene o no archivos If (CType(Directory.GetFiles(sDirectorios(1)), String()).Length() > 0) Then Console.WriteLine("No se puede borrar el directorio: {0} - " & _ "contiene archivos", sDirectorios(1)) Else Directory.Delete(sDirectorios(1)) End If Console.WriteLine("Completado") Console.ReadLine() La clase Path Esta clase nos proporciona un conjunto de campos y métodos compartidos, para la obtención de información y manipulación de rutas de archivos. El Código muestra un ejemplo en el que, una vez introducido un directorio, se muestra la información de cada uno de sus archivos, en lo que respecta a los métodos de esta clase. Console.WriteLine("Introducir nombre de directorio") Dim sDirectorio As String sDirectorio = Console.ReadLine() Dim sArchivos() As String sArchivos = Directory.GetFiles(sDirectorio) Console.WriteLine("Datos sobre archivos obtenidos del objeto Path") Console.WriteLine("==============================================") Dim sArchivo As String For Each sArchivo In sArchivos Console.WriteLine("GetDirectoryName() {0}", Path.GetDirectoryName(sArchivo)) Console.WriteLine("GetExtension() {0}", Path.GetExtension(sArchivo)) Console.WriteLine("GetFileName() {0}", Path.GetFileName(sArchivo)) Console.WriteLine("GetFileNameWithoutExtension() {0}", Path.GetFileNameWithoutExtension(sArchivo)) Console.WriteLine("GetFullPath() {0}", Path.GetFullPath(sArchivo)) Console.WriteLine() Next Console.ReadLine() Monitorización del sistema de archivos con FileSystemWatcher Esta clase contiene los mecanismos necesarios, que nos van a permitir la creación de objetos que actúen como observadores de los sucesos que ocurran en el sistema de archivos de un equipo local o remoto en cuanto a la creación, borrado, modificación, etc., de archivos y directorios. La creación de este proceso de vigilancia podemos dividirla en dos partes: instanciación y configuración del propio objeto FileSystemWatcher; y la escritura de los procedimientos manipuladores de los diversos eventos que pueden ocurrir sobre los archivos y directorios. Para facilitar la escritura de los manipuladores de evento, podemos declarar una variable de esta clase a nivel de módulo, con la palabra clave WithEvents. Module Module1 Private WithEvents oFSW As FileSystemWatcher Sub Main() '.... '.... Declarado el objeto FileSystemWatcher, lo instanciaremos y asignaremos valor a las propiedades mencionadas a continuación, que nos permitirán configurar el modo de observación que realizará este objeto sobre los archivos. • Path. Tipo String. Contiene la ruta de la unidad de disco sobre la que se efectuará la monitorización. • Filter. Tipo String. Contiene el tipo de fichero que se va a observar, admitiendo los caracteres comodín; por ejemplo: “*.*”, “*.txt”. • IncludeSubdirectories. Tipo Boolean. Establece si se van a monitorizar los subdirectorios de la ruta especificada en la propiedad Path. El valor True incluye los subdirectorio, mientras que False no los incluye. • EnableRaisingEvents. Tipo Boolean. Activa el proceso de observación sobre el sistema de archivos, teniendo en cuenta la configuración establecida en las demás propiedades mencionadas arriba. El valor True pone en marcha el mecanismo de observación, mientras que el valor False lo detiene. Sub Main() ' instanciar objeto FileSystemWatcher oFSW = New FileSystemWatcher() ' configurar objeto oFSW.Path = "C:\pruebas" oFSW.Filter = "*.txt" oFSW.IncludeSubdirectories = True ' activar oFSW.EnableRaisingEvents = True ' mientras que no pulsemos S, el objeto inspeccionará ' el sistema de archivos del equipo While (Console.ReadLine() <> "S") End While End Sub Para completar este proceso que estamos describiendo, sólo nos queda escribir los procedimientos que van a ejecutarse cuando se realice la creación, borrado, modificación, etc., de un archivo. Puesto que hemos declarado la variable FileSystemWatcher a nivel del módulo de código, seleccionaremos dicha variable en la lista desplegable Nombre de clase, del editor de código. Seguidamente, abriremos la lista Nombre de método, también del editor; seleccionando el evento a codificar. Las anteriores acciones, crearán el procedimiento de evento correspondiente, pero vacío, por lo que tendremos que escribir el código que queramos ejecutar en respuesta a tal evento. La lista de parámetros de este procedimiento consiste en un tipo Object, que contiene la referencia al objeto FileSystemWatcher que originó el evento; y un tipo FileSystemEventArgs, que contiene información adicional sobre el evento ocurrido, como el nombre y ruta del archivo. ' al crear un fichero se ejecutará este procedimiento de evento Public Sub oFSW_Created(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles oFSW.Created Console.WriteLine("Se ha creado un archivo : {0}", e.FullPath) End Sub ' al borrar un fichero se ejecutará este procedimiento de evento Public Sub oFSW_Deleted(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles oFSW.Deleted Console.WriteLine("Se ha producido el borrado: {0}", e.FullPath) End Sub Ajuste preciso de filtros para el monitor de archivos Si queremos realizar un filtro más puntual, por ejemplo, cuando hagamos cambios sobre los archivos a monitorizar, la clase FileSystemWatcher dispone de la propiedad NotifyFilter, que contiene una enumeración de tipo NotifyFilters, cuyos valores podemos combinar para que sólo se detecten los cambios al modificar el tamaño y/o la última escritura sobre un archivo. Establecer el procedimiento de evento con AddHandler Además de crear los procedimientos de evento de la forma descrita en apartados anteriores, podemos emplear una técnica más flexible, que nos permite conectar los eventos del objeto con sus manipuladores, utilizando la palabra clave AddHandler. Sub Main() ' instanciar objeto FileSystemWatcher Dim oFSW As New FileSystemWatcher() ' configurar objeto oFSW.Path = "C:\pruebas" oFSW.Filter = "*.txt" oFSW.IncludeSubdirectories = True ' conectamos manualmente los eventos del objeto ' con los procedimientos manipuladores de esos eventos AddHandler oFSW.Created, AddressOf oFSW_Created AddHandler oFSW.Changed, AddressOf CambioProducido ' activar oFSW.EnableRaisingEvents = True ' mientras que no pulsemos S, el objeto inspeccionará ' el sistema de archivos del equipo While (Console.ReadLine() <> "S") End While End Sub Public Sub oFSW_Created(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Console.WriteLine("Se ha creado un archivo: {0}", e.FullPath) End Sub Public Sub CambioProducido(ByVal emisor As Object, ByVal argumentos As FileSystemEventArgs) Console.WriteLine("Se ha cambiado el archivo: {0}", argumentos.FullPath) End Sub Observe el lector, que para el nombre del procedimiento manipulador de evento, podemos emplear tanto el formato que utiliza el editor de código, como otro nombre cualquiera. Para el evento de creación de archivo hemos utilizado el formato que usa también el editor, consistente en poner el nombre de objeto, guión bajo, y nombre de evento: oFSW_Created( ). Sin embargo para el evento de modificación de archivo hemos utilizado un nombre que no se ajusta en absoluto al formato del editor: CambioProducido( ). Consideraciones sobre la ruta de archivos El modo en que asignemos a la propiedad Path del objeto FileSystemWatcher, la cadena con la ruta a inspeccionar, influirá en el modo en que recuperemos la información del evento en el procedimiento manipulador correspondiente. Si asignamos a Path la ruta, sin especificar la unidad de disco, al intentar utilizar la propiedad FullName del objeto FileSystemEventArgs, en el procedimiento de evento, se producirá un error. Sub Main() '.... oFSW.Path = "\pruebas" '.... End Sub Public Sub oFSW_Created(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) ' al intentar utilizar la propiedad FullPath ocurrirá un error Console.WriteLine("Se ha creado un archivo: {0}", e.FullPath) End Sub Para que en el anterior ejemplo no se produzca un error, debemos indicar también la letra de unidad correspondiente al asignar la ruta a Path. oFSW.Path = "C:\pruebas" Detección con espera, de eventos producidos sobre archivos El método WaitForChanged( ) de la clase FileSystemWatcher, devuelve un objeto de tipo WaitForChangedResult, el cual efectúa una parada en la ejecución, quedando a la espera de que ocurra un determinado evento sobre el sistema de archivos. Una vez que dicho evento se produzca, se continuará la ejecución del programa. El tipo de evento que ponemos a la espera, lo definimos pasando como parámetro al método WaitForChanged( ), un valor de la enumeración WatcherChangeTypes. Dim oFSW As New FileSystemWatcher() '.... ' crear un objeto de espera para un evento Dim oWFCR As WaitForChangedResult oWFCR = oFSW.WaitForChanged(WatcherChangeTypes.Created) Console.WriteLine("Se ha creado el archivo: {0}", oWFCR.Name) '.... Manipulación de archivos mediante funciones específicas de Visual Basic Como comentábamos al comienzo de este tema, en anteriores versiones de VB, el programador tenía a su disposición un grupo de instrucciones como Open, Input, Write, etc., para la lectura y escritura de información en archivos. Por cuestiones de compatibilidad y migración de aplicaciones existentes, estas instrucciones han sido transformadas en funciones, para facilitar su manejo. Funciones como FileOpen( ), para abrir un archivo; FileClose( ), para cerrarlo; LineInput( ), para leer una línea de texto de un archivo, etc, son las que permiten en la actual versión del lenguaje, realizar las operaciones que anteriormente efectuábamos mediante sus correspondientes instrucciones. El Código fuente muestra un pequeño ejemplo, en el que se abre un fichero de texto y se lee su contenido utilizando algunas de estas funciones. Dim iNumArchivo As Integer ' obtener número de manipulador de archivo libre iNumArchivo = FreeFile() ' abrir archivo para lectura FileOpen(iNumArchivo, "\cubo\notas.txt", OpenMode.Input) Dim sLinea As String ' recorrer archivo hasta el final While Not EOF(iNumArchivo) ' leer una línea del archivo sLinea = LineInput(iNumArchivo) Console.WriteLine(sLinea) End While ' cerrar el archivo FileClose(iNumArchivo) Console.ReadLine() A pesar de que estas funciones nos permiten la manipulación de ficheros, debemos tener muy presente que se trata de elementos fundamentalmente proporcionados para compatibilidad con versiones anteriores, por lo que se recomienda que cuando tengamos que hacer cualquier tipo de operación con archivos en cuanto a su lectura, escritura, manipulación, etc., utilicemos las clases del espacio de nombres IO.Formularios 10-Programación orientada a objetos 13-Informes e impresión en aplicaciones Windows Form |