Método de utilidad de división de cadenas Problema cuando no se incluyen delimitadores

Question

Tengo el siguiente método que he creado que funciona bien si realmente está el delimitador en cuestión. Quiero mantener esto fuera de LINQ por ahora ...

p.

Si paso la cadena "123; 322; 323", funciona muy bien.

Pero si solo paso en un valor de cadena sin el delimitador como "123" obviamente no se dividirá ya que no hay delimitador. Estoy tratando de averiguar la mejor manera de comprobar y dar cuenta de esto y ser capaz de escupir que un valor de nuevo en la lista

public static List<int> StringToList(string stringToSplit, char splitDelimiter) 
{ 
    List<int> list = new List<int>(); 

    if (string.IsNullOrEmpty(stringToSplit)) 
     return list; 

    string[] values = stringToSplit.Split(splitDelimiter); 

    if (values.Length < 1) 
     return list; 

    foreach (string s in values) 
    { 
     int i; 
     if (Int32.TryParse(s, out i)) 
      list.Add(i); 
    } 

    return list; 
} 

Actualizado: Esto es lo que ocurrió con la que parece funcionar, pero seguro es largo

public static List<int> StringToList(string stringToSplit, char splitDelimiter) 
    { 
     List<int> list = new IntList(); 

     if (string.IsNullOrEmpty(stringToSplit)) 
      return list; 

     if (stringToSplit.Contains(splitDelimiter.ToString())) 
     { 
      string[] values = stringToSplit.Split(splitDelimiter); 

      if (values.Length <= 1) 
       return list; 

      foreach (string s in values) 
      { 
       int i; 
       if (Int32.TryParse(s, out i)) 
        list.Add(i); 
      } 
     } 
     else if (stringToSplit.Length > 0) 
     { 
      int i; 
      if(Int32.TryParse(stringToSplit, out i)) 
       list.Add(i); 
     } 

     return list; 
    } 

Answer 1

Hay MUCHAS revisiones innecesarias para condiciones que no importan a la lógica central del método.

public static List<int> StringToList(string stringToSplit, char splitDelimiter) 
{ 
    List<int> list = new IntList(); 

    if (string.IsNullOrEmpty(stringToSplit)) 
     return list; 

    //this if is not necessary. As others have said, Split will return a string[1] with the original string if no delimiter is found 
    if (stringToSplit.Contains(splitDelimiter.ToString())) 
    { 
     string[] values = stringToSplit.Split(splitDelimiter); 

     //why check this? if there are no values, the foreach will do nothing and fall through to a return anyway. 
     if (values.Length <= 1) 
      return list; 

     foreach (string s in values) 
     { 
      int i; 
      if (Int32.TryParse(s, out i)) 
       list.Add(i); 
     } 
    } 
    //again, this is rendered redundant due to previous comments 
    else if (stringToSplit.Length > 0) 
    { 
     int i; 
     if(Int32.TryParse(stringToSplit, out i)) 
      list.Add(i); 
    } 

    return list; 
} 

Pruebe esto. Usted con suerte tiene algunas pruebas de unidad llamando a este método para asegurarse de que funciona ... ¿verdad?

public static List<int> StringToList(string stringToSplit, char splitDelimiter) 
{ 
    List<int> list = new IntList(); 

    if (string.IsNullOrEmpty(stringToSplit)) 
     return list; 

    foreach(var s in stringToSplit.Split(splitDelimiter)) 
    { 
     int i; 
     if(int.TryParse(s, out i)) 
      list.Add(i); 
    } 
    return list; 
} 

Answer 2

Cambiar esta condición:

if (values.Length <= 1) 
    return list; 

Para:

if (values.Length <= 0) 
    return list; 

Esto funciona porque String.Split devuelve la cadena original si no puede encontrar el delimitador:

// stringToSplit does not contain the splitDelimiter 
string[] values = stringToSplit.Split(splitDelimiter); 
// values is a string array containing one value - stringToSplit 

Answer 3

Una aplicación más corto que podría considerar.

public static List<int> StringToList(string stringToSplit, char splitDelimiter) 
{ 
    int i; 
    return stringToSplit.Split(splitDelimiter) 
     .Where(str => int.TryParse(str, out i)) 
     .Select(str => int.Parse(str)) 
     .ToList(); 
} 

Answer 4

O bien se debe tener un delimitador o, que parte debe tener una longitud fija o, la cadena debe seguir un patrónpara el comportamiento de repetición.

Answer 5

Personalmente, no he probado su código, pero parece funcional. El método Split debería devolver una matriz con un elemento.

Puesto que usted dice que no es, se lo creen, y yo añadiría esto a la parte superior de su método:

if (!stringToSplit.Contains(splitDelimiter)) 
{ 
    int i; 
    if (Int32.TryParse(stringToSplit, out i)) 
     list.Add(i); 
    return list; 
} 

Answer 6

No es necesario dar cuenta de esa situación, como string.Split() devuelve una matriz con un solo elemento, cuando no se encuentra ningún delimitador:

If this instance does not contain any of the strings in separator, the returned array consists of a single element that contains this instance.

Ver msdn en "Observaciones"

Answer 7

¿Puedo sugerir un método de extensión para ayudarlo en casos como este en general?

La idea sería yield return todos los resultados de una colección de cadenas que se pueden analizar para un tipo especificado.

En primer lugar se necesitaría un delegado para que coincida con la firma de su norma TryParse método:

public delegate bool Parser<T>(string input, out T value); 

entonces usted puede escribir un método de extensión que tiene una instancia de este tipo de delegado y enumera más de una colección de cadenas , el análisis de todo el mundo que puede:

// Notice: extension methods must belong to a class marked static. 
public static class EnumerableParser 
{ 
    // modified code to prevent horizontal overflow 
    public static IEnumerable<T> ParseAll<T> 
    (this IEnumerable<string> strings, Parser<T> parser) 
    { 
     foreach (string str in strings) 
     { 
      T value; 
      if (parser(str, out value)) 
       yield return value; 
     } 
    } 
} 

Ahora su método StringToList convertido en algo trivial de implementar:

public List<int> StringToList(string stringToSplit, char delimiter) 
{ 
    // Notice: since string.Split returns a string[], and string[] implements 
    // IEnumerable<string>, so the ParseAll extension method can be called on it. 
    return stringToSplit.Split(delimiter).ParseAll<int>(int.TryParse).ToList(); 
}