C# Wie auf einen String zugreifen

[Johann (Gast)]

Hallo Leute.

ich will auf auf die Elemente eines Strings zu greifen, wie macht man 
das?

Das steht in dem String drin. Am Ende will ich ein Ergebnis int =103;

string Test ="V1.03"

Theoretisch ist mir klar zuerst muss ich einen neuen String machen in 
dem
steht "103" und dann mit Convert einen Int draus machen.

Nur weiss ich nicht wie man von dem String "V1.03" auf den String "103" 
kommt.

[Peter II (Gast)]

string Test ="V1.03"
string test2 = Test.Substring(1,1) + Test.Substring(3,2);

[ich (Gast)]

jedes Zeichen anschauen und prüfen obs eine Ziffer ist. Falls ja, an 
neuen String anhängen.

[Sam .. (sam1994)]

Wenn nur V, . und Zahlen im Strnig sind reicht auch das:
String version = Test.Replace("V", "").Replace(".","");

[asdf (Gast)]

ich schrieb:
> jedes Zeichen anschauen und prüfen obs eine Ziffer ist. Falls ja, an
> neuen String anhängen.

genau das. code nicht getestet.

            string before = "V1.03";
            string after = "";
            char currentChar;
            for (int i = 0; i < before.Length; i++)
            {
                currentChar = before.ToCharArray()[i];
                if ((currentChar > 47) && (currentChar < 58))  //is integer?
                {
                    after += currentChar;
                }
            }
            int result = int.Parse(after);

[asdf (Gast)]

evtl noch checken ob ueberhaupt zahlen enthalten waren:

if(after.Length > 0)
{
//parse int
}

[Peter II (Gast)]

asdf schrieb:
> genau das. code nicht getestet.

schöner code - aber schelcht umgesetzt. Der code ist viel zu lansame!!!!

- der Aufruf von before.ToCharArray() erfolgt viel zu oft
- for ist langsamer als foreach
- string verkettung ist langsam und hier nicht notwendig - wir wollen 
ein int


Man sollte auch bei kleinen dinge etwas auf Performace achten.

[c]
string s = "V1.03";
int i = 0;
foreach( char c in s ) {
   if ( char.IsDigit(c) ) {
  i = i * 10 + int.Parse( c.ToString() );
   }
}
[\c]

[Sam .. (sam1994)]

In C++ wär das was für Zeiger. Hier mal was mit Indexer:

int version(string str)
{
    int ret = 0;
    int pos = -1;
    while(++pos < str.Length)
        while(pos < str.Length && str[pos] > 47 && str[pos] < 58)
            ret = 10 * ret + str[pos++] - 48;
    return ret > 0 ? Convert.ToInt32(ret) : -1;
}

Wenn man schon Int.Parse vermeiden will, warum dann nicht ganz?

PS: Meine müsste ca. 5-6 mal schneller sein als deine.

[Sam .. (sam1994)]

Samuel K. schrieb:
> PS: Meine müsste ca. 5-6 mal schneller sein als deine.

Sry, hab falsch gemessen. Eher 2-3mal.

[Peter II (Gast)]

Samuel K. schrieb:
> Wenn man schon Int.Parse vermeiden will, warum dann nicht ganz?

weil ich mich bei unicode nicht genau auskenne und mit der festen 
codierung (-48) verhindest du die unicode zeichen für zahlen.

Warum kein iterrator in C++ verwenden, dürfte noch etwas mehr speed 
bringen, damit könnte man den index zugriff sparen.

[Markus V. (valvestino)]

Peter II schrieb:
> Warum kein iterrator in C++ verwenden, dürfte noch etwas mehr speed
> bringen, damit könnte man den index zugriff sparen.

Weil die Sparache des TO C# ist... ;-)

Gruß
Markus

[Sam .. (sam1994)]

Markus Volz schrieb:
> Peter II schrieb:
>> Warum kein iterrator in C++ verwenden, dürfte noch etwas mehr speed
>> bringen, damit könnte man den index zugriff sparen.
>
> Weil die Sparache des TO C# ist... ;-)

Deswegen hab ich es ja mit Indexer gemacht. In c++ könnte man einfach 
str++ schreiben um zum nächten Zeichen zu gelangen. In c# sind Zeigern 
relativ kompliziert und ich hab ehrlich gesagt noch nichts damit 
gemacht.

[Peter R. (gelb)]

gibt es in C# keine regulären Ausdrücke?

Test = regex(Test, "s/\D//g");

würde alle nicht-Zahlen-Zeichen entfernen.

Grüße, Peter

[bluppdidupp (Gast)]

Doch gibt es: http://msdn.microsoft.com/de-de/library/c75he57e.aspx

Ich hätte es so gelöst:

public int ParseNumber(string s)
{
  StringBuilder sb = new StringBuilder();
  // sb.Append("0"); 

  foreach (char c in s)
  {
    if (Char.IsDigit(c))
    {
      sb.Append(c);
    }
  }

  return Int32.Parse(sb.ToString());
}

[Markus V. (valvestino)]

Peter Roth schrieb:
> gibt es in C# keine regulären Ausdrücke?

Doch, gibt es. Die Syntax der Regular Expressions im .NET Framework ist 
allerdings leicht anders:

using System.Text.RegularExpressions;
...
int version;
bool parsed = int.TryParse( Regex.Replace( "V1.03",@"\D+","" ),out version );

Gruß
Markus

[Jasch (Gast)]

Johann schrieb:
> Hallo Leute.
>
> ich will auf auf die Elemente eines Strings zu greifen, wie macht man
> das?

Willst Du an dieser Stelle nicht. ;-)

Aber falls doch: string[0], string[1], etc.

> Das steht in dem String drin. Am Ende will ich ein Ergebnis int =103;

Hmm, hmm, nein, willst Du vermutlich auch nicht.

> string Test ="V1.03"
>
> Theoretisch ist mir klar zuerst muss ich einen neuen String machen in
> dem
> steht "103" und dann mit Convert einen Int draus machen.
>
> Nur weiss ich nicht wie man von dem String "V1.03" auf den String "103"
> kommt.

Ganz falsche Herangehensweise.

Du (und so ziemlich alle bisherigen Antworten auch) nimmst einfach an 
dass alle Versionsstrings (in alle Ewigkeit) dem Muster 
V<Major>.<Minor-with-leading-zero> folgen. Das wird erfahrungsgemäss 
nicht so sein.

Was Du wirklich willst ist sowas:

switch (Test) {
    case "V.1.03":
        foo = 103;
        break;

    case "v1.4":
        foo = 104;
        break;

    default:
        PANIC_CRASH_AND_BURN(); // UNKNOWN SHIT FOUND!
}

(schlauerweise mit definierten Konstanten für die Versionen).

Oder ein Äquivalent mit Hashtabellen oder so falls Du sehr viele 
Versionen hast und das zeitkritisch wäre.

[asdf (Gast)]

Jasch schrieb:
>
> Du (und so ziemlich alle bisherigen Antworten auch) nimmst einfach an

les dir den thread vielleicht erstmal durch bevor du so einen quatsch 
schreibst

[Sam .. (sam1994)]

Jasch schrieb:
> Was Du wirklich willst ist sowas:

Ich würde nicht gerne bei jeder neuen Version da noch etwas anhängen. 
Wenn man dann mal bei 100 Einträgen angekommen ist, sieht man ein das es 
Unsinn war.

[Jasch (Gast)]

Samuel K. schrieb:
> Jasch schrieb:
>> Was Du wirklich willst ist sowas:
>
> Ich würde nicht gerne bei jeder neuen Version da noch etwas anhängen.
> Wenn man dann mal bei 100 Einträgen angekommen ist, sieht man ein das es
> Unsinn war.

Du wirst realistisch niemals 100 dann steinalte Versionen in einer SW 
unterstützen.

Was mit so einer "flexiblen" Lösung passiert ist aber folgendes:

- die andere Seite ändert das Nummernschema, z.B. fliegt die führende 
Null raus weil das jemandem Probleme bei Version 1.08 gemacht hat 
(Bonuspunkte wer erkennt wieso ;-), jetzt folgt plötzlich 
Integer-Versionsnummer 18 auf 107...

- die andere Seite bringt eine neue Version raus, keiner merkt es 
erstmal, bis sich rausstellt es funktioniert irgendwas plötzlich nicht 
mehr, viel Geschrei resultiert

- will man wirklich einfach neue (Fremd-)Versionen im Einsatz haben ohne 
zu testen - und bei der Gelegenheit wäre ein Hinzufügen einer neuen 
Versionsnummer trivial?

Wie gesagt, das ist was ich aus meiner Erfahrung sagen kann, jeder kann 
natürlich machen was er für richtig hält.