lunes, 30 de noviembre de 2015

Cadenas de Caracteres y Manipulación de Texto en C# - Parte 3/5: Comparación de Cadenas de Caracteres

Índice

1. Introducción
2. Palabras Clave
3. Comparación de Valores en .NET
3.1 Comparación semántica
3.2 Comparación ordinal
3.3 Modos de comparación
3.4 Comparación de cadenas de caracteres
3.5 Comparación de cadenas de caracteres por orden
4. Compración Ordinal vs. Comparación Cultural de Cadenas de Caracteres
5. Comparación Semántica de Cadenas de Caracteres
6. Comparación Ordinal de cadenas d ecaracteres
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

En esta tercera parte de la serie Manipulación de Texto y Cadenas de Caracteres en C#, se estudia los métodos de comparación de cadenas de caracteres: comparación semántica y comparación ordinal. Estos métodos de comparación son de inmensa utilidad a la hora de construir nuevos tipos de datos para nuestros proyectos de ingeniería de software, o usar los definidos en las bibliotecas nativas de .NET Framework o desarrolladas por terceros, las cuales requieran un granulado sistema de comparación e igualdad. En especial se estudian los siguientes temas esenciales: comparación cultural vs comparación ordinal, comparación semántica de cadenas de caracteres y comparación ordinal de cadenas de caracteres.

2. Palabras Clave

  • Cadenas de caracteres
  • Comparación
  • Comparación ordinal
  • Comparación semántica
  • Cultura
  • Igualdad

3. Comparación de Valores en .NET

En Microsoft .NET se distingue entre la comparación semántica y la comparación ordinal (Albahari, 2012).

3.1 Comparación semántica

La comparación semántica -también conocida como comparación de igualdad- se caracteriza por determinar o validar si dos instancias son a nivel semántico iguales, es decir, si sus valores tienen el mismo significado en un determinado contexto (Albahari, 2012).

3.2 Comparación ordinal

Por su parte, la comparación ordinal consiste en comparar dos instancias respecto al orden natural de su tipo de dato. En el caso de números enteros la comparación ordinal consiste en determinar cuál es menor -descendencia-, cuál es mayor -ascendencia- o si los valores iguales.

3.3 Modos de comparación

Hay que tener en cuenta que estos modos de comparación son totalmente independientes y ninguno de ellos es una subcategoría del otro. Esto se advierte en Albahari (2012) de la siguiente manera:
"It's legal, for instance, to have two unequal values in the same ordering position."
Esto quiere decir que dos valores distintos pueden ocupar un misma posición de orden. Se puede pensar en este caso en agrupaciones o jerarquías de valores, por ejemplo.

3.4 Comparación de cadenas de caracteres

Para la comparación de cadenas de caracteres, el cual es tema principal de esta serie de artículos, el programador puede usar las siguientes dos alternativas:
  • el operador == o 
  • el método static Equals de la clase String
Para comparaciones básicas basta con el uso del operador ==, pero para comparaciones más granulares o especializadas, es preferible recurrir a la última opción: el método Equals. Con esto último el programador puede especificar opciones para no distinguir entre minúsculas y mayúsculas; algo que no se puede lograr con el operador nativo ==.

En Albahari (2012) se hace la siguiente advertencia:
"Another difference is that == does not work reliably on strings if the variables are cast to the object type."
En resumen, el operador de igualdad, ==, no es apto para comparar cadenas de caracteres convertidas al tipo de dato base object.

3.5 Comparación de cadenas de caracteres por orden

En .NET Framework el desarrollador encontrará los métodos de instancia: 
  • CompareTo
  • Compare, y 
  • CompareOrdinal
para efectuar una comparación ordinal entre instancias. Estos métodos se caracterizan por su tipo de retorno: que consiste en un número entero que determina su posición en una jerarquía de orden -ascendente o descendente-.

4. Comparación Ordinal vs. Comparación Cultural de Cadenas de Caracteres

.NET Framework cuenta con dos algoritmos de comparación de cadenas de caracteres (Albahari, 2012)
  • Ordinal y  
  • Cultural-sensitivo
Estos dos algoritmos de comparación de cadenas de caracteres se diferencian en que el primero, el ordinal, lleva a cabo las comparaciones de forma numérica. Esta comparación considera el valor numérico asignado en el juego de caracteres Unicode; mientras que el segundo, cultural-sensitivo, las comparaciones se interpretan de acuerdo a un alfabeto de una cultura específica (Albahari, 2012)

Vale advertir que respecto al método de comparación cultural-sensitivo existen estas dos variantes:
  • cultura actual: basada en la configuración regional del sistema actual donde se ejecuta la aplicación, y 
  • cultura no-variante: basada en el sistema americano.
Con un ejemplo se puede ampliar estos conceptos; en particular para diferenciar los algoritmos de comparación de cadenas caracteres. El siguiente programa en código fuente C# compara a nivel ordinal las cadenas de caracteres chsarp, CSharp y FSharp:

Al ejecutar este programa se obtienen los siguientes resultados -http://ideone.com/I5uOxy-:


Comparación independiente de la cultura:
einstein
Einstein
Newton

Comparación ordinal:
Einstein
Newton
einstein

Nótese que los resultados de la comparación de las cadenas "Einstein""einstein" y "Newton" con el uso StringComparer.InvariantCulture sigue el orden alfabético primeros letras minúsculas (a-z) y luego mayúsculas (A-Z); mientras que al especificar StringComparer.Ordinal para la comparación ordinal, el orden está basado en A...Z, a...z.

5. Comparación Semántica de Cadenas de Caracteres

La comparación semántica o de igualdad de cadenas de caracteres se puede llevar a cabo con los métodos 

public static bool Equals(string a, string b, StringComparison comparisonType)




public bool Equals(string value, StringComparison comparisonType)


Estos métodos están definidos en la clase String. El parámetro común de ambos métodos, StringComparison, es una enumeración con los siguientes miembros ("StringComparison Enumeration", 2015):
Miembros de StringComparison
Tabla 1. Miembros de StringComparison ("StringComparison Enumeration", 2015).

Con estos miembros de esta enumeración se especifica el modo de comparación del contenido de cadenas de caracteres.

Ejemplo de uso:

Archivo C# ComparacionSemantica.cs [Enlace alternativo][Enlace alternativo]:

Los resultados de ejecución de este código son:


¿Iguales EINSTEIN y Einstein?: True

¿Iguales Ṻ y Ǖ?: False

¿Iguales Ṻ y Ǖ?: True


La primera evaluación -línea 9- compara los valores de las cadenas de caracteres "EINSTEIN" y "Einstein" sin considerar si son o no mayúsculas; lo que da como resultado true. En el caso de la comparación ¿Iguales Ṻ y Ǖ? -línea 12- con el operador == su resultado es false debido a que son dos cadenas distintas -dos valores Unicode distintos: \u1E7A y \u01D5-.



Para el caso de ejemplo final -línea 15-, el resultado es dependiente de la configuración local de la computadora donde ejecuta el assembly.

6. Comparación Ordinal de Cadenas de Caracteres

En la clase System.String se halla el método CompareTo que cuenta con las siguientes versiones sobrecargadas ("String.CompareTo", 2015):
Método sobrecargado CompareTo
Tabla 2. Método sobrecargado CompareTo ("String.CompareTo", 2015).
Con este método de instancia se determina si una cadena de precede, procede o mantiene la misma posición en un orden específico a otra cadena de caracteres. El valor entero retornado determina su orden:
  • En caso de ser menor que cero: la instancia actual precede a otra cadena de caracteres.
  • En caso de ser igual a cero: la instancia mantiene la misma posición de orden.
  • En caso de ser mayor que cero: la instancia procede a otra cadena de caracteres.
Por ejemplo:

string cadena1 = "ani\u00ADmal";
string cadena2 = "animal";

Console.WriteLine (cadena1.CompareTo(cadena2)); // 0

Existen, además, los métodos Compare y CompareOrdinal para otros tipos de comparación. (Estos tipos de comparación se explorarán en otros artículos o recetas C#.)

7. Conclusiones

Se ha estudiado los métodos de comparación de cadenas de caracteres: semántico y ordinal. La distinción conceptual y práctica de éstos dos permite al programador conocer el conjunto de elementos de programa disponibles en .NET Framework para la comparación del contenido y orden de cadenas de caracteres. Se demostró, además, que la comparación se puede efectuar con dependencia o independencia de la configuración regional del sistema de cómputo donde se ejecuta un determinado programa que compara cadenas de caracteres. El próximo artículo de esta serie explicará la construcción de cadenas de caracteres a partir de la clase StringBuilder; en especial la propiedad de mutabilidad.

8. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
StringComparison Enumeration (System) (2015, noviembre 30). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.stringcomparison(v=vs.110).aspx.
String.CompareTo Method (System) (2015, noviembre 30). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.string.compareto(v=vs.110).aspx.


V

domingo, 29 de noviembre de 2015

Receta C# No. 6-2: Inserción de Nodos en un Documento XML

Índice

1. Introducción
2. Palabras Clave
3. Problema
4. Solución
5. Discusión de la Solución
5.1 Generalidades
5.2 Métodos de manipulación de XmlDocument
5.2.1 Método CreateElement
5.2.2 Método CreateAttribute
5.2.3 Método CreateNode
5.3 La clase XmlNode
5.3.1 Método InsertBefore
5.3.2 Método InsertAfter
6. Práctica: Código C#
7. Conclusiones
8. Literatura & Enlaces

1. Introducción

Segunda receta de la serie de recetas orientadas a la manipulación de documentos XML con el lenguaje de programación C#. En esta oportunidad se estudia el proceso de inserción de nodos en un documento XML. Para ello es necesario conocer otros de los elementos programáticos que dispone .NET Framework a través de la clase XmlDocument del namespace System.Xml: CreateElement, CreateAttribute, CreateNode; y éstos en conjugación con InsertAfter, InsertBefore y AppendChild de la clase XmlNode.

2. Palabras Clave

  • Atributo
  • Documento XML
  • Elemento
  • Nodo
  • XML

3. Problema

Se requiere modificar el contenido de un documento XML para la inserción de nuevos datos. También es necesario crear un nuevo documento XML en la memoria de trabajo.

4. Solución

La clase XmlDocument (namespace System.Xml) cuenta con varios métodos para dar solución al problema planteado. Estos métodos comprende:
  • CreateElement
  • CreateAttribute
  • CreateNode
También será necesario usar el método AppendChild de la clase XmlNode.

5. Discusión de la Solución

5.1 Generalidades

El proceso de creación o inserción de nuevos datos en un documento XML sigue estos pasos básicos:
  1. Creación del nodo a insertar, e 
  2. Inserción en la ubicación que corresponda.

5.2 Métodos de manipulación de XmlDocument

La clase XmlDocument ("XmlDocument Class", 2015) posee los métodos CreateElement, CreateAttribute y CreateNode para crear elementos -elementos, atributos y nodos- en un documento XML.

5.2.1 Método CreateElement

El método CreateElement ("XmlDocument.CreateElement", 2015) cuenta hasta con tres versiones sobrecargadas:
Métodos sobrecargados de XmlDocument.CreateElement
Tabla 1. Métodos sobrecargados de XmlDocument.CreateElement ("XmlDocument.CreateElement", 2015).
Su utilidad es la de crear elementos para la estructura de un documento XML.

5.2.2 Método CreateAttribute

De manera análoga al método anterior, con el método CreateAttribute ("XmlDocument.CreateAttribute", 2015) es posible crear atributos para nodos de un documento XML. También cuenta hasta con tres versiones sobrecargadas:
Métodos sobrecargados de XmlDocument.CreateAttribute
Tabla 2. Métodos sobrecargados de XmlDocument.CreateAttribute ("XmlDocument.CreateAttribute", 2015).

5.2.3 Método CreateNode

Al contar con una instancia de la clase XmlDocument se puede usar la invocación de una de las versiones sobrecargadas de CreateNode ("XmlDocument.CreateNode", 2015) 
Métodos sobrecargados de XmlDocument.CreateNode
Tabla 3. Métodos sobrecargados de XmlDocument.CreateNode ("XmlDocument.CreateNode", 2015).
para crear un nuevo nodo que formará parte de un documento XML especificado en la instanciación de un objeto de la clase XmlDocument.

5.3 La clase XmlNode

La clase XmlNode ("XmlNode Class", 2015) representa un nodo individual de un documento XML. Dos de sus métodos son útiles para especificar la ubicación de la estructura del documento XML donde debe ser insertado un nodo específico respecto a otro:
  • InsertBefore e
  • InsertAfter

5.3.1 Método InsertBefore

Con el método InsertBefore ("XmlNode.InsertBefore", 2015) se inserta un nodo específico antes de otro.

Sintaxis de declaración:

public virtual XmlNode InsertBefore(
XmlNode newChild,
XmlNode refChild
)

Parámetros:
  • newChild: es el nuevo nodo a insertar inmdiatamente antes de refChild.
  • refChild: es la referencia al nodo que irá inmediatamente después de newChild.

5.3.2 Método InsertAfter

El método InsertAfter realiza la operación opuesta al método InsertBefore, es decir inserta un nodo enseguida de otro.

Sintaxis de declaración:

public virtual XmlNode InsertBefore(
XmlNode newChild,
XmlNode refChild
)

Parámetros:
  • newChild: es el nuevo nodo a insertar inmediatamente delante de refChild.
  • refChild: es la referencia al nodo que irá inmediatamente después de newChild.

6. Práctica: Código C#

Es hora de crear código fuente C# para demostrar cómo usar los artefactos de la sección anterior y crear un archivo de tipo XML vacío para empezar a insertar elementos: elementos, atributos y valores.

En la línea 11 se crea un nuevo documento XML y acontinuación -línea 12- se especifica la declaración XML a usar a través del método CreateXmlDeclaration. Más adelante, en la línea 15 se inserta este nuevo nodo en el documento XML con la invocación del método AppendChild. Hasta aquí ya se tiene la estructura básica del documento XML.


A continuación, específicamente en la línea 18 se crea un nuevo nodo con el nombre Productos. A este elemento se agregarán los demás elementos. La agregación de los elementos se realiza creando nuevos nodos -líneas 22 y 37-  llamados Producto. A cada uno de estos nuevos nodos se les agrega otros nodos para el nombre del producto -líneas 30 y 44-, y su precio -líneas 33 y 47-.


Compilación: 

csc /t:exe CreacionDocumentoXml.cs


Ejecución assembly:

.\CreacionDocumentoXml.exe


> Prueba de ejecución (ideone.com): 

http://ideone.com/I1rGYA


> Prueba de ejecución (local):
Ejecución assembly CreacionDocumentoXml.exe
Figura 1. Ejecución assembly CreacionDocumentoXml.exe.

7. Conclusiones

Esta receta fue de utilidad para comprender el proceso de creación de un documento XML y la inserción de nodos en su estructura. La clase XmlDocument provee la infraestructura programática para llevar a cabo estas tareas de forma intuitiva y eficiente. En la sección práctica se demostró lo anterior por medio de la especificación de estructura y carga de datos de productos de una cafetería. La próxima receta se orientará a adjuntar nodos de forma más ágil sobre un documento XML.

8. Literatura & Enlaces

Jones, A., Freeman (2010). Visual C# 2010 Recipes: A Problem-Solution Approach. United States: Apress.
XmlDocument Class (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmldocument(v=vs.110).aspx.
XmlDocument.CreateElement Method (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmldocument.createelement(v=vs.110).aspx.
XmlDocument.CreateAttribute Method (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmldocument.createattribute(v=vs.110).aspx.
XmlDocument.CreateNode Method (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmldocument.createnode(v=vs.110).aspx.
XmlNode Class (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmlnode(v=vs.110).aspx.
XmlNode.InsertBefore Method (XmlNode, XmlNode) (System.Xml) (2015, noviembre 29). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.xml.xmlnode.insertbefore(v=vs.110).aspx.


V

sábado, 28 de noviembre de 2015

Cadenas de Caracteres y Manipulación de Texto en C# - Parte 2/5: String

Índice

1. Introducción
2. Palabras Clave
3. El Tipo de Dato por Referencia String
4. Generación y Construcción de Cadenas de Caracteres
5. Uso de Cadenas Vacías y null
6. Acceso a Caracteres Individuales
7. Búsqueda de Caracteres
8. Manipulación de Cadenas de Caracteres
9. Particionar y Unir Cadenas de Caracteres
10. Formato de Cadenas de Caracteres
11. Conclusiones
12. Literatura & Enlaces

1. Introducción

En esta segunda parte de la serie de artículos dedicados a cadenas de caracteres y manipulación de texto en C# se explica varias de las operaciones fundamentales del tipo de dato por referencia String. Temas importantes a estudiar: generación y construcción de cadenas de caracteres, cadenas vacías y null, acceso a caracteres individuales en una cadena de caracteres, búsqueda de caracteres, manipulación y particionamiento de cadenas de caracteres, y composición con formato de cadenas caracteres. Como es habitual, se introducirán ejemplos prácticos que demuestren estas capacidades inherentes en el lenguaje de programación C#. Estas mismas capacidades también se ofrecen en otros lenguajes compatible con .NET: VB.NET, C++, F#, entre otros.

2. Palabras Clave

  • .NET
  • Búsqueda
  • Cadena de caracteres
  • Carácter
  • Elemento de formato
  • Formato
  • Lenguaje de programación
  • Particionar
  • Sobrecarga

3. El Tipo de Dato por Referencia String

El tipo de dato por referencia String ("String Class", 2015) representa un grupo de caracteres de la codificación Unicode ("Unicode", 2015). Cuenta con el alias u homónimo string que cumple las mismas funciones aunque con algunas sutiles diferencias sintácticas e importación de nombres de espacio. (Se recomienda la lectura del artículo Pregunta C# (3 de 20): ¿Cuál es la Diferencia entre String y string? para saber más de sus diferencias y similitudes).

Esta clase cuenta con una serie de métodos para llevar a cabo tareas como:
  • Generación y construcción de cadenas de caracteres, 
  • Uso de cadenas vacías y null
  • Acceso a caracteres individuales, 
  • Búsqueda de caracteres, 
  • Manipulación y particionamiento de cadenas de caracteres, y 
  • Composición de cadenas de caracteres usando formato.

4. Generación y Construcción de Cadenas de Caracteres

Un objeto String puede ser compuesto a partir de una literal que represente una serie de caracteres Unicode. Ejemplo básicos de composición:

string cadena1 = "Blog xCSw";
string cadena2 = "Blog xCSw\http://ortizol.blogspot.com";
string cadena3 = "C" + "#";
string cadena4 = @"\\carpeta\\compartida\\Persona.cs";


Además, también es posible construir una cadena de caracteres usando cualquier de los constructores de la clase ("String Class", 2015):
Constructores de String
Tabla 1. Constructores de String ("String Class", 2015).
Si se desea construir una cadena que repita n veces un carácter en particular, se puede usar el tercer constructor -String(Char, Int32)-, así:

Console.WriteLine( new String ('#', 12)); // ############

De manera análoga, se puede recurrir al constructor String(Char[]) para componer una cadena de caracteres a partir de un arreglo de objetos Char:

char[] arregloCaracteres = "Blog xCSw".ToCharArray();
String cadena = new String (arregloCaracteres); // cadena = "Blog xCSw";

5. Uso de Cadenas Vacías y null

Es posible construir una cadena vacía usando alguno de estos dos métodos:
  • El literal de cadena vacía "", o 
  • Invocar el campo Empty ("String.Empty Field", 2015).
String cadenaVacia1 = "";
String cadenaVacia2 = String.Empty;

Ambas expresiones anteriores generarán una cadena vacía.

Para validar que una cadena de caracteres es vacía, se puede proceder con cualquier de estas expresiones:

Console.WriteLine (cadenaVacia1 == ""); // True
Console.WriteLine (cadenaVacia2 == String.Empty); // True
Console.WriteLine (cadenaVacia1.Length == 0); // True

Por otra parte, debido a que el tipo de dato String (o su alias string) es de tipo por referencia (Tipos por Valor vs. Tipos por Referencia), es importante considerar expresiones donde null puede estar asignado en una variable de este tipo de dato:

String nuevaCadena = null;
Console.WriteLine (nuevaCadena == null); // True
Console.WriteLine (nuevaCadena == ""); // False
Console.WriteLine (nuevaCadena.Length == 0); // Genera la excepción NullReferenceException

El hecho de intentar acceder a una función -en este caso una propiedad-, de una cadena inicializada en null genera la excepción NullReferenceException ("NullReferenceException Class", 2015).

Como se explica en Albahari (2012), a través del método String.IsNullOrEmpty ("String.IsNullOrEmpty Method", 2015) se puede validar si una cadena es null o vacía.

Console.WriteLine(!String.IsNullOrEmpty(nuevaCadena)?nuevaCadena.Length : "Cadena vacía o nula");

6. Acceso a Caracteres Individuales

Para acceder a un carácter individual de una cadena de caracteres es necesario usar el indizador (Indizadores en C#) implícito de String. Ejemplo básico de uso:

String blog = "Blog xCSw";
char caracterX = blog[5]; // caracterX == 'x'

En la sintaxis de la declaración de la clase String, se halla que ésta ("String Class", 2015) implementa la interfaz IEnumerable ("IEnumerable Interface", 2015):
Declaración clase String
Figura 1. Declaración clase String ("String Class", 2015).
Esto quiere decir que, por ejemplo, la iteración -enumeración- de cada elemento -carácter-, se puede llevar a cabo con el ciclo foreach:

foreach(char caracter in "xCSw")
{
Console.Write (caracter + " ") // x C S w
}

7. Búsqueda de Caracteres

La clase String cuenta con varios métodos para la búsqueda de caracteres en una cadena de caracteres. Principalmente se puede mencionar estos:
  • Contains
  • EndsWith y 
  • StartsWith
El tipo de retorno de cada uno de estos métodos es bool. Esto quiere decir que si la cadena en cuestión contiene el o los caracteres especificados como clave de búsqueda, retornará true.

Algunos ejemplos básicos de uso:

Console.WriteLine ("Blog xCSw".Contains ("CS")); // True
Console.WriteLine ("Blog xCSw".EndsWith ("sw")); // False

Alternativamente, en String se cuenta con el método IndexOf. Con este método se obtiene la primera posición de la ocurrencia encontrado en la cadena de caracteres objetivo. Un ejemplo básico y práctico podría ser:

Console.WriteLine ("Blog xCSw".IndexOf ("CS")); // 5

Con 

Console.WriteLine ("Blog xCSw".IndexOf ("sw")); // -1

en cambio se retorna el valor entero -1. Esto es así cuando no se ha podido encontrar la cadena especificada -i.e."sw"-.


Otro método interesante de búsqueda de caracteres es IndexOfAny. Este método retorna el índice de la primera ocurrencia de uno de los caracteres de búsqueda. Se puede considerar este ejemplo para ampliar su comprensión:


Console.WriteLine ("mvp .NET".IndexOfAny (new char[] {' ', 'p'})); // 2
Console.WriteLine ("jf.ortiz43@outlook.com".IndexOfAny ("0123456789")); // 8

8. Manipulación de Cadenas de Caracteres

En la receta Receta No. 2-1 en C#: Manipular el Contenido de una Cadena Texto Eficientemente se explica con detalle acerca de la naturaleza inmutable de los objetos declarados como String. La manipulación de una cadena de caracteres genera una nueva, dejando la original intacta. En consecuencia, los métodos que se discuten a continuación siguen esa misma propiedad de inmutabilidad.


Con el método Substring se extrae un conjunto de caracteres por medio de la especificación de un rango basado en índice 0. Para demostrarlo se escriben los siguientes ejemplos en código fuente C#:

String subcadena1 = "abcde".Substring (0, 2); // subcadena1 = "abc"
String subcadena2 = "abcde".Substring (1, 4); // subcadena2 = "bcde"


Este método posee la versión sobrecargada que sólo requiere un solo parámetro con el que se indica el inicio de extracción:

String subcadena3 = "abcde".Substring (2); // subcadena = "cde"


Otros métodos interesantes para manipulación de cadenas de caracteres son Insert y Remove. Con estos métodos se inserta o se remueve uno o más caracteres a en una posición determinada de una cadena de caracteres:

String insercion = "BlogxCSw".Insert (4, " "); // insercion = "Blog xCSw"
String remocion = insercion.Remove (4, " "); // remocion = "BlogxCSw";


Por otro lado, con PadLeft y Padright se puede alinear una cadena de caracteres a determinado número de caracteres a izquierda o derecha, respectivamente. En el alineamiento se puede usar un carácter de relleno; en caso de no especificarse ningún carácter, se usará el carácter de espacio:

Console.WriteLine ("CSharp".PadLeft (9, '#')); // ###CSharp


Trim es un método útil para la remoción espacios en blanco de una cadena de caracteres, al inicio o al final:

Console.WriteLine ("\t .NET \t\r\n ".Trim().Lenght); // 4


Finalmente, con el método Replace se reemplaza una cadena de caracteres por otra:

Console.WriteLine ("Microsoft-.NET-Framework".Replace ("-", " "); // Microsoft .NET Framework

9. Particionar y Unir Cadenas de Caracteres

Con el método Split se puede particionar una cadena de caracteres así:

String[] palabras = "Microsoft .NET Framework".Split();

foreach(String palabra in palabras)
{
Console.Write (palabra + ","); // Mirosoft,.NET,Framework,
}


Es evidente que Split particiona la cadena original usando los espacios en blancos de ésta. Sin embargo, cuenta con otros métodos sobrecargados para refinar el particionamiento:
Métodos sobrecargados Split
Tabla 2. Métodos sobrecargados Split ("String.Split", 2015).

El método opuesto es Join. Con Join es posible hacer lo siguiente:

String[] palabras = "Microsoft .NET Framework".Split();
String dotNet = String.Join (" ", palabras); // Microsoft .NET Framework


Finalmente, con Concat se concatena un conjunto de cadenas de caracteres, así:

String concatenacion = String.Concat ("Microsoft", ".NET", "Framework");


O equivalentemente con:

String nuevaCadena = "Microsoft" + ".NET" + "Framework";

10. Formato de Cadenas de Caracteres

A través del método static Format se puede especificar el formato de una cadena de caracteres. Esto es posible con la especificación de un elementos de formato. Los elementos de formato son cadenas especiales encerradas entre llaves -{ (corchete de apertura), } (corchete de cierre)- que indican el formato de una cadena de caracteres:

String cadenaCompuesta = "{0} es la capital de {1}.";
String nuevaCadena = String.Format(cadenaCompuesta, "Bogotá", "Colombia");

Cuando se imprima en la salida estándar el contenido de la variable nuevaCadena se obtendrá:

"Bogotá es la capital de Colombia."

(En "Custom Numeric Format" (2015) hay una lista de elementos de formato más extendida y con varios ejemplos prácticos).

11. Conclusiones

Se exploró varios de los métodos útiles para la manipulación, formato, búsqueda, acceso a caracteres individuales, particionamiento y unión de cadenas de caracteres. Saber y tener conocimiento práctico de los métodos discutidos amplía la capacidad de creación de programas informáticos más sofisticados y robustos. Vale mencionar, además, que se puede ampliar y profundizar en el conocimiento en cada uno de los puntos tratados; esto con el propósito de elaborar software capaz de cumplir con requerimientos más avanzados de diferentes ámbitos: comercial, científico, académico, etc. El próximo artículo estará orientado a conocer criterios de comparación de cadenas de caracteres y variación regional.

12. Literatura & Enlaces

Albahari, J., Albahari, B. (2012). C# 5.0 in a Nutshell. United States: O'Reilly Media.
String Class (System) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.string(v=vs.110).aspx.
Unicode (2015, noviembre 28). Recuperado desde: https://en.wikipedia.org/wiki/Unicode.
Pregunta C# (3 de 20): ¿Cuál es la Diferencia entre String y string? (2015, noviembre 28). Recuperado desde: http://ortizol.blogspot.com.co/2014/07/pregunta-csharp-3-de-20-cual-es-la-diferencia-entre-string-y-string.html.
String.Empty Field (System) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.string.empty(v=vs.110).aspx.
Tipos por Valor vs. Tipos por Referencia (2015, noviembre 28). Recuperado desde: http://ortizol.blogspot.com/2013/07/tipos-por-valor-vs-tipos-por-referencia.html.
NullReferenceException Class (System) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.nullreferenceexception(v=vs.110).aspx.
String.IsNullOrEmpty Method (String) (System) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.string.isnullorempty(v=vs.110).aspx.
Indizadores en C# (2015, noviembre 28). Recuperado desde; http://ortizol.blogspot.com.co/2013/10/tabla-de-contenido-0_14.html.
IEnumerable Interface (System.Collections) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.collections.ienumerable(v=vs.110).aspx.
Receta No. 2-1 en C#: Manipular el Contenido de una Cadena Texto Eficientemente (2015, noviembre 28). Recuperado desde: http://ortizol.blogspot.com/2014/04/receta-no-2-1-en-c-manipular-el.html.
String.Split Method (System) (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/system.string.split(v=vs.110).aspx.
Custom Numeric Format Strings (2015, noviembre 28). Recuperado desde: https://msdn.microsoft.com/en-us/library/0c899ak8(v=vs.110).aspx.


V