Ottieni sottostringa: tutto prima di un determinato carattere

Sto cercando di capire il modo migliore per ottenere tutto prima del carattere - in una stringa. Di seguito sono riportate alcune stringhe di esempio. La lunghezza della stringa prima di - varia e può essere qualsiasi lunghezza

223232-1.jpg
443-2.jpg
34443553-5.jpg

quindi ho bisogno del valore che va dall'indice iniziale di 0 a subito prima di -. Quindi le sottostringhe risulterebbero essere 223232, 443 e 34443553

.Net Fiddle esempio

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("223232-1.jpg".GetUntilOrEmpty());
        Console.WriteLine("443-2.jpg".GetUntilOrEmpty());
        Console.WriteLine("34443553-5.jpg".GetUntilOrEmpty());

        Console.ReadKey();
    }
}

static class Helper
{
    public static string GetUntilOrEmpty(this string text, string stopAt = "-")
    {
        if (!String.IsNullOrWhiteSpace(text))
        {
            int charLocation = text.IndexOf(stopAt, StringComparison.Ordinal);

            if (charLocation > 0)
            {
                return text.Substring(0, charLocation);
            }
        }

        return String.Empty;
    }
}

risultati:

223232
443
34443553
344

34

Usa la funzione split .

static void Main(string[] args)
{
    string s = "223232-1.jpg";
    Console.WriteLine(s.Split('-')[0]);
    s = "443-2.jpg";
    Console.WriteLine(s.Split('-')[0]);
    s = "34443553-5.jpg";
    Console.WriteLine(s.Split('-')[0]);

Console.ReadKey();
}

Se la tua stringa non ha un -, otterrai l'intera stringa.

String str = "223232-1.jpg"
int index = str.IndexOf('-');
if(index > 0) {
    return str.Substring(0, index)
}

Le cose sono cambiate un po 'dall'inizio di questo thread.

Ora potresti usare

string.Concat(s.TakeWhile((c) => c != '-'));

Un modo per farlo è usare String.Substringinsieme a String.IndexOf:

int index = str.IndexOf('-');
string sub;
if (index >= 0)
{
    sub = str.Substring(0, index);
}
else
{
    sub = ... // handle strings without the dash
}

Partendo dalla posizione 0, riporta tutto il testo fino al trattino, ma escluso.

Basandosi sulla risposta di BrainCore:

    int index = 0;   
    str = "223232-1.jpg";

    //Assuming we trust str isn't null 
    if (str.Contains('-') == "true")
    {
      int index = str.IndexOf('-');
    }

    if(index > 0) {
        return str.Substring(0, index);
    }
    else {
       return str;
    }

È possibile utilizzare espressioni regolari per questo scopo, ma è bene evitare eccezioni aggiuntive quando la stringa di input non corrisponde all'espressione regolare.

Prima di tutto per evitare un ulteriore mal di testa di sfuggire al pattern regex - potremmo semplicemente usare la funzione per quello scopo:

String reStrEnding = Regex.Escape("-");

So che questo non fa nulla - poiché "-" è uguale a Regex.Escape("=") == "=", ma farà la differenza, ad esempio, se il carattere lo è @"\".

Quindi dobbiamo abbinare dall'accattonaggio della stringa alla fine della stringa, o in alternativa, se la fine non viene trovata, non corrispondere a nulla. (Stringa vuota)

Regex re = new Regex("^(.*?)" + reStrEnding);

Se la tua applicazione è critica per le prestazioni, quindi una riga separata per il nuovo Regex, in caso contrario, puoi avere tutto in una riga.

Infine, confronta la stringa ed estrai il modello corrispondente:

String matched = re.Match(str).Groups[1].ToString();

Dopodiché puoi scrivere una funzione separata, come è stato fatto in un'altra risposta, oppure scrivere una funzione lambda inline. Ho scritto ora usando entrambe le notazioni: funzione lambda inline (non consente il parametro predefinito) o chiamata di funzione separata.

using System;
using System.Text.RegularExpressions;

static class Helper
{
    public static string GetUntilOrEmpty(this string text, string stopAt = "-")
    {
        return new Regex("^(.*?)" + Regex.Escape(stopAt)).Match(text).Groups[1].Value;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Regex re = new Regex("^(.*?)-");
        Func<String, String> untilSlash = (s) => { return re.Match(s).Groups[1].ToString(); };

        Console.WriteLine(untilSlash("223232-1.jpg"));
        Console.WriteLine(untilSlash("443-2.jpg"));
        Console.WriteLine(untilSlash("34443553-5.jpg"));
        Console.WriteLine(untilSlash("noEnding(will result in empty string)"));
        Console.WriteLine(untilSlash(""));
        // Throws exception: Console.WriteLine(untilSlash(null));

        Console.WriteLine("443-2.jpg".GetUntilOrEmpty());
    }
}

Btw - cambiare il pattern regex in "^(.*?)(-|$)"consentirà di riprendere fino al "-"pattern o se il pattern non è stato trovato - raccogliere tutto fino alla fine della stringa.

Il modo LINQy

String.Concat ("223232-1.jpg" .TakeWhile (c => c! = '-'))

(Ma devi testare per null;)