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;

Microsoft StyleCop: http://code.msdn.microsoft.com/sourceanalysis
This is the source analysis tool from and used by Microsoft programmers, and helps to “enforce a common set of best practices for layout, readability, maintainability, and documentation of C# source code”. It can also be integrated it into the build process to help keep you honest.

Once you learn and get used to its strict rules, they are easy to live by (I’ve even grown used to using this.variable rather then _Variable ).

GhostDoc: http://www.roland-weigelt.de/ghostdoc/
With just a keypress this adds in XML comments for the current type, often magically filling in the values from base types, other comments, or who knows where. Saves a lot of time, and it’s perfect for all those StyleCop “must have a documentation header” warnings.

Regionerate http://www.rauchy.net/regionerate/
Great little plugin that automatically arranges your code based on layout rules. Produce neat and friendly code without any effort. Check out this post in their forum for a StyleCop layout: http://www.rauchy.net/regionerate/forums/viewtopic.php?f=4&t=189. The only issue is that it uses tabs instead of spaces, but you just have to remember to select all (Ctrl-A), then format it (Ctrl-K-F).

Microsoft FxCop: http://code.msdn.microsoft.com/codeanalysis
Microsoft code analysis tool. It looks at the compiled code and produces a list of possible problems based on Microsoft’s design guidelines.

Proggy Fonts: http://www.proggyfonts.com/index.php?menu=download
A collection of small, neat, and easy to read fonts. They’re all good, but I tend to stick with Proggy Square.

The capture buffer can be used in two ways. As a static buffer, which stops when the buffer is full, or a streaming buffer, where once the buffer is full it returns to the start and begins overwriting the samples. You obviously need to read and do something with the data before this happens.

One method is to set up a Notify object, giving it an array of BufferPositionNotify objects. These contain the handle for an event, and the buffer offset at which to fire that event. This is usually an AutoResetEvent, monitored by a separate thread which then reads a section of the buffer, and processes that data. One problem is that they can be unreliable if another program is also using DirectSound notifications at the same time. You may start receiving those as well, or even have yours go missing.

The other option is to monitor it yourself, periodically checking the write position of the capture buffer through its GetCurrentPosition function. When you see that it has moved past a certain point (i.e. an offset position) you can then process that chunk of data as before.

To make a CaptureBuffer, first instantiate a new Capture object. Use no parameters or a Guid.Empty for the default device, or give it the Guid or an IntPtr to the device you want to use. The available devices can be discovered by creating a CaptureDevicesCollection object.

Then use this Capture object to a create a new CaptureBuffer, along with a WaveFormat, and the length of the buffer you want.

Reading the buffer is accomplished by simply calling the Read function with the start position, number of bytes to read, and a LockFlag to say if you want to prevent the data from being overwritten while you read it. Finally, cast the resultant Array to an array of bytes.

Each byte is a part of a sample, and a sample represents the average amplitude of the sound waves position at that point in time.²

There are two types of buffers used for output: Primary and Secondary. These both send data to an output device, represented by a Microsoft.DirectX.DirectSound.Device object.

Primary Buffer

There is only one Primary Buffer for a device, and the data it contains is exactly what will come out of that device.

Accessing and changing the primary buffer is possible, but usually unnecessary. It’s better to let DirectX handle the mixing, or you will have to take responsibility for outputting the buffer in real-time. You also lose the ability to use secondary buffers, and it prevents other applications from using buffers.

To access the primary buffer, create a Microsoft.DirectX.DirectSound.Buffer object using a DirectSound Device with its cooperative level set to CooperativeLevel.WritePrimary.

Secondary Buffer

The secondary buffer is a buffer of a specified size, and contains sound data ready to be output. An application can have as many secondary buffers as it wants, within memory limits.

When you call a buffer’s Play function the content is mixed into the primary buffer and output by DirectX.

If called with the BufferPlayFlags.Looping flag set, it will play the buffer from start to finish over and over again until stopped. By continually writing new data into the buffer just ahead of the current play position it is possible to output audio that would not have fitted into memory, or that did not even exist when you started the buffer. This is known as streaming.

You can either use a Microsoft.DirectX.DirectSound.Buffer, or a Microsoft.DirectX.DirectSound.SecondaryBuffer which inherits the previous and adds support for effects such as distortion, compression, reverb, and more.

1. Only data which matches that format can be loaded into the an output buffer. Sound data with different formats can be played at the same time by using separate secondary buffers for each.
2. Remember that sound is a waveform, and the buffer contains the actual wave data. Filling it with just one value will produce silence as the speaker cones will not move. To produce a tone programatically you need to fill the buffer with a waveform, such as a Sine Wave, a Square Wave, a Triangle Wave, or a Sawtooth Wave.

All I needed to do was to draw a series of characters onto an image, each one having a different Color value. Easy right? Straightforward code, plug it in to the Ascgen and… wait… we get the output required. After a quick profile of the application, it was clear that the problem was with the external function and there was nothing that could be done to speed things up to an acceptable level.

Before digging into api functions, I decided to look back to the older method of drawing strings: Graphics.DrawString.

The code is less straightforward, but, despite having to create a new SolidBrush object for every Color, it works quickly. An image that took around 10 seconds with TextRenderer takes milliseconds with DrawString. The only obvious problem was that DrawString shifted the text right a fraction, but a quick google leads to a solution: using StringFormat.GenericTypographic in the call.

Now, the next obvious step was to use DrawString to improve the speed of drawing text all in one Color, and that’s where it all goes wrong: DrawString adds extra space between characters, and there doesn’t seem to be a way to stop it.

Applying the same code as before and printing each character separately (after first having to split it into a string array) gives the text spaced correctly. However it’s actually marginally slower then calling TextRenderer once on the whole string, and far more complicated.

Ideally I’d like to put the two together, so I need to either find a way to speed up TextRenderer or a way to fix the spacing in DrawString.

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.