For a resilient, fast, and low effort solution, you can use [CsvHelper][1] which handles a lot of code and edge cases and has pretty good [documentation][2]

### First, install the [CsvHelper package on Nuget][3]

[![CsvHelper nuget download][4]][4]

## a) CSV *with* Headers

If your csv has headers like this:

```none
sport,date,team 1,team 2,score 1,score 2
basketball,2011/01/28,Rockets,Blazers,98,99
baseball,2011/08/22,Yankees,Redsox,4,3
```

You can add attributes to your class to map the field names to your class names like this:

```cs
public class SportStats
{
    [Name("sport")]
    public string Sport { get; set; }
    [Name("date")]
    public DateTime Date { get; set; }
    [Name("team 1")]
    public string TeamOne { get; set; }
    [Name("team 2")]
    public string TeamTwo { get; set; }
    [Name("score 1")]
    public int ScoreOne { get; set; }
    [Name("score 2")]
    public int ScoreTwo { get; set; }
}
```

And then invoke like this:

```
List<SportStats> records;

using (var reader = new StreamReader(@".\stats.csv"))
using (var csv = new CsvReader(reader))
{
    records = csv.GetRecords<SportStats>().ToList();
}
```

### b) CSV *without* Headers

If your csv doesn't have headers like this:

```none
basketball,2011/01/28,Rockets,Blazers,98,99
baseball,2011/08/22,Yankees,Redsox,4,3
```

You can add attributes to your class and map to the CSV ordinally by position like this:

```cs
public class SportStats
{
    [Index(0)]
    public string Sport { get; set; }
    [Index(1)]
    public DateTime Date { get; set; }
    [Index(2)]
    public string TeamOne { get; set; }
    [Index(3)]
    public string TeamTwo { get; set; }
    [Index(4)]
    public int ScoreOne { get; set; }
    [Index(5)]
    public int ScoreTwo { get; set; }
}
```

And then invoke like this:

```
List<SportStats> records;

using (var reader = new StreamReader(@".\stats.csv"))
using (var csv = new CsvReader(reader))
{
    csv.Configuration.HasHeaderRecord = false;
    records = csv.GetRecords<SportStats>().ToList();
}
```

### Further Reading

* [Reading CSV file and storing values into an array][7] (295🡅)
* [Parsing CSV files in C#, with header][9] (245🡅)
* [Import CSV file to strongly typed data structure in .Net][6] (104🡅)
* [Reading a CSV file in .NET?][5] (45🡅)
* [Is there a “proper” way to read CSV files][8] (17🡅)
* ... many more

[1]: https://github.com/JoshClose/CsvHelper
[2]: https://joshclose.github.io/CsvHelper/getting-started/
[3]: https://www.nuget.org/packages/CsvHelper/
[4]: https://i.stack.imgur.com/RaOZM.png
[5]: https://stackoverflow.com/q/1405038/1366033
[6]: https://stackoverflow.com/q/1898/1366033
[7]: https://stackoverflow.com/q/5282999/1366033
[8]: https://stackoverflow.com/a/2315182/1366033
[9]: https://stackoverflow.com/q/2081418/1366033

I know how to read and display a line of a .csv file. Now I would like to parse that file, store its contents in arrays, and use those arrays as values for some classes I created.

I'd like to learn how though.

Here is an example:

    basketball,2011/01/28,Rockets,Blazers,98,99
    baseball,2011/08/22,Yankees,Redsox,4,3

As you can see, each field is separated by commas. I've created the Basketball.cs and Baseball classes which is an extension of the Sport.cs class, which has the fields:

    private string sport;
    private string date;
    private string team1;
    private string team2;
    private string score;

I understand that this is simplistic, and that there's better ways of storing this info, i.e. creating classes for each team, making the date a DateType datatype, and more of the same but I'd like to know how to input this information into the classes. 

I'm assuming this has something to do with getters and setters... I've also read of dictionaries and collections, but I'd like to start simple by storing them all in arrays... (If that makes sense... Feel free to correct me).

Here is what I have so far. All it does is read the csv and parrot out its contents on the Console:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;

    namespace Assign01
    {
        class Program
        {
            static void Main(string[] args)
            {
                string line;
                FileStream aFile = new FileStream("../../sportsResults.csv", FileMode.Open);
                StreamReader sr = new StreamReader(aFile);
                
                // read data in line by line
                while ((line = sr.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                    line = sr.ReadLine();
                }
                sr.Close();
            }
        }
    }


Help would be much appreciated.

Importing CSV data into C# classes

One option for webpack users is to install [**directory-named-webpack-plugin**][1]

Install, and then add the following to Webpack's config file:

```js
var DirectoryNamedWebpackPlugin = require("directory-named-webpack-plugin");

resolve: {
    plugins: [
        new DirectoryNamedWebpackPlugin()
    ]
}
```

When using `require("component/foo")` *and* the path `"component/foo"` is resolved to a directory, Webpack will try to look for `component/foo/foo.js` as the entry point.

**Caution**: While this approach does allow webpack to resolve filenames when building and bundling, your intellisense / tooling options are a different beast altogether.  Unless they also have similar functionality, you may lose *Go To Definition* and *Intellisense* support by not providing the full reference statically.


[1]: https://www.npmjs.com/package/directory-named-webpack-plugin

In my React and Webpack project, I have the following project structure of React components:

    Component/
    ├── Component.jsx
    ├── index.jsx
    └── styles.css
The `index.jsx` file simply imports and exports `Component.jsx`; the reason being that in files that require it, it allows the usage of the following:

    import Component from '../Component'
    
as opposed to

    import Component from '../Component/Component'

However this seems like it may be an unnecessary extra step which requires all new components to follow suit.

With this in mind, my question is: Can I have the best of both worlds? I want to be able to only have `Component.jsx` and `styles.css` in my directory, but not have to use the name twice in my `import` declaration.