Archivo de la categoría: mis cosas

Posts de tipo personal o al menos que no son técnicos

Un regalito a una suscripción a Visual Studio Enterprise (por 12 meses)

Pues eso… que te acabo de contar que la licencia de Visual Studio 2017 Professional que parecía que me habían dado hace unos meses ya había expirado (y parecía que era definitiva y no de prueba) y acabo de abrir el correo y me encuentro que me han dado una suscripción a Visual Studio Enterprise (válida por un año) tal como puedes ver en la captura de la figura 1.

Un regalito para un ex-MVP (ahora rMVP)
Figura 1. Un regalito para un ex-MVP (ahora rMVP)

Esta suscripción (para 12 meses) contiene el Visual Studio y muchas más cosas (Windows, Office, etc.), como las antiguas suscripciones a MSDN que nos daban a los MVP reconocidos como developers… pero esta vez la dan por 12 meses a algunos ex-MVP ahora llamados MVP Reconnect (rMVP) y puede que la renueven… a ver qué pasa dentro de un año.

¡Muchas gracias!

Nos vemos.
Guillermo

Donde dije digo, digo Diego (y buscar las referencias a un método)

Pues eso… como te comenté hace unos meses (Tiene una licencia para Visual Studio Professional 2017) resulta que solo era de evaluación, pero se ve que de unos tres meses… en fin… eso de que no digan las cosas claras es un poco frustrante, por decir algo suave, ya que en ningún lugar decían nada de que fuese una licencia de prueba, en fin… uno que siempre intenta ver la parte buena… Winking smile

Nota:
Poco después de publicar esta entrada he abierto el correo y me encontrado con un bonito regalo: Un regalito a una suscripción a Visual Studio Enterprise (por 12 meses).
Gracias

Pero resulta que solo era una licencia temporal… o al menos así lo dice la captura de la ventana de aviso que me ha salido (ver la figura 1).

La licencia de prueba ha expirado
Figura 1. La licencia de prueba ha expirado

En esta ocasión si dice que “era” una licencia de prueba (Trial extension), en fin…

Pero no me importa, con la versión Community me apaño, ya que en realidad la versión Professional la instalé porque tenía una cosilla que me venía muy bien: saber dónde se estaban usando los métodos de mis clases, (con enlaces a cada uno de los sitios en los que se accedía al método) cosa que desde hace unos meses ya no aparece, al menos como aparecía antes: encima de la definición del método.

 

Buscar todas las referencias a un método

Si te sitúas en la definición de un método y pulsas en el menú contextual, te saldrá algo como lo mostrado en la figura 2 y seleccionando Buscar todas las referencias te mostrará una lista desde dónde se accede a ese método (ver la figura 3).

Menú contextual de la definición de un método
Figura 2. Menú contextual de la definición de un método
Las referencias al método
Figura 3. Las referencias al método

Nota:
Comentarte que no solo se pueden ver las referencias a un método, también a las clases y otros tipos definidos.

Y esto es todo… seguiré con la versión Community de Visual Studio 2017 y (mientras tenga acceso) a las versiones Preview de Visual Studio 2019 y cuando salga la definitiva (recuerda que está prevista para el 2 de abril) si no consigo una versión mayor, seguiré con la de la comunidad (que esa sí que es gratuita de por vida… o al menos por ahora lo es).

Nos vemos.
Guillermo

ApplicationCommands, localización u otras historias idiomáticas

Pues eso… si has usado alguna vez los ApplicationCommands en una aplicación WPF sabrás de que te hablo, al menos si has trabajado con el Visual Studio en un idioma diferente al inglés o si tienes una versión de Windows configurada con otro idioma diferente al inglés, que para el caso es lo mismo… o casi…

Si has mirado el enlace de ApplicationCommands sabrá que son comandos para añadir funcionalidad “automática” de Guardar, Abrir, etc. a tus opciones de menús, botones o donde decidas que esos comandos se ejecuten.

Lo primero con lo que nos encontramos al añadir uno de esos comandos, por ejemplo el comando de Guardar (Save) a un elemento de menú (MenuItem) es que esa opción no estará habilitada, siempre se mostrará inhabilitada… ya que ese comando de aplicación necesita saber si la opción debe estar disponible o no…

Vayamos por pasos, así que… añadimos primero un menú Archivo a una aplicación de WPF definiendo un menú principal y la opción de Guardar, tal como vemos en el siguiente código XAML.

<Menu Grid.Row="0" Grid.Column="0" 
      Grid.ColumnSpan="2" Background="AliceBlue">
    <MenuItem Header="_Archivo" ToolTip="Abrir, Guardar, Salir">
        <MenuItem x:Name="mnuGuardar" Header="_Guardar" 
                  Command="ApplicationCommands.Save"
                  ToolTip="Guardar (Ctrl+S o Ctrl+G)"
                  Click="MnuGuardar_Click">
            <MenuItem.Icon>
                <Image Source="Images\Save_16x.png" />
            </MenuItem.Icon>
        </MenuItem>
</Menu>

En modo edición este menú se mostrará más o menos como vemos en la figura 1, en la que hay más opciones de ese menú de archivo que las mostradas en el código anterior, pero solo debes prestar atención al menú Guardar.

Figura 1. El menú Guardar usando ApplicationCommands.Save en modo diseño

Fíjate que el texto Ctrl+S lo ha añadido automáticamente. Ese sería el acceso de teclado rápido para el idioma inglés.

Decirte que esa captura la he tomando con el Visual Studio 2017 (lo mismo mostraría el VS 2019) con el idioma inglés.

Si iniciamos la aplicación, veremos dos cosas interesantes… al menos una de ellas es interesante, la otra… pues… cosas de la localización automática según el idioma de Windows, que en mi caso es el Windows 10 con el paquete de idiomas en español.

Si te fijas en la figura 2 verás que el comando Guardar está deshabilitado y la segunda cosa a destacar es que ahora no se muestra Ctrl+S si no Ctrl+G que es el equivalente a Guardar en el idioma español.

Figura 2.

¡Guay! o no… Ahora verás porque puede no ser cool (guay).

Veamos qué ocurre si el Visual Studio lo usamos con el idioma en español… pues… tal como puedes ver en la figura 3, se muestra Ctrl+G en lugar de Ctrl+S.

Figura 3. Usando el Visual Studio con el idioma en español.

Aquí vuelve a mostrar Ctrl+G tanto en modo diseño como en ejecución.

Pero lo curioso de todo esto es que ¡el acceso de teclado Ctrl+G no funciona!

El que funciona es Ctrl+S está en el idioma que esté el Visual Studio y el Windows. Pues sí, como te lo cuento…

Solucionando entuertos…

Vayamos arreglando las cosas… para empezar el que ese menú esté inaccesible (deshabilitado) es porque no le hemos dicho que se habilite.

Esto lo arreglamos añadiendo una definición en el código XAML , concretamente en la sección <Window.CommandBindings> tal como vemos en el siguiente código XAML, que estará después de la definición de la ventana.

<Window.CommandBindings>
    <CommandBinding Command="ApplicationCommands.Save" 
                    CanExecute="CommandGuardar_CanExecute"
                    Executed="CommandGuardar_Executed" />
    

</Window.CommandBindings>

Con ese código le estamos indicando que tenemos dos métodos definidos, el primero asignado a la propiedad CanExecute que es el que indica si debe estar habilitado o no ese comando, el segundo (el asignado a la propiedad Execute) es lo que debe hacer si se puede ejecutar el comando (el usuario puede pulsar en la opción del menú o usar el acceso rápido del teclado).

El siguiente código (para Visual Basic) te muestra lo que yo he hecho en esos dos comandos.

' Comando guardar
Private Sub CommandGuardar_CanExecute(sender As Object, 
                                       e As CanExecuteRoutedEventArgs)
    If IsLoaded = False Then Return
    e.CanExecute = rtbModificado
End Sub

Private Sub CommandGuardar_Executed(sender As Object, 
                                     e As ExecutedRoutedEventArgs)
    mnuGuardar.RaiseEvent(New RoutedEventArgs(MenuItem.ClickEvent))
End Sub

En el método asociado al comando CanExecute le indicamos cuando habilitar la opción, que será cuando la ventana esté cargada y se podrá ejecutar si el valor de rtbModificado es TRUE. Esa variable indicará si el texto se ha modificado.

Por otro lado, el comando Execute contiene una llamada al método que se encarga de llamar al método asociado con el evento Click del MenuItem. Fíjate que no se pone el nombre del método de evento, de cuál es ya se encargará el compilador o motor de ejecución de averiguarlo.

Ya tenemos una parte del problema resuelta. Creo que la más importante, ya que si el menú no está habilitado, pues… el resto de problemas dejan de serlos Winking smile

Ahora veamos cómo dar la funcionalidad de que ese comando se ejecute si el usuario que utiliza nuestra aplicación en un entorno con el idioma español pulsa Ctrl+G (recuerda que te dije que aunque se muestra Ctrl+G, el acceso rápido sigue siendo Ctrl+S).

Lo que necesitamos es añadir funcionalidad a la pulsación de teclas Ctrl+G y que esté relacionado con el comando guardar.

Decirte que no vale (o al menos no vale la pena) intentar interceptar en la aplicación esa combinación de teclas, ya que tenemos una forma más fácil de hacerlo… al menos si se sabe cómo hacerlo… y ya sabes… aquí esta el Guille para decirte cómo… jejeje.

En el código XAML de la definición de la ventana, creamos una sección llamada <Window.InputBindings> (la podemos poner detrás de la que creamos antes para definir los comandos). Y añadimos lo siguiente:

<Window.InputBindings>
    <!-- podemos indicar las teclas a usar con los comandos definidos 
         aunque no estén asociados a ningún control ni MenuItem -->

    <!-- aunque muestra Ctrl+G en realidad usa Ctrl+S por eso defino Ctrl+G -->
    <KeyBinding Command="ApplicationCommands.Save" Key="G" Modifiers="Ctrl" />


</Window.InputBindings>

Y eso es todo, por supuesto la combinación predeterminada (Ctrl+S) sigue funcionando.

Decirte que no todas las combinaciones que pongas ahí se tendrán en cuenta, hay algunas combinaciones que ya están asociadas a otros comandos que no podrás usar.

Además me ha ocurrido que hay ciertas combinaciones de teclas que tampoco se pueden usar y aparentemente no están asociadas a nada… (por ejemplo Ctrl+Shift+S que en Visual Studio es Guardar todo, pero en mi aplicación… ¿qué comando es?). En fin… misterios por resolver I don't know smile

Nos vemos.
Guillermo

Ya están los foros en modo SOLO-LECTURA

Pues eso… ya es 1 de febrero de 2019 y como te comenté hace unos días, los foros (no el blog ni el sitio) ya está en modo SOLO-LECTURA, es decir, se podrán seguir viendo los mensajes que haya, pero no se podrán hacer nuevas consultas, ni responder a las existentes, ni tampoco editarlas. aunque sí se podrán marcar los mensajes como que responden a la pregunta o consulta realizada, pero si quieres que te diga la verdad, dudo que muchos entren nuevamente en los foros para marcar las respuestas… si no lo hicieron en su día… no lo van a hacer después de algún tiempo… Winking smile

Desde el 1 de febrero de 2019 los foros del Guille son de solo lectura

Si eres moderador de mis foros o estás en la categoría de MVP (antes debes estar registrado en los foros) podrás seguir modificando, respondiendo o escribiendo nuevos mensajes.

Los usuarios “normales” si pulsan en el botón de responder, modificar o nuevo, los mandará a la página de aviso de que está cerrado.

Por cierto, si quieres colaborar comprobando las respuestas a los mensajes para ver si responden a la pregunta, coméntalo en este mismo post y así los foros tendrán un valor añadido. Gracias.

Y esto es todo por ahora…. en marzo nuevos cambios… espero…

Nos vemos.
Guillermo

Quitar avisos de Windows 10 al instalar con ClickOnce

Pues eso… que el otro día estaba probando en mi equipo con Windows 10 la instalación con ClickOnce de una aplicación y era un rollo la de preguntas que te decía, que si te está protegiendo, que no confía en la aplicación, y cosas así (ver figura 1).

Figura 1. Aviso de Windows 10 al instalar con ClickOnce desde un sitio Web
Figura 1. Aviso de Windows 10 al instalar con ClickOnce desde un sitio Web

La solución es simple.

Pero debes hacerlo en el equipo en el que se va a instalar la aplicación.

Panel control>opciones internet>Seguridad>Sitios de confianza>sitios (agregar la dirección web)

Abre el Panel de Control, (si no lo tienes a mano abre Inicio y escribe “panel” y te lo mostrará), selecciona Opciones de Internet (si no ves las opciones de internet, pulsa en Redes e Internet) se mostrará una ventana como la de la figura 2.

Figura 2. Propiedades de Internet.
Figura 2. Propiedades de Internet.

Pulsa en la pestaña Seguridad, a continuación en Sitios de confianza y en el botón Sitios. Te mostrará una ventana nueva con los Sitios de confianza (figura 3).

Figura 3. Sitios de confianza.
Figura 3. Sitios de confianza.

Si tu sitio no es https quita la marca de abajo a la derecha donde dice “Requerir comprobación del servidor (https:) para todos los sitios de esta zona“.

Escribe el nombre de tu sitio en “Agregar este sitio web a la zona de:” (sin el http:// ni https://) y pulsa en el botón Agregar.

Cierra todas las ventanas y ya no tendrás más avisos como el de la figura 1 (y otros parecidos) cuando se vuelva a instalar (o actualizar) algo desde el sitio que has indicado.

Y ya está… Smile

Espero que te sea de utilidad.

Nos vemos.
Guillermo

En breve cerraré los foros del Guille

Pues eso.,.. me refiero a la página: http://foros.elguille.info/ no al blog, ni al sitio ni la página de Facebook Winking smile

Ya han pasado unos 15 años desde que los puse en marcha (hubo antes otras versiones de los foros, pero me refiero al que está actualmente ¿activo?) y no hay prácticamente movimiento, ni por mi parte… así que… si no cambio de opinión… el 31 de enero de este año 2019 será el último día que se podrá postear en los foros de elGuille.info… y a partir del 1 de febrero de 2019 serán de solo lectura (o solo para consultar y ver los hilos), porque quitarlo no lo voy a quitar, ya que sé que hay respuestas válidas, y muchas… Si acaso quitaré visibilidad a los hilos que no han obtenido respuesta, más que nada para que no aparezcan en los buscadores, que no es plan que alguien busque algo y le aparezca solo la pregunta sin respuesta (que suele ocurrir en muchos foros, jeje).

Los foros de elGuille.info pasarán a solo lectura el 1 de febrero de 2019
Los foros de elGuille.info pasarán a solo lectura el 1 de febrero de 2019

Pues eso… si quieres dar tu opinión, puedes darla en este hilo.

Gracias.

Nos vemos.
Guillermo

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