Personas que lo han encontrado útil: 1 de 2 - Valorar este tema

Char (Estructura)

.NET Framework 3.5

Otras versiones

Actualización: noviembre 2007

Representa un carácter Unicode.

Espacio de nombres: System
Ensamblado: mscorlib (en mscorlib.dll)

Sintaxis

C++

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Char : IComparable, IConvertible, 
	IComparable<char>, IEquatable<char>

/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public final class Char extends ValueType implements IComparable, 
	IConvertible, IComparable<char>, IEquatable<char>

JScript

JScript admite el uso de estructuras, pero no admite la declaración de estructuras nuevas.

Comentarios

.NET Framework utiliza la estructura Char para representar un carácter Unicode. El estándar Unicode identifica cada carácter Unicode con un número escalar de 21 bits único, denominado punto de código, y define el formato de codificación UTF-16 que especifica cómo se codifica un punto de código en una secuencia de uno o varios valores de 16 bits. Cada valor de 16 bits va del hexadecimal 0x0000 al 0xFFFF y se almacena en una estructura Char. El valor de un objeto Char es su valor numérico de 16 bits (ordinal).

Un objeto String es una colección secuencial de estructuras Char que representa una cadena de texto. Se puede representar la mayoría de los caracteres Unicode por medio de un único objeto Char, aunque el carácter codificado como carácter base, par suplente y/o secuencia de caracteres combinables está representado por varios objetos Char. Por esta razón, una estructura Char de un objeto String no equivale necesariamente a un único carácter Unicode.

Para obtener más información sobre el estándar Unicode, vea la página principal de Unicode.

Funcionalidad

La estructura Char proporciona métodos para comparar objetos Char, convertir el valor del objeto Char actual en un objeto de otro tipo y determinar la categoría Unicode de un objeto Char:

Los métodos CompareTo y Equals se utilizan para comparar objetos Char.
El método ConvertFromUtf32 se utiliza para convertir un punto de código en una cadena. Utilice los métodos ConvertToUtf32 para convertir un objeto Char o un par suplente de objetos Char en un punto de código.
Los métodos GetUnicodeCategory se utilizan para obtener la categoría Unicode de un carácter. Utilice los métodos IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper y IsWhiteSpace para determinar si un carácter pertenece a una categoría Unicode concreta, como dígitos, letras, signos de puntuación, caracteres de control, etc.
Los métodos GetNumericValue se utilizan para convertir a un tipo de valor numérico un objeto Char que representa un número. Utilice Parse y TryParse para convertir un carácter de una cadena en un objeto Char. Utilice ToString para convertir un objeto Char en un objeto String.
Los métodos ToLower, ToLowerInvariant, ToUpper y ToUpperInvariant se utilizan para cambiar las mayúsculas/minúsculas de un objeto Char.

Implementaciones de interfaces

Este tipo implementa las interfaces IConvertible, IComparable y IComparable<T>. Utilice la clase Convert para las conversiones en lugar de la implementación de miembro de interfaz explícita de IConvertible de este tipo.

Ejemplos

En el ejemplo de código siguiente se muestran algunos de los métodos de Char.

C++

using System;

public class CharStructureSample {
	public static void Main() {
		char chA = 'A';
		char ch1 = '1';
		string str = "test string"; 

		Console.WriteLine(chA.CompareTo('B'));			// Output: "-1" (meaning 'A' is 1 less than 'B')
		Console.WriteLine(chA.Equals('A'));				// Output: "True"
		Console.WriteLine(Char.GetNumericValue(ch1));	// Output: "1"
		Console.WriteLine(Char.IsControl('\t'));		// Output: "True"
		Console.WriteLine(Char.IsDigit(ch1));			// Output: "True"
		Console.WriteLine(Char.IsLetter(','));			// Output: "False"
		Console.WriteLine(Char.IsLower('u'));			// Output: "True"
		Console.WriteLine(Char.IsNumber(ch1));			// Output: "True"
		Console.WriteLine(Char.IsPunctuation('.'));		// Output: "True"
		Console.WriteLine(Char.IsSeparator(str, 4));	// Output: "True"
		Console.WriteLine(Char.IsSymbol('+'));			// Output: "True"
		Console.WriteLine(Char.IsWhiteSpace(str, 4));	// Output: "True"
		Console.WriteLine(Char.Parse("S"));				// Output: "S"
		Console.WriteLine(Char.ToLower('M'));			// Output: "m"
		Console.WriteLine('x'.ToString());				// Output: "x"
	}
}

import System.* ;

public class CharStructureSample
{
    public static void main(String[] args)
    {
        Character chA = new Character('A');
        char ch1 = '1';
        String str = "test string";

        // Output: "-1" (meaning 'A' is 1 less than 'B')        
        Console.WriteLine(chA.compareTo(new Character('B')));        
        // Output: "True"
        Console.WriteLine(chA.equals(new Character('A')));            
        // Output: "1"
        Console.WriteLine(System.Char.GetNumericValue(ch1));        
        // Output: "True"
        Console.WriteLine(Char.IsControl('\t'));                    
        // Output: "True"
        Console.WriteLine(System.Char.IsDigit(ch1));                
        // Output: "False"
        Console.WriteLine(Char.IsLetter(','));                        
        // Output: "True"
        Console.WriteLine(Char.IsLower('u'));                        
        // Output: "True"
        Console.WriteLine(System.Char.IsNumber(ch1));                
        // Output: "True"
        Console.WriteLine(Char.IsPunctuation('.'));                    
        // Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));                
        // Output: "True"
        Console.WriteLine(Char.IsSymbol('+'));                        
        // Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4));                
        // Output: "S"
        Console.WriteLine(Char.Parse("S"));                            
        // Output: "m"
        Console.WriteLine(Char.ToLower('M'));                        
        // Output: "x"
        Console.WriteLine(System.Convert.ToString('x'));                
    } //main
} //CharStructureSample

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para la ejecución de subprocesos. Los miembros que aparecen para modificar el estado de la instancia devuelven una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.

Plataformas

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Información de versión