VB 'Option Strict' issue with conversion from double to long - vb.net

Question

I just started using VB and had to switch 'Option Strict' to on. I got this error in my code saying "Option Strict On disallows implicit conversions from 'double to long.'" I know what it means, but my friend and I can not seem to resolve the issue.
Error: "Option Strict disallows implicit conversions from 'Double' to 'Long' for both value1 and value 2 on line 24. (Private Sub btnIntDiv_Click)
Here is the code:
Public Class frmMathCalculator
Dim value1 As Double
Dim value2 As Double
Private Sub btnAdd_Click(sender As Object, e As EventArgs) Handles btnAdd.Click
value1 = Integer.Parse(txtValue1.Text)
value2 = Integer.Parse(txtValue2.Text)
Dim addResult As Double = value1 + value2
lstAnswer.Items.Add(addResult)
End Sub
Private Sub btnSubtract_Click(sender As Object, e As EventArgs) Handles btnSubtract.Click
Dim subtractResults As Double = value1 - value2
lstAnswer.Items.Add(subtractResults)
End Sub
Private Sub btnMultiply_Click(sender As Object, e As EventArgs) Handles btnMultiply.Click
Dim multiplyResults As Double = value1 * value2
lstAnswer.Items.Add(multiplyResults)
End Sub
Private Sub btnLongDiv_Click(sender As Object, e As EventArgs) Handles btnLongDiv.Click
Dim divideResults As Double = value1 / value2
lstAnswer.Items.Add(divideResults)
End Sub
Private Sub btnIntDiv_Click(sender As Object, e As EventArgs) Handles btnIntDiv.Click
Dim intDivResults As Double = value1 \ value2
lstAnswer.Items.Add(intDivResults)
End Sub
Private Sub btnMod_Click(sender As Object, e As EventArgs) Handles btnMod.Click
Dim modResults As Double = value1 Mod value2
lstAnswer.Items.Add(modResults)
End Sub
Private Sub btnExponent_Click(sender As Object, e As EventArgs) Handles btnExponent.Click
Dim expResults = value1 ^ value2
lstAnswer.Items.Add(expResults)
End Sub
End Class

Answer 1

Consider:
Public Class frmMathCalculator
Private value1 As Double 'we typically specify access levels like public or private for variables declared inside a class
Private value2 As Double
'We need to do this often, so rather than repeat the parsing in every
'Button click handler we create a sub we can call
Private Sub ParseUserInput()
'TODO: switch these to TryParse and provide user feedback if input is bad
'TODO: make this sub a function that returns a Boolean and return false if input is bad
value1 = Double.Parse(txtValue1.Text) 'value1 is a double, so use double.parse not int.parse
value2 = Double.Parse(txtValue2.Text)
End Sub
Private Sub btnAdd_Click(sender As Object, e As EventArgs) Handles btnAdd.Click
ParseUserInput() 'set our value variables
'VB will be able to work out that double + double is double so can skip the "As Double" bit
Dim addResult = value1 + value2
'List.Items.Add takes an object, and the list will simply call ToString on it when it wants
' to display it. For a double this is fine unless we want to format it - more on this later
lstAnswer.Items.Add(addResult)
End Sub
I haven't done all of them, but the pattern is repeatable..
This is ultimately an exercise in precision and knowing about datatypes. Functions take variables that are a certain type and emit data that has a type, possibly different. You need to keep consistency and generally be aware all the time what types of data are being put where
Double.Parse takes in a string, returns a double. Double+Double results in a double. ListBox.Items.Add takes in an object (returns nothing, but some collection add methods return something that you might capture and use) so you can put anything you like in but it's important to appreciate that to display it it has to be a string. To achieve this, if you didn't tell List to display the contents of a particular property of the item, then list will just blindly call ToString on the object you put in. For a double this is fine- it just takes the 1.234 double and makes it a string "1.234" which looks the same. If however you have created some custom class like Person, but you haven't provided a specialized variation of ToString that eg returns first name and last name, then all you'll see in your list is "MyNamespace.Person" over and over again. This is because by default ToString just returns the name of the kind of object.
Suppose in this case we wanted to format our doubles to 3dp all the time.. instead of putting the double in the list and having the list do the ToString, we could format a string and put it in: list.Items.Add(aDouble.ToString("0.000"))
So, which to use and why? If you're just using this list to hold the results, then format a string. You could even put the whole sum in: list.Items.Add($"{value1} + {value2} = {result:0.000} (to 3dp)")
If you're going to get these numbers back out of the list and do something with them later, keep them as doubles
If you want to get them out later and also have a customized presentation of them you need to add them as their own custom object that knows the value but can present a customized representation when asked. That's probably a bit advanced for now
With option strict off VB is very(overly) forgiving; if you try and put a string into something that takes a double, it'll try and convert the string to double for you. That's great, perhaps, but it doesn't encourage a strict mindset in the programmer - and eventually it goes wrong. Being mindful about the ins and outs and their types, and being explicit, is a great way to avoid subtle bugs in the future