Hallo

 

ich will hobbymäßig mal in meiner Freizeit ein bisschen Coden lernen und habe einen VideoKurs bei Udemy gekauft...

ich wollte mal die Profis fragen, um sicherzugehen dass das gelernte auch wirklich richtig ist und ich es wirklich verstanden habe.

Wie der Name schon sagt behandel ich gerade Fehler abfangen bei Konvertierung von Usereingaben...

Ist der Vorteil/Unterschied von TryParse zu TryCatchFinally, dass man bei TryParse nicht alle möglichen Fehler zur genauen Deklaration Ccoden muss und dass das TryParse ein wenig übersichtlicher ist?

 

Wenn Codebeispiele der beiden gewünscht , kann ich die auch erbringen, allerdings mit viel Kommentaren für mein Verständnis, ihr wisst aber sicher von was ich rede ^^

 

Mit Freundlichen Gruß

Bei TryParse bekommst du  als Rückgabewert einen boolean zurück der angibt ob die Konvertierung erfolgreich war oder nicht. 
Ich verstehe in dem Zusammenhang aber deine Frage nicht.

• TryParse wird genutzt um Datentypen zu konvertieren.
• TryCatch(Finally) nutzt man um unerwartete Fehler abzufangen und diese dann zu behandeln. 

Soviel ich weiß nutzt TryParse bei bspw. int (int.TryParse) kein TryCatch intern.

So würde eine Konvertierung mit TryCatch in dem Fall aussehen:

int value = 0;
string stringValue = "dawdawdawd";
try
{
   	value = Convert.ToInt32(stringValue);
}
catch (Exception ex)
{
	Debug.WriteLine("Ouch!");
}

Aber ja:
TryParse macht mehr sinn da du keine unerwarteten Fehler erhälst sondern einen boolean der Angibt ob die Konvertierung erfolgreich war oder nicht. Entsprechend kannst du dann anhand des boolean reagieren.

Bearbeitet 11. November 20186 j von r4phi

ok ich poste mal vielleciht ein codebeispiel anhand einer folgenden IF Abfrage

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TryParse
{
    class Program
    {
        /*für demonstration nehmen wir das IF Konstrukt: 
        https://www.udemy.com/die-komplette-csharp-masterclass/learn/v4/t/lecture/10249440?start=30
        https://www.udemy.com/die-komplette-csharp-masterclass/learn/v4/t/lecture/10249442?start=195 (effizienter) [hier wird auch das TryParse errklärt*/
        static void Main(string[] args)
        {
            Console.WriteLine("wie warm schätzt du ist es momentan? Gib eine Ganze Zahl (in Grad) an:");
            string TemperatureInput = Console.ReadLine(); //Eingabe (immer) als string
            //int temperature = int.Parse(Temperature); //den string umwandeln in einer Zahl mit der wir arbeiten können

            int temperature;
            int number;  //das wird unsere TryParse Ausgabevariable
            //TryParse tut eig das gleiche wie die TryCatch Funktion, allerdings fängt es gleichzeitig den potentiellen fehler ab

           // bool UserEnteredANumber = int.TryParse(TemperatureInput, out number); //Alternativ geht es auch mit dem hier 
            //-> wir speichern das als true/false wert in eine bool Variable

            if (int.TryParse(TemperatureInput, out number)) //hat das TryParse funktioniert? out ist die Variable die ausgegeben  werden soll, falls der PARSE funktioniert hat
                //wenn wir mit dem alternativen bool arbeiten wollen, müssen wir dementsprechend die bool Variable in die Bedingung überpüfen lassen
            {
                temperature = number; // hat das funktioniert?- dann speichere in temperature den geparsten wert des strings in denwert number
            }
            else
            {
                temperature = -888; //wenn e snicht erfolgreich war, dann speichere den wert -888
                //wenn wir das hier nicht haben, erwartet das folgende programm einen wert um weiter atrbeiten zu können und abfragen zu können
                //denn mit den TryParse probieren wir es nur, können aber nicht garantieren dass es klappt... dann wäre temperature nicht zugewiesen
            }
            //Vorteil/Unterschied zu der TryCatchFinally? wir müssen bei TryParse nicht alle möglichen Fehler zur genauen Deklaration coden und gestalten das hier ein wenig übersichlicher
           Console.WriteLine("");

            if (temperature == -888) //Bedingung überprüfen
            {
                Console.WriteLine("1. Abfrage = Konvertierungsfehler! Zahl zu groß oder Eingabe ist keine Zahl oder Eingabe Leer oder sonstiges"); //Wenn zweig 
                //das Try Parse hat nicht geklappt (ich habe dementsprechend mal als >Variable temperature auf utopische -888 gelegt
                Console.WriteLine("Du solltest eine Ganze Zahl (ohme Komma) eingeben du honk!"); //Spaß :)
            }
            else if (temperature == 15) //Prüfe im selben CodeBlock eine 2. Anweisung im sonst zweig der 1. abfrage
            {
                Console.WriteLine("2. Abfrage im 1. SONST Zweig = es ist genau 15°C, Optimal!");
                Console.WriteLine("Der User hat {0}°C eingegeben", temperature); //Ausgabe, was der nutzer eingegeben hat (Kontrollmechanismus)
            }
            else if (temperature > 15) //Prüfe im selben CodeBlock eine 3. Anweisung im sonst zweig der 2. abfrage
            {
                Console.WriteLine("3. Abfrage im 2. SONST Zweig = es ist eine Bullen Hitze!", temperature);
                Console.WriteLine("Der User hat {0}°C eingegeben", temperature); //Ausgabe, was der nutzer eingegeben hat (Kontrollmechanismus)
            }
            else if (temperature  < 15) //Prüfe im selben CodeBlock eine 4. Anweisung im sonst zweig der 3. abfrage
            {
                Console.WriteLine("4.Abfrage im 3. SONST Zweig= zieh deine jacke an, es ist unter 15°C kalt - es ist etwas frischlich/kalt!");
                Console.WriteLine("Der User hat {0}°C eingegeben", temperature); //Ausgabe, was der nutzer eingegeben hat (Kontrollmechanismus)
            }
            else //das wird ausgeführt, wenn keine bedigung von oben zutrifft "Sonst zweig) - um was unvorhergesehendes festzulegen
            {
                Console.WriteLine("4. endlicher SONST Zweig= - alle anderen Abfragen treffen NICHT Zu (wie auch immer)");
            }
            Console.WriteLine("");
            Console.WriteLine("Beenden mit beliebiger Taste...");
            Console.ReadKey(); //Pausiere die Konsole wieder

            //der Code ist effizienter und benötigt weniger Rechenleistunmg anstatt immer und immer wieder EXTRA abzufragen, so fragen wir nur 2mal (trotzdem mehrere male) ab
        }
    }

}

 

TryParse ist nur ein Wrapper um Try-Catch. So sieht die Implementierung aus:

static bool TryParse(string s, out int result)
{
    try
    {
        result = int.Parse(s);
        return true;
    }
    catch
    {
        result = 0;
        return false;
    }
}

TryParse ist eben nur eine Vereinfachung, um den Code leserlicher zu machen, wenn einem die Exception egal ist.

vor 57 Minuten schrieb Whiz-zarD:

TryParse ist nur ein Wrapper um Try-Catch. So sieht die Implementierung aus:

TryParse ist eben nur eine Vereinfachung, um den Code leserlicher zu machen, wenn einem die Exception egal ist.

Nö. Die Implementierung kann man sich ja ansehen: https://referencesource.microsoft.com/#mscorlib/system/number.cs,958cb8bc00d00a94

Da kommt nirgends ein Try-Catch vor - ist deswegen auch schneller.

 

 

vor 2 Stunden schrieb Whiz-zarD:

TryParse ist nur ein Wrapper um Try-Catch. So sieht die Implementierung aus:

static bool TryParse(string s, out int result)
{
    try
    {
        result = int.Parse(s);
        return true;
    }
    catch
    {
        result = 0;
        return false;
    }
}

TryParse ist eben nur eine Vereinfachung, um den Code leserlicher zu machen, wenn einem die Exception egal ist.

Ok danke

 

vor 1 Stunde schrieb RipperFox:

Nö. Die Implementierung kann man sich ja ansehen: https://referencesource.microsoft.com/#mscorlib/system/number.cs,958cb8bc00d00a94

Da kommt nirgends ein Try-Catch vor - ist deswegen auch schneller.

 

 

Auch hier danke

vor 2 Stunden schrieb RipperFox:

Nö. Die Implementierung kann man sich ja ansehen: https://referencesource.microsoft.com/#mscorlib/system/number.cs,958cb8bc00d00a94

Da kommt nirgends ein Try-Catch vor - ist deswegen auch schneller.

Danke. Lag ich als doch richtig   

@derpat18

Was musst oder willst du nun genau wissen?

vor 15 Stunden schrieb derPat18:

Vorteil/Unterschied von TryParse zu TryCatchFinally, dass man bei TryParse nicht alle möglichen Fehler zur genauen Deklaration Ccoden muss

Keiner geht darauf ein bzw. musste das zwei mal lesen?

Müssen tust du überhaupt nichts. Wenn ein Fehler auftritt, ist meist schon bekannt welcher Fehler da ist. Du kannst nur genau definieren, wie verschiedene Fehler behandelt werden sollen (bei Fehler X zeige das an usw.). Generell kannst du einfach nur auf Exception e setzen und die ErrorMessage loggen (wenn du einen Logger hast). Du musst nicht alle möglichen Exceptions hinschreiben, die auftreten können Lol

Also, der Hauptunterschied ist folgender:

Ein Try-Catch-Block ist eine Anweisung, die du für alles Mögliche nutzen kannst, um dort Fehler abzufangen und anschließend zu behandeln. Das muss nicht zwingend der Versuch sein einen String in einen Integerwert zu konvertieren.

TryParse hingegen ist eine bereits eingebaute Methode bei Datentypen, mit der du 1. überprüfst ob sich der Wert der Variable überhaupt in den Datentyp mit der du die Methode aufrufst konvertieren lässt (Rückgabewert der Methode ist true oder false), und 2. den Wert dann in eine von dir definierten Variable des entsprechenden Datentyps schreibt (das ist der Part mit dem out number bei dir im Coding).

Bearbeitet 12. November 20186 j von Rienne