We can't help you - we have no access to your data, and it is very much crucial to how that code runs.
So, it's going to be up to you.
Fortunately, you have a tool available to you which will help you find out what is going on: the debugger. If you don't know how to use it then a quick Google for "Visual Studio debugger" should give you the info you need.
Put a breakpoint on the first line in the function, and run your code through the debugger. Then look at your code, and at your data and work out what should happen manually. Then single step each line checking that what you expected to happen is exactly what did. When it isn't, that's when you have a problem, and you can back-track (or run it again and look more closely) to find out why.
Sorry, but we can't do that for you - time for you to learn a new (and very, very useful) skill: debugging!
Quote:Is there an error in my question?
Not as such, it's just that the problem isn't solvable without the actual data it's working with - and we don't have access to that but you do. So we don't know what
contains, or what it's
property might evaluate to, or that
s, or that they are all
es, or what their
might be. And we have no way to find out - but you do!
Think of the development process as writing an email: compiling successfully means that you wrote the email in the right language - English, rather than German for example - not that the email contained the message you wanted to send. Compiling does not mean your code is right! :laugh:
So now you enter the second stage of development (in reality it's the fourth or fifth, but you'll come to the earlier stages later): Testing and Debugging.
Start by looking at what it does do, and how that differs from what you wanted. This is important, because it give you information as to why it's doing it. For example, if a program is intended to let the user enter a number and it doubles it and prints the answer, then if the input / output was like this:
Input Expected output Actual output
1 2 1
2 4 4
3 6 9
4 8 16
Then it's fairly obvious that the problem is with the bit which doubles it - it's not adding itself to itself, or multiplying it by 2, it's multiplying it by itself and returning the square of the input.
So with that, you can look at the code and it's obvious that it's somewhere here:
Private Function Double(ByVal value As Integer) As Integer
Return value * value
Once you have an idea what might be going wrong, start using the debugger to find out why. Put a breakpoint on the first line of the method, and run your app. When it reaches the breakpoint, the debugger will stop, and hand control over to you. You can now run your code line-by-line (called "single stepping") and look at (or even change) variable contents as necessary (heck, you can even change the code and try again if you need to while it's running).
Think about what each line in the code should do before you execute it, and compare that to what it actually did when you use the "Step over" button to execute each line in turn. Did it do what you expect? If so, move on to the next line.
If not, why not? How does it differ?
Hopefully, that should help you locate which part of that code has a problem, and what the problem is.
This is a skill, and it's one which is well worth developing as it helps you in the real world as well as in development. And like all skills, it only improves by use!
Quote:Sorry! My question updated
And? What does the debugger show you is happening when you run your code? You seem to be making assumptions rather than watching what your code is actually doing with your actual data. Remember that even a leading or trailing space, or a change of case can make what looks like identical strings not match:
"string" == "string"
"string " != "string"
" string" != "string"
"String" != "string"
That's why it's essential to use your actual data, your actual controls rather than assuming anything.
For example, if your input string
looked like this:
Clients, Sales, Items
would give you three strings: "
", and "
- and only the first would probably match your
Assumptions are killers when you debug - because what you assume is right doesn't have to be and that throws you right off on a "but why doesn't it work?" branch instead of a "why doesn't that data look right?" one.