Archivo de la etiqueta: .NET core

Contar las palabras de un texto usando expresiones regulares (RegEx)

Pues eso… que estoy preparando el artículo para usar dos RichTextBox de WPF sincronizados y esta es una de las cosas que allí (cuando lo publique) te explicaré. Hay muchas cosas que te tengo que explicar, así que… hoy empiezo por la más simple o que menos texto necesita Winking smile

Esto es sencillo, pero… lo necesité para mostrar el número de palabras del documento activo (en el ejemplo de los RichTextBox sincronizados voy a usar 2 RichTextBox y un TextBox, los tres sincronizados -si así lo decides- ) y no lo investigué… preferí buscar una solución que alguien haya publicado ya… es que esto de las expresiones regulares, más que regulares son malas jajajajaja.

En serio, encontré un sitio web, en realidad un foro de Microsoft en el que alguien respondía con el código que te voy a mostrar, eso sí, el código original está en C# y para la aplicación base (ya sabes que empiezo escribiendo los ejemplos o mis aplicaciones con Visual Basic para .NET).

Una vez que se ve el código, uno dice… ¡pos qué fácil era! pero como todas estas cosas, hay que hacerlo primero Winking smile

Este es el código de una función que recibe una cadena de texto y devuelve el número de palabras que hay.

La versión de Visual Basic .NET

''' <summary>
''' Contar las palabras de una cadena de texto
''' 
''' Adaptado usando una cadena en vez del Text del RichTextBox
''' (sería del RichTextBox para WinForms)
''' El código lo he adaptado de:
''' https://social.msdn.microsoft.com/Forums/en-US/
'''     81e438ed-9d35-47d7-a800-1fabab0f3d52/
'''     c-how-to-add-a-word-counter-to-a-richtextbox
'''     ?forum=csharplanguage
''' </summary>
Private Function TextWordCount(texto As String) As Integer
    Dim wordColl As MatchCollection = Regex.Matches(texto, "[\W]+")
    Return wordColl.Count
End Function

La versión de C#:

/// <summary>
/// Contar las palabras de una cadena de texto
/// 
/// Adaptado usando una cadena en vez del Text del RichTextBox
/// (sería del RichTextBox para WinForms)
/// El código lo he adaptado de:
/// https://social.msdn.microsoft.com/Forums/en-US/
///     81e438ed-9d35-47d7-a800-1fabab0f3d52/
///     c-how-to-add-a-word-counter-to-a-richtextbox
///     ?forum=csharplanguage
/// </summary>
private int TextWordCount(string texto)
{
    MatchCollection wordColl = Regex.Matches(texto, @"[\W]+");
    return wordColl.Count;
}

Aquí tienes un ejemplo de uso en una aplicación de consola de .NET Core para Visual Basic y la salida del código.

Imports System
Imports System.Text.RegularExpressions

Module Program
    Sub Main(args As String())
        Dim s = "Hello World de las aplicaciones de consola en .net core!"
        Console.WriteLine(s)
        Dim w = TextWordCount(s)

        Console.WriteLine($"la cadena anterior tiene {w} palabras")

        Console.ReadKey()
    End Sub

    ''' <summary>
    ''' Contar las palabras de una cadena de texto
    ''' 
    ''' Adaptado usando una cadena en vez del Text del RichTextBox
    ''' (sería del RichTextBox para WinForms)
    ''' El código lo he adaptado de:
    ''' https://social.msdn.microsoft.com/Forums/en-US/
    '''     81e438ed-9d35-47d7-a800-1fabab0f3d52/
    '''     c-how-to-add-a-word-counter-to-a-richtextbox
    '''     ?forum=csharplanguage
    ''' </summary>
    Private Function TextWordCount(texto As String) As Integer
        Dim wordColl As MatchCollection = Regex.Matches(texto, "[\W]+")
        Return wordColl.Count
    End Function

End Module

Y esta es la salida por la consola de ese código.

Y esto es todo. Smile

¡Mañana más!

Nos vemos.
Guillermo

P.S.
Ese código funciona también en .NET Core, la captura es de una aplicación de consola de .NET Core

Cómo usar las Tuplas en Visual Basic y C Sharp con .NET Core 2.1 (o Visual Studio 2017 con .NET 4.7.2)

Pues eso… aquí te voy a explicar (con ejemplo de código) cómo definir y usar las tuplas (Tuples) en Visual Basic .NET (y para los amantes de C#, también pondré algunos ejemplos en ese lenguaje puntoycomagudo Winking smile)

En esta primera «entrega» te voy a dar 3 ejemplos (+ 1 extra) de cómo usar las tuplas con .NET Core 2.1 (si prefieres hacerlo con .NET normal tendrás que usar la versión 4.7.2 o superior) en una aplicación de Consola.

El contenido es el siguiente:

Ejemplo 1: definir las tuplas sin nombres
Ejemplo 2: definir las tuplas con nombres y asignación después de definir
Ejemplo 3: definir las tuplas con nombres y asignando al definir
Ejemplo 4: definir las tuplas con nombres y asignando al definir (al estilo de C#)
Ejemplo 5: definir un método que recibe un array tuplas

Mmmmm… te dije 3 + un extra y resulta que son 4 + un extra Winking smile

Si no sabes qué son las tuplas, decirte que son como una estructura (Struct) pero definidas de forma «directa» sin necesidad de crear el tipo previamente.

Si quieres saber más sobre las tuplas, te recomiendo que leas la documentación de .NET:
Tipos de tupla en C#
Tuplas (Visual Basic)

Código de uso de Tuplas (Tuples) en Visual Basic

Ejemplo 1: Ejemplo básico de tuplas sin definir los nombres de los miembros:

' Al definirla de esta forma 
' tenemos una tupla con dos elementos del tipo cadena
Dim t1 = ("Hola", "mundo")

' para acceder a los miembros usaremos Item1, Item2
Console.WriteLine("{0} {1}", t1.Item1, t1.Item2)

Ejemplo 2: Definimos una tupla con miembros con nombres, asignando los nombres individualmente. Para acceder a los miembros de la tupla usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 As (saludo As String, destino As String)
' para acceder a los miembros, usamos los nombres
t2.saludo = "Hola"
t2.destino = "Mundo"

Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 3: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 As (saludo As String, destino As String) =
("Hola", "Mundo") ' para acceder a los miembros, usamos los nombres Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 4: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

' definimos una tupla con miembros con nombres
Dim t2 = (saludo:="Hola", destino:="Mundo")
' para acceder a los miembros, usamos los nombres
Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

Ejemplo 5 (extra): Método que recibe un array de tipo «tupla».

Este código es un método llamado colorear que recibe un array del tipo (ConsoleColor, String), se procesa cada uno de los elementos del array y se usa el valor del color para indicar el color del valor ForegroundColor (color del texto) de la clase Consola, el contenido del valor String lo usamos para mostrarlo en la consola por medio de WriteLine.

Con ese código se consiguen salidas en la ventana de la consola como la siguiente:

tuplasVB_04

El código del método colorear es el siguiente:

''' <summary>
''' Colorear la salida de los ejemplos, 
''' también usando tuplas 😉
''' Se pasa como argumento 
''' un array del tipo (color As ConsoleColor, texto As String)
''' </summary>
''' <param name=items">un array del tipo (color As ConsoleColor, texto As String)</param>"
Private Sub colorear(items As (color As ConsoleColor, texto As String)())
    For Each it In items
        Console.ForegroundColor = it.color
        Console.WriteLine(it.texto)
    Next

    Console.ForegroundColor = co.Gray
    Console.WriteLine()
End Sub

Para usarlo podemos hacer como en el código para el cuarto ejemplo:

Private Sub ejemplo4()
    colorear({(co.Green, "definimos una tupla con miembros con nombres"),
              (co.Green, "(asignando los valores al definirla)"),
              (co.Yellow, "Dim t2 = (saludo:=""Hola"", destino:=""Mundo"")"),
              (co.Green, "para acceder a los miembros, usamos los nombres"),
              (co.Yellow, "Console.WriteLine(""{0} {1}"", t2.saludo, t2.destino)")})

    ' definimos una tupla con miembros con nombres
    Dim t2 = (saludo:="Hola", destino:="Mundo")
    ' para acceder a los miembros, usamos los nombres
    Console.WriteLine("{0} {1}", t2.saludo, t2.destino)

    Console.ReadLine()
End Sub

Nota:
Es curioso, pero resulta que es más fácil definir los parámetros (de tipo array o matriz) directamente en la llamada del método colorear en Visual Basic que en C#.
En Visual Basic se indica el array del tipo tupla de la siguiente forma:

colorear({
    (co.Green, «definimos una tupla con miembros con nombres»),

     (co.Green, «(asignando los valores al definirla)»),     (co.Yellow, «Dim t2 = (saludo:=»»Hola»», destino:=»»Mundo»»)»),

     (co.Green, «para acceder a los miembros, usamos los nombres»),

     (co.Yellow, «Console.WriteLine(«»{0} {1}»», t2.saludo, t2.destino)»)})

Mientras que en C# hay indicar que es un nuevo array:
colorear(new []{
       (co.Green, «definimos una tupla con miembros con nombres»),
       (co.Green, «(asignando los valores al definirla)»),
       (co.Yellow, «var t2 = (saludo:\»Hola\», destino:\»Mundo\»);»),
       (co.Green, «para acceder a los miembros, usamos los nombres»),
       (co.Yellow, «Console.WriteLine(\»{0} {1}\», t2.saludo, t2.destino);»)});

Y esto es todo por hoy.
Bueno, no, más abajo te muestro el código de estos dos últimos códigos para C#.

Nota:
En otra ocasión te mostraré más código de ejemplo del uso de tuplas en Visual Basic y C#, seguramente usando funciones que devuelvan tuplas y cómo usar la «inferencia» de los argumentos con nombre… ¿se podrá hacer eso con Visual Basic? sí se puede… pero necesita más explicación, ya que el Visual Studio 2017 no lo compilará y hay que hacer «un tuquillo» para que lo compile. Con C# tampoco lo compila, y también hay que hacer un truco similar al de Visual Basic.
En realidad no te lo explico aquí porque no lo había probado, entre otras cosas porque no me ha hecho falta; lo de la función que devuelve una tupla si que lo he usado en una aplicación que estoy haciendo actualmente.

Espero que te sea de utilidad Smile

Nos vemos.
Guillermo

P.S. 09/Dic/18:
No es un artículo dedicado a las tuplas, pero en el ejemplo que publiqué ayer sobre el Error al guardar datos decimales: El valor del parámetro ‘xxx’ está fuera del intervalo tienes un ejemplo de cómo usar una función que devuelve una tupla.

Private Function AñadirMiTabla1(valor As Decimal) As (hayError As Boolean, msg As String)

private (bool hayError, string msg) AñadirMiTabla1(decimal valor)

P.S.

Código de uso de Tuplas (Tuples) en C#

Ejemplo 1: Ejemplo básico de tuplas sin definir los nombres de los miembros:

// Al definirla de esta forma
// tenemos una tupla con dos elementos del tipo cadena
var t1 = ("Hola", "mundo");

// para acceder a los miembros usaremos Item1, Item2
Console.WriteLine("{0} {1}", t1.Item1, t1.Item2);

Ejemplo 4: Definimos una tupla con miembros con nombres, asignando los valores al definirla. Para acceder a los miembros, usamos los nombres.

// definimos una tupla con miembros con nombres
var t2 = (saludo: "Hola", destino: "Mundo");
// para acceder a los miembros, usamos los nombres
Console.WriteLine("{0} {1}", t2.saludo, t2.destino);

Ejemplo 5 (extra): Método que recibe un array de tipo «tupla».

Este código es un método llamado colorear que recibe un array del tipo (ConsoleColor, string), se procesa cada uno de los elementos del array y se usa el valor del color para indicar el color del valor ForegroundColor (color del texto) de la clase Consola, el contenido del valor string lo usamos para mostrarlo en la consola por medio de WriteLine.

Con ese código se consiguen salidas en la ventana de la consola como la siguiente:

tuplasCS_04

El código del método colorear es el siguiente:

/// <summary>
/// Colorear la salida de los ejemplos,
/// también usando tuplas 😉
/// Se pasa como argumento
/// un array del tipo (ConsoleColor color, string texto)
/// </summary>
/// <param name=items">un array del tipo (ConsoleColor color, string texto)</param>"
static private void colorear((ConsoleColor color, string texto)[] items)
{
    foreach (var it in items)
    {
        Console.ForegroundColor = it.color;
        Console.WriteLine(it.texto);
    }

    Console.ForegroundColor = co.Gray;
    Console.WriteLine();
}

Para usarlo podemos hacer como en el código para el cuarto ejemplo:

/// <summary>
/// Definimos una tupla con miembros con nombres
/// (asignando los valores al definirla)
/// Para acceder a los miembros, usamos los nombres
/// </summary>
static private void ejemplo4()
{
    //new (co color,string texto)[]

    colorear(new []{
          (co.Green, "definimos una tupla con miembros con nombres"),
          (co.Green, "(asignando los valores al definirla)"),
          (co.Yellow, "var t2 = (saludo:\"Hola\", destino:\"Mundo\");"),
          (co.Green, "para acceder a los miembros, usamos los nombres"),
          (co.Yellow, "Console.WriteLine(\"{0} {1}\", t2.saludo, t2.destino);")});

    // definimos una tupla con miembros con nombres
    var t2 = (saludo: "Hola", destino: "Mundo");
    // para acceder a los miembros, usamos los nombres
    Console.WriteLine("{0} {1}", t2.saludo, t2.destino);

    Console.ReadLine();
}

¡Hasta el siguiente post! Smile