Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

A Very Easy to Use Excel XML Import-Export Library

, 25 Nov 2008 CPOL
Import export library for the Excel XML format, which reduces a programmer's work to the bare minimum.
Documentation.zip
Documentation.chm
ExcelXml.zip
ExcelXml
ExcelXmlTest
bin
Debug
ExcelXmlTest.exe
ExcelXmlTest.vshost.exe
Yogesh.ExcelXml.dll
Yogesh.Extensions.dll
obj
Debug
TempPE
Properties
Yogesh.ExcelXml
bin
Debug
Yogesh.ExcelXml.dll
Yogesh.Extensions.dll
Help
Documentation.chm
LastBuild.log
obj
Debug
Refactor
TempPE
Release
Properties
Extensions.zip
Extensions
Yogesh.Extensions
bin
Debug
Yogesh.Extensions.dll
Properties
Yogesh.Extensions.zip
Yogesh.Extensions.dll
Yogesh.ExcelXml.dll
using System;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Globalization;
using System.Xml;
using Yogesh.Extensions;

namespace Yogesh.ExcelXml
{
	/// <summary>
	/// Gets or sets cell's font options
	/// </summary>
	public class FontOptions : IFontOptions
	{
		#region Public Properties
		/// <summary>
		/// Gets or sets the name of the font
		/// </summary>
		public string Name { get; set; }
		/// <summary>
		/// Gets or sets the size of the font
		/// </summary>
		public int Size { get; set; }
		/// <summary>
		/// Gets or sets font's bold property
		/// </summary>
		public bool Bold { get; set; }
		/// <summary>
		/// Gets or sets font's underline property
		/// </summary>
		public bool Underline { get; set; }
		/// <summary>
		/// Gets or sets font's italic property
		/// </summary>
		public bool Italic { get; set; }
		/// <summary>
		/// Gets or sets font's strike-through property
		/// </summary>
		public bool Strikeout { get; set; }
		/// <summary>
		/// Gets or sets font's color
		/// </summary>
		public Color Color { get; set; }
		#endregion

		#region Constructor
		/// <summary>
		/// Creates a new instance
		/// </summary>
		public FontOptions()
		{
			Name = "Tahoma";
			Size = 0;
			Bold = false;
			Underline = false;
			Italic = false;
			Strikeout = false;
			Color = Color.Black;
		}

		/// <summary>
		/// Creates a new instance based on another instance
		/// </summary>
		/// <param name="fo">Instance to copy</param>
		public FontOptions(IFontOptions fo)
		{
			Name = fo.Name;
			Size = fo.Size;
			Bold = fo.Bold;
			Underline = fo.Underline;
			Italic = fo.Italic;
			Strikeout = fo.Strikeout;
			Color = fo.Color;
		}
		#endregion

		#region Private and Internal methods
		internal bool CheckForMatch(FontOptions other)
		{
			return (Name == other.Name &&
					Size == other.Size &&
					Bold == other.Bold &&
					Underline == other.Underline &&
					Italic == other.Italic &&
					Strikeout == other.Strikeout &&
					Color == other.Color);
		}
		#endregion

		#region Import
		internal void Import(XmlReader reader)
		{
			foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
			{
				switch (xa.LocalName)
				{
					case "FontName":
						{
							Name = xa.Value;

							break;
						}
					case "Size":
						{
							int i;
							if (xa.Value.ParseToInt(out i))
								Size = i;

							break;
						}
					case "Color":
						{
							Color = XmlStyle.ExcelFormatToColor(xa.Value);

							break;
						}
					case "Bold":
						{
							Bold = xa.Value == "1" ? true : false;

							break;
						}
					case "Italic":
						{
							Italic = xa.Value == "1" ? true : false;

							break;
						}
					case "Underline":
						{
							Underline = xa.Value == "Single" ? true : false;

							break;
						}
					case "Strikeout":
						{
							Strikeout = xa.Value == "1" ? true : false;

							break;
						}
				}
			}
		}
		#endregion

		#region Export
		internal void Export(XmlWriter writer)
		{
			// Font
			writer.WriteStartElement("Font");
			writer.WriteAttributeString("ss", "FontName", null, Name);
			if (Size != 0)
				writer.WriteAttributeString("ss", "Size", null, Size.ToString(
					CultureInfo.InvariantCulture));
			// Color
			writer.WriteAttributeString("ss", "Color", null, XmlStyle.ColorToExcelFormat(Color));
			// Bold?
			if (Bold)
				writer.WriteAttributeString("ss", "Bold", null, "1");
			// Italic?
			if (Italic)
				writer.WriteAttributeString("ss", "Italic", null, "1");
			// Underline?
			if (Underline)
				writer.WriteAttributeString("ss", "Underline", null, "Single");
			if (Strikeout)
				writer.WriteAttributeString("ss", "Strikeout", null, "1");
			// Font end
			writer.WriteEndElement();
		}
		#endregion
	}

	/// <summary>
	/// Gets or sets cell's interior options
	/// </summary>
	public class InteriorOptions : IInteriorOptions
	{
		#region Public Properties
		/// <summary>
		/// Gets or sets cell background color
		/// </summary>
		public Color Color { get; set; }
		/// <summary>
		/// Gets or sets cell pattern color
		/// </summary>
		public Color PatternColor { get; set; }
		/// <summary>
		/// Gets or sets cell pattern
		/// </summary>
		public Pattern Pattern { get; set; }
		#endregion

		#region Constructor
		/// <summary>
		/// Creates a new instance
		/// </summary>
		public InteriorOptions()
		{
			Color = Color.Empty;
			PatternColor = Color.Empty;
			Pattern = Pattern.Solid;
		}

		/// <summary>
		/// Creates a new instance based on another instance
		/// </summary>
		/// <param name="io">Instance to copy</param>
		public InteriorOptions(IInteriorOptions io)
		{
			Color = io.Color;
			PatternColor = io.PatternColor;
			Pattern = io.Pattern;
		}
		#endregion

		#region Private and Internal methods
		internal bool CheckForMatch(InteriorOptions other)
		{
			return (Color == other.Color &&
					PatternColor == other.PatternColor &&
					Pattern == other.Pattern);					
		}
		#endregion

		#region Import
		internal void Import(XmlReader reader)
		{
			foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
			{
				switch (xa.LocalName)
				{
					case "Color":
						{
							Color = XmlStyle.ExcelFormatToColor(xa.Value);

							break;
						}
					case "PatternColor":
						{
							PatternColor = XmlStyle.ExcelFormatToColor(xa.Value);

							break;
						}
					case "Pattern":
						{
							Pattern = ObjectExtensions.ParseEnum<Pattern>(xa.Value);

							break;
						}
				}
			}
		}
		#endregion

		#region Export
		internal void Export(XmlWriter writer)
		{
			if (Color != Color.Empty || PatternColor != Color.Empty)
			{
				// Interior start
				writer.WriteStartElement("Interior");

				if (Color != Color.Empty)
					writer.WriteAttributeString("ss", "Color", null, XmlStyle.ColorToExcelFormat(Color));

				if (PatternColor != Color.Empty)
					writer.WriteAttributeString("ss", "PatternColor", null, XmlStyle.ColorToExcelFormat(PatternColor));

				writer.WriteAttributeString("ss", "Pattern", null, Pattern.ToString());

				// Interior end
				writer.WriteEndElement();
			}
		}
		#endregion
	}

	/// <summary>
	/// Gets or sets cell's alignment options
	/// </summary>
	public class AlignmentOptions : IAlignmentOptions
	{
		#region Public Properties
		private VerticalAlignment vertical;
		/// <summary>
		/// Gets or sets vertical alignment of the cell
		/// </summary>
		public VerticalAlignment Vertical
		{
			get
			{
				return vertical;
			}
			set
			{
				vertical = value;

				if (!vertical.IsValid())
					throw new ArgumentException("Invalid vertical alignment value encountered");
			}
		}

		private HorizontalAlignment horizontal;
		/// <summary>
		/// Gets or sets horizontal alignment of the cell
		/// </summary>
		public HorizontalAlignment Horizontal
		{
			get
			{
				return horizontal;
			}
			set
			{
				horizontal = value;

				if (!horizontal.IsValid())
					throw new ArgumentException("Invalid horizontal alignment value encountered");
			}
		}

		/// <summary>
		/// Gets or sets the indent
		/// </summary>
		public int Indent { get; set; }
		/// <summary>
		/// Gets or sets the text rotation
		/// </summary>
		public int Rotate { get; set; }

		/// <summary>
		/// Gets or sets text wrap setting
		/// </summary>
		public bool WrapText { get; set; }
		/// <summary>
		/// Gets or sets cell's shrink to cell setting
		/// </summary>
		public bool ShrinkToFit { get; set; }
		#endregion

		#region Constructor
		/// <summary>
		/// Creates a new instance
		/// </summary>
		public AlignmentOptions()
		{
			horizontal = HorizontalAlignment.None;
			vertical = VerticalAlignment.None;

			Indent = 0;
			Rotate = 0;

			WrapText = false;
			ShrinkToFit = false;
		}

		/// <summary>
		/// Creates a new instance based on another instance
		/// </summary>
		/// <param name="ao">Instance to copy</param>
		public AlignmentOptions(IAlignmentOptions ao)
		{
			horizontal = ao.Horizontal;
			vertical = ao.Vertical;

			Indent = ao.Indent;
			Rotate = ao.Rotate;

			WrapText = ao.WrapText;
			ShrinkToFit = ao.ShrinkToFit;
		}
		#endregion

		#region Private and Internal methods
		internal bool CheckForMatch(AlignmentOptions other)
		{
			return (Vertical == other.Vertical &&
					Horizontal == other.Horizontal &&
					Indent == other.Indent &&
					Rotate == other.Rotate &&
					WrapText == other.WrapText &&
					ShrinkToFit == other.ShrinkToFit);
		}
		#endregion

		#region Import
		internal void Import(XmlReader reader)
		{
			foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
			{
				switch (xa.LocalName)
				{
					case "Vertical":
						{
							Vertical = ObjectExtensions.ParseEnum<VerticalAlignment>(xa.Value);

							break;
						}
					case "Horizontal":
						{
							Horizontal = ObjectExtensions.ParseEnum<HorizontalAlignment>(xa.Value);

							break;
						}
					case "WrapText":
						{
							WrapText = xa.Value == "1" ? true : false;

							break;
						}
					case "ShrinkToFit":
						{
							ShrinkToFit = xa.Value == "1" ? true : false;

							break;
						}
					case "Indent":
						{
							int i;
							if (xa.Value.ParseToInt(out i))
								Indent = i;

							break;
						}
					case "Rotate":
						{
							int i;
							if (xa.Value.ParseToInt(out i))
								Rotate = i;

							break;
						}
				}
			}
		}
		#endregion

		#region Export
		internal void Export(XmlWriter writer)
		{
			// Alignment
			writer.WriteStartElement("Alignment");

			if (Vertical != VerticalAlignment.None)
				writer.WriteAttributeString("ss", "Vertical", null, Vertical.ToString());
			if (Horizontal != HorizontalAlignment.None)
				writer.WriteAttributeString("ss", "Horizontal", null, Horizontal.ToString());

			if (WrapText)
				writer.WriteAttributeString("ss", "WrapText", null, "1");
			if (ShrinkToFit)
				writer.WriteAttributeString("ss", "ShrinkToFit", null, "1");
			if (Indent > 0)
				writer.WriteAttributeString("ss", "Indent", null, Indent.ToString(
					CultureInfo.InvariantCulture));
			if (Rotate > 0)
				writer.WriteAttributeString("ss", "Rotate", null, Rotate.ToString(
					CultureInfo.InvariantCulture));

			// End Alignment
			writer.WriteEndElement();
		}
		#endregion
	}

	/// <summary>
	/// Gets or sets the border options
	/// </summary>
	public class BorderOptions : IBorderOptions
	{
		#region Public Properties
		private BorderSides sides;
		/// <summary>
		/// Gets or sets the border side flags
		/// </summary>
		public BorderSides Sides
		{
			get
			{
				return sides;
			}
			set
			{
				sides = value;

				if (!sides.IsValid())
					throw new ArgumentException("Invalid Border side value encountered");
			}
		}

		private Borderline lineStyle;
		/// <summary>
		/// Gets or sets the border line style
		/// </summary>
		public Borderline LineStyle
		{
			get
			{
				return lineStyle;
			}
			set
			{
				lineStyle = value;

				if (!lineStyle.IsValid())
					throw new ArgumentException("Invalid line style value encountered");
			}
		}

		/// <summary>
		/// Gets or sets the width of the border
		/// </summary>
		public int Weight { get; set; }
		/// <summary>
		/// Gets or sets border color
		/// </summary>
		public Color Color { get; set; }
		#endregion

		#region Constructor
		/// <summary>
		/// Creates a new instance
		/// </summary>
		public BorderOptions()
		{
			sides = BorderSides.None;
			lineStyle = Borderline.Continuous;
			Weight = 1;
			Color = Color.Black;
		}

		/// <summary>
		/// Creates a new instance based on another instance
		/// </summary>
		/// <param name="borderOptions">Instance to copy</param>
		public BorderOptions(IBorderOptions borderOptions)
		{
			sides = borderOptions.Sides;
			lineStyle = borderOptions.LineStyle;
			Weight = borderOptions.Weight;
			Color = borderOptions.Color;
		}
		#endregion

		#region Private and Internal methods
		internal bool CheckForMatch(BorderOptions other)
		{
			return (Sides == other.Sides &&
					LineStyle == other.LineStyle &&
					Weight == other.Weight &&
					Color == other.Color);

		}
		#endregion

		#region Import
		internal void Import(XmlReader reader)
		{
			if (reader.IsEmptyElement)
				return;

			while (reader.Read() && !(reader.Name == "Borders" && reader.NodeType == XmlNodeType.EndElement))
			{
				if (reader.NodeType == XmlNodeType.Element)
				{
					if (reader.Name == "Border")
					{
						foreach (XmlReaderAttributeItem xa in reader.GetAttributes())
						{
							switch (xa.LocalName)
							{
								case "Position":
									{
										Sides |= ObjectExtensions.ParseEnum<BorderSides>(xa.Value);

										break;
									}
								case "LineStyle":
									{
										LineStyle = ObjectExtensions.ParseEnum<Borderline>(xa.Value);

										break;
									}
								case "Weight":
									{
										int i;
										if (xa.Value.ParseToInt(out i))
											Weight = i;

										break;
									}
							}
						}
					}
				}
			}
		}
		#endregion

		#region Export
		private void ExportBorder(XmlWriter writer, string border)
		{
			writer.WriteStartElement("Border");
			writer.WriteAttributeString("ss", "Position", null, border);
			writer.WriteAttributeString("ss", "LineStyle", null, LineStyle.ToString());
			writer.WriteAttributeString("ss", "Weight", null, Weight.ToString(
					CultureInfo.InvariantCulture));

			if (Color != Color.Black)
				writer.WriteAttributeString("ss", "Color", null, XmlStyle.ColorToExcelFormat(Color));

			writer.WriteEndElement();
		}

		internal void Export(XmlWriter writer)
		{
			if (Sides != BorderSides.None)
			{
				// Border start
				writer.WriteStartElement("Borders");
				if (Sides.IsFlagSet(BorderSides.Left))
					ExportBorder(writer, "Left");
				if (Sides.IsFlagSet(BorderSides.Top))
					ExportBorder(writer, "Top");
				if (Sides.IsFlagSet(BorderSides.Right))
					ExportBorder(writer, "Right");
				if (Sides.IsFlagSet(BorderSides.Bottom))
					ExportBorder(writer, "Bottom");
				// Border end
				writer.WriteEndElement();
			}
		}
		#endregion
	}

	/// <summary>
	/// Style class for cells, rows and worksheets
	/// </summary>
	public class XmlStyle : IStyle
	{
		#region Private and Internal fields
		internal string ID { get; set; }
		#endregion

		#region Public Properties
		private FontOptions _Font { get; set; }
		/// <summary>
		/// Gets or sets the font options
		/// </summary>
		public IFontOptions Font
		{
			get
			{
				return _Font;
			}
			set
			{
				_Font = (FontOptions) value;
			}
		}

		private AlignmentOptions _Alignment { get; set; }
		/// <summary>
		/// Gets or sets cell alignment options
		/// </summary>
		public IAlignmentOptions Alignment
		{ 
			get
			{
				return _Alignment;
			}
			set
			{
				_Alignment = (AlignmentOptions) value;
			}
		}

		private InteriorOptions _Interior { get; set; }
		/// <summary>
		/// Gets or sets interior options
		/// </summary>
		public IInteriorOptions Interior
		{
			get
			{
				return _Interior;
			}
			set
			{
				_Interior = (InteriorOptions) value;
			}
		}

		private BorderOptions _Border { get; set; }
		/// <summary>
		/// Gets or sets border settings
		/// </summary>
		public IBorderOptions Border
		{
			get
			{
				return _Border;
			}
			set
			{
				_Border = (BorderOptions)value;
			}
		}

		private DisplayFormatType displayFormat;
		/// <summary>
		/// Gets or sets the cell display format
		/// </summary>
		public DisplayFormatType DisplayFormat
		{
			get
			{
				return displayFormat;
			}
			set
			{
				displayFormat = value;

				if (!displayFormat.IsValid())
					throw new ArgumentException("Invalid display format value encountered");

				if (displayFormat == DisplayFormatType.Custom && CustomFormatString.IsNullOrEmpty())
					displayFormat = DisplayFormatType.None;
			}
		}

		private string customFormatString;
		/// <summary>
		/// Gets or sets a custom display string
		/// </summary>
		public string CustomFormatString
		{
			get
			{
				return customFormatString;
			}
			set
			{
				customFormatString = value;

				DisplayFormat = customFormatString.IsNullOrEmpty() ? DisplayFormatType.None : DisplayFormatType.Custom;
			}
		}
		#endregion

		#region Constructor
		/// <summary>
		/// Creates a new instance
		/// </summary>
		public XmlStyle()
		{
			Initialize();
			SetDefaults();
		}

		/// <summary>
		/// Creates a new instance from another instance of XmlStyle
		/// </summary>
		/// <param name="style">Instance to copy</param>
		public XmlStyle(XmlStyle style)
		{
			if (style == null)
			{
				Initialize();
				SetDefaults();
				return;
			}

			ID = "";

			_Font = new FontOptions(style._Font);
			_Interior = new InteriorOptions(style._Interior);
			_Alignment = new AlignmentOptions(style._Alignment);
			_Border = new BorderOptions(style._Border);

			DisplayFormat = style.DisplayFormat;
		}
		#endregion

		#region Private and Internal methods
		private void Initialize()
		{
			_Font = new FontOptions();
			_Interior = new InteriorOptions();
			_Alignment = new AlignmentOptions();
			_Border = new BorderOptions();
		}

		private void SetDefaults()
		{
			ID = "";

			DisplayFormat = DisplayFormatType.None;
		}

		internal bool CheckForMatch(XmlStyle style)
		{
			if (style == null)
				return false;

			if (_Font.CheckForMatch(style._Font) &&
				_Alignment.CheckForMatch(style._Alignment) &&
				_Interior.CheckForMatch(style._Interior) &&
				_Border.CheckForMatch(style._Border) &&
				DisplayFormat == style.DisplayFormat)
			{
				return true;
			}

			return false;
		}

		internal static string ColorToExcelFormat(Color color)
		{
			return String.Format(CultureInfo.InvariantCulture,
				"#{0:X2}{1:X2}{2:X2}", color.R, color.G, color.B);
		}

		internal static Color ExcelFormatToColor(string str)
		{
			int r;

			if (Int32.TryParse(str.Substring(1, 2), NumberStyles.HexNumber,
				CultureInfo.InvariantCulture, out r))
			{
				int g;

				if (Int32.TryParse(str.Substring(3, 2), NumberStyles.HexNumber,
					CultureInfo.InvariantCulture, out g))
				{
					int b;

					if (Int32.TryParse(str.Substring(5, 2), NumberStyles.HexNumber,
						CultureInfo.InvariantCulture, out b))
					{

						return Color.FromArgb(r, g, b);
					}
				}
			}

			return Color.Black;
		}
		#endregion

		#region Public methods
		/// <summary>
		/// Equality operator
		/// </summary>
		/// <param name="cellOne">Instance one to compare</param>
		/// <param name="cellTwo">Instance two to compare</param>
		/// <returns>true if all the values of the styles match, false otherwise</returns>
		public static bool operator ==(XmlStyle cellOne, XmlStyle cellTwo)
		{
			if (!(cellOne is XmlStyle))
			{
				return !(cellTwo is XmlStyle);
			}

			return cellOne.Equals(cellTwo);
		}

		/// <summary>
		/// Inequality operator
		/// </summary>
		/// <param name="cellOne">Instance one to compare</param>
		/// <param name="cellTwo">Instance two to compare</param>
		/// <returns>true if the values of the styles dont match, false otherwise</returns>
		public static bool operator !=(XmlStyle cellOne, XmlStyle cellTwo)
		{
			if (!(cellOne is XmlStyle))
			{
				return (cellTwo is XmlStyle);
			}

			return !cellOne.Equals(cellTwo);
		}

		/// <summary>
		/// Equality operator
		/// </summary>
		/// <param name="obj">Instance to compare</param>
		/// <returns>true if all the values of the styles match, false otherwise</returns>
		[SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
		public override bool Equals(object obj)
		{
			if (obj is XmlStyle)
			{
				// do compare logic here
				return CheckForMatch((XmlStyle) obj);
			}

			return false;
		}

		/// <summary>
		/// Returns the hash code of the class
		/// </summary>
		/// <returns>Hash code of the class</returns>
		public override int GetHashCode()
		{
			return base.GetHashCode();
		}
		#endregion

		#region Import
		internal static XmlStyle Import(XmlReader reader)
		{
			XmlStyle style = new XmlStyle();

			bool isEmpty = reader.IsEmptyElement;

			XmlReaderAttributeItem xa = reader.GetSingleAttribute("ID");
			if (xa != null)
				style.ID = xa.Value;

			if (isEmpty)
				return xa == null ? null : style;

			while (reader.Read() && !(reader.Name == "Style" && reader.NodeType == XmlNodeType.EndElement))
			{
				if (reader.NodeType == XmlNodeType.Element)
				{
					switch (reader.Name)
					{
						case "Font":
							{
								style._Font.Import(reader);

								break;
							}
						case "Alignment":
							{
								style._Alignment.Import(reader);

								break;
							}
						case "Interior":
							{
								style._Interior.Import(reader);

								break;
							}
						case "Borders":
							{
								style._Border.Import(reader);

								break;
							}
						case "NumberFormat":
							{
								XmlReaderAttributeItem nfAttr = reader.GetSingleAttribute("Format");
								if (nfAttr != null)
								{
									string format = nfAttr.Value;

									switch (format)
									{
										case "Short Date":
											{
												style.DisplayFormat = DisplayFormatType.ShortDate;
												break;
											}
										case "General Date":
											{
												style.DisplayFormat = DisplayFormatType.GeneralDate;
												break;
											}
										case "@":
											{
												style.DisplayFormat = DisplayFormatType.Text;
												break;
											}
										default:
											{
												if (format == DateTimeFormatInfo.CurrentInfo.LongDatePattern)
													style.DisplayFormat = DisplayFormatType.LongDate;

												string timeFormat = DateTimeFormatInfo.CurrentInfo.LongTimePattern;
												if (timeFormat.Contains("t"))
													timeFormat = timeFormat.Replace("t", "AM/PM");
												if (timeFormat.Contains("tt"))
													timeFormat = timeFormat.Replace("tt", "AM/PM");

												if (format == timeFormat)
													style.DisplayFormat = DisplayFormatType.Time;

												try
												{
													style.DisplayFormat = ObjectExtensions.ParseEnum<DisplayFormatType>(format);
												}
												catch (ArgumentException)
												{
													if (format.IsNullOrEmpty())
														style.DisplayFormat = DisplayFormatType.None;
													else
													{
														style.DisplayFormat = DisplayFormatType.Custom;
														style.CustomFormatString = format;
													}
												}

												break;
											}
									}

								}

								break;
							}
					}
				}
			}

			return style;
		}
		#endregion

		#region Export
		internal void Export(XmlWriter writer)
		{
			// Start Style tag
			writer.WriteStartElement("Style");
			// ID...
			writer.WriteAttributeString("ss", "ID", null, ID);

			_Font.Export(writer);

			_Alignment.Export(writer);

			_Border.Export(writer);

			_Interior.Export(writer);

			if (DisplayFormat != DisplayFormatType.None)
			{
				string format = "";

				switch (DisplayFormat)
				{
					case DisplayFormatType.ShortDate:
						{
							format = "Short Date";
							break;
						}
					case DisplayFormatType.GeneralDate:
						{
							format = "General Date";
							break;
						}
					case DisplayFormatType.LongDate:
						{
							format = DateTimeFormatInfo.CurrentInfo.LongDatePattern;
							break;
						}
					case DisplayFormatType.Time:
						{
							format = DateTimeFormatInfo.CurrentInfo.LongTimePattern;

							if (format.Contains("t"))
								format = format.Replace("t", "AM/PM");
							if (format.Contains("tt"))
								format = format.Replace("tt", "AM/PM");

							break;
						}
					case DisplayFormatType.Text:
						{
							format = "@";
							break;
						}
					case DisplayFormatType.Fixed:
					case DisplayFormatType.Percent:
					case DisplayFormatType.Scientific:
					case DisplayFormatType.Standard:
						{
							format = DisplayFormat.ToString();
							break;
						}
					case DisplayFormatType.Custom:
						{
							format = CustomFormatString;
							break;
						}
				}

				writer.WriteStartElement("NumberFormat");
				writer.WriteAttributeString("ss", "Format", null, format);
				writer.WriteEndElement();
			}

			// Style end
			writer.WriteEndElement();
		}
		#endregion
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author


| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.141223.1 | Last Updated 26 Nov 2008
Article Copyright 2008 by Yogesh Jagota
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid