Euler's Method in C#
Your code is essentially fine, but stylistically, I would nitpick a few of your patterns.
Merging the declaration with the assignment of variables
You declare (almost) all of your variables at the start of your method, and then assign them later.  In general, it's better to declare the variable as late as possible, as it makes it more clear when the variable is actually relevant.  (of course, this is a matter of opinion)  Furthermore, it makes the code more concise with no sacrifice in readability, which makes it easier to reason about the code later.
Standard C# naming conventions
For variables in C#, the convention is camcelCasing.  Yet all of your variables are strictly lowercase even when they clearly represent multiple words.  For example, stepby ought to be stepBy, etc.
Using the built-in keywords when applicable
When using static methods on the int primitive, prefer to use the reserved word. Instead of:
Int32.Parse(xyvals[1]);

Prefer:
int.Parse(xyvals[1]);

If, for the sake of discussion, you prefer Int32, then be consistent and avoid using int to declare your variables.  It makes it more clear when you reference the same type consistently in your code.
Use string interpolation if using C# 6
String interpolation is a new feature in C# 6 and in general I would recommend you prefer it to string concatenation (there are performance caveats, but you should focus on that only when that performance becomes an issue over readability).  Instead of:
Parser.Parse(&quot;y =&quot; + yval.ToString()).Execute();

Use string interpolation:
Parser.Parse($&quot;y = {yval}&quot;).Execute();

The code becomes more concise, and (I believe) a little easier to read.  Also, the .ToString() is unnecessary as that call will be performed implicitly if the type of the variable is not already a string. (as a side-note, for some reason you format x = ... differently than y =... -- it should probably be consistent.)

I admit a lot of this guidance is somewhat subjective, but I hope you find it helpful. :)