Mostrando entradas con la etiqueta VB.NET. Mostrar todas las entradas
Mostrando entradas con la etiqueta VB.NET. Mostrar todas las entradas

sábado, 17 de septiembre de 2022

Archivos externos de recursos resx en .NET

Para no tener que recompilar un proyecto cuando cambian ciertas condiciones (rutas, ubicaciones, etc) conviene almacenar algunas variables en un archivo externo de recursos .resx donde podremos modificar manualmente dichas variables sin tener que recompilar de nuevo el proyecto.

1ª Opción

En nuestro proyecto, elegimos proyecto -> propiedades

 

Archivos externos de recursos resx en .NET

Vamos a la última pestaña de recursos y pulsamos sobre “Este proyecto no contiene un archivo de recursos predeterminado….”

 

Este proyecto no contiene un archivo de recursos predeterminado

Esta acción, nos abre una pantalla de recursos donde podemos introducir la declaración de variables y sus valores correspondientes

 

declaración de variables y sus valores correspondientes

Hecho esto, no es necesario que declaremos dichas variables en el código, podemos referirnos a ellas desde nuestro código tecleando My.Resources.[Nombre_Variable]

Estas definiciones se encuentran en la carpeta My Project del explorador de soluciones

 

carpeta My Project del explorador de soluciones

Podemos ir al directorio de nuestro proyecto y en la carpeta My Project encontraremos un archivo llamado Resources.resx donde se encuentran definidas nuestras variables, podemos modificar sus valore directamente en el archivo abriéndolo con un editor, por ejemplo notepad++


notepad++


Y al final del archivo aparecen nuestras definiciones donde podemos cambiar los valores sin necesidad de recompilar el proyecto

 

definiciones donde podemos cambiar los valores

En este ejemplo hemos utilizado rutas, pero si no escribimos bien la ruta puede dar error, porque en realidad leerá C:\Ruta_Aplicacion\C:\PRUEBAS Hay que estar atentos a ver que parte de la ruta ponemos, podemos poner por ejemplo en vez de C:\PRUEBAS poner sólo pruebas, y el programa lo añadirá a la ruta de la aplicación, pero si queremos una ruta diferente de la aplicación podemos utilizar la segunda opción.

2ª Opción

Otra solución consiste en añadir un archivo de configuración app.config o settings. En el explorador de soluciones con el botón derecho del ratón pulsamos Agregar -> Nuevo elemento

app.config o settings


Sobre la pestaña General de Elementos comunes, elegimos Archivo de configuración 


Pestaña General de Elementos comunes

Ahora nos sale una pantalla donde podemos elegir el nombre de la variable y su valor

 

Archivo de configuración

Si el código creado automáticamente no funciona, podemos editarlo manualmente y dejarlo de este modo:

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

     <configSections>

          <sectionGroup name="applicationSettings"

                      type="System.Configuration.ApplicationSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >

 

                <section name="Nombre_de_tu_Proyecto.Properties.Settings"

                     type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"

                     requirePermission="false" />

 

          </sectionGroup>

     </configSections>

   

     <appSettings>

          <!--Directorio de entrada de los ficheros-->

          <add key="dirEntrada" value="C:\Pruebas" />

          <!--Directorio de salida para el fichero una vez unido-->

          <add key="dirSalida" value="C:\Pruebas\Out" />

          <!--Directorio donde se deja la copia del original-->

          <add key="dirCopiaOriginal" value="C:\Pruebas\Original" />

          <add key="dirTemporal" value="C:\Pruebas\TEMPORAL" />

          <!--Posicion final e inicial de coincidencia de archivos-->

          <add key="posInicial" value= "1" />

          <add key="posFinal" value= "1" />

     </appSettings>

</configuration>


Luego en el código le llamamos así a las variables definidas.

Dim dirEntrada As String = ConfigurationManager.AppSettings("dirEntrada").ToString()

Para que el código nos reconozca las instrucciones de llamada a ConfigurationManage, es importante importar antes la librería System.Configuration

Imports System.Configuration

Si aun así no funciona, es posible que tengamos que instalar el paquete System.Configuration desde nuget, para ello sobre el error pulsamos en Mostrar posibles correcciones del error.

Mostrar posibles correcciones del error.


Esto nos despliega un combo con las diferentes opciones, elegimos Instalar Paquete “System.ConfigurationManager” -> Buscar e instalar la última versión

 

Instalar Paquete “System.ConfigurationManager” -> Buscar e instalar la última versión

Ahora ya podemos editar el archivo app.config o settings para cambiar los valores de las variables definidas, sin necesidad de recompilar el proyecto cada vez.


sábado, 29 de mayo de 2021

Crear un archivo de log para una aplicación de VB.net

En este post vamos a ver como crear un archivo de Log para una aplicación vb.net que vaya escribiendo cualquier cosa que deseemos en un archivo de texto en la ubicación que queramos.

Primero definimos una variable del tipo streamwriter

Dim swLog As System.IO.StreamWriter

 

Crear un archivo de log para una aplicación de VB.net


En nuestro programa, cada vez que queramos escribir algo en el log lo llamamos así: 

 EscribirLog("-------------ERROR----------------------------")

            EscribirLog("Se ha producido un error: " & ex.Message & Now())

            EscribirLog(strVariable_con_la_información_a_mostrar & " Texto fijo - " & Now())

            EscribirLog("-----------------------------------------")

 

Finalmente las definiciones de para crear el log son estas. Al comienzo del programa llamaremos a AbrirLog, cuando queramos escribir llamamos a EscribirLog y cuando finalice el programa lo cerramos con CerrarLog.

Sub AbrirLog()

Dim strMisDocumentos As String

strMisDocumentos = System.Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)

     If Not System.IO.Directory.Exists(strMisDocumentos & "\" & "Logs") Then

            System.IO.Directory.CreateDirectory(strMisDocumentos & "\" & "Logs")

        End If

 

        swLog = New System.IO.StreamWriter(strMisDocumentos & "\Logs\" & Now.ToString("yyyyMMddHHmmss") & ".txt")

        EscribirLog("Usuario: " & Environment.UserName & "  Maquina: " & Environment.MachineName)

        EscribirLog("")

        EscribirLog("-----------------------")

        EscribirLog("  COMIENZO PROCESO")

        EscribirLog("-----------------------")

        EscribirLog("")

        EscribirLog(Now.ToString("dd/MM/yyyy HH:mm:ss") & " - Inicio del proceso")

End Sub

Sub CerrarLog()

        EscribirLog(Now.ToString("dd/MM/yyyy HH:mm:ss") & " - Fin del proceso")

        EscribirLog("")

        EscribirLog("------------------------------------")

        EscribirLog("FIN PROCESO")

        EscribirLog("-------------------------------------")

        EscribirLog("")

        If Not swLog Is Nothing Then

            swLog.Close()

        End If

        swLog = Nothing

End Sub

 

Sub EscribirLog(ByVal texto As String)

        If Not swLog Is Nothing Then

            swLog.WriteLine(texto)

            swLog.Flush()

            Console.WriteLine(texto)

        End If

 End Sub

 

sábado, 28 de diciembre de 2019

Serializar un archivo JSON

Comprendiendo la serialización

La serialización es el proceso de transformar un objeto en una forma que pueda persistir para ser almacenado  o transferido de un dominio de aplicación a otro. Al transformar el objeto, se serializa el objeto; cuando se lee de nuevo, se deserializa el objeto. Se puede serializar un objeto hacia un disco, una secuencia de memoria o hacia  una red. Dos formatos comunes para pasar  objetos entre sistemas son XML y JSON. 

Los objetos son serializados en XML o JSON antes de ser transferidos al cliente. El Framework de.NET tiene clases que admiten binarios, XML y JSON, e incluso podemos crear nuestra propia serialización personalizada.

Serializar un archivo JSON
Más fotos de este estilo.

sábado, 10 de mayo de 2014

Visión general de la programación orientada a objetos. (Con Visual Basic .NET)

Pongo a continuación un resumen de los atributos principales del lenguaje Visual Basic .NET así como de  su utilización en programación orientada a Objetos. Este artículo contiene los siguientes puntos:

Definiciones Generales:


Constantes.

Variables static.

Namespaces.

Punto de entrada al programa.

Clases.

Reglas de ámbito de las clases.

Código de clase y código de cliente.

Propiedades de la clase. (Encapsulación).

Propiedades virtuales.

Propiedades de sólo lectura o sólo escritura.

Me y MyClass.

Sobrecarga de Métodos. (Polimorfismo)

Enlaces (Binding) de variables a referencias de objetos.

Herencia.

Reglas de ámbito.

Herencia y sobrecarga de métodos.

MyBase.

Herencia y sobreescritura de métodos.

Herencia y métodos constructores.

Clases selladas no heredables.

Clases abstractas o no instanciables.

Comprobación del tipo de un objeto y Moldeado (Casting).

Miembros compartidos (Shared) de una clase.

Destrucción de Objetos y recolección de basura.

Interfaces.

Estructuras.


Enumeraciones.


Programación orientada a objetos con Visual Basic.NET


lunes, 8 de julio de 2013

Visual Basic .NET: Crear campos y propiedades


En este articulo aprenderemos a programar en VB.NET una clase con campos y propiedades, también aprenderemos a:

Crear una propiedad de sólo lectura.

Crear una propiedad que toma un parámetro.

Usar un array de instancias de clase como fuente de un control DataGrid.

Las propiedades contienen las características de los objetos a los que pertenecen. Por ejemplo la clase coche tiene la propiedad color para indicar el color del coche. O una caja de texto tiene las propiedades alto y ancho que especifica sus dimensiones en la pantalla.

Existe también una interacción entre las propiedades de una clase y el comportamiento del objeto. Al mover una caja de texto (un comportamiento) cambia su ubicación (una propiedad). Veremos este modelo en varias ocasiones en el diseño orientado a objetos.