To do this you just need to override the GetProperties method. Call the Sort function on the PropertyDescriptorCollection object returned by the base function, passing an array of strings with the property names in the order that you desire.

For example:

public override PropertyDescriptorCollection
      GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
    return base.GetProperties(context, value, attributes)
                            .Sort(new string[] { "Name", "Street", "City", "Country" });
}

Any properties not in the string array will be added on afterwards in alphabetical order.

Paste the following code into a text file, and save it as “usbmp.snippet”. In Visual Studio go to “Tools/Code Snippets Manager…” and import the file.

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets
    xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Title>Unsafe Bitmap Processing</Title>
      <Shortcut>usbmp</Shortcut>
      <Description>Code for accessing a bitmaps pixel data with unsafe code</Description>
      <Author>Jonathan Mathews Software</Author>
    </Header>
    <Snippet>
      <Declarations>
        <Object>
          <ID>bitmap</ID>
          <Type>System.Drawing.Bitmap</Type>
          <ToolTip>Replace with a bitmap in your application.</ToolTip>
          <Default>bitmap</Default>
        </Object>
      </Declarations>
      <Code Language="CSharp">
        <![CDATA[unsafe
                {
                    BitmapData data = $bitmap$.LockBits(
                                                    new Rectangle(new Point(0, 0), $bitmap$.Size), 
                                                    ImageLockMode.ReadOnly, 
                                                    PixelFormat.Format24bppRgb);

                    byte* pointer = (byte*)data.Scan0;

                    int padding = data.Stride - ($bitmap$.Width * 3);

                    for (int y = 0; y < $bitmap$.Height; y++)
                    {
                        for (int x = 0; x < $bitmap$.Width; x++)
                        {
                            // pointer[2]; // R
                            // pointer[1]; // G
                            // pointer[0]; // B
                            $end$

                            pointer += 3;
                        }

                        pointer += padding;
                    }

                    $bitmap$.UnlockBits(data);
                }]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Notes:

• Use it by entering “usbmp” in your code, and pressing tab twice. Edit the bitmap name to your bitmap.
• You’ll need to add using System.Drawing.Imaging; if it’s not there already.
• If you want to edit the pixels instead of just reading them, change “ImageLockMode.ReadOnly”.

Instead, copy the image in memory using Image copy = new Image(source).

If we have an enumerator, say:

public enum MyEnumerator { Oranges, Apples, Hedgehogs, Laptops, Budgies, Other }

Having a form with a ComboBox called comboBox1, put this in the constructor/form load etc:
this.comboBox1.DataSource = Enum.GetValues(typeof(MyEnumerator));

This fills the combobox with the values. To convert the current combobox value back into the enumerator’s value:
MyEnumerator selected = (MyEnumerator)this.comboBox1.SelectedValue;

Let’s assume that you’ve created a form and added a RichTextBox called richTextBox1. Rather then going to the properties window to add the events, you’ll need to do it yourself.

Add the following in the constructor of the form:

richTextBox1.AllowDrop = true;
richTextBox1.DragDrop += new DragEventHandler(richTextBox1_DragDrop);
richTextBox1.DragEnter += new DragEventHandler(richTextBox1_DragEnter);

Type in the “+=” and press tab to automatically complete the line, then press tab again to create the function. Or just add the handler functions manually:

public void richTextBox1_DragEnter(object sender, DragEventArgs e) {
	if (e.Data.GetDataPresent(DataFormats.FileDrop)) {
		e.Effect = DragDropEffects.Copy;
	}
	else {
		e.Effect = DragDropEffects.None;
	}
}

public void richTextBox1_DragDrop(object sender, DragEventArgs e) {
	string[] filenames = (string[])e.Data.GetData(DataFormats.FileDrop);

	foreach (string filename in filenames) {
		// code to process a filename
	}
}

You can also implement DragOver and DragLeave in the same way, although those are there to “support the .NET Framework infrastructure” and are “not intended to be used directly from your code”. Intellisense doesn’t even show those events, but you can type them in and compile without problems. Also note that DragLeave is an EventHandler rather then a DragEventHandler.

After realising that there really wasn’t a built in function like:

Result[x, y] = Math.Between(0, 255, pixel);

I initially used the minimum and maximum functions:

Result[x, y] = Math.Max(0, Math.Min(255, pixel));

This works, and is a pretty neat little piece of code. However, after profiling the application it quickly became obvious that it was slowing things down. A look at the compiled code shows that even when built for release, Min and Max are left as function calls instead of being inlined.

Looking into bitwise operations, we see that using a bitwise AND with 255 will trim the value to be between 0 and 255. Unfortunately it loops around, so that isn’t what we need:

  100101100   300
& 011111111   255
= 000101100   044

The next option was to just check it manually:

if (pixel > 255) {
	Result[x, y] = 255;
}
else if (pixel < 0) {
	Result[x, y] = 0;
}
else {
	Result[x, y] = (byte)pixel;
}

Which is better, or:

Result[x, y] = (byte)(pixel > 255 ? 255 : (pixel < 0 ? 0 : pixel));

Which is silly and harder to maintain.

Either way a new problem is that most of the pixel values are between 0 and 255, therefore two checks will usually be required. Thanks to a great suggestion by biznatchio, we can instead do it in one comparison.

We saw earlier that “value &= 255″ will trim the value to be between 0 and 255. So, if we just compare the value to the trimmed value we will know if it is in range:

if ((pixel & 255) == pixel) {
	Result[x, y] = (byte)pixel;
}
else if (pixel > 255) {
	Result[x, y] = 255;
}
else {
	Result[x, y] = 0;
}

This will be slower then before if the value is <0 or >255. As our values will be in range most of the time, this method is the best.