Metodo Split Split Method Problema quando non sono inclusi i delimitatori

Question

Ho il seguente metodo che ho creato che funziona bene se effettivamente c'è il delimitatore in questione. Voglio tenerlo fuori da LINQ per ora ...

ad es.

Se passo nella stringa "123; 322; 323" funziona alla grande.

Ma se passo solo un valore di stringa senza il delimitatore come "123" ovviamente non lo dividerò poiché non c'è delimitatore. Sto solo cercando di capire il modo migliore per controllare e conto di questo ed essere in grado di sputare che un valore di nuovo nella 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; 
} 

aggiornamento: Questo è ciò che mi si avvicinò con che sembra funzionare, ma certo è lunga

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

Ci sono MOLTI controlli non necessari per condizioni che non sono rilevanti per la logica di base del metodo.

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; 
} 

Prova questo. Si si spera che abbia qualche unit test che chiami questo metodo per assicurarsi che funzioni ... giusto?

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

Cambiamento questa condizione:

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

A:

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

Questo funziona perché String.Split restituirà la stringa originale, se non riesce a trovare il delimitatore:

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

Answer 3

Un'implementazione più breve si potrebbe prendere in considerazione.

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 deve avere un delimitatore o, si parte deve avere una lunghezza fissao, la stringa deve seguire un modello per comportamento ripetizione.

Answer 5

Personalmente, non ho provato il codice, ma sembra funzionale. Il metodo Split dovrebbe restituire un array con un elemento.

Dal momento che si dice che non è, ti credo, e vorrei aggiungere questo alla parte superiore del metodo:

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

Answer 6

Non è necessario per tenere conto di questa situazione, come string.Split() restituisce un array con un singolo elemento se non si trova delimitatore:

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

Vedi msdn a "Osservazioni"

Answer 7

Potrei suggerire un metodo di estensione per aiutarti in casi come questo in generale?

L'idea sarebbe di yield return tutti i risultati di una raccolta di stringhe che possono essere analizzate in un tipo specificato.

Prima avresti bisogno di un delegato per abbinare la firma del tuo TryParse metodo standard:

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

Quindi è possibile scrivere un metodo di estensione che prende un'istanza di questo tipo delegato e enumera su un insieme di stringhe , l'analisi ovunque si può:

// 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; 
     } 
    } 
} 

Ora il metodo di StringToList diventa banale da implementare:

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(); 
}