Including control characters in a .txt file to be read by C#

Question

I'm working on a project that uses a plain ASCII .txt file as a key/value configuration file. The current format for ConfigFile.txt is something like

FirstName=Elmer|LastName=Fudd|UserId=EFudd|Password=fubar|Date=7/29/2016

This is easy to read into the program and create a dictionary with KeyValuePairs with code something like:

   using (FileStream fs = new FileStream("ConfigFile.txt", FileMode.Open))
    {
      using (StreamReader sr = new StreamReader(fs))
      {
        string fileText = sr.ReadToEnd();

        //  Tokenize the entire file string into separate key=value strings.
        string[] tokens = fileText.Split('|');

        //  Iterate through all of the key=value strings, tokenize each one into a key=Value 
        //  pair and add the key and value as separate strings into the dictionary.
        foreach (string token in tokens)
        {
          string[] keyValuePair = token.Split('=');
          configDict.Add(keyValuePair[0], keyValuePair[1]);
        }
      }
    }

It first splits out each key/value as a separate string using the '|' as the delimiter.

FirstName=Elmer

LastName=Fudd

UserId=EFudd

Password=foobar

Date=7/29/2016

Then, for each key/value string, it separates the key and value on the '=' delimiter, creates a KeyValuePair, and inserts it into a dictionary for later lookups in the program.

So far so good. Users are instructed not to create passwords with either delimiter. However, I now have to encrypt the password before including it in the file and the encryption routine can produce any printable character from 0x20 through 0x7F. So, an encrypted password can end up with either or both of the delimiters. I can end up with 'foobar' (or whatever) being encrypted by the encryption engine into P#|=g%. This messes up the ability of the split function to work properly.

So, I want to change the delimiters typed into the Notepad .txt file to control characters so that, instead of the '|' delimiter, I am using 0x1E (Record Separator) and replace the '=' sign with 0x1F (Unit Separator).

I can escape and code this directly in C# with no problems, but how would I modify the original .txt disk file so that it will read in the delimiters as single (non-printable) characters correctly?

Answer 1

So, Instead of having plain text like that, What I would do is use a proper serialization format, such as JSON.

There are tools out there that do the hard work for you.
The built-in System.Web.Script.Serialization namespace has some tools that you can use, but I prefer to use Json.Net. If you have Visual Studio, you can install it with nuGet(let me know in the comments if you need more help than that).

But once you add it to your project, you can do something like this

using System.Collections.Generic;
using System.IO;
using Newtonsoft.Json;

namespace ConsoleApplication1
{
    public class Program
    {
        static void Main(string[] args)
        {
            var dict = new Dictionary<string, string>();

            dict.Add("FirstName", "Elmer");
            dict.Add("LastName", "Fudd");
            dict.Add("Password", @"\a\ansld\sb\b8d95nj");

            var json = JsonConvert.SerializeObject(dict);

            File.WriteAllText("ConfigFile.txt, json);

            var txt = File.ReadAllText("ConfigFile.txt");
            var newDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(txt);

        }
    }
}

and ConfigFile.txt will look like this

{"FirstName":"Elmer","LastName":"Fudd","Password":"\\a\\ansld\\sb\\b8d95nj"}

---

If you want it more human-readable, use

var json = JsonConvert.SerializeObject(dict, Formatting.Indented);

and you'll get

{
  "FirstName": "Elmer",
  "LastName": "Fudd",
  "Password": "\\a\\ansld\\sb\\b8d95nj"
}

Answer 2

You can convert integers to chars so just do this...

string[] tokens = fileText.Split((char)0x1e);
// ...
string[] keyValuePair = token.Split((char)0x1f);

... but encoding your passwords as base64 would be easier and cleaner...

string base64 = Convert.ToBase64String(passwordHash);
byte[] passwordHash = Convert.FromBase64String(base64);

... NOTE: it is possible that the hashes/encrypted data will contain these characters so I wouldn't just dump the hases into the text file.

Answer 3

The following class extract the string segments using Regular Expressions and support password with non-printable characters : 0x00 .. 0xFF The class include properties to the segments of the configuration

you can run Demo Example at .NEt Fiddle

using System;
using System.Text.RegularExpressions;


class ConfigParser
{
    public string Text { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string UserId { get; set; }
    public string Password { get; set; }
    public string Date { get; set; }

    public ConfigParser(string text)
    {
        Text =text;
        Parse(text);
    }


    private static string pattern = @"
     ^FirstName=(?<firstname>\w+)    \|          
     LastName=(?<lastname>\w+)       \|              
     UserId=(?<userid>\w+)           \|                  
     Password=(?<pasword>.+)        
     Date=(?<date>.+)                         
     $
    ";

    private Regex regex = new Regex(pattern,
           RegexOptions.Singleline
           | RegexOptions.ExplicitCapture
           | RegexOptions.CultureInvariant
           | RegexOptions.IgnorePatternWhitespace
           | RegexOptions.Compiled
           );



    private void Parse(string text)
    {
        Console.WriteLine("text: {0}",text);
        Match m = regex.Match(text);
        FirstName = m.Groups["firstname"].ToString();
        LastName = m.Groups["lastname"].ToString();
        UserId = m.Groups["userid"].ToString();
        Password = m.Groups["pasword"].ToString();
        Date = m.Groups["date"].ToString();

    }

}

How to use:

   var text ="your text here"; 
   var c = new ConfigParser(text );             

   you can access the properties of the class: FirstName, LastName,....

   Console.WriteLine("firstname: {0}", c.FirstName);
   Console.WriteLine("lastname: {0}", c.LastName);
   Console.WriteLine("UserId: {0}", c.UserId);
   Console.WriteLine("Password: {0}", c.Password);
   Console.WriteLine("date {0}", c.Date);

Sample output: The password include non-printable characters | separator and symbols

text: FirstName=Elmer|LastName=Fudd|UserId=EFudd|Password=fg%|uy|◄¶|hj↑khg|Date=7/29/2016
firstname: Elmer
lastname: Fudd
UserId: EFudd
Password: fg%|uy|◄¶|hj↑khg
date: 7/29/2016

Answer 4

Easiest Answer:

Insert the special characters into the string using the ALT-numberpad value trick. Record Group ALT-31 (▼) to delimit the end of a Key/Value pair and Item Group ALT-30 (▲) to delimit the key from the value. Save the string as UTF-8.

Code for delimiters is

private static char tokenDelimiter = ('▲');
private static char keyValuePairDelimiter = ('▼');

using the same ALT-numberpad trick to put in the up and down triangles. Include instructions that the black triangles are NEVER to be edited or removed and explain their meaning.

It takes me back to my old DOS days. Simple, and took 5 minutes to implement - and it doesn't require that the existing code base be materially changed - just the two delimiter characters changed.