¿Cómo puedo verificar si una cadena contiene un carácter en C#?

Question

Hay una función que puedo aplicar a una cadena que devolverá verdadero o falso si una cadena contiene un carácter.

que tienen cuerdas con una o más opciones de caracteres tales como:

var abc = "s"; 
var def = "aB"; 
var ghi = "Sj"; 

Lo que me gustaría hacer, por ejemplo, es una función que devolvería verdadero o falso si lo anterior contenía una mayúsculas o minúsculas "s".

if (def.Somefunction("s") == true) { } 

También en C# necesito para comprobar si algo es cierto como esto o podría simplemente eliminar el "== true"?

Answer 1

Se puede utilizar el método de extensión de la .Contains() System.Linq espacio de nombres:

if (abc.ToLower().Contains('s')) { } 

Y no, para comprobar si una expresión booleana es verdadera, no es necesario == true

Desde el Contains método es un método de extensión, mi solución parecía ser confusa para algunos. Aquí hay dos versiones que no requieren que agregue using System.Linq;:

if (abc.ToLower().IndexOf('s') != -1) { } 

// or: 

if (abc.IndexOf("s", StringComparison.CurrentCultureIgnoreCase) != -1) { } 

actualización

Si lo desea, puede escribir su propio método de extensiones para facilitar la reutilización:

public static class MyStringExtensions 
{ 
    public static bool ContainsAnyCaseInvariant(this string haystack, char needle) 
    { 
     return haystack.IndexOf(needle, StringComparison.InvariantCultureIgnoreCase) != -1; 
    } 

    public static bool ContainsAnyCase(this string haystack, char needle) 
    { 
     return haystack.IndexOf(needle, StringComparison.CurrentCultureIgnoreCase) != -1; 
    } 
} 

Entonces puede llamarlo así:

if (def.ContainsAnyCaseInvariant('s')) { } 
// or 
if (def.ContainsAnyCase('s')) { } 

En la mayoría de los casos al tratar con datos de usuario, realmente desea utilizar CurrentCultureIgnoreCase(o el método de extensión ContainsAnyCase), porque de esa manera permite que el sistema maneje problemas de mayúsculas/minúsculas, que dependen del idioma. Cuando se trata de problemas computacionales, como nombres de etiquetas HTML, etc., desea utilizar la cultura invariable.

Por ejemplo: En turco, la letra mayúscula I en minúsculas es ı(sin punto) y no i(con un punto).

Answer 2

bool containsCharacter = test.IndexOf("s", StringComparison.OrdinalIgnoreCase) >= 0; 

Answer 3

El siguiente debería funcionar:

var abc = "sAb"; 
bool exists = abc.IndexOf("ab", StringComparison.CurrentCultureIgnoreCase) > -1; 

Answer 4

Use los String.Contains de función();

una llamada de ejemplo,

abs.Contains("s"); // to look for lower case s 

here es más de MSDN.

Answer 5

Usted puede utilizar el método IndexOf, que tiene una sobrecarga adecuada para este tipo de comparación de cadenas:

if (def.IndexOf("s", StringComparison.OrdinalIgnoreCase) >= 0) ... 

Además, no se necesitaría la == true, ya que una sentencia if sólo se espera una expresión que se evalúa como un bool .

Answer 6

Será difícil trabajar en C# sin saber cómo trabajar con cadenas y booleanos. Pero de todos modos:

 String str = "ABC"; 
     if (str.Contains('A')) 
     { 
      //... 
     } 

     if (str.Contains("AB")) 
     { 
      //... 
     } 

Answer 7

aquí es un ejemplo lo que la mayoría de los han hecho

using System; 

class Program 
{ 
    static void Main() 
    { 
     Test("Dot Net Perls"); 
     Test("dot net perls"); 
    } 

    static void Test(string input) 
    { 
     Console.Write("--- "); 
     Console.Write(input); 
     Console.WriteLine(" ---"); 
     // 
     // See if the string contains 'Net' 
     // 
     bool contains = input.Contains("Net"); 
     // 
     // Write the result 
     // 
     Console.Write("Contains 'Net': "); 
     Console.WriteLine(contains); 
     // 
     // See if the string contains 'perls' lowercase 
     // 
     if (input.Contains("perls")) 
     { 
      Console.WriteLine("Contains 'perls'"); 
     } 
     // 
     // See if the string contains 'Dot' 
     // 
     if (!input.Contains("Dot")) 
     { 
      Console.WriteLine("Doesn't Contain 'Dot'"); 
     } 
    } 
} 

Answer 8

usted puede crear su propio método de extensión si va a usar esto mucho.

public static class StringExt 
{ 
    public static bool ContainsInvariant(this string sourceString, string filter) 
    { 
     return sourceString.ToLowerInvariant().Contains(filter); 
    } 
} 

ejemplo de uso:

public class test 
{ 
    public bool Foo() 
    { 
     const string def = "aB"; 
     return def.ContainsInvariant("s"); 
    } 
}