C＃ - 实现Markdown to Word（OpenXML）

Question

I'm trying to implement my own version of markdown for creating Word Documents in a C# application. For bold/italic/underline I am going to use ** / ` / _ respectively. I have created something that parses combinations of ** 's to output bold text by extracting a match and using something like this:

RunProperties rPr2 = new RunProperties();
rPr2.Append(new Bold() { Val = new OnOffValue(true) });

Run run2 = new Run();
run2.Append(rPr2);
run2.Append(new Text(extractedString));
p.Append(run2);

My issue is when I come to combining the three different formats, as I'm thinking I would have to weigh up all the different formatting combinations and split them into separate runs. Bold runs, bold italic runs, underline runs, bold underline runs etc etc. I want my program to be able to handle something like this:

**_Lorem ipsum_** (creates bold & underlined run)

`Lorem ipsum` dolor sit amet, **consectetur _adipiscing_ elit**. 
_Praesent `feugiat` velit_ sed tellus convallis, **non `rhoncus** tortor` auctor.

Basically any mix of the styles you could throw at it I want it to handle. However if I am programmatically generating these runs, I need to weigh everything up before setting the text into runs, should I handle this with an array of character indexes for each style and merge them into a big list of styles (not sure how exactly I would do this)?

The final question is does something like this already exist? If it does I have been unable to find it (markdown to word).

Answer 1

I think you'll have to split your text into parts by the formatting they have and add each part with the correct formatting to the document. Like here http://msdn.microsoft.com/en-us/library/office/gg278312.aspx .

So

**non `rhoncus** tortor` will become - "non "{bold}, "rhoncus "{bold,italic}, "tortor"{italic}

I think it'll be easier than performing several runs. You don't even have to parse the entire document. Just parse as you go and after each "change" in the formatting write to the docx.

Another thought - If all you're creating is simple text and that's all you need, it might be even simpler to generate the openXML itself. Your data is very structured, should be easy enough to create an XML out of it.

Here's a simple algorithm to do what I propose...

// These are the different formattings you have
public enum Formatings
    {
        Bold, Italic, Underline, Undefined
    }

    // This will store the current format
    private Dictionary<Formatings, bool> m_CurrentFormat;

    // This will store which string translates into which format
    private Dictionary<string, Formatings> m_FormatingEncoding;


    public void Init()
    {
        m_CurrentFormat = new Dictionary<Formatings, bool>();
        foreach (Formatings format in Enum.GetValues(typeof(Formatings)))
        {
            m_CurrentFormat.Add(format, false);
        }

        m_FormatingEncoding = new Dictionary<string, Formatings>
                                  {{"**", Formatings.Bold}, {"'", Formatings.Italic}, {"\\", Formatings.Underline}};
    }

    public void ParseFormattedText(string p_text)
    {
        StringBuilder currentWordBuilder = new StringBuilder();
        int currentIndex = 0;

        while (currentIndex < p_text.Length)
        {
            Formatings currentFormatSymbol;
            int shift;
            if (IsFormatSymbol(p_text, currentIndex, out currentFormatSymbol, out shift))
            {   
                // This is the current word you need to insert                 
                string currentWord = currentWordBuilder.ToString();

                // This is the current formatting status --> m_CurrentFormat
                // This is where you can insert your code and add the word you want to the .docx

                currentWordBuilder = new StringBuilder();
                currentIndex += shift;
                m_CurrentFormat[currentFormatSymbol] = !m_CurrentFormat[currentFormatSymbol];

            }

            currentWordBuilder.Append(p_text[currentIndex]);
            currentIndex++;
        }


    }

    // Checks if the current position is the begining of a format symbol
    // if true - p_currentFormatSymbol will be the discovered format delimiter
    // and p_shift will denote it's length
    private bool IsFormatSymbol(string p_text, int p_currentIndex, out Formatings p_currentFormatSymbol, out int p_shift)
    {
        // This is a trivial solution, you can do better if you need
        string substring = p_text.Substring(p_currentIndex, 2);
        foreach (var formatString in m_FormatingEncoding.Keys)
        {
            if (substring.StartsWith(formatString))
            {
                p_shift = formatString.Length;
                p_currentFormatSymbol = m_FormatingEncoding[formatString];
                return true;
            }
        }

        p_shift = -1;
        p_currentFormatSymbol = Formatings.Undefined;
        return false;
    }