using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml.Serialization;

using System.Xml;

using System.IO;

using System.Diagnostics;

using System.Collections.ObjectModel;

using System.Threading;

using System.ComponentModel;

using System.Xml.Linq;

using System.Reflection;

using System.Data;

using System.Xml.Schema;

using System.Text.RegularExpressions;

using System.Net;

using System.Xml.XPath;

using System.Globalization;

using System.ComponentModel.DataAnnotations;

using System.Collections;

using System.Runtime.InteropServices;

using System.Runtime.Serialization;

​

// https://stackoverflow.com/questions/32193334/error-in-xml-document-unexpected-xml-declaration-xml-declaration-must-be-the-f/32193982#32193982

​

​

    [Serializable()]

    [XmlType("StoredMessage")]

    public class StoredMessage

    {

        public StoredMessage()

        {

        }

        [XmlElement("From")]

        public string From { get; set; }

        [XmlElement("Date")]

        public string Date { get; set; }

        [XmlElement("Message")]

        public string Message { get; set; }

    }

​

    [Serializable()]

    [XmlRoot("MessageHistory")]

    public class MessageHistory : List<StoredMessage>

    {

    }

​

    class ErrorLogger : IDisposable

    {

        private string xmlPath = "Messages.Xml";//System.Web.Hosting.HostingEnvironment.MapPath(WebConfigurationManager.AppSettings["DATA_XML"]);

        private object objLock = new Object();

        public string ErrorMessage { get; set; }

​

        const string rootName = "MessageHistory";

        static readonly XmlSerializer serializer = new XmlSerializer(typeof(StoredMessage), new XmlRootAttribute(rootName));

​

        public MessageHistory Operation(string from, string message, FileAccess access)

        {

            var list = new MessageHistory();

            lock (objLock)

            {

                ErrorMessage = null;

                try

                {

                    using (var file = File.Open(xmlPath, FileMode.OpenOrCreate))

                    {

                        list.AddRange(XmlSerializerHelper.ReadObjects<StoredMessage>(file, false, serializer));

                        if (list.Count == 0 && String.IsNullOrEmpty(message))

                        {

                            from = "Code Window";

                            message = "Created File";

                        }

                        var item = new StoredMessage()

                        {

                            From = from,

                            Date = DateTime.Now.ToString("s"),

                            Message = message

                        };

                        if ((access == FileAccess.ReadWrite) || (access == FileAccess.Write))

                        {

                            file.Seek(0, SeekOrigin.End);

                            var writerSettings = new XmlWriterSettings

                            {

                                OmitXmlDeclaration = true,

                                Indent = true, // Optional; remove if compact XML is desired.

                            };

                            using (var textWriter = new StreamWriter(file))

                            {

                                if (list.Count > 0)

                                    textWriter.WriteLine();

                                using (var xmlWriter = XmlWriter.Create(textWriter, writerSettings))

                                {

                                    serializer.Serialize(xmlWriter, item);

                                }

                            }

                        }

                        list.Add(item);

                    }

                }

                catch (Exception error)

                {

                    var sb = new StringBuilder();

                    int index = 0;

                    sb.AppendLine(String.Format("Top Level Error: <b>{0}</b>", error.Message));

                    var err = error.InnerException;

                    while (err != null)

                    {

                        index++;

                        sb.AppendLine(String.Format("\tInner {0}: {1}", index, err.Message));

                        err = err.InnerException;

                    }

                    ErrorMessage = sb.ToString();

                }

            }

            return list;

        }

​

        public string GetXml()

        {

            lock (objLock)

            {

                try

                {

                    if (xmlPath != null && File.Exists(xmlPath))

                        return File.ReadAllText(xmlPath);

                }

                catch (Exception)

                {

                }

                return "";

            }

        }

​

        #region IDisposable Members

​

        public void Dispose()

        {

            var xmlPath = Interlocked.Exchange(ref this.xmlPath, null);

            if (xmlPath != null && File.Exists(xmlPath))

            {

                try

                {

                    File.Delete(xmlPath);

                }

                catch (Exception)

                {

                }

            }

        }

​

        #endregion

    }

​

    public partial class XmlSerializerHelper

    {

        public static List<T> ReadObjects<T>(Stream stream, bool closeInput = true, XmlSerializer serializer = null)

        {

            var list = new List<T>();

​

            serializer = serializer ?? new XmlSerializer(typeof(T));

            var settings = new XmlReaderSettings

            {

                ConformanceLevel = ConformanceLevel.Fragment,

                CloseInput = closeInput,

            };

            using (var xmlTextReader = XmlReader.Create(stream, settings))

            {

                while (xmlTextReader.Read())

                {   // Skip whitespace

                    if (xmlTextReader.NodeType == XmlNodeType.Element)

                    {

                        using (var subReader = xmlTextReader.ReadSubtree())

                        {

                            var logEvent = (T)serializer.Deserialize(subReader);

                            list.Add(logEvent);

                        }

                    }

                }

            }

​

            return list;

        }    

    }

​

    class TestClass

    {

        public static void Test()

        {

            using (var logger = new ErrorLogger())

            {

                var messages = new []

                    {

                        "message 1",

                        "message 2",

                        "message 3",

                        "message 4",

                    };

​

                List<MessageHistory> lists = new List<MessageHistory>();

​

                foreach (var message in messages)

                {

                    var list = logger.Operation("test class", message, FileAccess.ReadWrite);

                    Assert.IsTrue(list.Last().Message == message);

                    lists.Add(list);

                }

​

                Assert.IsTrue(lists.Count == messages.Length && lists.Last().Select(i => i.Message).SequenceEqual(messages));

​

                Console.WriteLine("Final XML: ");

                Console.WriteLine(logger.GetXml());

                Console.WriteLine("\nFinal list of messages in memory: ");

                Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(lists.Last(), Newtonsoft.Json.Formatting.Indented));

            }

​

            Console.WriteLine("\nDone.");

        }

    }

​

    public class AssertionFailedException : System.Exception

    {

        public AssertionFailedException() : base() { }

​

        public AssertionFailedException(string s) : base(s) { }

    }

​

    public static class Assert

    {

        public static void IsTrue(bool value)

        {

            IsTrue(value, "failed");

        }

​

        public static void IsTrue(bool value, string message)

        {

            if (value == false)

                throw new AssertionFailedException(message ?? "failed");

        }

    }

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Environment version: " + Environment.Version);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​