regular - regex caracteres especiales c#

¿Cómo puedo validar una cadena para permitir solo caracteres alfanuméricos en ella?

Question

¿Cómo puedo validar una cadena usando expresiones regulares para permitir solo caracteres alfanuméricos en ella?

(No quiero permitir ningún espacio tampoco).

Answer 1

Aconsejo no depender del código listo e integrado en el marco .NET, intentar mostrar una nueva solución ... esto es lo que hago ...

public bool isAlphaNumeric(string N)
{
bool YesNumeric = false;
bool YesAlpha = false;
bool BothStatus = false;
for (int i = 0; i < N.Length; i++)
{
if (char.IsLetter(N[i]) )
YesAlpha=true;
if (char.IsNumber(N[i]))
YesNumeric = true;
}
if (YesAlpha==true && YesNumeric==true)
{
BothStatus = true;
}
else
{
BothStatus = false;
}
return BothStatus;
}

Answer 2

En .NET 4.0 puedes usar LINQ:

if (yourText.All(char.IsLetterOrDigit))
{
//just letters and digits.
}

yourText.All dejará de ejecutarse y devolverá false la primera vez que char.IsLetterOrDigit informe de false ya que el contrato de All no se puede cumplir en ese momento.

¡Nota! esta respuesta no revisa estrictamente los caracteres alfanuméricos (que generalmente es AZ, az y 0-9). Esta respuesta permite caracteres locales como åäö .

Actualización 2018-01-29

La sintaxis anterior solo funciona cuando utiliza un único método que tiene un único argumento del tipo correcto (en este caso, char ).

Para usar condiciones múltiples, debe escribir de esta manera:

if (yourText.All(x => char.IsLetterOrDigit(x) || char.IsWhiteSpace(x)))
{
}

Answer 3

Necesitaba buscar AZ, az, 0-9; sin una expresión regular (aunque OP solicite expresiones regulares).

Combinando varias respuestas y comentarios aquí, y la discusión de https://.com/a/9975693/292060 , esto prueba la letra o el dígito, evitando otras letras de idioma y evitando otros números como los caracteres de fracción.

if (!String.IsNullOrEmpty(testString)
&& testString.All(c => Char.IsLetterOrDigit(c) && (c < 128)))
{
// Alphanumeric.
}

Answer 4

Para comprobar si la cadena es una combinación de letras y dígitos, puede volver a escribir @jgauffin responder de la siguiente manera con .NET 4.0 y LINQ:

if(!string.IsNullOrWhiteSpace(yourText) &&
(!yourText.Any(char.IsLetter) || !yourText.Any(char.IsDigit)))
{
// do something here
}

Answer 5

Podrías hacerlo fácilmente con una función de extensión en lugar de una expresión regular ...

public static bool IsAlphaNum(this string str)
{
if (string.IsNullOrEmpty(str))
return false;
for (int i = 0; i < str.Length; i++)
{
if (!(char.IsLetter(str[i])) && (!(char.IsNumber(str[i]))))
return false;
}
return true;
}

Por comentario :) ...

public static bool IsAlphaNum(this string str)
{
if (string.IsNullOrEmpty(str))
return false;
return (str.ToCharArray().All(c => Char.IsLetter(c) || Char.IsNumber(c)));
}

Answer 6

Si bien creo que la solución basada en expresiones regulares es probablemente la forma en que iría, me sentiría tentado a encapsular esto en un tipo.

public class AlphaNumericString
{
public AlphaNumericString(string s)
{
Regex r = new Regex("^[a-zA-Z0-9]*$");
if (r.IsMatch(s))
{
value = s;
}
else
{
throw new ArgumentException("Only alphanumeric characters may be used");
}
}
private string value;
static public implicit operator string(AlphaNumericString s)
{
return s.value;
}
}

Ahora, cuando necesite una cadena validada, puede hacer que la firma del método requiera AlphaNumericString, y sepa que si obtiene una, es válida (aparte de los valores nulos). Si alguien intenta pasar una cadena no validada, generará un error de compilación.

Puede hacerse más elegante e implementar todos los operadores de igualdad, o un lanzamiento explícito a AlphaNumericString desde cadena sencilla, si le importa.

Answer 7

Usa la expresión:

^[a-zA-Z0-9]*$

es decir: utilizando System.Text.RegularExpressions;

Regex r = new Regex("^[a-zA-Z0-9]*$");
if (r.IsMatch(SomeString)) {
...
}

Answer 8

^/w+$ permitirá a-zA-Z0-9_

Utilice ^[a-zA-Z0-9]+$ para rechazar el guión bajo.

Tenga en cuenta que ambos requieren que la cadena no esté vacía. Usar * lugar de + permite cadenas vacías.