Fehlermeldung bei einfachem Prozentrechner in VB 2010 (Ungültige Konvertierung von der Zeichenfolge in Typ Double).

  • VB.NET

Es gibt 44 Antworten in diesem Thema. Der letzte Beitrag () ist von VB1963.

    Die wollte ich ja einfügen mit Hilfe der vorigen Antworten.
    RodFromGermany schrieb:

    VB.NET-Quellcode

    1. Dim text = "123,456" ' "Bockwurst mit Senf"
    2. Dim dd As Double = 0
    3. If Not Double.TryParse(text, dd) Then
    4. MessageBox.Show("Das war wohl nix")
    5. Return
    6. End If
    7. MessageBox.Show(dd.ToString)


    klar müssen die Deklarationen vor die Subs. Dann fragte ich, ob ich jedes Mal in jeden Private Sub

    VB.NET-Quellcode

    1. If Not Double.TryParse(Text, dd) Then
    2. MessageBox.Show("Das war wohl nix")
    3. Return
    4. End If

    eingeben soll. Als ich das getan habe kam, egal was ich eingegeben habe die Messagebox.
    Und so wusste ich nicht weiter.

    In Post #22 hatte ich dir geschrieben, dass es mehrere Möglichkeiten gibt, wie man da vorgehen könnte...

    Auch wenn's eine kleine Anwendung ist, solltest du dir zuerst eine Struktur des Programms zurechtlegen:

    Wie soll die Eingabe erfolgen:
    über TextBoxen:
    Dann muss zuerst eine Validierung aller Werteingaben vor der Wertzuweisung zu den Variablen erfolgen (siehe Post #19)
    Wann soll die Eingabe-Prüfung passieren:
    • sofort während der Eingabe (Box kann nur bei einer gültiger Eingabe verlassen werden)
    • nach Verlassen der Eingabebox mit Meldung (wenn nicht Ok zurück zur Box oder Abbruch)
    • oder willst du einen Errorprovider für die TextBoxen benutzen, der dir Eingabefehler anzeigt?
    • oder noch was anderes?
    über NUD's ist keine Validierung notwendig - da kannst du sofort die Eingabe der Variable zuweisen!

    Und jetzt erst kannst du mit den gefütterten Variablen Berechnungen durchführen...

    Als Nächstes überlegen, wie die Ergebnisse ausgegeben werden sollen...

    Dein Vorhaben jetzt Schritt für Schritt umsetzen! (Bei Ungereimtheiten gezielte Fragen stellen...)

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „VB1963“ ()

    Ich habe mir mal für den Threadersteller die Mühe gemacht, den Code auf Option Strict On anzupassen. Außerdem stürzt es jetzt nicht mehr ab. Die Programmlogik sowie die Controls habe ich nicht verändert.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Public Class Form1
    3. Dim G, P, W As Double
    4. Private Sub cmdp_Click(ByVal sender As Object, ByVal e As EventArgs) Handles cmdP.Click
    5. If txtp.Text = String.Empty Then
    6. txtp.Text = "0"
    7. Else
    8. txtp.Text = txtp.Text
    9. End If
    10. If txtw.Text = String.Empty Then
    11. txtw.Text = "0"
    12. Else
    13. txtw.Text = txtw.Text
    14. End If
    15. If txtg.Text = String.Empty Then
    16. txtg.Text = "0"
    17. Else
    18. txtg.Text = txtg.Text
    19. End If
    21. Double.TryParse(txtw.Text, W)
    22. Double.TryParse(txtg.Text, G)
    24. lblp.Text = ((W / G) * 100 - 100).ToString & "%"
    25. End Sub
    26. Private Sub cmdw_Click(ByVal sender As Object, ByVal e As EventArgs) Handles cmdw.Click
    27. If txtw.Text = String.Empty Then
    28. txtw.Text = "0"
    29. Else
    30. txtw.Text = txtw.Text
    31. End If
    32. If txtp.Text = String.Empty Then
    33. txtp.Text = "0"
    34. Else
    35. txtp.Text = txtp.Text
    36. End If
    37. If txtg.Text = String.Empty Then
    38. txtg.Text = "0"
    39. Else
    40. txtg.Text = txtg.Text
    41. End If
    43. Double.TryParse(txtp.Text, P)
    44. Double.TryParse(txtg.Text, G)
    46. lblw.Text = (G * (P + 100) / 100).ToString
    47. End Sub
    48. Private Sub cmdg_Click(ByVal sender As Object, ByVal e As EventArgs) Handles cmdg.Click
    49. If txtg.Text = String.Empty Then
    50. txtg.Text = "0"
    51. Else
    52. txtg.Text = txtg.Text
    53. End If
    54. If txtp.Text = String.Empty Then
    55. txtp.Text = "0"
    56. Else
    57. txtp.Text = txtp.Text
    58. End If
    59. If txtw.Text = String.Empty Then
    60. txtw.Text = "0"
    61. Else
    62. txtw.Text = txtw.Text
    63. End If
    65. Double.TryParse(txtp.Text, P)
    66. Double.TryParse(txtw.Text, W)
    68. lblg.Text = (W / ((P + 100) / 100)).ToString
    69. End Sub
    70. End Class



    Und hier noch die verbesserte Variante mit NumericUpDown's:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Option Strict On
    2. Public Class Form2
    3. Private Sub NumericUpDownp_ValueChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles NumericUpDownp.ValueChanged, NumericUpDowng.ValueChanged, NumericUpDownw.ValueChanged
    4. Try
    5. lblp.Text = ((NumericUpDownw.Value / NumericUpDowng.Value) * 100 - 100).ToString & "%"
    6. lblw.Text = (NumericUpDowng.Value * (NumericUpDownp.Value + 100) / 100).ToString
    7. lblg.Text = (NumericUpDownw.Value / ((NumericUpDownp.Value + 100) / 100)).ToString
    8. Catch ex As Exception
    9. End Try
    10. End Sub
    11. End Class


    „Was ich gerade mache? Ich reite Hand in Hand mit dem Matthäus-Effekt auf einer Exponentialfunktion.“ ^^

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Mikro Fahrrad“ ()

    Vielen Dank Mikro Fahrrad,

    mit NumericUpDown ist es ja wirklich viel einfacher. Ich hatte es nur nicht gewählt, weil ich damit noch nie gearbeitet habe und so auf bekanntes zurückgreifen wollte.

    (Noch nicht ganz verstanden habe ich, weshalb ich für den Grundwert keine höhere Zahl, als 100 eingeben kann (es springt sofort zurück auf 100).)

    Schon gut hats sich erledigt.
    Ein Blick in die Eigenschaften würde auch helfen :S

    Wie ich oben schon erwähnt habe - dafür gibt es mehrere Möglichkeiten:
    Siehe folgende Snippets zum Probieren...

    Wertkonvertierung unmittelbar vor einer Berechnung

    VB.NET-Quellcode

    1. Option Strict On
    3. ''' <summary>
    4. ''' Wertkonvertierung unmittelbar vor einer Berechnung
    5. ''' </summary>
    6. Public Class Form1
    7. Private G, P, W As Double
    9. Private Sub Button_Click(sender As Object, e As EventArgs) Handles cmdG.Click, cmdW.Click, cmdP.Click
    10. If ConvertAllValues() Then
    11. Select Case True
    12. Case sender Is cmdP
    13. lblP.Text = (W / G).ToString("P2")
    14. Case sender Is cmdW
    15. lblW.Text = (G * P / 100).ToString("F2")
    16. Case sender Is cmdG
    17. lblG.Text = (W / P * 100).ToString("F2")
    18. End Select
    19. Else
    20. MessageBox.Show("Eingabe-Fehler!")
    21. End If
    22. End Sub
    24. Private Function ConvertAllValues() As Boolean
    25. Dim cG = Double.TryParse(txtG.Text, G)
    26. Dim cP = Double.TryParse(txtP.Text, P)
    27. Dim cW = Double.TryParse(txtW.Text, W)
    28. Return (cG AndAlso cP AndAlso cW)
    29. End Function
    30. End Class

    Konvertierung wird nach der Eingabe im Feld angezeigt

    VB.NET-Quellcode

    1. Option Strict On
    3. ''' <summary>
    4. ''' Konvertierung wird nach der Eingabe im Feld angezeigt
    5. ''' </summary>
    6. Public Class Form1
    7. Private G, P, W As Double
    9. Private Sub Button_Click(sender As Object, e As EventArgs) Handles cmdG.Click, cmdW.Click, cmdP.Click
    10. Select Case True
    11. Case sender Is cmdP
    12. lblP.Text = (W / G).ToString("P2")
    13. Case sender Is cmdW
    14. lblW.Text = (G * P / 100).ToString("F2")
    15. Case sender Is cmdG
    16. lblG.Text = (W / P * 100).ToString("F2")
    17. End Select
    18. End Sub
    20. Private Sub txtG_Validated(sender As Object, e As EventArgs) Handles txtG.Validated, txtW.Validated, txtP.Validated
    21. Select Case True
    22. Case sender Is txtP
    23. Double.TryParse(DirectCast(sender, TextBox).Text, P)
    24. txtP.Text = P.ToString
    25. Case sender Is txtW
    26. Double.TryParse(DirectCast(sender, TextBox).Text, W)
    27. txtW.Text = W.ToString
    28. Case sender Is txtG
    29. Double.TryParse(DirectCast(sender, TextBox).Text, G)
    30. txtG.Text = G.ToString
    31. End Select
    32. End Sub
    33. End Class

    eine gültige Eingabe muss unbedingt erforderlich sein

    VB.NET-Quellcode

    1. Option Strict On
    2. Imports System.ComponentModel
    4. ''' <summary>
    5. ''' eine gültige Eingabe muss unbedingt erforderlich sein
    6. ''' sonst wird die Anwendung geschlossen!
    7. ''' </summary>
    8. Public Class Form1
    9. Private G, P, W As Double
    11. Private Sub Button_Click(sender As Object, e As EventArgs) Handles cmdG.Click, cmdW.Click, cmdP.Click
    12. Select Case True
    13. Case sender Is cmdP
    14. lblP.Text = (W / G).ToString("P2")
    15. Case sender Is cmdW
    16. lblW.Text = (G * P / 100).ToString("F2")
    17. Case sender Is cmdG
    18. lblG.Text = (W / P * 100).ToString("F2")
    19. End Select
    20. End Sub
    22. Private Sub Textbox_Validating(sender As Object, e As CancelEventArgs) Handles txtG.Validating, txtW.Validating, txtP.Validating
    23. Dim Result As Double
    24. Dim tbx = DirectCast(sender, TextBox)
    25. If Not Double.TryParse(tbx.Text, Result) Then
    26. If MessageBox.Show("Wollen Sie Ihre Eingabe überarbeiten?", "Eingabe-Fehler!", MessageBoxButtons.YesNo) = Windows.Forms.DialogResult.No Then Application.Exit()
    27. e.Cancel = True
    28. tbx.Select(0, tbx.Text.Length)
    29. End If
    30. If sender Is txtP Then P = Result
    31. If sender Is txtW Then W = Result
    32. If sender Is txtG Then G = Result
    33. End Sub
    35. End Class

    Fehler von einem Errorprovider anzeigen lassen

    VB.NET-Quellcode

    1. Option Strict On
    2. Imports System.ComponentModel
    4. ''' <summary>
    5. ''' Werkonvertierung geschieht direkt im TextBox.Validating/Validated-Event
    6. ''' hier werden Fehler von einem Errorprovider angezeigt
    7. ''' </summary>
    8. Public Class Form1
    9. Private G, P, W As Double
    10. Private errProvider As New ErrorProvider
    12. Private Sub Button_Click(sender As Object, e As EventArgs) Handles cmdG.Click, cmdW.Click, cmdP.Click
    13. Select Case True
    14. Case sender Is cmdP
    15. lblP.Text = (W / G).ToString("P2")
    16. Case sender Is cmdW
    17. lblW.Text = (G * P / 100).ToString("F2")
    18. Case sender Is cmdG
    19. lblG.Text = (W / P * 100).ToString("F2")
    20. End Select
    21. End Sub
    23. Private Sub Textbox_Validating(sender As Object, e As CancelEventArgs) Handles txtG.Validating, txtW.Validating, txtP.Validating
    24. Dim Result As Double
    25. Dim tbx = DirectCast(sender, TextBox)
    26. If Not Double.TryParse(tbx.Text, Result) Then
    27. e.Cancel = True
    28. errProvider.SetError(tbx, "keine Zahl!")
    29. tbx.Select(0, tbx.Text.Length)
    30. End If
    31. If sender Is txtP Then P = Result
    32. If sender Is txtW Then W = Result
    33. If sender Is txtG Then G = Result
    34. End Sub
    36. Private Sub txtG_Validated(sender As Object, e As EventArgs) Handles txtG.Validated, txtW.Validated, txtP.Validated
    37. errProvider.Clear()
    38. End Sub
    40. End Class


    Zum Schluss muss noch gesagt werden, dass obige Konvertierungen ohne kulturabhängige Formatierungsinformatione abgewickelt werden...
    (dazu verlinkte TryParse-Überladung verwenden...)

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „VB1963“ ()