Averages and standard deviations for a Knn application
As others mentioned in comments, you should follow the .Net naming guidelines. It will make your code consistent with all other .Net code.
Try to avoid abbreviated names like KNN, because they can be confusing. And if that's supposed to mean k-nearest neighbors, then I don't see how does your class compute that.

This applies also to names like numK.
Computing some statistics on your data should be separate from parsing inputs. So the constructor of KNN should take directly numK and dataSet and it should be the job of its caller to parse the inputs.
If the common approach is to create a DataRow once and then never change it again, consider making it immutable: make the property setters private and create a constructor that can be used to set them.

You could also add a constructor from an array of doubles, as an counterpart of ToArray().
Both your GetAverage() and GetStdDev() follow the same pattern. I would try to abstract away this pattern into a separate method, to avoid repetition:

public static DataRow AggregateRows(
    this IList&lt;DataRow&gt; rows, Func&lt;IEnumerable&lt;double&gt;, double&gt; func)
{
    return new DataRow
    {
        Sun = func(rows.Select(row =&gt; row.Sun)),
        Temp = func(rows.Select(row =&gt; row.Temp)),
        Humidity = func(rows.Select(row =&gt; row.Humidity)),
        Wind = func(rows.Select(row =&gt; row.Wind))
    };
}


With this, both methods can be significantly simplified using the LINQ method Average():

public DataRow Average()
{
    return dataSet.AggregateRows(values =&gt; values.Average());
}

public DataRow StdDev()
{
    return dataSet.AggregateRows(
        values =&gt;
        {
            var average = values.Average();
            var variance = values.Average(value =&gt; Math.Pow(value - average, 2));
            return Math.Sqrt(variance);
        });
}


Note that the structure of the expression for computing variance is very similar to the way it's normally written: E[(X - E[X])2].

Also, if you do it this way, you won't need the ToArray() method anymore.
If you have many types whose ToString() follows the same pattern, you could implement it just once using reflection and then use that implementation everywhere.