从模板文件加载文本

Question

Currently I have a lot of strings in an array that can be filled with all kinds of data. An example:

var obj = new Example();    
var test = new Test();

// This must be stored in a text file
var text = new[] {
    $"{obj} contains {obj.attribute}",
    $"This is a {test.title}"
}

foreach (var line in text)
    Console.WriteLine(line);

As you see, this text array is filled with different strings, which contain external data (for example, data from the obj and test objects).

---

My question: The goal is to read lines of text from a .txt file and load them into the text variable, so the result will be the same as above.

The only condition is that this text file must include all the 'variables', like obj and test.title , so it will print the correct data contained in these objects. How do I store these lines in a .txt file and load them into the application?

Answer 1

You will nedd create Placeholders

In file will have lines:

${obj} contains ${obj.attribute}
This is a ${test.title}"

Placeholders are ${....}

Then You will need parse file, line by line.

You resolve the placeholders.

In placeholders first part of string is name of object.

Therefore you will need to have mapper of existings object in program to object in file.

Then, You create container with that mapper

Then you are map the object from file to object from container and using reflection you get the vale of what You define in placeholder

Another way:

You have only placeholders and mapper.

In file:

${obj} contains ${obj.attribute}
    This is a ${test.title}"

Mapper (for example dictionary)

  var fileMapper = new Dictionary<string, string>
                    {
                        ["obj"] = "sfsfs",
                        ["obj.attribute"] = "sfsfs"
                    };

And now you need to get placeholders and replace with object form dictionary.

Reflection is not nessesery

Full working example (compiled and tested)

class Example
    {
        public void GetFile()
        {
            var fileMapper = new Dictionary<string, string>
            {
                ["obj"] = "sfsfs",
                ["obj.attribute"] = "sfsfs"
            };

            var fileLines = new List<string>();

            using (var sr = new StreamReader("FileName"))
            {
                var line = string.Empty;

                while ((line = sr.ReadLine()) != null)
                {
                    List<string> listOfPlaceHolders = this.GetPlaceHolders(line);

                    for (var i = 0; i < listOfPlaceHolders.Count; i++)
                    {
                        line = line.Replace("${" + listOfPlaceHolders[i] + "}", fileMapper[listOfPlaceHolders[i]]);
                    }

                    fileLines.Add(line);
                }
            }


            foreach (var line in fileLines)
            {
                Console.WriteLine(line);
            }
        }

        public List<string> GetPlaceHolders(string line)
        {
            var result = new List<string>();

            var placeHoldersIndex = new List<int>();

            var open = false;

            for (var i = 0; i < line.Length; i++)
            {
                if (line[i] == '{' && !open)
                {
                    open = true;
                    placeHoldersIndex.Add(i+1);
                }

                if (line[i] == '}' && open)
                {
                    placeHoldersIndex.Add(i);
                    open = false;
                }
            }

            for (var j = 0; j < placeHoldersIndex.Count(); j += 2)
            {
               result.Add(line.Substring(placeHoldersIndex[j], placeHoldersIndex[j+1] - placeHoldersIndex[j]));
            };

            return result;
        }

    }

Answer 2

Here is a possible solution (compiled, but not tested):

Declare a class like this:

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


namespace ConsoleApplication1 {
    public class TemplateParser {

        private string content;

        public TemplateParser(string fileName) {
            Tags = new Dictionary<string, object>();
            //TODO: Add exception control. Perhaps move the reading operation outside the constructor
            content = File.ReadAllText(fileName);
        }

        public Dictionary<string, object> Tags { get; private set; }

        public void Parse() {
            foreach (string key in Tags.Keys) {
                if (Tags[key] != null) {
                object propertyValue;
                int position = key.IndexOf('.');
                if (position >= 0) {
                    string propertyName = key.Substring(position + 1);
                    propertyValue = GetPropertyValue(Tags[key], propertyName);
                } else {
                    propertyValue = Tags[key];
                }
                content = content.Replace(string.Concat("{", key, "}"), propertyValue.ToString());
                } else {
                    //TODO: what to do without not specified replacement?
                }
            }
        }

        public string[] ToArray() {
            return content.Split(new string[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
        }


        private object GetPropertyValue(object obj, string propertyName) {
            PropertyInfo pi = obj.GetType().GetProperties().FirstOrDefault(x => x.Name == propertyName);
            if (pi != null) {
                return pi.GetValue(obj, null);
            }
            return null;
        }

    }
}

Usage:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1 {
    class Program {
        static void Main(string[] args) {
            TemplateParser parser = new TemplateParser("C:\\myTextFile.txt");
            parser.Tags.Add("obj", 1);
            parser.Tags.Add("Test", new Test { Id = 1, Title = "This is a text" });

            parser.Parse();
            foreach (string line in parser.ToArray()) {
                Console.WriteLine(line);
            }
        }
    }

    class Test {
        public int Id { get; set; }
        public string Title { get; set; }
    }
}

Answer 3

Based on mnieto's answer I have been able to build an actual solution to my problem:

public class TemplateParser
{
    private string _content;
    public Dictionary<string, object> Variables { get; } = new Dictionary<string, object>();

    public TemplateParser(string filepath)
    {
        try
        {
            _content = File.ReadAllText(filepath);
        }
        catch (IOException)
        {
            Console.WriteLine("File could not be found on the following location:\n" + filepath);
        }
    }

    public void Parse()
    {
        var placeholder = "";
        var beginIndex = 0;
        var busy = false;

        for (var i = 0; i < _content.Length; i++)
            switch (_content[i])
            {
                case '{':
                    placeholder = "";
                    busy = true;
                    beginIndex = i;

                    break;
                case '}':
                    if (placeholder != "")
                    {
                        var position = placeholder.IndexOf('.');
                        var success = false;

                        try
                        {
                            object pValue;
                            if (position >= 0)
                            {
                                var pName = placeholder.Substring(position + 1);
                                pValue = GetPropertyValue(Variables[placeholder.Substring(0, position)], pName);
                            }
                            else pValue = Variables[placeholder];

                            if (pValue == null)
                            {
                                Console.WriteLine("Property not found");
                                throw new KeyNotFoundException("Property not found");
                            }

                            _content = _content.Replace("{" + placeholder + "}", pValue.ToString());
                            success = true;
                        }
                        catch (KeyNotFoundException)
                        {
                            Console.WriteLine("WARNING: Placeholder {" + placeholder + "} is unknown");
                            _content = _content.Replace("{" + placeholder + "}", "x");
                        }

                        busy = false;
                        if (success) i = beginIndex;
                    }

                    break;
                default:
                    if (busy) placeholder += _content[i];
                    break;
            }
    }

    private static object GetPropertyValue(object obj, string propertyName)
    {
        var pi = obj.GetType().GetProperties().FirstOrDefault(x => x.Name == propertyName);

        FieldInfo fi = null;
        if (pi == null)
            foreach (var x in obj.GetType().GetFields().Where(x => x.Name == propertyName))
            {
                fi = x;
                break;
            }

        return pi != null ? pi.GetValue(obj) : fi?.GetValue(obj);
    }

    public string[] ToArray() => _content.Split(new[] {Environment.NewLine}, StringSplitOptions.RemoveEmptyEntries);
}