C#

//fill datasource with some test data
PieChartDataSource dataSource = new PieChartDataSource();
dataSource.Add(new PieSliceData("Running", 1841200, Color.Green));
dataSource.Add(new PieSliceData("Waiting", 290000, Color.Blue));
dataSource.Add(new PieSliceData("Blocked", 181000, Color.Yellow));
dataSource.Add(new PieSliceData("Interruption", 62000, Color.Orange));
dataSource.Add(new PieSliceData("Fault", 45000, Color.Red));

PieChart chart = new PieChart(dataSource);
Bitmap chartBmp = chart.DrawChart(new Size(800,600));
chartBmp.Save(@"d:\chart.bmp");

Bitmap legendBmp = chart.DrawLegend();
legendBmp.Save(@"d:\legend.bmp");

PieChart chart = new PieChart(dataSource);
chart.DrawLegendInChart = true;
chart.LegendPosition = Position.top;
Bitmap chartBmp = chart.DrawChart(new Size(800,600));
chartBmp.Save(@"d:\chart.bmp");

Bitmap legendBmp = chart.DrawLegend();
legendBmp.Save(@"d:\legend.bmp");

PieChart chart = new PieChart(dataSource);
chart.DrawLegendInChart = true;
chart.LegendPosition = Position.top;
Bitmap chartBmp = chart.DrawChart(new Size(800,600));
chartBmp.Save(@"d:\chart.bmp");

Bitmap legendBmp = chart.DrawLegend();
legendBmp.Save(@"d:\legend.bmp");

graphics.DrawString(strText, m_FontLegend, blackBrush, iStartX, iStartY);

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections;

namespace Charts
{
	#region enums
	public enum Position{top, bottom, left, right};
	#endregion
	
	/// <summary>
	/// Holds data of one single slice of the PieChart
	/// </summary>
	public class PieSliceData
	{
		#region fields
		string m_strName;
		double m_dValue;
		Color m_Color;
		#endregion

		#region constructors
		public PieSliceData(string strName, double dValue, Color color)
		{
			m_strName=strName;
			m_dValue=dValue;
			m_Color=color;
		}
		#endregion

		#region properties
		public string Name
		{
			get
			{
				return m_strName;
			}
		}

		public double Value
		{
			get
			{
				return m_dValue;
			}
		}

		public Color SliceColor
		{
			get
			{
				return m_Color;
			}
		}
		#endregion
	}
	
	/// <summary>
	/// A collection of PieSliceData
	/// </summary>
	public class PieChartDataSource
	{
		#region fields
		ArrayList m_List;
		#endregion

		#region constructors
		public PieChartDataSource()
		{
			m_List = new ArrayList();
		}
		#endregion

		#region methods
		public void Add(PieSliceData sliceData)
		{
			m_List.Add(sliceData);
		}

		public void RemoveAt(int iIndex)
		{
			m_List.RemoveAt(iIndex);
		}

		public IEnumerator GetEnumerator()
		{
			return m_List.GetEnumerator();
		}
		#endregion

		#region properties
		/// <summary>
		/// Gets the number of PieSlices in the PieSliceDataSource
		/// </summary>
		public int Count
		{
			get
			{
				return m_List.Count;
			}
		}
		#endregion

		#region operators
		public PieSliceData this[int index]
		{
			get
			{
				return (PieSliceData) m_List[index];
			}
		}
		#endregion
	}
	
	/// <summary>
	/// Draw a pie chart using the given information.
	/// </summary>
	public class PieChart
	{
		#region fields
		//chart variables
		PieChartDataSource m_DataSource;
		Color m_BGColor;

		//legend variables
		float m_FontSizeLegend;
		Font m_FontLegend;
		bool m_bDrawLegendInChart;
		Position m_LegendPosition;
		#endregion
		
		#region constructors
		public PieChart(PieChartDataSource dataSource)
		{
			m_DataSource = dataSource;
			m_BGColor = Color.White;
			
			m_FontSizeLegend = 10.0f;
			m_FontLegend = new Font("Verdana", m_FontSizeLegend);
			m_bDrawLegendInChart = false;
			m_LegendPosition = Position.bottom;
		}
		#endregion
		
		#region methods
		/// <summary>
		/// draws a chart in a bitmap
		/// </summary>
		/// <param name="size">size of the bitmap</param>
		/// <returns>a bitmap that holds the chart</returns>
		public Bitmap DrawChart(Size size)
		{
			// Create a new bitmap
			Bitmap bitmap = new Bitmap(size.Width, size.Height, PixelFormat.Format32bppArgb);
			Graphics graphics = Graphics.FromImage(bitmap);
			
			//draw chart in bitmap
			DrawChart(graphics, size);

			return bitmap;
		}

		/// <summary>
		/// draws a chart
		/// </summary>
		/// <param name="graphics">graphics object to draw</param>
		/// <param name="size">desired size of the chart</param>
		public void DrawChart(Graphics graphics, Size size)
		{
			//color background
			SolidBrush brush = new SolidBrush(m_BGColor);
			graphics.FillRectangle(brush, 0, 0, size.Width, size.Height);
			brush.Dispose();

			//draw legend
			if(m_bDrawLegendInChart == true)
			{
				Size legendSize = CalculateLegendSize(graphics);
				
				switch(m_LegendPosition)
				{
					case Position.top:
					{
						//place legen at top middle
						int iLegendOriginX = Convert.ToInt32((size.Width/2) - (legendSize.Width/2));
						int iLegendOriginY = 5;
						DrawLegend(graphics,new Point(iLegendOriginX,iLegendOriginY), legendSize);
					}
						break;
					case Position.bottom:
					{
					}
						break;
					case Position.left:
					{
					}
						break;
					case Position.right:
					{
					}
						break;
				}
			}

			//sum the values to get the total
			double total = 0.0;
			for(int i = 0; i < m_DataSource.Count; i++)
			{
				total+=m_DataSource[i].Value;
			}

			//draw the pie chart
			float start = 0.0f;
			float end = 0.0f;
			double current = 0.0;
			for(int i = 0; i < m_DataSource.Count; i++)
			{
				current += m_DataSource[i].Value;
				start = end;
				end = (float) (current / total) * 360.0f;
				
				SolidBrush sliceBrush = new SolidBrush(m_DataSource[i].SliceColor);
				graphics.FillPie(sliceBrush, 0.0f, 0.0f, size.Width, size.Height, start, end - start);
				sliceBrush.Dispose();
			}
		}

		/// <summary>
		/// draws the chart's legend into a bitmap
		/// </summary>
		/// <param name="size">size of the bitmap</param>
		/// <returns>bitmap that holds the legend</returns>
		public Bitmap DrawLegend()
		{
			// Create a dummy bitmap to get a graphics object
			Bitmap bitmap = new Bitmap(1, 1, PixelFormat.Format32bppArgb);
			Graphics dummyGraphics = Graphics.FromImage(bitmap);

			Size legendSize = CalculateLegendSize(dummyGraphics);

			//now create the actual bitmap
			bitmap = new Bitmap(legendSize.Width, legendSize.Height, PixelFormat.Format32bppArgb);
			Graphics graphics = Graphics.FromImage(bitmap);

			//now draw the legend
			DrawLegend(graphics, new Point(0,0), bitmap.Size);

			return bitmap;
		}

		/// <summary>
		/// draws the chart's legend
		/// </summary>
		/// <param name="graphics">graphics object to draw</param>
		/// <param name="origin">start point for drawing</param>
		/// <param name="size">desired size of the legend</param>
		public void DrawLegend(Graphics graphics, Point origin, Size size)
		{
			//color background
			SolidBrush brush = new SolidBrush(m_BGColor);
			graphics.FillRectangle(brush, origin.X, origin.Y, size.Width, size.Height);
			brush.Dispose();

			//draw a line around the bitmap
			graphics.DrawRectangle(new Pen(Color.Black, 2), origin.X, origin.Y, size.Width, size.Height);
			
			//create brush for text
			Brush blackBrush = Brushes.Black;
			
			//draw little rectangles with the appropriate color and write the legend text 
			for(int i = 0; i < m_DataSource.Count; i++)
			{
				SolidBrush sliceBrush = new SolidBrush(m_DataSource[i].SliceColor);

				graphics.FillRectangle(sliceBrush, origin.X + 5, origin.Y + 5 + (m_FontLegend.Height * i), 10, 10);
				
				string strText = m_DataSource[i].Name +": "+ m_DataSource[i].Value.ToString();
				int iStartX = origin.X + 20;
				int iStartY = origin.Y + 1 + (m_FontLegend.Height * i);
				graphics.DrawString(strText, m_FontLegend, blackBrush, iStartX, iStartY);
			
				sliceBrush.Dispose();
			}
	
			//don't forget to dispose the text brush
			blackBrush.Dispose();
		}
		
		/// <summary>
		/// calculates the size that is required for a bitmap of the legend
		/// </summary>
		/// <param name="graphics">graphis object to measure the string sizes</param>
		/// <returns>required size</returns>
		private Size CalculateLegendSize(Graphics graphics)
		{
			float fRequiredSizeX = 0;

			//add start point of strings, because this is on the right of the little colored rectangles
			fRequiredSizeX = fRequiredSizeX + 20;

			//check for the longest string and sum up height
			float fLongestString = 0.0f;
			float fRequiredHeight = 0.0f;
			
			for(int i = 0; i < m_DataSource.Count; i++)
			{
				SizeF stringSize = graphics.MeasureString(m_DataSource[i].Name +": "+ m_DataSource[i].Value.ToString(), m_FontLegend);
				if( stringSize.Width > fLongestString)
				{
					fLongestString = stringSize.Width;
				}
				fRequiredHeight += stringSize.Height;
			}

			fRequiredSizeX += fLongestString;

			return new Size(Convert.ToInt32(fRequiredSizeX), Convert.ToInt32(fRequiredHeight));
		}

		#endregion

		#region properties
		/// <summary>
		/// gets or sets a the background color of the chart
		/// </summary>
		public Color BGColor
		{
			get
			{
				return m_BGColor;
			}
			set
			{
				m_BGColor = value;
			}
		}

		/// <summary>
		/// gets or sets a bool to control if the legend should be drawn together with the chart
		/// </summary>
		public bool DrawLegendInChart
		{
			get
			{
				return m_bDrawLegendInChart;
			}
			set
			{
				m_bDrawLegendInChart = value;
			}
		}

		/// <summary>
		/// gets or sets the position of the legend in relation to the chart
		/// </summary>
		public Position LegendPosition
		{
			get
			{
				return m_LegendPosition;
			}
			set
			{
				m_LegendPosition = value;
			}
		}
		#endregion
	}
}

DataSet comparisonDocs = facade.CompareMetadata(objectVids, elementPaths);<br />
DataView compSort = new DataView(comparisonDocs.Tables[0]); 		 	<br />
compSort.Sort="Title, Version/Major DESC, Version/Minor DESC";<br />
comparisonRepeater.DataSource = compSort;<br />
comparisonRepeater.DataBind();