From procedural to OOP
Thanks for your question. IMHO, converting procedural code to OO code is an excellent thing to practice. Congratulations on your epiphany! 

In general, the problem of persisting your game's data is a serialization problem. I would invite you to explore whether .NET's native "settings" functionality might be able to meet your needs. And beyond that, standard serialization to JSON or XML might be worth a look.

If you insist on "rolling your own" serialization, you can certainly do so in an object-oriented way. My take on getting started is below. 

If you have complex data like game level definitions, you might be serializing quite a bit of data, which would be all the more reason to use a standard format like JSON or XML. 

For serializing and deserializing a relatively simple config file, you can probably skip the factory pattern. But, if the config spans multiple files, including image blobs, etc., then a "Config Factory" might be worth considering.

I would recommend building one (or more) classes to properly model the actual config properties, and serializing/deserializing that instead of processing everything as strings. 

For example: 

public class Config
{
    public string PlayerName {get; set;}
    public DateTime LastPlayed {get; set;}
    public int HighScore {get; set;}
} 


The below example takes a "hybrid" approach. It goes further than processing raw strings by using KeyValuePair, but stops short of a fully-typed Config class (as shown above). 

Another quick tip: Instead of RawLineCollection, I'd call it RawLines, or even better, Lines.

Welcome to the wide world of OOP. In some of my other code review answers I go deeper into the principles that guide my OOP practice.

Here's the sample (this code compiles, but I didn't test it):  

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

public class App_ConfigFile
{
    /*  Config file example 

        player1Name:Jane
        player2Name:Joe
        difficulty:medium
        lastPlayed:04/20/2020
        lastLevel:5
        highScore:31000
     */

    public void Run()
    {
        var file = new ConfigFile(@"c:\myGame\config.txt");
        var config = file.ToConfigData();
        var player1name = config.GetByName("player1Name");
        var lastPlayed = DateTime.Parse(config.GetByName("lastPlayed"));
        var highScore = int.Parse(config.GetByName("highScore"));
    }
}

public class ConfigFile
{
    private string path;
    private List&lt;Line&gt; lines;
    public List&lt;Line&gt; Lines =&gt; lines ?? (lines = getLines());
    public bool HasContent =&gt; Lines.Count &gt; 0;

    public ConfigFile(string path) =&gt; this.path = path;

    public ConfigData ToConfigData(char separator = ':') =&gt; new ConfigData(Lines.Select(l =&gt; l.ToKvp(separator)).ToList());

    private List&lt;Line&gt; getLines() =&gt; File.ReadAllLines(path).Select(l =&gt; new Line(l)).ToList();
}

public class Line
{
    public string Raw { get; private set; }
    public Line(string line) =&gt; Raw = line;

    public KeyValuePair&lt;string, string&gt; ToKvp(char separator)
    {
        var tokens = Raw.Split(separator);
        return new KeyValuePair&lt;string, string&gt;(tokens.First(), tokens.Last());
    }
}

public class ConfigData
{
    private List&lt;KeyValuePair&lt;string, string&gt;&gt; data;
    private Dictionary&lt;string, string&gt; _dictionary;
    private Dictionary&lt;string, string&gt; dictionary =&gt; _dictionary ?? (_dictionary = data.ToDictionary(d =&gt; d.Key, d =&gt; d.Value, StringComparer.OrdinalIgnoreCase));

    public ConfigData(List&lt;KeyValuePair&lt;string, string&gt;&gt; data) =&gt; this.data = data;

    public string GetByName(string key) =&gt; dictionary[key];
    public bool TryGetByName(string key, out string value) =&gt; dictionary.TryGetValue(key, out value);
}


}