<p>Congratulations! You may have just clicked on the net's ugliest image tag. I need to make nice with Photoshop or make friends with more graphic designers :)</p>
      <p>After showing up to the wrong location for my <a href="http://www.usms.org/">workout</a> because of incorrect information on my coach&#39;s regional website, I gently explained how ridiculously simple it is to maintain accurate information on the internet these days. So for one of the days of my week off between jobs I made a super simple CMS website. Here are the important parts.</p>

      <p>Good &#39;ol XML as my data source using this static manager class. I really could run all my sites on xml data since they are so small, and not multiple instances.</p>

      <script type="syntaxhighlighter" class="brush: csharp"><![CDATA[
    /// <summary>
    /// Static CmsManager handles Get, Insert, Update, Delete against the data source
    /// </summary>
    public static class CmsManager
    {
        private static readonly XmlSerializer _xmlSerializer = new XmlSerializer(typeof(List<CmsItem>));

        /// <summary>
        /// Get Cms Item
        /// </summary>
        /// <param name="nameId"></param>
        /// <returns></returns>
        public static CmsItem GetCmsItem(string nameId)
        {
            var result = DeserializeXmlDataSource(path: BuildPath())
                .SingleOrDefault(c => c.NameId == nameId);
            return result;
        }

        /// <summary>
        /// Get All Cms Items
        /// </summary>
        /// <returns></returns>
        public static List<CmsItem> GetAllCmsItems()
        {
            return DeserializeXmlDataSource(path: BuildPath()).OrderByDescending(i=>i.Created).ToList();
        }

        /// <summary>
        /// Get a list of existing cms item nameIds to help with validation
        /// </summary>
        /// <returns></returns>
        public static List<string> GetCmsItemNames()
        {
            return DeserializeXmlDataSource(path: BuildPath()).Select(c => c.NameId).ToList();
        }

        /// <summary>
        /// Update Cms Item
        /// </summary>
        /// <param name="cmsItem"></param>
        public static void UpdateCmsItem(CmsItem cmsItem)
        {
            var items = DeserializeXmlDataSource(path: BuildPath());//get all items
            var item = items.Single(i => i.NameId == cmsItem.NameId);//find the matching item
            items.Remove(item);//remove the matching item
            items.Add(cmsItem);//replace it with the new version.
            SerializeToXmlDataSource(cmsItems: items, path: BuildPath());// put the xml data back
        }

        /// <summary>
        /// Insert a new Cms Item
        /// Throws an error if the item already exists
        /// </summary>
        /// <param name="cmsItem"></param>
        public static void InsertCmsItem(CmsItem cmsItem)
        {
            var items = DeserializeXmlDataSource(path: BuildPath());//get all items
            var item = items.SingleOrDefault(i => i.NameId == cmsItem.NameId);
            if (item == null)
            {
                items.Add(cmsItem);
                SerializeToXmlDataSource(cmsItems: items, path: BuildPath());
            }
            else
            {
                throw new Exception(String.Format("An item with the name {0} already exists.", cmsItem.NameId));
            }
        }

        /// <summary>
        /// Delete Cms Item by NameId
        /// </summary>
        /// <param name="nameId"></param>
        public static void DeleteCmsItem(string nameId)
        {
            var items = DeserializeXmlDataSource(path: BuildPath());//get all items
            var item = items.SingleOrDefault(i => i.NameId == nameId);//find the matching item
            if (item != null)
            {
                items.Remove(item);
                SerializeToXmlDataSource(cmsItems: items, path: BuildPath());
            }
            else
            {
                throw new Exception(String.Format("There was no item with the NameId {0} to delete.", nameId));
            }
        }

        /// <summary>
        /// Get the source xml file as an object
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        internal static List<CmsItem> DeserializeXmlDataSource(string path)
        {
            List<CmsItem> result = null;
            if (!File.Exists(path))
            {
                SerializeToXmlDataSource(cmsItems: new List<CmsItem>(), path: path);
            }
            using (var reader = new StreamReader(path))
            {
                result = _xmlSerializer.Deserialize(reader) as List<CmsItem>;
            }
            return result;
        }

        /// <summary>
        /// Save the object back to the source xml file
        /// </summary>
        /// <param name="cmsItems"></param>
        /// <param name="path"></param>
        internal static void SerializeToXmlDataSource(List<CmsItem> cmsItems, string path)
        {
            using (var stream = new StreamWriter(path: path))
            {
                _xmlSerializer.Serialize(textWriter: stream, o: cmsItems);
            }
        }

        /// <summary>
        /// Build the path to the xml file based on the web config setting
        /// </summary>
        /// <returns></returns>
        public static string BuildPath()
        {
            var result = String.Format("{0}{1}", HostingEnvironment.ApplicationPhysicalPath, Config.RelativePathToCmsItemsXml); 
            return result;
        }
     }
]]></script>

      <p>And the definition for CmsItem.</p>
      <script type="syntaxhighlighter" class="brush: csharp"><![CDATA[
    public class CmsItem
    {
        public string NameId { get; set; }
        public string SeoTitle { get; set; }
        public string SeoDescription { get; set; }
        public string SeoAuthor { get; set; }
        public string SeoKeywords { get; set; }//comma separated
        public DateTime LastUpdated { get; set; }
        public string LastUpdatedBy { get; set; }
        public DateTime Created { get; set; }
        public string CreatedBy { get; set; }
        public DateTime UtcAvailableDate { get; set; }
        [XmlIgnore]
        public string Html { get; set; }
        public XmlCDataSection HtmlValueCData//http://stackoverflow.com/questions/1506499/xml-serialization-of-html
        {
            get
            {
                var _dummyDoc = new XmlDocument();
                return _dummyDoc.CreateCDataSection(this.Html);
            }
            set { this.Html = (value != null) ? value.Data : null; }
        }
    }
]]></script>
      <p>The Controller Code</p>
      <script type="syntaxhighlighter" class="brush: csharp"><![CDATA[
		
		[HttpGet]
        public ActionResult Cms(string id)
        {
            var model = new HomeCmsModel();
            model.CmsItem = CmsManager.GetCmsItem(id) ?? new CmsItem() { SeoTitle = String.Format("Unable to find Item {0}.", id) };//just so it doesn't break;
            return View(model);
        }
		
		]]></script>

      <p>The View</p>
      <script type="syntaxhighlighter" class="brush: html"><![CDATA[		
@model AZSunDevilMasters.Models.HomeCmsModel
@{
    ViewBag.Title = Model.CmsItem.SeoTitle;
    ViewBag.Author = Model.CmsItem.SeoAuthor;
    ViewBag.Description = Model.CmsItem.SeoDescription;
    ViewBag.Keywords = Model.CmsItem.SeoKeywords;
}

<h2>@Model.CmsItem.SeoTitle</h2>

      <div id="cms-item">
    @Html.Raw(Model.CmsItem.Html)
</div>
		
]]></script>

Allan Chadwick

Xml as a Data Source