using System;

using System.Collections.Generic;

using System.Linq;

using System.IO;

using System.Text;

using System.Net;

using System.Text.RegularExpressions;

using System.Xml;

​

public class Program

{

    public static void Main()

    {

        WebRequest request = WebRequest.Create("http://services.aonaware.com/DictService/DictService.asmx/DefineInDict");

        request.Method = "POST";

        string postData = "dictId=wn&word=abandon";

        byte[] byteArray = Encoding.UTF8.GetBytes(postData);

        request.ContentType = "application/x-www-form-urlencoded";

        request.ContentLength = byteArray.Length;

        Stream dataStream = request.GetRequestStream();

        dataStream.Write(byteArray, 0, byteArray.Length);

        dataStream.Close();

        WebResponse response = request.GetResponse();

        //Console.WriteLine(((HttpWebResponse)response).StatusDescription);

        dataStream = response.GetResponseStream();

        StreamReader reader = new StreamReader(dataStream);

        string responseFromServer = reader.ReadToEnd();

        //Console.WriteLine(responseFromServer);

        var doc = new XmlDocument();

        doc.LoadXml(responseFromServer);

        XmlNode el = doc.GetElementsByTagName("WordDefinition")[1];

        //Console.WriteLine(el.InnerText);

        ParseyMcParseface parseyMcParseface = new ParseyMcParseface(el.InnerText);

        var parsingResult = parseyMcParseface.Parse();

        foreach(var r in parsingResult){

            Console.WriteLine(r.type);

            foreach(var def in r.Def){

                Console.WriteLine("\t" + def.text);

                foreach(var s in def.synonym){

                    Console.WriteLine("\t\t" + s);

                }

            }

        }

​

    }

}

​

class ParseyMcParseface

{

    /// <summary>

    /// Word definition lines

    /// </summary>

    private string[] _text;

    /// <summary>

    /// Constructor (Takes the innerText of the WordDefinition tag as input

    /// </summary>

    /// <param name="text">innerText of the WordDefinition</param>

    public ParseyMcParseface(string text)

    {

        _text = text.Split(new [] {'\n'}, StringSplitOptions.RemoveEmptyEntries)

                .Skip(1) // Skip the first line where the word is mentioned

                .ToArray();

    }

    /// <summary>

    /// Convert from single letter type to full human readable type

    /// </summary>

    /// <param name="c"></param>

    /// <returns></returns>

    private string CharToType(char c)

    {

        switch (c)

        {

            case 'a':

            return "Adjective";

            case 'n':

            return "Noun";

            case 'v':

            return "Verb";

            default:

            return "Unknown";

        }

    }

    /// <summary>

    /// Reorganize the data for easier parsing

    /// </summary>

    /// <param name="text">Lines of text</param>

    /// <returns></returns>

    private static List<List<string>> MakeLists(IEnumerable<string> text)

    {

        List<List<string>> types = new List<List<string>>();

        int i = -1;

        int j = 0;

        foreach (var line in text)

        {

            // New type (Noun, Verb, Adj.)

            if (Regex.IsMatch(line.Trim(), "^[avn]{1}\\ \\d+"))

            {

                types.Add(new List<string> { line.Trim() });

                i++;

                j = 0;

            }

            // New definition in the previous type

            else if (Regex.IsMatch(line.Trim(), "^\\d+"))

            {

                j++;

                types[i].Add(line.Trim());

            }

            // New line of the same definition

            else

            {

                types[i][j] = types[i][j] + " " + line.Trim();

            }

        }

        return types;

    }

    public List<Definition> Parse()

    {

        var definitionsLines = MakeLists(_text);

        List<Definition> definitions = new List<Definition>();

        foreach (var type in definitionsLines)

        {

            var defs = new List<Def>();

            foreach (var def in type)

            {

                var match = Regex.Match(def.Trim(), "(?:\\:\\ )(\\w|\\ |;|\"|,|\\.|-)*[\\[]{0,1}");

                MatchCollection syns = Regex.Matches(def.Trim(), "\\{(\\w|\\ )+\\}");

                List<string> synonymes = new List<string>();

                foreach (Match syn in syns)

                {

                    synonymes.Add(syn.Value.Trim('{', '}'));

                }

                defs.Add(new Def()

                         {

                             text = match.Value.Trim(':', '[', ' '),

                             synonym = synonymes

                         });

            }

            definitions.Add(new Definition

                            {

                                type = CharToType(type[0][0]),

                                Def = defs

                            });

        }

        return definitions;

    }

}

​

public class Def

{

    public string text { get; set; }

    public List<string> synonym { get; set; }

​

}

​

public class Definition

{

    public string type { get; set; } // single character: n or v or a 

    public List<Def> Def { get; set; }

​

}