C#

// Get all the property elements of the Color struct
PropertyInfo[] PropertyInfo = typeof(Color).GetProperties();

// Loop through the property info elements...
foreach (PropertyInfo propertyElement in PropertyInfo)
{
 // We're interested in color types...
 if (propertyElement.PropertyType == typeof(Color))
 {
  // propertyElement.Name will indicate the name of the colour, stick this into an array if needed...
  string colourName = propertyElement.Name;
  // Define a new Color type using the static FromName method to get the base colour value.
  Color c = Color.FromName(colourName );
 }
}

    public partial class Form1 : Form
    {
        private List<color> colorList = new List<color>();

        public Form1()
        {
            InitializeComponent();
        }

        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            e.Graphics.FillRectangle(new SolidBrush(Color.White), 
                new Rectangle(pictureBox1.Location, pictureBox1.Size));

            int x, y;
            x = 0; y = 0;

            foreach (Color c in colorList)
            {
                e.Graphics.FillRectangle(new SolidBrush(c),
                    new Rectangle(x, y, 25, 25));

                x += 25;
                if ((x + 25) > pictureBox1.Width)
                {
                    x = 0;
                    y += 25;
                }
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            foreach (KnownColor c in Enum.GetValues(typeof(KnownColor)))
            {
                colorList.Add(Color.FromKnownColor(c));
            }

            colorList.Sort(
                delegate(Color x, Color y) 
                {
                    return ColorTranslator.ToWin32(x).CompareTo(ColorTranslator.ToWin32(y)); 
                });
        }
    }
</color></color>

public enum WebColors // To be completed!
{
    Transparent, Black, White,
    DimGray, Gray, DarkGray, Silver, LightGray, Gainsboro, WhiteSmoke,
    Maroon, DarkRed, Red
}
public class WebColorDictionary : Dictionary<int, Color>
{
    public WebColorDictionary()
    {
        Initialize();
    }
    private void Initialize() // To be completed!
    {
        this.Add(0, Color.Transparent);
        this.Add(1, Color.Black);
        this.Add(2, Color.White);
        this.Add(3, Color.DimGray);
        this.Add(4, Color.Gray);
        this.Add(5, Color.DarkGray);
        this.Add(6, Color.Silver);
        this.Add(7, Color.LightGray);
        this.Add(8, Color.Gainsboro);
        this.Add(9, Color.WhiteSmoke);
        this.Add(10, Color.Maroon);
        this.Add(11, Color.DarkRed);
        this.Add(12, Color.Red);
    }
}

foreach (string s in Enum.GetNames(typeof(WebColors)))
Console.WriteLine(s);

WebColorDictionary myColors = new WebColorDictionary();
BackColor = myColors[(int)WebColors.Silver];

private int myVar = 200;

[DefaultValue(200)] //<-- This attribute will make the 200 value as default (means not in bold in property grid)
public int MyProperty
{
    get { return myVar; }
    set { myVar = value; }
}

public class Client {
   public string Name { get; set;}
   public string Email { get; set;}
   public System.Drawing.Size PreferredSizeForName {
      get {
         return new System.Drawing.Size(35, 13);
      }
   }
}

[System.AttributeUsage(AttributeTargets.Property)]
public class PreferredSizeAttribute : System.Attribute {
   private int _width;
   private int _height;

   public PreferredSizeAttribute(int width, int height) {
      this._width = width;
      this._height = height;
   }

   public int Width {
      get {
         return this._width;
      }
      set {
         this._width = value;
      }
   }
   public int Height {
      get {
         return this._height;
      }
      set {
         this._height = value;
      }
   }
   public System.Drawing.Size Size {
      get {
         return new System.Drawing.Size(this.Width, this.Height);
      }
   }
}

public class Client {
   private string name;
   [PreferredSize(35, 13)]
   public string Name {
      get {
         return name;
      }
      set {
         name = value;
      }
   }
   public string Email { get; set;}
}

Kel_ wrote:

what is actually faster, wrap Direct3D with Managed C++ or in C# using standard C#

DirectX.Device.Clear(0, null, ClearFlags.D3DCLEAR_TARGET | ClearFlags.D3DCLEAR_ZBUFFER, 0, 1, 0);
DirectX.Device.BeginScene();
// todo
DirectX.Device.EndScene();
DirectX.Device.Present(null, null, IntPtr.Zero, null);