Archivo de la etiqueta: Visual Basic

Cuidadín con los For Each si se modifica el objeto del bucle

Pues eso… aunque esto ya es algo viejo, y se supone que sabido, el otro día no lo recordé y revisando el código de un procedimiento que, a pesar de tratar con muchos registros de una base de datos de SQL Server, veía que tardaba demasiado… y mientras estaba trabajando el método me entretuve en ver la ventana esa de diagnóstico en la que te muestra todo lo que iba haciendo el código (ver la figura 1), y me percaté que repetía fechas…

Ventana de las herramientas de diagnóstico de Visual Studio
Figura 1. La ventana de las Herramientas de diagnósticos de Visual Studio.

Al principio no caí en porqué lo hacía, así que… me puse a revisar el código con las llamadas a las actualizaciones a la base de datos… y al cabo de un rato caí en que estaba usando un bucle For Each y que la variable de ese bucle era un objeto de la clase que se encarga de actualizar los datos (e incluso de crearlos si no existen en la base de datos) y… ¡se me encendió la bombillita esa Light bulb de… idea!

Fue cambiarlo a un bucle normal y tardar muchísimo menos Eye rolling smile, creo que una de las veces me llegó a tardar más de media hora y al hacer el cambio se quedó en 4 minutos o menos.
Y el cambio que hice fue, por ejemplo (en VB), de este:

For Each p In Productos

a este otro:

For i = 0 To Productos.Count - 1
Dim p = Productos(i)

Nota:
El problema de los bucles for each no es solo de Visual Basic, también lo es de C# aunque se escriba de otra forma.

Y lo cuento aquí para que cuando busque «problemas» me de la solución.

Es que, por si no lo sabes, cuando no recuerdo cómo hacer algo en VB o C#, busco en Google, pero le añado al final elguille para que salgan los resultados que tengo publicados y, salvo excepciones, encuentro siempre lo que busco Flirt male, así que… ya sabes… Winking smile

Nos vemos.
Guillermo

Problemas con IntelliSense en VS2019 con el editor de VB

Pues eso… que te quería seguir contando las cosas buenas de Visual Studio 2019, pero… hay que decirlo todo, y lo malo es que en la fecha en que te cuento esto, no creo que lo vayan a solucionar en la versión final que estará el próximo martes día 2 de abril. Sad smile

Te cuento lo que me pasa y voy a usar el texto con el bug que he publicado hoy en la comunidad de desarrolladores de Visual Studio (Developer Community). Te dejo el enlace por si te parece la votes a ver si así le hacen más caso (siempre hacen caso a las cosas que cuento por ahí, pero… algunas no las solucionan rápidamente… será porque es Visual Basic… y ya sabes que algunos nos consideran desarrolladores de clase B… Angry smile

Nota del 05/Abr/19

Pues resulta que esto mismo ocurre en C# pero en casos concretos (Completion gets in the way attempting to line up arguments) y por tanto han cerrado la incidencia por estar duplicada, y según cuentan ya está solucionado en VS 16.1 Preview 2.

Aquí va el texto y las capturas (más abajo está la traducción al inglés):

 

Problemas con IntelliSense en VS2019 y VB

Con Visual Studio 2019 (RC.4) da muchísimos problemas con IntelliSense y Visual Basic (con C# no ocurre lo mismo).

Comento dos de los que me suelen ocurrir habitualmente (tanto que estoy pensando dejar de usar el VS2019 al menos para los proyectos de VB) es un verdadero «desastre» hacer ciertas cosas… más o menos habituales.

Por ejemplo:
En las declaraciones de los métodos de evento me gusta poner los parámetros del método en líneas separadas (para que se vean mejor los controles que utilizan ese método) y lo que suelo hacer es poner el cursor antes del segundo parámetro (después de la coma) para pulsar la tecla ENTER, cuando lo hago y se cambia de línea se muestra la ventana de IntelliSense (ver la captura de figura 1), si a continuación pulso la tecla TAB para agrandar la indentación, el editor añade la definición de la ventana de IntelliSense (ver la captura de la figura 2) en la que se ve que añade ByRef.

Figura 1.
Figura 2.

Lo mismo ocurre cuando me pongo al principio de una línea con código y pulso ENTER para escribir en la línea anterior, IntelliSense muestra en el principio de la línea el método que estoy usando en ese control (ver la captura de la figura 3), nuevamente si pulso TAB (que en este caso no es la acción que yo querría hacer, pero para demostrar el mismo fallo) se añade erróneamente lo que haya seleccionado en la ventana emergente de IntelliSense (ver captura de la figura 4) y si no pulso la tecla TAB y quiero mover el cursor a la línea anterior (la que se ha creado al pulsar ENTER) tengo que pulsar la tecla ESC para que quite la ventana de IntelliSense.

Figura 3.
Figura 4.

Y como comento al principio esta es una acción muy, muy habitual… y es «frustrante» escribir código de esta manera…

Ese último error (pulsar INTRO al principio de una línea con código) también ocurre con los comentarios, y en el ejemplo que he hecho (un comentario encima de una asignación a la propiedad TEXT de un Label), al pulsar la tecla ENTER la ventana de IntelliSense muestra la misma propiedad que la indicada en la figura 4 tal como se puede ver en la captura de la figura 5.

Figura 5.

 

Esto con Visual Studio 2017 no ocurre.

En C# he probado los dos ejemplos que acabo de comentar y no ocurre así.

Realmente es algo que deberían solucionar, ya que si el producto final que saldrá al mercado el próximo 2 de abril tiene este tipo de BUG,, sería lamentable.

Gracias.
Guillermo

 

A ver si lo solucionan rápido… que es un rollo que ocurra eso…

 

Nos vemos.

Guillermo

 

Y como también se lo traducido al inglés (eso lo suelen hacer ellos, pero… para adelantar tiempo. Winking smile

 

Problems with IntelliSense in VS2019 and VB

With Visual Studio 2019 (RC.4) it gives many problems with IntelliSense and Visual Basic (with C# the same thing does not happen).

I mention two of those that usually happen to me habitually (so much so that I’m thinking about stopping using VS2019 at least for VB projects) it’s a real «disaster» to do certain things … more or less usual.

For example:
In the declarations of the methods of event I like to put the parameters of the method in separate lines (so that the controls that use that method are seen better) and what I usually do is put the cursor before of the second parameter (after the comma) to press the ENTER key, when I do it and the line is changed the IntelliSense window is displayed (see the capture in Figura 1), if I then press the TAB key to enlarge the indentation, the editor adds the definition of the IntelliSense window (see the capture in Figura 2) in which it is seen that it adds ByRef.

The same thing happens when I put myself at the beginning of a line with code and pulse ENTER to write on the previous line, IntelliSense shows at the beginning of the line the method I am using in that control (see the capture in Figura 3), again if I press TAB (which in this case is not the action that I would like to do, but to show the same fault) it is wrongly added what you have selected in the IntelliSense pop-up window (see the capture in Figura 4) and if not I press the TAB key and I want to move the cursor to the previous line (the one that was created when pressing ENTER) I have to press the ESC key to remove the IntelliSense window.

And as I said at the beginning this is a very, very usual action … and it is «frustrating» to write code in this way …

That last error (press ENTER at the beginning of a line with code) also occurs with the comments, and in the example that I have made (a comment above an assignment to the TEXT property of a Label), by pressing the ENTER key the window of IntelliSense shows the same property as that indicated in the capture: Figure 4 as it can be seen in the capture of Figura 5.

 

This with Visual Studio 2017 does not happen.

In C # I have tried the two examples that I just commented and it does not happen that way.

It really is something that should be solved, because if the final product that will be released on April 2 has this type of BUG, it would be unfortunate.

Thank you.
Guillermo

Novedades (algunas) del IDE de Visual Studio 2019

Pues eso… a falta de una semana para que Microsoft libere la versión final de Visual Studio 2019 (el martes 2 de abril para ser concreto) te voy a explicar un par de cosillas que creo que debes saber para que no te pase lo que a mí… Winking smile

 

Lo primero, es lo primero… evitarte quebraderos de cabeza

Así que… y como te digo en el encabezado, si quieres evitarte quebraderos de cabeza nada más empezar con esta monería de Visual Studio (porque ha mejorado mucho con respecto al Visual Studio 2017), debes quitar una de las nuevas opciones que tiene esta versión.

Al menos si usas el VS2019 en un monitor grande (o de los que tienen mucha densidad de píxeles) lo primero que deberías hacer es ir al menú Herramientas (Tools), seleccionar Opciones (Options) y en la ventana que te muestra, en Entorno>General (Environmet>General) (ver la figura 1) quitar la marca de Optimizar la representación de las pantallas con densidades de píxeles distintas (Optimize rendering for screens with different pixel densities).

Una nueva opción de VS2019 que puede darte problemas... a mí me las ha dado...
Figura 1. Una nueva opción de VS2019 que puede darte problemas… a mí me las ha dado…

¿Por qué he quitado esa opción?

Te explico.

Yo uso el portátil (laptop) como equipo de desarrollo con un monitor grande con una resolución de 3840×2160 y ahí es donde uso el Visual Studio 2019 (y el VS2017) y al menos con la versión RC.3 (y también con la RC.4) me da problemas como ni siquiera poder cambiar el tamaño de los formularios y/o controles. Aparte que al mostrar las opciones del proyecto, la ventana se mostraba muy mal o cuando el cursor del ratón estaba sobre un texto y se muestra IntelliSense no dejaba escribir salvo que ocultaras la ventana emergente (de IntelliSense)… y más cosas de las que ahora mismo no me acuerdo, pero cuando me vengan a la memoria te las contaré…

Nota:

A ver… lo mismo tú no tienes los problemas que yo he tenido, solo te lo explico por si te pasan cosas raras cuando empieces a usar Visual Studio 2019.

El que avisa…

 

El coloreado del código de VB y C# ha cambiado

Esa es otra novedad con respecto a Visual Studio 2017 que nos puede facilitar la lectura del código (si quieres).

La figura 2 es una captura de Visual Studio 2017 con un código de Visual Basic. Este coloreado seguro que ya lo conoces.

El coloreado (clásico) de Visual Studio 2017
Figura 2. El coloreado (clásico) de Visual Studio 2017

En la figura 3 tienes la nueva versión del coloreado que trae Visual Studio 2019.

El coloreado (mejorado) de Visual Studio 2019
Figura 3. El coloreado (mejorado) de Visual Studio 2019

Pregunta: ¿No te gusta el nuevo coloreado de Visual Studio 2019?

Respuesta: Sí, me gusta, pero no me lo muestra así; lo veo como en la figura 2.

Esa característica la puedes cambiar en las opciones de configuración, concretamente en las opciones del editor de texto, ya sabes: Herramientas>Opciones y en la ventana de opciones selecciona Editor de Texto (Text Editor) y después Basic o C# (esta opción solo está disponible para esos dos lenguajes). A continuación marca la opción Usar colores mejorados para C# y Basic (Use enhanced colors for C# and VB) tal como puedes ver en la figura 4.

El coloreado mejorado del código se puede cambiar para usar el de las versiones anteriores
Figura 4. El coloreado mejorado del código se puede cambiar para usar el de las versiones anteriores

Nota:

Si te fijas en la figura 4, también hay opciones para colorear las expresiones regulares y otras mejoras.

 

Nueva pantalla de inicio de Visual Studio 2019

Para finalizar esta introducción a las mejoras (o cambios) del IDE de Visual Studio 2019 vamos a lo primero que nos mostrará Visual Studio al empezar: La pantalla de inicio.

La pantalla de inicio de Visual Studio 2019
Figura 5. La pantalla de inicio de Visual Studio 2019

Tal como puedes ver en la figura 5 la pantalla de inicio de VS 2019 ha cambiado, si no quieres cargar ningún proyecto, ni crear uno nuevo, puedes pulsar en el enlace mostrado en la parte inferior derecha: Continuar sin código (Continue without code).

Los proyectos mostrados están sincronizados con los que ya tuvieras en la ventana de inicio de Visual Studio 2017, incluso siguen sincronizados en los dos entornos, respetando también los que están anclados.

Lo único que no me gusta es la forma de crear nuevos proyectos, de eso te hablaré en otra ocasión. Además de que hecho en falta las noticias, que seguramente estarán en otra parte, pero por ahora no he dado con ellas, aparte de ir a el blog de los desarrolladores de Visual Studio.

 

Espero que te haya sido de utilidad. Esa es la idea (que no IDE) Winking smile

 

Nos vemos.
Guillermo

P.S.

Aquí te dejo unos enlaces, dos de ellos sobre lo primero que te he contado y que la gente de Visual Studio lo llama: Representación con reconocimiento del monitor (Per-monitor aware (PMA) rendering).

Si prefieres ver los artículos en inglés, al menos los publicados en docs.microsoft.com, puedes cambiar /es-es/ por /en-us/ (o viceversa) en la barra de direcciones.

Normalmente las traducciones al español son generadas automáticamente, pero mucho mejores que si las traduces con algunas herramientas de traducción, incluso la que incorpora Edge que se supone que es la misma que usa Microsoft en su sitio.

VarChar y NVarChar en SQL Server y MySQL el código para VB y C#

Pues eso… lo prometido es deuda y aquí tienes el código que te prometí del ejemplo correspondiente al post anterior (VarChar y NVarChar en SQL Server) para VB y C#.

Este código te permite comprobar que usando VARCHAR también puedes agregar caracteres especiales del idioma español: vocales acentuadas, eñes, etc.

En este ejemplo también uso dos bases de datos (en realidad 3), una de SQL Server y otra de MySQL en un servidor que está en la nube (en un hosting de Internet, concretamente en uno de Domitienda.com que es donde yo tengo mis sitios alojados). La tercera base es una de SLQ Server en mi servidor local (el de SQLEXPRESS).

El diseño del formulario y el código de VB y C#

Este es el formulario en modo de diseño (figura 1):

Figura 1. El formulario en modo de diseño.
Figura 1. El formulario en modo de diseño.

Nota:

En el código tienes la cadena de conexión para las bases de datos que están en «la web» y es posible que dejen de estar disponibles dentro de algún tiempo (no sé si una semana, un mes, un año o un día), así que… si quieres probarlo, usa cuanto antes el código del ZIP que te pondré al final o crea un proyecto a partir de lo que aquí te muestro.

El proyecto está creado con Visual Studio 2019 Preview 4.3 pero debería cargar también en Visual Studio 2017 y utiliza el .NET Framework 4.7.2.

El código para Visual Basic .NET

'------------------------------------------------------------------------------
' Prueba de los tipos de SQL VarChar y NVarChar                     (19/Mar/19)
' Usando base de SQL Server y MySQL
'
'
' (c) Guillermo (elGuille) Som, 2019
'------------------------------------------------------------------------------
Option Strict On
Option Infer On

Imports System.Data
Imports System.Data.SqlClient
' Versión de mysql.data.dll: Connector/Net 6.0.3.0
Imports MySql.Data.MySqlClient

Imports System.Linq


Public Class Form1

    Private inicializando As Boolean = True

    ''' <summary>
    ''' Para las primeras pruebas uso una base local
    ''' </summary>
    Private UsarBaseLocal As Boolean = True

    Private ServerName As String = ".\SQLEXPRESS"
    Private DatabaseName As String = "PruebaVarChar"
    Private UsuarioDB As String = "elGuille_info"
    Private PasswordDB As String = "VarChar_19"

    Private Tabla As String = "VarCharElGuille"
    ' Campos: Fecha, ConVarChar varchar(50), ConNVarChar nvarchar(50)
    ' en MySQL no hay NVARCHAR y uso TEXT(50)

    Private MaxFilas As Integer = 5

    ''' <summary>
    ''' La cadena de conexión a la base de datos
    ''' </summary>
    Private Function CadenaConexionSQL() As String
        ConectarSQL()

        Dim csb As New SqlConnectionStringBuilder

        csb.DataSource = ServerName
        csb.InitialCatalog = DatabaseName
        csb.UserID = UsuarioDB & "SQL"
        csb.Password = PasswordDB
        csb.IntegratedSecurity = False

        Return csb.ConnectionString
    End Function

    ''' <summary>
    ''' La cadena de conexión a la base de datos
    ''' </summary>
    Private Function CadenaConexionMySQL() As String
        If UsarBaseLocal Then Return "No hay base local de MySQL"

        ConectarMySQL()

        Dim csb As New MySqlConnectionStringBuilder

        csb.Server = ServerName
        csb.Database = DatabaseName
        csb.UserID = UsuarioDB & "My"
        csb.Password = PasswordDB

        Return csb.ConnectionString
    End Function


    ''' <summary>
    ''' Conectar a la base de datos de SQL Server
    ''' </summary>
    Private Sub ConectarSQL()
        If UsarBaseLocal Then
            ServerName = ".\SQLEXPRESS"
        Else
            ServerName = "sql3.servidoreswindows.net"
        End If
    End Sub

    ''' <summary>
    ''' Conectar a la base de datos de MySQL.
    ''' Siempre en remoto.
    ''' </summary>
    Private Sub ConectarMySQL()
        ServerName = "mysql1.servidoreswindows.net"
    End Sub


    ''' <summary>
    ''' Añadir el dato a la base de SQL Server
    ''' </summary>
    Private Function AñadirSQL() As String
        Dim sCon As String = CadenaConexionSQL()
        Dim sel = $"INSERT INTO {Tabla} (Fecha, ConVarChar, ConNVarChar) " &
                  $"VALUES('{DateTime.Now}', '{txtDato.Text}', '{txtDato.Text}')"

        Using con As New SqlConnection(sCon)
            Dim cmd As New SqlCommand(sel, con)

            Try
                con.Open()
                cmd.ExecuteNonQuery()
                con.Close()

                Return ""
            Catch ex As Exception
                Return $"ERROR: {ex.Message}"
            End Try
        End Using
    End Function

    ''' <summary>
    ''' Añadir el dato a la base de datos de MySQL
    ''' </summary>
    Private Function AñadirMySQL() As String
        If UsarBaseLocal Then Return "No hay base local de MySQL"

        Dim sCon = CadenaConexionMySQL()
        ' En MySQL he definido Fecha como varchar(20)
        Dim sel = $"INSERT INTO {Tabla} (Fecha, ConVarChar, ConNVarChar) " &
                  $"VALUES('{DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")}', '{txtDato.Text}', '{txtDato.Text}')"

        Using con As New MySqlConnection(sCon)
            Dim cmd As New MySqlCommand(sel, con)

            Try
                con.Open()
                cmd.ExecuteNonQuery()
                con.Close()

                Return ""
            Catch ex As Exception
                Return $"ERROR: {ex.Message}"
            End Try
        End Using
    End Function

    ''' <summary>
    ''' Mostrar los datos de la base de SQLServer
    ''' </summary>
    Private Function MostrarDatosSQL(ByRef dt As DataTable) As String
        Dim orden = If(chkOrden.Checked, "DESC", "ASC")
        Dim sel = $"SELECT TOP ({MaxFilas}) * FROM {Tabla} ORDER BY Fecha {orden}"

        Dim sCon = CadenaConexionSQL()
        Dim da As SqlDataAdapter
        dt = New DataTable

        Try
            ' Crear un nuevo objeto del tipo DataAdapter
            da = New SqlDataAdapter(sel, sCon)

            ' Llenar la tabla con los datos indicados
            da.Fill(dt)

            Return $"Recuperadas {dt.Rows.Count} filas."
        Catch ex As Exception
            Return $"ERROR: {ex.Message}"
        End Try

    End Function

    ''' <summary>
    ''' Mostrar los datos de MySQL
    ''' </summary>
    Private Function MostrarDatosMySQL(ByRef dt As DataTable) As String
        If UsarBaseLocal Then Return "No hay base local de MySQL"

        Dim orden = If(chkOrden.Checked, "DESC", "ASC")
        ' MySQL no tiene TOP, usar en su lugar LIMIT
        Dim sel = $"SELECT * FROM {Tabla} ORDER BY Fecha {orden} LIMIT {MaxFilas}"

        Dim sCon = CadenaConexionMySQL()
        Dim da As MySqlDataAdapter
        dt = New DataTable

        Try
            ' Crear un nuevo objeto del tipo DataAdapter
            da = New MySqlDataAdapter(sel, sCon)

            ' Llenar la tabla con los datos indicados
            da.Fill(dt)

            Return $"Recuperadas {dt.Rows.Count} filas."
        Catch ex As Exception
            Return $"ERROR: {ex.Message}"
        End Try

    End Function

    Private Sub btnAñadir_Click(sender As Object,
                                e As EventArgs) Handles btnAñadir.Click
        Dim msg = ""

        msg = AñadirSQL() & vbCrLf
        msg &= AñadirMySQL()

        LabelError.Text = msg

        btnRefrescar.PerformClick()
    End Sub

    Private Sub btnRefrescar_Click(sender As Object,
                                   e As EventArgs) Handles btnRefrescar.Click
        Dim dt As DataTable = Nothing
        Dim msg = ""
        lvDatos.Items.Clear()

        Dim i = 5
        Integer.TryParse(txtFilas.Text, i)
        MaxFilas = i

        msg = MostrarDatosSQL(dt) & vbCrLf
        asignarDatos("SQL", dt)

        Dim lvi = lvDatos.Items.Add("---")
        lvi.SubItems.Add("---")
        lvi.SubItems.Add("---")
        lvi.SubItems.Add("---")

        dt = Nothing
        msg &= MostrarDatosMySQL(dt)
        asignarDatos("MySQL", dt)

        LabelError.Text = msg
    End Sub

    Private Sub asignarDatos(base As String, dt As DataTable)
        If dt Is Nothing Then Return

        For Each r As DataRow In dt.Rows
            Dim lvi = lvDatos.Items.Add(base)
            lvi.SubItems.Add(r("Fecha").ToString)
            lvi.SubItems.Add(r("ConVarChar").ToString)
            lvi.SubItems.Add(r("ConNVarChar").ToString)
        Next

    End Sub

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        inicializando = False
    End Sub

    Private Sub ChkUsarBaseLocal_CheckedChanged(sender As Object, e As EventArgs) Handles chkUsarBaseLocal.CheckedChanged
        If inicializando Then Return

        UsarBaseLocal = chkUsarBaseLocal.Checked
    End Sub

End Class

El código para C#

//-----------------------------------------------------------------------------
// Prueba de los tipos de SQL VarChar y NVarChar                    (21/Mar/19)
// Usando base de SQL Server y MySQL
//
//
// (c) Guillermo (elGuille) Som, 2019
//-----------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

using System.Data.SqlClient;
// Versión de mysql.data.dll: Connector/Net 6.0.3.0
using MySql.Data.MySqlClient;

namespace VarChar_y_NVarChar_cs
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private bool inicializando = true;

        /// <summary>
        /// Para las primeras pruebas uso una base local
        /// </summary>
        private bool UsarBaseLocal = true;

        private string ServerName = @".\SQLEXPRESS";
        private string DatabaseName = "PruebaVarChar";
        private string UsuarioDB = "elGuille_info";
        private string PasswordDB = "VarChar_19";

        private string Tabla = "VarCharElGuille";
        // Campos: Fecha, ConVarChar varchar(50), ConNVarChar nvarchar(50)
        // en MySQL no hay NVARCHAR y uso TEXT(50)

        private int MaxFilas = 5;

        /// <summary>
        /// La cadena de conexión a la base de datos
        /// </summary>
        private string CadenaConexionSQL()
        {
            ConectarSQL();

            var csb = new SqlConnectionStringBuilder();

            csb.DataSource = ServerName;
            csb.InitialCatalog = DatabaseName;
            csb.UserID = UsuarioDB + "SQL";
            csb.Password = PasswordDB;
            csb.IntegratedSecurity = false;

            return csb.ConnectionString;
        }

        /// <summary>
        /// La cadena de conexión a la base de datos
        /// </summary>
        private string CadenaConexionMySQL()
        {
            if (UsarBaseLocal)
                return "No hay base local de MySQL";

            ConectarMySQL();

            var csb = new MySqlConnectionStringBuilder();

            csb.Server = ServerName;
            csb.Database = DatabaseName;
            csb.UserID = UsuarioDB + "My";
            csb.Password = PasswordDB;

            return csb.ConnectionString;
        }


        /// <summary>
        /// Conectar a la base de datos de SQL Server
        /// </summary>
        private void ConectarSQL()
        {
            if (UsarBaseLocal)
                ServerName = @".\SQLEXPRESS";
            else
                ServerName = "sql3.servidoreswindows.net";
        }

        /// <summary>
        /// Conectar a la base de datos de MySQL.
        /// Siempre en remoto.
        /// </summary>
        private void ConectarMySQL()
        {
            ServerName = "mysql1.servidoreswindows.net";
        }


        /// <summary>
        /// Añadir el dato a la base de SQL Server
        /// </summary>
        private string AñadirSQL()
        {
            string sCon = CadenaConexionSQL();
            var sel = $"INSERT INTO {Tabla} (Fecha, ConVarChar, ConNVarChar) " + 
                      $"VALUES('{DateTime.Now}', '{txtDato.Text}', '{txtDato.Text}')";

            using (var con = new SqlConnection(sCon))
            {
                var cmd = new SqlCommand(sel, con);

                try
                {
                    con.Open();
                    cmd.ExecuteNonQuery();
                    con.Close();

                    return "";
                }
                catch (Exception ex)
                {
                    return $"ERROR: {ex.Message}";
                }
            }
        }

        /// <summary>
        /// Añadir el dato a la base de datos de MySQL
        /// </summary>
        private string AñadirMySQL()
        {
            if (UsarBaseLocal)
                return "No hay base local de MySQL";

            var sCon = CadenaConexionMySQL();
            // En MySQL he definido Fecha como varchar(20)
            var sel = $"INSERT INTO {Tabla} (Fecha, ConVarChar, ConNVarChar) " + 
                      $"VALUES('{DateTime.Now.ToString("dd/MM/yyyy HH:mm:ss")}', '{txtDato.Text}', '{txtDato.Text}')";

            using (var con = new MySqlConnection(sCon))
            {
                var cmd = new MySqlCommand(sel, con);

                try
                {
                    con.Open();
                    cmd.ExecuteNonQuery();
                    con.Close();

                    return "";
                }
                catch (Exception ex)
                {
                    return $"ERROR: {ex.Message}";
                }
            }
        }

        /// <summary>
        /// Mostrar los datos de la base de SQLServer
        /// </summary>
        private string MostrarDatosSQL(ref DataTable dt)
        {
            var orden = chkOrden.Checked ? "DESC" : "ASC";
            var sel = $"SELECT TOP ({MaxFilas}) * FROM {Tabla} ORDER BY Fecha {orden}";

            var sCon = CadenaConexionSQL();
            SqlDataAdapter da;
            dt = new DataTable();

            try
            {
                // Crear un nuevo objeto del tipo DataAdapter
                da = new SqlDataAdapter(sel, sCon);

                // Llenar la tabla con los datos indicados
                da.Fill(dt);

                return $"Recuperadas {dt.Rows.Count} filas.";
            }
            catch (Exception ex)
            {
                return $"ERROR: {ex.Message}";
            }
        }

        /// <summary>
        /// Mostrar los datos de MySQL
        /// </summary>
        private string MostrarDatosMySQL(ref DataTable dt)
        {
            if (UsarBaseLocal)
                return "No hay base local de MySQL";

            var orden = chkOrden.Checked ? "DESC" : "ASC";
            // MySQL no tiene TOP, usar en su lugar LIMIT
            var sel = $"SELECT * FROM {Tabla} ORDER BY Fecha {orden} LIMIT {MaxFilas}";

            var sCon = CadenaConexionMySQL();
            MySqlDataAdapter da;
            dt = new DataTable();

            try
            {
                // Crear un nuevo objeto del tipo DataAdapter
                da = new MySqlDataAdapter(sel, sCon);

                // Llenar la tabla con los datos indicados
                da.Fill(dt);

                return $"Recuperadas {dt.Rows.Count} filas.";
            }
            catch (Exception ex)
            {
                return $"ERROR: {ex.Message}";
            }
        }

        private void BtnAñadir_Click(object sender, EventArgs e)
        {
            var msg = "";

            msg = AñadirSQL() + "\n";
            msg += AñadirMySQL();

            LabelError.Text = msg;

            btnRefrescar.PerformClick();
        }

        private void BtnRefrescar_Click(object sender, EventArgs e)
        {
            DataTable dt = null;
            var msg = "";
            lvDatos.Items.Clear();

            var i = 5;
            int.TryParse(txtFilas.Text, out i);
            MaxFilas = i;

            msg = MostrarDatosSQL(ref dt) + "\n";
            asignarDatos("SQL", dt);

            var lvi = lvDatos.Items.Add("---");
            lvi.SubItems.Add("---");
            lvi.SubItems.Add("---");
            lvi.SubItems.Add("---");

            dt = null;
            msg += MostrarDatosMySQL(ref dt);
            asignarDatos("MySQL", dt);

            LabelError.Text = msg;
        }

        private void asignarDatos(string @base, DataTable dt)
        {
            if (dt == null) return;

            foreach (DataRow r in dt.Rows)
            {
                var lvi = lvDatos.Items.Add(@base);
                lvi.SubItems.Add(r["Fecha"].ToString());
                lvi.SubItems.Add(r["ConVarChar"].ToString());
                lvi.SubItems.Add(r["ConNVarChar"].ToString());
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            inicializando = false;
        }

        private void ChkUsarBaseLocal_CheckedChanged(object sender, EventArgs e)
        {
            if (inicializando) return;

            UsarBaseLocal = chkUsarBaseLocal.Checked;
        }
    }
}

Y esto es todo… espero que te sea de utilidad.

Nos vemos.
Guillermo

El código completo del ejemplo
(solución para Visual Studio usando .NET 4.7.2)

El ZIP con el código completo (una solución de Visual Studio 2019 Preview con los proyectos de Visual Basic y C# además de la DLL de MySQL con la referencia a la copia dentro del directorio de la solución.

El zip: VarChar_y_NVarChar_20190321.zip (147 KB)

MD5 Checksum: 888346C11622183F6A39FE5FBA4339D3

Nota:

Aquí tienes el enlace para la descarga del ZIP que me descargué con el conector de MySQL para .NET versión 6.0.3 (mysql-connector-net-6.0.3-noinstall.zip) el tamaño es 1.64MB y el MD5 Checksum es: 57BB7F42645665D5A616A3484041F0C0.

VarChar y NVarChar en SQL Server

Actualizado el 21/Mar/2019 con los pasos para resolver el fallo que tenía de acceso a las bases de datos remotas y también con el enlace al código para VB y C#.

Pues eso… el otro día estaba creando una base de datos de MySQL y me di cuenta que MySQL no tiene el tipo NVARCHAR o al menos a mí no me daba la opción de crear un campo con ese tipo, al menos desde el panel de control del hosting que utilizo (Domitienda.com), así que… utilicé VARCHAR, el problema que me temía que iba a tener era no poder usar las vocales acentuadas (con tilde), la eñe, etc. Pero resultó que sí… que lo aceptaba sin problemas.

Así que, me puse a buscar en Internet a ver cuál era la diferencia entre VARCHAR y NVARCHAR, ya que yo siempre usaba NVARCHAR en mis bases de SQL Server (que es el tipo de base que uso, salvo excepciones muy, muy contadas) porque era el tipo que me permitía usar los caracteres especiales del idioma español (o al menos así lo entendí yo, que puede ser que lo entendiese mal… ).

Pero resulta que si utilizo VARCHAR puedo indicar esos caracteres especiales sin mayor problema.

Por supuesto la información que encontré hablando de esa diferencia entre esos dos tipos de datos era… bueno… no aclaratoria del todo… pero en realidad me daba igual lo que me quisieran decir, ya que yo he comprobado por mí mismo que se puede guardar algo así: Raúl Rodríguez López es de Valdepeñas en un campo del tipo VARCHAR.

Un ejemplo para acceder a SQL Server y MySQL

Aquí tienes una captura de un ejemplo que he hecho para mostrar que sí funciona eso de guardar los caracteres especiales, al menos los usados en español.

El código lo publicaré otro día, ya que es tarde y además no me funciona el código para acceder a las bases de datos remotas (en el hosting de Domitienda), seguramente habré configurado algo mal, ya que a otras que tengo en el mismo hosting si que puedo acceder…

Nota del 21 de Marzo:

Según parece resulta que en el «plesk» del hosting no permite usar el mismo nombre de usuario para varias bases de datos o bien la longitud de la contraseña debe ser menor de la que usé… en cualquier caso lo he solucionado haciendo lo siguiente:

He creado dos usuarios diferentes, el de la base de datos de SQL Server se llama elGuille_infoSQL y el de MySQL se llama elGuille_infoMy.

He usado una clave más corta.

Y ahora todo funciona bien… o casi… ya que añadí un campo DATETIME a la base de MySQL y da error al convertir el contenido de la base de datos a un tipo DateTime de .NET, así que… lo he creado como VARCHAR(20).

Otra cosa con la que me he encontrado con la consulta de MySQL es que no acepta TOP para indicar el número de filas a devolver, en su lugar he usado LIMIT y ya va bien.

En la captura de la Figura 2 puedes ver la aplicación totalmente operativa y accediendo a las bases de datos remotas.

Si te fijas en los valores mostrados al final con todo a cero, eso era lo que había añadido usando el tipo de datos DATETIME en MySQL, después al añadirlo como VARCHAR ya se muestra bien.

El código de VB y C# lo puedes ver en la entrada publicada el 21 de marzo: VarChar y NVarChar en SQL Server y MySQL el código para VB y C#.

Figura 2. La aplicación operativa con acceso remoto después de los cambios hechos en el hosting.
Figura 2. La aplicación operativa con acceso remoto después de los cambios hechos en el hosting.

Figura 1. Formulario de prueba
Figura 1. El formulario de prueba

Los datos mostrados en la figura 1 son de una base de datos de SQL Server usada localmente, el mensaje de error que se muestra es el devuelto por el servidor de MySQL.

Lo importante es que puedes comprobar que tanto el campo VARCHAR como NVARCHAR muestran las vocales con tilde y la eñe.

Seguramente si uso caracteres de otros idiomas como el CHINO o RUSO no se guardarían bien en el VARCHAR… no lo sé porque no lo he probado… 😉

Pues esto es todo por hoy… en los enlaces puedes ver más información sobre esos tipos de datos (en la documentación de SQL Server) y lo que cuentan en algunos sitios sobre la diferencia entre ellos.

Este enlace es sobre VARCHAR en la documentación de MySQL.

A ver si el jueves próximo (día 21, luna llena, por más señas) te pongo el código de ejemplo de la aplicación que guarda esos caracteres en los dos tipos de datos y como de costumbre tanto para Visual Basic como para C#.

Nos vemos.
Guillermo

Nota:
Según el panel de control la versión de MySQL es:

mysql1.servidoreswindows.net
Versión del servidor: 5.1.73-log

DoEvents para aplicaciones WPF

Pues eso… que en las aplicaciones de Windows Presentation Foundation (WPF) no podemos usar el equivalente a DoEvents de Windows Forms, simplemente porque no existe esa funcionalidad para WPF, pero no te preocupes porque aquí te explico cómo crear un método DoEvents listo para usar en las aplicaciones de WPF, por supuesto con el código del VB y C#.

Yo utilizo DoEvents en las ocasiones que quiero refrescar la pantalla (formulario o ventana) de la aplicación, por ejemplo cuando se está haciendo un proceso largo para que no se quede congelada la aplicación.

Y anoche me ocurrió eso mientras ejecutaba una aplicación (de WPF) que me fabriqué para copiar el contenido de una lista de canciones (PlayList tipo m3u) en una carpeta. Y como el disco usado para guardar los MP3 era un disco externo, pues… aparte de que eran muchas canciones (354), pues… parecía que la aplicación fallaba, ya que no mostraba la canción que estaba copiando y… pues eso… que hasta yo pensé que me había equivocado escribiendo el código… Angel

Así que… sabiendo que DoEvents no está definido en WPF y después de probar con que tampoco hay Refresh en los controles de WPF, probé con Thread.Sleep que no solucionó el problema (y no era plan de crear un temporizador), así que… ¡a buscar en Internet!

Y dio resultado la búsqueda, concretamente en esta página:
Implement Application.DoEvents in WPF, ¿el problema? ninguno, salvo que, como suele ocurrir por los interneses, todo está con ejemplos para C#, así que… a convertir el código encontrado.

Este es el código de esa página para simular el DoEvents (en C#):

public static void DoEvents()
    {
        Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background,
                new EmptyDelegate(delegate{}));
    }

En otra parte del código debes tener la definición de EmptyDelegate:

private delegate void EmptyDelegate();

No me sonó demasiado a chino mandarín ya que algo parecido usé hace muuuuuuchos años para llamar a otro control desde el método de evento de un temporizador:
24- Acceder a un control desde un evento de un timer, pero ya ni me acordaba Eye rolling smile

Y esta es la versión para Visual Basic .NET:

' Adaptado de:
' http://www.java2s.com/Tutorial/CSharp/0470__Windows-Presentation-Foundation/
'   ImplementApplicationDoEventsinWPF.htm

Private Delegate Sub EmptyDelegate()

Private Sub DoEvents()
    Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Background,
                                        New EmptyDelegate(Sub()
                                                          End Sub))
End Sub

Te tienes que fiar de mi palabra, pero sin el DoEvents, al pulsar en el botón Copiar la aplicación parece como si se hubiese colgado… hasta pasado un buen rato no termina… (Figura 1)

Figura 1. Sin el DoEvents, después de pulsar en Copiar la aplicación se queda congelada
Figura 1. Sin el DoEvents, después de pulsar en Copiar la aplicación se queda congelada

Sin embargo, poniendo el DoEvents, se va mostrando el progreso de copia. Y de eso se trata… que se vea lo que está haciendo Winking smile

Pues… ¡ya está! esto es todo…

Nos vemos.
Guillermo

Si quieres que tu aplicación se muestre en el monitor externo dile que se centre en la pantalla (CenterScreen)

Pues eso… que estuve un tiempo buscando soluciones para que se mostrasen mis aplicaciones en el monitor secundario (que es el que uso como principal) y resulta que la solución es más simple que todo eso… sí, solo con indicarle que se centre en la pantalla (CenterScreen) es suficiente Winking smile

Y esto vale tanto para aplicaciones de Windows Forms como para las de WPF (Windows Presentation Foundation).

En WPF lo haces con este código en el diseñador de la ventana (Window):

WindowStartupLocation = "CenterScreen"

En WinForms asigna a la propiedad StartPosition del formulario de inicio el valor CenterScreen.

Y ya está… ya no tengo más que contarte Winking smile

Nos vemos.
Guillermo

Indicar el Encoding al guardar el contenido de un RichTextBox de WPF

Pues eso… que el otro día te puse un ejemplo de Abrir y guardar archivos usando RichTextBox para WPF y anoche haciendo pruebas con vocales acentuadas, me di cuenta que el formato XAML (DataFormats.Xaml) las tildes se las pasaba por el forro… así que… buscando en la red de redes vi un ejemplo que evita eso… o casi, al menos te permite tener la opción de poder hacerlo.

El problema está (o estaba) en que en el ejemplo de donde saqué el código para guardarlo utiliza esto para crear el Stream de salida: Using fStream As New FileStream(_fileName, FileMode.Create) y usando FileStream no se puede indicar la codificación. O yo no sé cómo hacerlo, que todo hay que decirlo Winking smile

Al abrir el Stream se hace la llamada al método Save del rango (TextRange) y se indica el formato con el que se guardará: range.Save(fStream, formato, True). range.Save precisa de un Stream, pero el ofrecido por StreamWriter, que es el que yo suelo usar para guardar indicando la codificación, no le sirve.

El truco está en guardar primero el contenido del RichTextBox en la memoria (usando MemoryStream) y después pasar ese flujo de caracteres al disco por medio de StreamWriter.

El código final quedaría de la siguiente forma:

''' <summary>
''' Adaptado del ejemplo de la documentación de Microsoft
''' https://docs.microsoft.com/es-es/dotnet/framework/wpf/controls/
'''     richtextbox-overview
''' </summary>
Private Function SaveRtfFormat(_fileName As String,
                               richTB As RichTextBox,
                               formato As String) As Boolean
    Dim range As TextRange
    Dim guardado As Boolean = False

    range = New TextRange(richTB.Document.ContentStart,
                          richTB.Document.ContentEnd)

    ' Para guardar con el formato que queramos
    ' Adaptado de:
    ' https://social.msdn.microsoft.com/Forums/vstudio/en-US/
    '   a9ef25ef-fada-4cbd-a341-f9eb22fb2f48/
    '   how-to-save-a-rich-text-into-a-sql-server-database-in-a-wpf-application?forum=wpf
    Using stream As New MemoryStream
        Try
            range.Save(stream, formato, True)
            Dim buffer = Encoding.UTF8.GetString(stream.ToArray())
            Using sw As New StreamWriter(_fileName, False, Encoding.Default)
                sw.Write(buffer)
            End Using

            guardado = True
        Catch ex As Exception
            MessageBox.Show("Error el formato no es válido" & vbCrLf &
                            ex.Message,
                            $"Guardar {formato}",
                            MessageBoxButton.OK,
                            MessageBoxImage.Asterisk)
        End Try
    End Using
    'Using fStream As New FileStream(_fileName, FileMode.Create)
    '    Try
    '        range.Save(fStream, formato, True)
    '        guardado = True
    '    Catch ex As Exception
    '        MessageBox.Show("Error el formato no es válido" & vbCrLf &
    '                        ex.Message,
    '                        $"Guardar {formato}",
    '                        MessageBoxButton.OK,
    '                        MessageBoxImage.Asterisk)
    '    End Try
    '    fStream.Close()
    'End Using

    Return guardado
End Function

Al final de la función tienes (comentado) el código anterior.

/// <summary>
///  Adaptado del ejemplo de la documentación de Microsoft
///  https://docs.microsoft.com/es-es/dotnet/framework/wpf/controls/
///     richtextbox-overview
///  </summary>
private bool SaveRtfFormat(string _fileName, 
                           RichTextBox richTB, 
                           string formato)
{
    TextRange range;
    bool guardado = false;

    range = new TextRange(richTB.Document.ContentStart, 
                          richTB.Document.ContentEnd);

    // Para guardar con el formato que queramos
    // Adaptado de:
    // https://social.msdn.microsoft.com/Forums/vstudio/en-US/
    // a9ef25ef-fada-4cbd-a341-f9eb22fb2f48/
    // how-to-save-a-rich-text-into-a-sql-server-database-in-a-wpf-application?forum=wpf
    using (MemoryStream stream = new MemoryStream())
    {
        try
        {
            range.Save(stream, formato, true);
            var buffer = Encoding.UTF8.GetString(stream.ToArray());
            using (StreamWriter sw = new StreamWriter(_fileName, 
                                                      false, 
                                                      Encoding.Default))
            {
                sw.Write(buffer);
            }

            guardado = true;
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error el formato no es válido\r\n" + 
                            ex.Message, 
                            $"Guardar {formato}", 
                            MessageBoxButton.OK, 
                            MessageBoxImage.Asterisk);
        }
    }

    //    using (FileStream fStream = new FileStream(_fileName, 
    //                                               FileMode.Create))
    //    {
    //        try
    //        {
    //            range.Save(fStream, formato);
    //            guardado = true;
    //        }
    //        catch (Exception ex)
    //        {
    //            MessageBox.Show("Error el formato no es válido\r\n" + 
    //                ex.Message, $"Guardar {formato}", 
    //                MessageBoxButton.OK, MessageBoxImage.Asterisk);
    //        }

    //        fStream.Close();
    //    }

    return guardado;
}

Lo curioso del caso es que si lo guardaba como Rtf (DataFormats.Rtf) las vocales acentuadas se guardaban bien… Pero de esta forma, todo se guarda bien, al menos los tres formatos que he probado: Rtf, Xaml y Text.

Y es que en las pruebas que estaba haciendo usaba el código de ejemplo de la utilidad Compilar y ejecutar y tengo en varios sitios escrita la palabra versión y al guardarlo y después volver a abrirlo con formato Xaml, se mostraba como en la figura 1.

Figura 1. Los caracteres raros de la o con tilde ó
Figura 1. Los caracteres raros de la o con tilde ó

Al principio ni me fijé, pero cuando la ristra esa de caracteres raros se hizo más larga, ya que si me fijé Surprised smile

¡Como para no darme cuenta!

Y ya está… ahora modificaré la entrada anterior o pondré una aclaración para que vengas aquí Winking smile (para que se vea que el Guille también se equivoca jajaja)

Espero que te sea de utilidad. Esa es la idea.

Nos vemos.
Guillermo

Abrir y guardar archivos usando RichTextBox para WPF

Pues eso… hoy te voy a explicar cómo implementar las opciones de abrir y guardar archivos usando un control RichTextBox para WPF.

Actualizado (o nota del 15/Ene/19)
En realidad actualizado no está, salvo este comentario del martes 15 de enero.

Donde está la actualización es en el post que he publicado hoy: Indicar el Encoding al guardar el contenido de un RichTextBox de WPF, y es que resulta que con el código tal como te lo muestro aquí, si decides usar el formato Xaml (ya sabes: lo guarda como párrafos, etc.) y tu texto tiene tildes (vocales acentuadas), pues… resulta que no lo hace bien.

Así que… te recomiendo que veas el post de hoy y si te has descargado el zip con los proyectos, modifiques el código. Gracias

Como ya vimos en el post anterior (Leer el contenido como cadena y asignar un valor nuevo) usaremos tres opciones de formatos admitidos por RichTextBox de WPF. ¿Los recuerdas? Vale, te los resumo de nuevo:

  • Rtf el contenido debe estar en formato RTF.
  • Xaml el contenido debe estar en formato Xaml pero el que se puede poner en un RichTextBox o FlowDocument, cuando lo guardas lo pone dentro de un elemento Section. Es decir, no vale cualquier código Xaml y menos el que define un objeto Window.
  • Text Formato de texto plano, sin ningún tipo de formato.

Contenido de la ventana principal (MainWindow)

En la aplicación he puesto un control RichTextBox (de eso se trata este ejemplo, ¿no?) y además de una etiqueta para mostrar la información del archivo activo, también hay un menú con un elemento (Archivo) con las opciones de Abrir, Guardar como y Salir.

En esos tres submenús he puesto imágenes, éstas están descargadas de las que pone Visual Studio 2017 a nuestra disposición, realmente las que utiliza el propio Visual Studio 2017. El enlace para descargar todas esas imágenes (son un montón, lo que yo te diga) es este: Biblioteca de imágenes de Visual Studio. En ese enlace te explica qué tipos de imágenes contiene y más cosillas, aparte, claro del enlace para descargarlas.

Este es el código XAMl de la ventana principal (recuerda que es el mismo diseño para Visual Basic que para C#, lo único que cambia es el espacio de nombres usado en cada proyecto, más abajo te pongo el ZIP con el código completo para Visual Basic y para C# en una solución de Visual Studio 2017.

<Window x:Class="MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:Wpf_Abrir_y_guardar_en_RichTextBox_vb"
        mc:Ignorable="d"
        Title="Abrir y guardar archivos en un RichTextBox (VB)" 
        WindowStartupLocation="CenterScreen"
        ResizeMode="CanResizeWithGrip" 
        WindowStyle="ThreeDBorderWindow"
        Loaded="Window_Loaded" Closing="Window_Closing"
        Height="450" Width="800"
        Icon="Images/RichTextBox_16x.png">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition />
            <ColumnDefinition Width="Auto" MinWidth="100" />
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" MinHeight="24"/>
            <RowDefinition />
            <RowDefinition />
            <RowDefinition Height="Auto" MinHeight="24" />
        </Grid.RowDefinitions>
        <Menu Grid.Row="0" Grid.Column="0" 
              Grid.ColumnSpan="2" Background="AliceBlue">
            <MenuItem Header="_Archivo" ToolTip="Abrir, Guardar, Salir">
                <MenuItem x:Name="mnuAbrir" Header="_Abrir..."
                                  Click="MnuAbrir_Click">
                    <MenuItem.Icon>
                        <Image Source="Images\OpenFile_16x.png" />
                    </MenuItem.Icon>
                </MenuItem>
                <MenuItem x:Name="mnuGuardar" Header="_Guardar cómo..."
                                  Click="MnuGuardar_Click">
                    <MenuItem.Icon>
                        <Image Source="Images\Save_16x.png" />
                    </MenuItem.Icon>
                </MenuItem>
                <Separator />
                <MenuItem x:Name="mnuSalir" Header="_Salir" Click="MnuSalir_Click">
                    <MenuItem.Icon>
                        <Image Source="Images\Close_16x.png" />
                    </MenuItem.Icon>
                </MenuItem>
            </MenuItem>
        </Menu>
        <RichTextBox x:Name="rtb" 
                     BorderThickness="2"
                     AcceptsTab="True" AcceptsReturn="True"
                     Grid.Column="0" Grid.Row="1" 
                     Grid.ColumnSpan="2" Grid.RowSpan="2"
                     TextChanged="Rtb_TextChanged">
            <FlowDocument />
        </RichTextBox>
        <Label x:Name="lblStatus" Content="Información..."
               Padding="4,2,4,2"
               Grid.Column="0" Grid.Row="3" 
               Grid.ColumnSpan="2"
               Background="{DynamicResource {x:Static SystemColors.InfoBrushKey}}" />
    </Grid>
</Window>

Las definiciones de las filas y columnas del Grid nos dan espacio (no demasiado ancho) para la primera fila (la de los menús) y la última (la de la etiqueta de estado).

La columna esa que tengo con MinWidth a 100 era para poder poner el típico botón Salir, pero como ya lo tengo en el menú de Archivo, ¿pa qué ponerlo? pero ya que estaba… la he dejado Smile

Las imágenes usadas como recurso están en una carpeta llamada Images y aparte de las mostradas en los menús, hay otra para usarla como icono de la ventana: RichTextBox_16x.png.

Nota:
Fíjate que en la definición de la ventana (Window) se asigna a la propiedad Icon, pero en realidad no es un icono. Te lo digo por si lo quieres usar como icono de la aplicación. En ese caso tendrás que crear un icono nuevo, añadir una nueva imagen (o tipo de imagen) de 16×16 con 24 bits, copiar la imagen con un programa, por ejemplo el Paint que se incluye con Windows y después pegarla en ese icono creado en Visual Studio.

Vale, te lo explico paso a paso.

Crear un icono con Visual Studio a partir de una imagen

Lo he puesto como post separado para no cargar más de la cuenta este: Crear un icono con Visual Studio a partir de una imagen.

Fíjate que en el código XAML no he indicado la visibilidad de las barras de desplazamiento del control RichTextBox, por tanto no se muestran (tampoco está incluido en un control ScrollViewer). Si quieres que se muestren tanto la horizontal como la vertical, tendrás que indicarlo expresamente.

HorizontalScrollBarVisibility="Auto"
VerticalScrollBarVisibility="Auto"

Si le asignas un valor Auto se mostrarán según sea necesario (al menos la vertical, ya que la horizontal siempre se mostrará). Si quieres que siempre sean visible las dos, en vez de Auto indica el valor Visible.

El código para abrir un archivo y asignar el contenido en el RichTextBox

A continuación te muestro las funciones (tanto para VB.NET como para C#) del método usado para abrir un archivo y asignarlo al contenido del control RichTextBox.

Nota:
El código mostrado en el método LoadRtfFormat lo he convertido a partir de un ejemplo mostrado en la documentación en línea de Visual Studio.

''' <summary>
''' Adaptado del ejemplo de la documentación de Microsoft
''' https://docs.microsoft.com/es-es/dotnet/framework/wpf/
'''     controls/richtextbox-overview
''' </summary>
Private Function LoadRtfFormat(_fileName As String,
                               richTB As RichTextBox,
                               formato As String) As Boolean
    Dim abierto = False

    If File.Exists(_fileName) Then
        Dim range = New TextRange(richTB.Document.ContentStart,
                                  richTB.Document.ContentEnd)
        Using sr As New StreamReader(_fileName, Encoding.Default, True)
            Try
                ' leer el contenido para admitir tildes, etc.   (09/Ene/19)
                Dim texto = sr.ReadToEnd
                Dim stream = New MemoryStream(Encoding.UTF8.GetBytes(texto))

                range.Load(stream, formato)
                abierto = True
            Catch ex As Exception
                MessageBox.Show("Error el formato no es válido" & vbCrLf &
                                ex.Message,
                                $"Abrir {formato}",
                                MessageBoxButton.OK,
                                MessageBoxImage.Asterisk)
            End Try
        End Using
    End If

    Return abierto
End Function

Private Function LoadRtf(ByVal _fileName As String,
                         richTB As RichTextBox) As Boolean
    Return LoadRtfFormat(_fileName, richTB, DataFormats.Rtf)
End Function

' Al cargar como Xaml da error el Visual Studio
' ya que lo trata como una clase
' y esto en realidad es para abrir con el XAML generado,
'   con los elementos Paragraph, Bold, Run, etc.
Private Function LoadRtfXaml(ByVal _fileName As String,
                             richTB As RichTextBox) As Boolean
    Return LoadRtfFormat(_fileName, richTB, DataFormats.Xaml)
End Function

''' <summary>
''' El formato texto abrirlo directamente
''' Aunque funciona igual que llamando a LoadRtfFormat
''' </summary>
Private Function LoadRtfText(ByVal _fileName As String,
                             richTB As RichTextBox) As Boolean
    'Return LoadRtfFormat(_fileName, richTB, DataFormats.Text)

    Dim abierto = False

    If File.Exists(_fileName) Then
        Dim range = New TextRange(richTB.Document.ContentStart,
                                  richTB.Document.ContentEnd)
        Using sr As New StreamReader(_fileName, Encoding.Default, True)
            Try
                ' leer el contenido para admitir tildes, etc.   (09/Ene/19)
                Dim texto = sr.ReadToEnd

                Dim textRange = New TextRange(richTB.Document.ContentStart,
                                              richTB.Document.ContentEnd)
                textRange.Text = texto

                abierto = True
            Catch ex As Exception
                MessageBox.Show("Error el formato no es válido" & vbCrLf &
                                ex.Message,
                                "Abrir Text",
                                MessageBoxButton.OK,
                                MessageBoxImage.Asterisk)
            End Try
        End Using
    End If

    Return abierto
End Function
/// <summary>
/// Adaptado del ejemplo de la documentación de Microsoft
/// https://docs.microsoft.com/es-es/dotnet/framework/wpf/
///     controls/richtextbox-overview
/// </summary>
private bool LoadRtfFormat(string _fileName, RichTextBox richTB, string formato)
{
    var abierto = false;

    if (File.Exists(_fileName))
    {
        var range = new TextRange(richTB.Document.ContentStart, 
                                  richTB.Document.ContentEnd);

        using (StreamReader sr = new StreamReader(_fileName, 
                                                  Encoding.Default, 
                                                  true))
        {
            try
            {
                // leer el contenido para admitir tildes, etc.   (09/Ene/19)
                var texto = sr.ReadToEnd();
                var stream = new MemoryStream(Encoding.UTF8.GetBytes(texto));

                range.Load(stream, formato);
                abierto = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error el formato no es válido\r\n"  + 
                                ex.Message, $"Abrir {formato}", 
                                MessageBoxButton.OK, 
                                MessageBoxImage.Asterisk);
            }
        }
    }

    return abierto;
}

private bool LoadRtf(string _fileName, RichTextBox richTB)
{
    return LoadRtfFormat(_fileName, richTB, DataFormats.Rtf);
}

// Al cargar como Xaml da error el Visual Studio
// ya que lo trata como una clase
// y esto en realidad es para abrir con el XAML generado,
// con los elementos Paragraph, Bold, Run, etc.
private bool LoadRtfXaml(string _fileName, RichTextBox richTB)
{
    return LoadRtfFormat(_fileName, richTB, DataFormats.Xaml);
}

/// <summary>
/// El formato texto abrirlo directamente
/// Aunque funciona igual que llamando a LoadRtfFormat
/// </summary>
private bool LoadRtfText(string _fileName, RichTextBox richTB)
{
    var abierto = false;

    if (File.Exists(_fileName))
    {
        var range = new TextRange(richTB.Document.ContentStart, 
                                  richTB.Document.ContentEnd);

        using (StreamReader sr = new StreamReader(_fileName, 
                                                  Encoding.Default, 
                                                  true))
        {
            try
            {
                // leer el contenido para admitir tildes, etc.   (09/Ene/19)
                var texto = sr.ReadToEnd();

                var textRange = new TextRange(richTB.Document.ContentStart, 
                                              richTB.Document.ContentEnd);
                textRange.Text = texto;

                abierto = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error el formato no es válido\r\n" + 
                                ex.Message, 
                                "Abrir Text", 
                                MessageBoxButton.OK, 
                                MessageBoxImage.Asterisk);
            }
        }
    }

    return abierto;
}

Nota:
El código del método LoadRtfText se podría haber reducido haciendo una llamada al método LoadRtfFormat e indicando como último argumento DataFormats.Text. Pero… ese también vale, por si quieres verlo de la forma tradicional.

Te recuerdo que el tipo XAML no es un archivo de diseño normal XAML / WPF si no el formato XAML del contenido del RichTextBox.

Para llamar a ese método lo haremos desde el método de evento MnuAbrir_Click que es el que usará la aplicación cuando el usuario pulse en el menú Abrir.

Veamos el código para VB y C# y te explico un par de detalles.

Private Sub MnuAbrir_Click(sender As Object, e As RoutedEventArgs)
    If rtbModificado Then
        If MessageBox.Show("El texto está modificado," & vbCrLf &
                           "¿seguro que quieres abir?",
                           "Texto Modificado",
                           MessageBoxButton.YesNo,
                           MessageBoxImage.Question) = MessageBoxResult.No Then
            Exit Sub
        End If
    End If
    Dim oFD As New OpenFileDialog
    oFD.Filter = "Formato RTF|*.rtf|" &
                 "Formato Xaml del contenido RTF|*.xaml|" &
                 "Código C# y VB|*.cs;*.vb|" &
                 "Texto (*.txt)|*.txt|Todos (*.*)|*.*"

    oFD.Title = "Selecciona el archivo"
    oFD.InitialDirectory = My.Computer.FileSystem.SpecialDirectories.MyDocument
    oFD.FileName = ""
    If oFD.ShowDialog() Then
        Dim ext = System.IO.Path.GetExtension(oFD.FileName).ToLower()
        Select Case ext
            Case ".rtf"
                LoadRtf(oFD.FileName, rtb)
            Case ".xaml"
                LoadRtfXaml(oFD.FileName, rtb)
            Case Else
                LoadRtfText(oFD.FileName, rtb)
        End Select

        rtbModificado = False
        lblStatus.Content = $"Texto cargado de: {oFD.FileName}"
    End If
End Sub
private void MnuAbrir_Click(object sender, RoutedEventArgs e)
{
    if (rtbModificado)
    {
        if (MessageBox.Show("El texto está modificado,\r\n" + 
                            "¿seguro que quieres abir?", 
                            "Texto Modificado", 
                            MessageBoxButton.YesNo, 
                            MessageBoxImage.Question) == MessageBoxResult.No)
            return;
    }
    OpenFileDialog oFD = new OpenFileDialog();
    oFD.Filter = "Formato RTF|*.rtf|" + "Formato Xaml del contenido RTF|*.xaml|" + 
                 "Código C# y VB|*.cs;*.vb|" + "Texto (*.txt)|*.txt|Todos (*.*)|*.*";

    oFD.Title = "Selecciona el archivo";
    // oFD.InitialDirectory = My.Computer.FileSystem.SpecialDirectories.MyDocuments;
    oFD.InitialDirectory = Environment.GetFolderPath(
                                        Environment.SpecialFolder.MyDocuments);
    oFD.FileName = "";
    if (oFD.ShowDialog() == true)
    {
        var ext = System.IO.Path.GetExtension(oFD.FileName).ToLower();
        switch (ext)
        {
            case ".rtf":
                {
                    LoadRtf(oFD.FileName, rtb);
                    break;
                }

            case ".xaml":
                {
                    LoadRtfXaml(oFD.FileName, rtb);
                    break;
                }

            default:
                {
                    LoadRtfText(oFD.FileName, rtb);
                    break;
                }
        }

        rtbModificado = false;
        lblStatus.Content = $"Texto cargado de: {oFD.FileName}";
    }
}

En este método se comprueba si el texto está modificado, de ser así, da la oportunidad para guardarlo antes de abrir el nuevo.

El método OpenFileDialog está definido en el espacio de nombres Microsoft.Win32, si prefieres el clásico de Windows Forms, tendrás que agregar una referencia al proyecto a esa biblioteca de WinForms.
Para los de Visual Basic no hay gran diferencia, salvo que el método ShowDialog devuelve True o False según se haya aceptado o cancelado. En el caso de C# hay que comprobarlo con el signo de igualdad, ya que el valor devuelto por el método ShowDialog es de tipo bool?.

En cuanto al directorio de inicio (InitialDirectory) con Visual Basic he utilizado el objeto My, para C# tengo una clase que simula algunas de las características de My, concretamente My.Properties, My.Application.Info y My.Computer.FileSystem.SpelciaDirectories, pero he preferido usar aquí la llamada directa a las clases de .NET (que es lo que supongo que harán las definiciones correspondientes de Visual Basic). Concretamente la llamada al método Environment.GetFolderPath al que le pasamos el valor MyDocuments de la enumeración Environment.SpecialFolder y devuelve el valor como una cadena, que es lo que necesitamos aquí.

El tipo de archivo lo dará la extensión del mismo y eso hago, una comprobación según la extensión, diferenciando los tipos Rtf y Xaml del resto, que los considero como texto (Text).

Finalmente mostramos en la etiqueta de información el nombre del archivo e indicamos que el texto no se ha modificado.

El código para guardar en un archivo el contenido del RichTextBox

Ahora le toca la parte de guardar. El método principal lo he llamado SaveRtfFormat que también está en el ejemplo sobre RichTextBox que te he indicado antes.

Veamos el código para Visual Basic y C#.

''' <summary>
''' Adaptado del ejemplo de la documentación de Microsoft
''' https://docs.microsoft.com/es-es/dotnet/framework/wpf/controls/
'''     richtextbox-overview
''' </summary>
Private Function SaveRtfFormat(_fileName As String,
                               richTB As RichTextBox,
                               formato As String) As Boolean
    Dim range As TextRange
    Dim guardado As Boolean = False

    range = New TextRange(richTB.Document.ContentStart, richTB.Document.ContentEnd)
    Using fStream As New FileStream(_fileName, FileMode.Create)
        Try
            range.Save(fStream, formato)
            guardado = True
        Catch ex As Exception
            MessageBox.Show("Error el formato no es válido" & vbCrLf &
                            ex.Message,
                            $"Guardar {formato}",
                            MessageBoxButton.OK,
                            MessageBoxImage.Asterisk)
        End Try

        fStream.Close()
    End Using

    Return guardado
End Function

Private Function SaveRtf(ByVal _fileName As String,
                         richTB As RichTextBox) As Boolean
    Return SaveRtfFormat(_fileName, richTB, DataFormats.Rtf)
End Function
Private Function SaveRtfXaml(ByVal _fileName As String,
                             richTB As RichTextBox) As Boolean
    Return SaveRtfFormat(_fileName, richTB, DataFormats.Xaml)
End Function

''' <summary>
''' El formato Text lo guardo como texto normal
''' </summary>
Private Function SaveRtfText(ByVal _fileName As String,
                        richTB As RichTextBox) As Boolean
    'Return SaveRtfFormat(_fileName, richTB, DataFormats.Text)

    Dim guardado = False

    Try
        Dim texto = getRtbText(richTB)
        Using sw As New StreamWriter(_fileName, False, Encoding.Default)
            sw.WriteLine(texto)
        End Using

        guardado = True
    Catch ex As Exception
        MessageBox.Show("Error al guardar:" & vbCrLf &
                        ex.Message,
                        "Guardar Text",
                        MessageBoxButton.OK,
                        MessageBoxImage.Asterisk)
    End Try

    Return guardado
End Function
/// <summary>
/// Adaptado del ejemplo de la documentación de Microsoft
/// https://docs.microsoft.com/es-es/dotnet/framework/wpf/controls/
///     richtextbox-overview
/// </summary>
private bool SaveRtfFormat(string _fileName, RichTextBox richTB, string formato)
{
    TextRange range;
    bool guardado = false;

    range = new TextRange(richTB.Document.ContentStart, 
                          richTB.Document.ContentEnd);

    using (FileStream fStream = new FileStream(_fileName, 
                                               FileMode.Create))
    {
        try
        {
            range.Save(fStream, formato);
            guardado = true;
        }
        catch (Exception ex)
        {
            MessageBox.Show("Error el formato no es válido\r\n"+ 
                            ex.Message, 
                            $"Guardar {formato}", 
                            MessageBoxButton.OK, 
                            MessageBoxImage.Asterisk);
        }

        fStream.Close();
    }

    return guardado;
}

private bool SaveRtf(string _fileName, RichTextBox richTB)
{
    return SaveRtfFormat(_fileName, richTB, DataFormats.Rtf);
}
private bool SaveRtfXaml(string _fileName, RichTextBox richTB)
{
    return SaveRtfFormat(_fileName, richTB, DataFormats.Xaml);
}

/// <summary>
/// El formato Text lo guardo como texto normal
/// </summary>
private bool SaveRtfText(string _fileName, RichTextBox richTB)
{
    var guardado = false;

    try
    {
        var texto = getRtbText(richTB);
        using (StreamWriter sw = new StreamWriter(_fileName, 
                                                  false, 
                                                  Encoding.Default))
        {
            sw.WriteLine(texto);
        }

        guardado = true;
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error al guardar:\r\n" + 
                        ex.Message, 
                        "Guardar Text", 
                        MessageBoxButton.OK, 
                        MessageBoxImage.Asterisk);
    }

    return guardado;
}

/// <summary>
/// Extrae el texto de un RichTextBox y lo devuelve como una cadena.
/// De un ejemplo en C# de:
/// https://docs.microsoft.com/es-es/dotnet/framework/wpf/controls/
///     how-to-extract-the-text-content-from-a-richtextbox
/// </summary>
private string getRtbText(RichTextBox rtb)
{
    var textRange = new TextRange(rtb.Document.ContentStart,
                                  rtb.Document.ContentEnd);
    return textRange.Text;
}

Como en el método SaveRtfText lo hago directamente, llamo al método getRtbText que ya vimos en el post anterior.

Estos métodos los llamaremos desde el método de evento relacionado con el evento Click del menú Guardar como…, tal como te muestro a continuación.

Private Sub MnuGuardar_Click(sender As Object, e As RoutedEventArgs)
    Dim oFD As New SaveFileDialog
    oFD.Filter = "Formato RTF|*.rtf|" &
                 "Formato Xaml del contenido RTF|*.xaml|" &
                 "Código C# y VB|*.cs;*.vb|" &
                 "Texto (*.txt)|*.txt|Todos (*.*)|*.*"

    oFD.Title = "Selecciona el archivo para guardar el contenido RTF"
    oFD.InitialDirectory = My.Computer.FileSystem.SpecialDirectories.MyDocuments
    oFD.FileName = ""
    If oFD.ShowDialog() Then
        Dim ext = System.IO.Path.GetExtension(oFD.FileName).ToLower()
        Select Case ext
            Case ".rtf"
                SaveRtf(oFD.FileName, rtb)
            Case ".xaml"
                SaveRtfXaml(oFD.FileName, rtb)
            Case Else
                SaveRtfText(oFD.FileName, rtb)
        End Select

        rtbModificado = False
        lblStatus.Content = $"Texto guardado como: {oFD.FileName}"
    End If

End Sub
private void MnuGuardar_Click(object sender, RoutedEventArgs e)
{
    SaveFileDialog oFD = new SaveFileDialog();
    oFD.Filter = "Formato RTF|*.rtf|" + "Formato Xaml del contenido RTF|*.xaml|" + 
                 "Código C# y VB|*.cs;*.vb|" + "Texto (*.txt)|*.txt|Todos (*.*)|*.*";

    oFD.Title = "Selecciona el archivo para guardar el contenido RTF";
    // oFD.InitialDirectory = My.Computer.FileSystem.SpecialDirectories.MyDocuments;
    oFD.InitialDirectory = Environment.GetFolderPath(
                                        Environment.SpecialFolder.MyDocuments);
    oFD.FileName = "";
    if (oFD.ShowDialog() == true)
    {
        var ext = System.IO.Path.GetExtension(oFD.FileName).ToLower();
        switch (ext)
        {
            case ".rtf":
                {
                    SaveRtf(oFD.FileName, rtb);
                    break;
                }

            case ".xaml":
                {
                    SaveRtfXaml(oFD.FileName, rtb);
                    break;
                }

            default:
                {
                    SaveRtfText(oFD.FileName, rtb);
                    break;
                }
        }

        rtbModificado = false;
        lblStatus.Content = $"Texto guardado como: {oFD.FileName}";
    }
}

Aquí nada especial que contar, salvo que en vez de usar la clase OpenFileDialog usamos SaveFileDialog, el resto, es lo mismo que te expliqué antes.

Y este es el código principal de la aplicación, a falta de la comprobación al cerrar el formulario, perdón ventana, principal que se comprueba si el código se ha modificado y el evento TextChanged del control RichTextBox.

Private Sub Rtb_TextChanged(sender As Object, e As TextChangedEventArgs)
    If inicializando Then Return

    rtbModificado = True
End Sub



Private Sub Window_Closing(sender As Object, e As CancelEventArgs)
    ' Comprobar si están modificados
    If rtbModificado Then
        If MessageBox.Show("El texto está modificado," & vbCrLf &
                           "¿Quieres guardarlo?",
                           "Texto Modificado",
                           MessageBoxButton.YesNo,
                           MessageBoxImage.Question) = MessageBoxResult.Yes Then
            rtb.Focus()
            MnuGuardar_Click(mnuGuardar, Nothing)
        End If
    End If
End Sub
private void Rtb_TextChanged(object sender, TextChangedEventArgs e)
{
    if (inicializando)
        return;

    rtbModificado = true;
}

private void Window_Closing(object sender, CancelEventArgs e)
{
    // Comprobar si est\f2án modificados
    if (rtbModificado)
    {
        if (MessageBox.Show("El texto está modificado,\r\n" + 
                            "¿Quieres guardarlo?", 
                            "Texto Modificado", 
                            MessageBoxButton.YesNo, 
                            MessageBoxImage.Question) == MessageBoxResult.Yes)
        {
            rtb.Focus();
            MnuGuardar_Click(mnuGuardar, null);
        }
    }
}

Ah, sí, una cosilla que he puesto en el evento de carga de la ventana (evento Window_Loaded) en el que asigno un ancho grande al documento interno del RichTextBox con idea de que no se muestren las líneas cortadas (ver figuras 1 y 2).

Figura 1. Si no asignamos un valor grande a Document.PageWidth, las líneas largas se mostrarán partidas
Figura 1. Si no asignamos un valor grande a Document.PageWidth, las líneas largas se mostrarán partidas
Figura 2. Al asignar un valor alto a Document.PageWidth las líneas no se cortan
Figura 2. Al asignar un valor alto a Document.PageWidth las líneas no se cortan

Nota:
El archivo mostrado en las figuras 1 y 2 es uno en formato RTF coloreado por mi aplicación gsColorear.

Lo que hago es asignar un valor 2000 a la propiedad PageWidth del objeto Document del RichTextBox (si crees que tendrás líneas de más de 2000, pues ponle un valor mayor).

Ese ejemplo (o el truco para hacer eso) lo saqué (creo) de un foro de StackOverflow:
C#/WPF: Disable Text-Wrap of RichTextBox.

Private Sub Window_Loaded(sender As Object,
                          e As RoutedEventArgs)
    ' Para que no corte las líneas
    rtb.Document.PageWidth = 2000

    lblStatus.Content = My.Application.Info.Copyright & " - " &
                        My.Application.Info.Description

    inicializando = False

    rtb.Focus()

End Sub
private void Window_Loaded(object sender, RoutedEventArgs e)
{
    // Para mostrar la info del Copyright y Description
    FileVersionInfo fvi;
    System.Reflection.Assembly ensamblado;
    ensamblado = System.Reflection.Assembly.GetExecutingAssembly();
    fvi = FileVersionInfo.GetVersionInfo(ensamblado.Location);

    // Para que no corte las líneas
    rtb.Document.PageWidth = 2000;

    //lblStatus.Content = My.Application.Info.Copyright + " - " +
    //                    My.Application.Info.Description;

    lblStatus.Content = fvi.LegalCopyright + " - " +
                        fvi.Comments;

    inicializando = false;

    rtb.Focus();
}

Nota:
Esto ocurre (que se corten las líneas) porque el control RichTextBox no tiene una propiedad TextWrapping como ocurre con el control TextBox.

Eso mismo se puede hacer asignando el valor directamente en la definición del objeto FlowDocument del RichTextBox:

<FlowDocument PageWidth="2000" />

Resaltar en el código para C# que como no tiene el objeto My de Visual Basic, para acceder a la información del Copyright y Description uso llamadas directas a la información ofrecida por la clase FileVersionInfo a partir del ensamblado actual.

Pues ya está, esto es todo… para la próxima ocasión veremos cómo cambiar algunas propiedades del contenido del RichTextBox, como por ejemplo el tipo y tamaño de la letra y algunas cosillas más, ya que si pruebas a abrir un archivo de texto plano, pues… como que no se ve muy bien, en la figura 3 tienes un ejemplo de cómo se vería un archivo de C# (sin colorear).

Figura 3. Así se vería el contenido de un archivo abierto como texto
Figura 3. Así se vería el contenido de un archivo abierto como texto

Nos vemos.
Guillermo

Aquí tienes el código completo para poder usarla (una vez descomprimido) con la solución para Visual Studio 2017. Están los dos proyectos, el de Visual Basic y el de C# (como de costumbre).

El zip: Wpf_Abrir_guardar_RichTextBox_20190112_2355.zip (34.7 KB)

MD5 Checksum: 461518743ED0913B642C788342774057

Crear un icono con Visual Studio a partir de una imagen

Pues eso… esto en realidad lo empecé a incluir en el post que estoy escribiendo sobre cómo implementar las opciones de abrir y guardar archivos usando un control RichTextBox para WPF, opero se iba a hacer demasiado largo, así que… he decidido publicarlo como post separado, ya que creo que puede servir para otra gente que no quieran saber nada sobre WPF ni RichTextBox 😉

Yo estoy usando Visual Studio 2017, pero creo que servirá con las versiones anteriores.

Lo que te voy a explicar es cómo crear un icono a partir de una imagen incluida como recurso en el proyecto, concretamente en una carpeta llamada Images. Como Visual Basic y C# no tienen exactamente las mismas opciones a la hora de añadir un nuevo icono ni a la hora de seleccionar el icono del proyecto, te pongo capturas diferenciadas para cada uno de esos lenguajes. El resto de acciones son comunes a los dos lenguajes.

Veamos paso a paso cómo crear un icono a partir de una imagen

Lo primero es seleccionar la imagen que queremos como un icono (figura1), con el botón secundario del ratón y elegimos la opción Abrir con… eso nos muestra otra ventana (figura 2) seleccionamos Paint y pulsamos en Aceptar.

Figura 1. Abrir la imagen a usar como icono
Figura 1. Abrir la imagen a usar como icono
Figura 2. Abrir con Paint
Figura 2. Abrir con Paint

La imagen se abre en Paint, allí indicamos Seleccionar todo y después le damos a copiar y ya tenemos la imagen en el portapapeles. ¡No la dejes escapar! Winking smile

Volvemos a Visual Studio y agregamos al proyecto un nuevo archivo de tipo icono (figura 3): Menú contextual sobre el proyecto>Agregar>Nuevo elemento…

Figura 3. Añadir un nuevo archivo de tipo icono
Figura 3. Añadir un nuevo archivo de tipo icono

Nota:
En C# te mostrará una lista con todo lo que puedes añadir, entre los cuales se incluye Archivo de icono.
En Visual Basic, te mostrará la lista de Elementos comunes, tendrás que selecciona la rama General y ahí estará el Archivo de icono.

Habrá un montón de tipos de imágenes con varias resoluciones, pero la que nos interesa es la de 16×16 de 24 bits, que no está, así que… tendrás que añadirla. Pulsa con el botón secundario del ratón sobre una de las imágenes que hay para que muestre el menú contextual y selecciona Nuevo tipo de imagen… y tendrás un cuando de diálogo como el mostrado en la figura 4.

Figura 4. Añadimos una imagen de 16x16 de 24 bits
Figura 4. Añadimos una imagen de 16×16 de 24 bits

Nota:
Lo mismo piensas que la de 32 bits nos puede valer, ¡pero no! ya que en ese tipo de imágenes, Visual Studio no permite la edición.

En la barra de herramientas de edición de imágenes selecciona Herramienta Seleccionar rectángulo (figura 5) (para que se seleccione la imagen y poder pegar en ella) y dale a pegar y te quedará algo como lo mostrado en la imagen 6. El icono ese de 256 es uno de los que estaban ya al crear el icono.

Figura 5. Seleccionamos Herramienta Seleccionar rectángulo
Figura 5. Seleccionamos Herramienta Seleccionar rectángulo
Figura 6. Aspecto al pegar la imagen copiada en la memoria en el icono
Figura 6. Aspecto al pegar la imagen copiada en la memoria en el icono

Todos los iconos que hay, salvo el de 16×16 de 24 bits, los tenemos que eliminar. Para ello, selecciona el icono a eliminar, pulsa con el botón secundario del ratón y del menú desplegable que te muestra, elige Eliminar tipo de imagen (figura 7). Eso lo tienes que hacer con todas las imágenes, salvo la que nos interesa.

Figura 7. Eliminar los tipos de imágenes que no nos interesan
Figura 7. Eliminar los tipos de imágenes que no nos interesan

Una vez que hemos quitado las imágenes que nos sobran, guárdalo.

El siguiente paso es abrir las propiedades del proyecto y seleccionar el icono que hemos guardado. En las propiedades de Aplicación selecciona el icono. En Visual Basic será Icono (figura 8) y en C# será donde indica Icono y manifiesto (figura 9). En ambos casos, el icono que acabamos guardado estará en la lista de iconos disponibles.

Figura 8. Seleccionar el icono en el proyecto de Visual Basic
Figura 8. Seleccionar el icono en el proyecto de Visual Basic
Figura 9. Seleccionar el icono en el proyecto de C#
Figura 9. Seleccionar el icono en el proyecto de C#

¡Y ya está!

Espero que te sea de utilidad.

Nota:
La imagen usada para el icono es una basada en una imagen PNG que se incluye con los recursos de Visual Studio 2017, concretamente RichTextBox_16x.png.

Si quieres las imágenes de recursos de Visual Studio 2017, pulsa en el siguiente enlace: Biblioteca de imágenes de Visual Studio.

Nos vemos.
Guillermo