Video Demo

  Download Video

This April Fools' Day article walks you through how you can programmatically change the Windows system sound events to mess with a co-worker or family member. Like many other pranks, this one requires you to have physical access to your victim's computer at a time when they're not around. As a best practice, I recommend that you back up your registry before running any code to manipulate registry settings, especially if you've never programmed the registry before.

Microsoft Windows enables users to set sounds for system events, such as when Windows starts up, when a device is connected, when an error occurs, when a window is maximized, and more. What this article walks through is adding humorous or annoying system sounds for your victim for *every* Windows system sound. As with all pranks, you should find a way to personalize the sounds for your victim. Here are some ideas:

• For the person with too much work, use C3PO from Star Wars saying,"We're doomed."
• For The Simpsons fan, use Nelson the Bully's "Ha Ha" laugh or Homer Simpson's "Doh."
• For the Warcraft player, use "Leeeeeeroy Jennnnnnkins."
• For the South Park fan, use Cartman's "Respect My Authoritay" clip.
• For the disgruntled employee, use any quote from "Office Space."

If you're not sure where to find wave audio clips, you can find a good set of sound clips on sites like http://www.reelwavs.com/and http://www.funwavs.com/ among others. Below I'll show you two different ways to change system sounds, from requiring no code at all, to building a utility created with Express, to automate changing the system sounds.

No Tech System Sounds

With your victim's machine unlocked, you can change their system sounds simply by opening the Control Panel and selecting "Sounds." This will display the image below, which you can scroll through. Click "Browse" to assign a sound file to each system event. Then watch as just about every possible event triggers that sound file.

Using Express to Change the System Sounds

Using Visual Basic or Visual C# Express, you can take this a step further and create a utility that can automatically change all of the system sound files, back up and restore sounds settings, and test sounds.

How Does Windows Store Sound Events?

The first thing we want to do is find out where the system sound files are stored. Since most Windows settings are stored in the registry, that seems like a logical place to start looking. To look inside the registry, click Start > Run, then type "regedit" to open the Registry Editor. You can search the registry by clicking "Edit > Find," and since I know that the Windows Startup sound contains startup.wav, I simply search the registry for that sound. What you'll find is the registry hive that represents the system sounds, as shown below:

The way this works is that each folder under Schemes/Apps/.Default represents an event you can map sounds to. For example, if you've ever unplugged a USB device, you know that there is a system sound associated with that event, the DeviceDisconnect event. Underneath a specific event, like the DeviceDisconnect event, there will be a list of folders: .current, .Default, and one folder for any sound schemes they may have saved.

As you can see in the picture above, a specific system event has the following structure:

• .current folder — Contains a blank registry key whose value is the sound file currently set to play with that event. For the DeviceDisconnect event, the current sound file for this event on my PC is "%SystemRoot%\media\Windows XP Hardware Remove.wav", which maps to "C:\WINDOWS\media\Windows XP Hardware Remove.wav".
• .Default folder — Contains a blank registry key whose value is the default sound file to play with that event. Since I haven't changed my sound file, it is the same sound file as given in the .current key.
• other folders — You may have other folders listed under each key (system event). This is because Windows allows you to save "sound schemes," which represents your customized list of sound files. If you have a custom sound scheme, you'll see a directory for each scheme under every sound event.

Reading and Writing Event Sound Files

Now that I know where the registry keys are located and what I want to do, I'm going to create a DataSet that represents the Windows sound event and the path to the sound file to play when that event occurs. To do this, I'm going to start a new Windows Forms project and select "Add New Item..." from the Solution Explorer window, and then select the DataSet template. To represent a sound event as a DataSet, I'll add two text fields, "SoundName" and "SoundFile," as shown below:

Next, I'll add a class file, RegistryWrapper.cs, which will wrap all of my registry functions, including reading and writing data. We'll walk through the major tasks we want to achieve here including registry tasks like reading, writing, backing up, restoring, and even playing a sound event.

Reading Sound Events from the Registry

Since I know the exact location of the sound events in the registry, I'm going to declare two variables in the RegistryWrapper class to store the registry prefix and suffix, so I won't have to declare the full path *everywhere* in my application.

Visual Basic

'these represent the location in the registry with the user sounds
Private hivePrefix As String = "AppEvents\Schemes\Apps\.Default\"
Private hiveSuffix As String = "\.current"

Visual C#

//these represent the location in the registry with the user sounds
string hivePrefix = @"AppEvents\Schemes\Apps\.Default\";
string hiveSuffix = @"\.current";   

Next, we'll add a method called GetSystemSound() that returns a RegSoundDataTable containing the SoundName and SoundFile values for the registry. The first thing we do is get the list of all the subkeys for the path we specified above by calling the GetSubKeyNames method. This will return a list of all of the sound events. Next, we loop through each sound event, creating a new row for the DataTable while setting the SoundName to the current sound event and the SoundFile to the registry key value that contains the location of the sound. Note that when we call the GetValue method to get the sound file, we need to pass in the name of the key, which in our case is blank so we pass in "". We'll also add a helper function that simply concatenates the two variables declared earlier.

Visual Basic

Public Function GetSystemSound() As RegSound.RegSoundDataTable
    'Get the subkey key
    Dim values() As String = Registry.CurrentUser.OpenSubKey(hivePrefix).GetSubKeyNames
    Dim tb As RegSound.RegSoundDataTable = New RegSound.RegSoundDataTable
    For Each s As String In values
        'Loop through rows
        Dim newRow As RegSound.RegSoundRow = tb.NewRegSoundRow
        newRow.SoundName = s
        newRow.SoundFile = _
            CType(My.Computer.Registry.CurrentUser.OpenSubKey(getRegKeyPath(s)).GetValue(""), _
            String)
        tb.Rows.Add(newRow)
    Next
    Return tb
End Function

'adds the full registry key including prefix and suffix
Private Function getRegKeyPath(ByVal s As String) As String
    Return (hivePrefix & s & hiveSuffix)
End Function

Visual C#

public RegSound.RegSoundDataTable GetSystemSound()
{
    //Get the subkey key
    string[] values = Registry.CurrentUser.OpenSubKey(hivePrefix).GetSubKeyNames();

    RegSound.RegSoundDataTable tb = new RegSound.RegSoundDataTable();

    foreach (string s in values)
    {
        //Loop through rows
        RegSound.RegSoundRow newRow = tb.NewRegSoundRow();
        newRow.SoundName = s;
        newRow.SoundFile = 
            (string)Registry.CurrentUser.OpenSubKey(getRegKeyPath(s)).GetValue("") ;
        tb.Rows.Add(newRow);
    }
    return tb;
}

//adds the full registry key including prefix and suffix
private string getRegKeyPath(string s)
{
    return hivePrefix + s + hiveSuffix;
}

Writing Sound Events to the Registry

To set all of the sound events to a specific sound, we'll create another method that takes a RegSound DataTable and the sound file we'll use for the change. We loop through every row in the DataTable and set the registry key value for the sound by calling the SetValue method. To call the SetValue method, we need to know the key name (in our case its blank or ""), the value to set it to (in our case the sound file path), and the RegistryKind, which describes the type or kind of value being stored (in our case a string) in the registry.

Visual Basic

Public Sub SetSystemSound(ByVal sounds As RegSound.RegSoundDataTable, 
             ByVal soundPath As String)
    'loop through all sounds
    For Each row As RegSound.RegSoundRow In sounds
        'Set key and value
        Dim key As RegistryKey = _
           My.Computer.Registry.CurrentUser.OpenSubKey(getRegKeyPath(row.SoundName), _
           True)
        key.SetValue("", soundPath, RegistryValueKind.String)
    Next
End Sub

Visual C#

public void SetSystemSound(RegSound.RegSoundDataTable sounds, 
        string soundPath)
{
    //loop through all sounds
    foreach (RegSound.RegSoundRow row in sounds)
    {
        //Set key and value
        RegistryKey key = 
           Registry.CurrentUser.OpenSubKey(getRegKeyPath(row.SoundName), true);
        key.SetValue("", soundPath, RegistryValueKind.String);    
    }
}

Back Up Current Sound Settings

Since your victim may be upset you changed his or her sounds, we'll add a way to save their current sound settings to the local hard drive where you can restore them later. To do this, we'll add the SaveSystemSound method that takes the DataTable you want to save and the file location to save to. We can use the WriteXml method on the DataTable object to save the DataTable as an XML file.

Visual Basic

Public Sub SaveSystemSound(
         ByVal sounds As RegSound.RegSoundDataTable, 
         ByVal savePath As String)
    'Save Sound DataSet
    sounds.WriteXml(savePath)
End Sub

Visual C#

public void SaveSystemSound(
     RegSound.RegSoundDataTable sounds, string savePath)
{
    //Save Sound DataSet
    sounds.WriteXml(savePath);
}

Restoring Saved Sound Settings

Now let's add a method to restore the sound settings from the previous step. In this case, we just need to know where the location of the saved DataTable is and call the ReadXml method to read the data we stored previously. Once we have the data we can loop through each sound event and call the setValue method to replace the current sound.

Visual Basic

Public Sub RestoreSystemSound(ByVal savePath As String)
    'Restore Sound DataSet
    Dim sounds As RegSound.RegSoundDataTable = _
         New RegSound.RegSoundDataTable
    sounds.ReadXml(savePath)
    For Each row As RegSound.RegSoundRow In sounds
        'Set Key
        Dim key As RegistryKey = _
            My.Computer.Registry.CurrentUser.OpenSubKey( _
            getRegKeyPath(row.SoundName), True)
        key.SetValue("", row.SoundFile, RegistryValueKind.String)
    Next
End Sub

Visual C#

public void RestoreSystemSound(string savePath)
{
    //Restore Sound DataSet
    RegSound.RegSoundDataTable sounds = 
        new RegSound.RegSoundDataTable();
    sounds.ReadXml(savePath);

    foreach (RegSound.RegSoundRow row in sounds)
    {
        //Set Key
        RegistryKey key = 
               Registry.CurrentUser.OpenSubKey(
               getRegKeyPath(row.SoundName), true);
        key.SetValue("", row.SoundFile, RegistryValueKind.String);
    }
}

Playing a Registry Sound Event

Finally, we'll add a way to play a registry sound. Since some sound files assume a path to the media folder under System root, we need to add a quick check to see if the file has any backslashes ("\"), which we'll use as a test to see if the sound file contains both a path and sound file. If it doesn't, we'll append the path to the sound file and play it.

Visual Basic

Public Sub PlayRegistrySound(ByVal soundFile As String)
    'play sound if there is an associated file
    If (soundFile <> "") Then

        'add default path if there isn't one
        Dim a As Integer = soundFile.IndexOf(Microsoft.VisualBasic.ChrW(92))
        If (a <> 0) Then

        Else
            soundFile = "%SystemRoot%\\media\\" + soundFile
        End If
        My.Computer.Audio.Play(soundFile)
    End If
End Sub

Visual C#

public void PlayRegistrySound(string soundFile)
{
    //play sound if there is an associated file
    if (soundFile != "")
    {
        SoundPlayer sp = new SoundPlayer();

        //add default path if there isn't one
        int a = soundFile.IndexOf('\\');
        if (a != 0)
        {
            soundFile = "%SystemRoot%\\media\\" + soundFile;
        }
        sp.SoundLocation = soundFile;
        sp.Play(); 
    }       
}

Creating the User Interface

To create the user interface, we'll begin by adding some controls to our form including:

• A ToolStrip control for the Backup, Restore, Select, and Apply Changes buttons.
• A DataGridView that we can drag and drop by clicking "Data > Show Data Sources," and dragging and dropping the RegSound DataGridView control.
• Two OpenFileDialog controls, one to choose where to restore from and another to choose the sound file to replace.
• One SaveFileDialog control to choose where to backup the current system sounds.

After adding in some nice IconBuffet icons that you get for registering Express, your UI should look something like this:

Loading Data

Finally, we're going to put it all together by adding a couple of functions to the Windows Form. The first thing we'll want to do is add two form variables, one to represent the RegistryWrapper we wrote before and another to store the RegSoundDataTable data. To populate the DataTable, well call the GetRegistrySounds method, which in turn calls the GetSystemSound method we created earlier. We'll call the GetRegistrySounds method when the form loads, when we restore the sounds, or when we apply changes so that the DataGridView will display the current registry sounds.

Visual Basic

Private Sub frmMainForm_Load(ByVal sender As System.Object, _
        ByVal e As System.EventArgs) Handles MyBase.Load
    GetRegistrySounds()
End Sub

Private Sub GetRegistrySounds()
    'Call the RegistryWrapper Class
    sounds = myReg.GetSystemSound
    RegSoundDataGridView.DataSource = sounds
End Sub

Visual C#

private void frmMainMenu_Load(object sender, EventArgs e)
{
    GetRegistrySounds();            
}
private void GetRegistrySounds()
{
    //Call the RegistryWrapper Class
    sounds = myReg.GetSystemSound();
    regSoundDataGridView.DataSource = sounds;
}

Formatting the DataGridView

To add a nice UI, we'll format the DataGridView control by changing some of the properties, like setting the AlternatingRowsDefaultCellStyle property to a different color, changing the DefaultCellStyle font to Arial 10, and turning off adding, editing, and deleting.

We'll also add an image column with a "play" image so that we can here the currently associated sound. To do this, you can right-click on the DataGridView and select "Edit Columns" to bring up the Edit Column dialog box as shown below. Here we'll add a new column called "Play," set the column type to DataGridViewImageColumn, set the Image property to our sound image, and set the ImageLayout property to "Zoom" so that the image will fit the cell contents.

Finally, we'll want to add code to play a sound when someone clicks the sound image, and we can do this by adding the following code to the DataGridView CellContentClick event. As you can see below, we only play a sound if they clicked the third column (index start at 0 so the third is #2). To play a sound, we'll need the sound path, that we get by creating a DataGridViewTextBoxCell for the SoundFile column and reading its value.

Visual Basic

Private Sub RegSoundDataGridView_CellContentClick( _
        ByVal sender As System.Object, _
        ByVal e As System.Windows.Forms.DataGridViewCellEventArgs) _
        Handles RegSoundDataGridView.CellContentClick
    'Represents col #3 the "Play" column
    If (e.ColumnIndex = 2) Then
        Dim cell As DataGridViewTextBoxCell = _
           CType(RegSoundDataGridView.Rows(e.RowIndex).Cells((e.ColumnIndex - 1)), _
           DataGridViewTextBoxCell)
        'Play Sound
        myReg.PlayRegistrySound(cell.Value.ToString)
    End If
End Sub

Visual C#

private void regSoundDataGridView_CellContentClick(
       object sender, DataGridViewCellEventArgs e)
{
    //Represents col #3 the "Play" column
    if (e.ColumnIndex == 2)
    {
        DataGridViewTextBoxCell cell = (DataGridViewTextBoxCell)
          regSoundDataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex - 1]; 
        //Play Sound
        myReg.PlayRegistrySound(cell.Value.ToString());
    }
}

Conclusion

Reading and writing data out of the registry is pretty easy, as is saving structured data like a DataSet. It's almost too easy to find the right sound file on the Internet and of course make hilarity ensue when your poor unsuspecting victim tries to figure out what's wrong with their PC. If you want to extend this application, a couple of additions would be to add the ability to change sounds beyond the system sound, like logon sounds for MSN Messenger, blocked pop-ups by Internet Explorer, and a host of other sound files you can map your PC.

Video Demo

 Download the video

This April Fools' Day article walks you through adding entries into Microsoft Word 2003 AutoCorrect to mess with a co-worker or family member. As you might expect, this prank requires you to have physical access to your victim's computer at a time when they're not around. Luckily, it seems that the least technically inclined people are the most likely to leave their PCs unlocked for us to have fun with! As some of you probably know, AutoCorrect is a feature in Microsoft Word that, as its name states, automatically corrects text. What is does is replace misspelled words, such as "teh," which it corrects to "the" automatically as you type. Using AutoCorrect, you can add a bunch of bogus AutoCorrect entries that ought to confuse and annoy your victim. I was inspired to use AutoCorrect for an April Fools' Day prank after using it in college on a nontech-savvy friend who was borrowing my computer and assured me that my computer had a virus because Word kept "correcting" his name to Moe Sislack (The Simpsons bar keep). Here are some fun AutoCorrect entries you can add to your hapless victim's computer:

• Replace a your victim's name with an amusing nickname, so "Dan Fernandez" becomes "Danny 'two-tone' Fernandez."
• Replace "over" with "I see dead people" so that they'll think their PC is haunted.
• Replace "the" with "le" to make them think they somehow changed Word's default dictionary to French.
• Replace "Linux" with "Windows" and watch as your office Linux bigot accidentally sends an e-mail praising Linux.

If you're not sure what words to add, you can get the maximum impact by using the most popular words in the English language. Below I'll show you three different ways to add AutoCorrect entries, from requiring no code at all, to a utility created with Express, to automating adding multiple entries into AutoCorrect.

No Tech AutoCorrect

With your victim's machine unlocked, you can add AutoCorrect entries simply by opening Word and clicking "Tools > AutoCorrect Options." This will display the image below, which you can use to add AutoCorrect entries. To add an entry, type the text you want replaced in the left text box and the replacement text to the right. As you can see in the screen shot, when "c4f" in Word has been automatically replaced by "Coding4Fun."

Using Macros to Add AutoCorrect Entries

One of the nice things about Word is that it includes a Macro Recorder which you can use to record actions and see the associated VBA Macro code. To record a macro, click "Tool > Macro > Record New Macro." Enter a name in the Record Macro dialog box as shown below and click "OK."

Then simply follow the steps in the No Tech AutoCorrect section above to manually add an entry into AutoCorrect. The Macro Recorder will generate the code to add entries into AutoCorrect, which you can see by pressing ALT+F11 to bring up the Visual Basic for Applications Editor. The code below shows how adding an AutoCorrect entry is only one line of code.

AutoCorrect.Entries.Add Name:="c4f", Value:="Coding4Fun" 

Using Express to Add AutoCorrect Entries

Using Visual Basic or Visual C# Express, we can take this a step further and create a utility that can automatically upload AutoCorrect entries represented as comma-separated values like "hello, world" to replace "hello" with "world." To begin with, simply start a blank new Windows Form application in Express. To automate Word, you'll need to add a reference to the Microsoft Word 11.0 Object Library. To do this, click "Project > Add Reference" and switch to the COM Tab. Scroll down to Microsoft Word 11.0 Object Library as shown below.

Next, we'll set up our Windows Form UI by dragging and dropping a text box and having it fill the entire form. Make sure to set the Textbox MultiLine property = "True". To support opening and saving files, drag and drop the OpenFileDialog and SaveFileDialog controls onto the form. Finally, let's add a ToolStrip button and use the "Insert Standard Items" to get a classic Windows UI.

For this utility, we will only need the New, Open, Save, and Help buttons as well as two custom buttons, the first Add to AutoCorrect, another the other Remove from AutoCorrect. To make these prettier, I'm using the icons provided by IconBuffett when you register Express so that the final toolbar looks like this:

Our form uses some top-level variables that store a flag if the text in the text box has changed, the file name, and a generic Dictionary object that will hold the name/value pairs to be replaced.

Visual Basic

'Variables
Dim textHasChanged As Boolean = False
Dim fileName As String = "doc1.txt"
'Use to hold a list of AutoCorrect entries
Dim myAutoCorrect As New Dictionary(Of String, String) 

Visual C#

//Variables

private bool textHasChanged = false;
private string fileName = "doc1.txt";

//Use to hold a list of AutoCorrect entries
Dictionary<string, string> myAutoCorrect =
    new Dictionary<string, string>();

Coding the New Button

When a user clicks the "New" button, we'll call the promptToSave() routine. The code below checks if the textHasChanged property is set to true, and if so, it displays a message box asking them to save with Yes or No options. If the user clicks "Yes," we'll call the Save Button click event, to prompt them to save the file.

Visual Basic

'Display a dialog to Save the text
Public Sub promptToSave()
If textHasChanged = True Then
   'Display a message box asking them to save
   Dim dr As DialogResult = MessageBox.Show("Do you want to save the changes to " & _
       fileName & "?", "Save File", MessageBoxButtons.YesNo, MessageBoxIcon.Warning)
   If dr = System.Windows.Forms.DialogResult.Yes Then
       Me.SaveToolStripButton_Click("Save File", EventArgs.Empty)
   End If
 End If
End Sub

Visual C#

//Display a dialog to Save the text
private void promptToSave()
{
if (textHasChanged == true)
   {
       //Display a message box asking them to save
       DialogResult dr = MessageBox.Show("Do you want to save the changes to " +
           fileName + "?", "Save File", MessageBoxButtons.YesNo, 
           MessageBoxIcon.Warning);
      if (dr == DialogResult.Yes)
       {
          this.saveToolStripButton_Click("Save File", EventArgs.Empty);
       }
}
}

Coding the Open Button 

When a user clicks the "Open" button, we display the OpenFileDialog by calling the ShowDialog() method. If the user clicks "OK" in that dialog, we'll set the file name and read in the contents of the file, in Visual Basic using My, and in Visual C# using the File class.

Visual Basic

Private Sub OpenToolStripButton_Click(ByVal sender As System.Object, 
     ByVal e As System.EventArgs) Handles OpenToolStripButton.Click
'Open File Dialog
OpenFileDialog1.InitialDirectory = 
      My.Computer.FileSystem.SpecialDirectories.Desktop
OpenFileDialog1.FileName = fileName
If OpenFileDialog1.ShowDialog() = System.Windows.Forms.DialogResult.OK Then
fileName = OpenFileDialog1.FileName
     txtWordList.Text = My.Computer.FileSystem.ReadAllText(fileName)
End If
End Sub

Visual C# 

//Open document
private void openToolStripButton_Click(object sender, EventArgs e)
{
    openFileDialog1.InitialDirectory = Environment.SpecialFolder.Desktop;
    //Show the Open File Dialog
    openFileDialog1.FileName = fileName;
    if (openFileDialog1.ShowDialog() == DialogResult.OK)
    {
        fileName = openFileDialog1.FileName;
          txtWordList.Text = File.ReadAllText(fileName);
    }
}

Coding the Save Button

To wrap up, we'll display the SaveFileDialog when a user clicks the "Save" button and write the file to the file system, again in Visual Basic using My and in Visual C# using use the File class.

Visual Basic

'Save Document
Private Sub SaveToolStripButton_Click(ByVal sender As System.Object, 
ByVal e As System.EventArgs) Handles SaveToolStripButton.Click

'Show the Save File Dialog
   SaveFileDialog1.FileName = fileName
   SaveFileDialog1.InitialDirectory = 
          My.Computer.FileSystem.SpecialDirectories.Desktop
If SaveFileDialog1.ShowDialog() = System.Windows.Forms.DialogResult.OK Then
My.Computer.FileSystem.WriteAllText(SaveFileDialog1.FileName,
          txtWordList.Text, False)
      textHasChanged = False
End If
End Sub

Visual C# 

//Save document
private void saveToolStripButton_Click(object sender, EventArgs e)
{
    //Show the Save File Dialog            
    saveFileDialog1.FileName = fileName;
    saveFileDialog1.InitialDirectory = Environment.SpecialFolder.Desktop.ToString();
    if (saveFileDialog1.ShowDialog() == DialogResult.OK)
    {
        File.WriteAllText(saveFileDialog1.FileName, txtWordList.Text);
        textHasChanged = false;
    }
}

Adding items to the AutoCorrect Dictionary Object

To add items to AutoCorrect, first we'll need to parse the text of the text box into name/value pairs and add them to the AutoCorrect dictionary object which will hold our new entries. To do this, we'll use the StringReader class and read in the contents of the text box. Note that Visual Basic 2005 now has "Using/End Using" statements which enable you to automatically dispose of resources like file handles. We then use a While loop to loop through every line in the text box and make sure the line isn't NULL. Next, we'll use the Split() method to split the contents of a line into a string array using a comma (",") as our separator. For example, if currentLine was set to "Hello, World," calling Split() would return an array where element(0) is "Hello" and element(1) is "World." Finally we call the Add method to add the key (Hello) and value (World) to the myAutoCorrect dictionary.

Visual Basic

Public Sub updateDictionary()
    Dim splitKeyValues() As String
    Dim currentLine As String
    Using sr As New StringReader(txtWordList.Text)
        'loop through each line
        While True
            currentLine = sr.ReadLine()
                If Not (currentLine Is Nothing) Then
                'split the text and add it to the AutoCorrect Dictionary
                    splitKeyValues = currentLine.Split(","c)
                     myAutoCorrect.Add(splitKeyValues(0), splitKeyValues(1))
                  Else  'break when we run out of lines
                    Exit While
                  End If
        End While
    End Using
End Sub

Visual C#

private void updateDictionary()
{
    string[] splitKeyValues;
    string currentLine;
    using (StringReader sr = new StringReader(txtWordList.Text))
       {
               //loop through each line
        while (true)
        {
            currentLine = sr.ReadLine();
                if (currentLine != null)
                 {
                //split the text and add it to the AutoCorrect Dictionary
                splitKeyValues = currentLine.Split(',');
                myAutoCorrect.Add(splitKeyValues[0], splitKeyValues[1]);
            }
                 else //break when we run out of lines
                     break;
        }
    }
}

Adding AutoCorrect Entries Using the Word Object Library

Now that we have a dictionary of key/value pairs representing AutoCorrect entries, we need to add them to Word using the Microsoft Word Object Library. In this project, we'll wrap Word operations into a WordWrapperClass to encapsulate adding and removing items from AutoCorrect. The WordWrapperClass has two public methods, AddToAutoCorrect() and RemoveFromAutoCorrect(), both of which expect a key/value generic dictionary class like myAutoCorrect. Notice below that we have two imports ("using" in C#) statements at the top of the file, one for the generic dictionary collection, and the other for interoperating with Word. The first thing we do in the AddToAutoCorrect method is call the startWord() function, which creates a nonvisible instance of Microsoft Word. Next, for each of the keys in our dictionary, we get the value for a given key and call the AutoCorrect.Entries.Add(key,value) method to add the entry into Word. When we're done adding, we call the quitWord() method, which ensures the Word instance we created in the startWord() method is properly closed. One thing to note in the quitWord method is that since Visual C# doesn't support optional parameters, we explicitly declare a variable named "empty" to represent a System.Reflection.Missing.Value type.

Visual Basic

Imports System.Collections.Generic
Imports Microsoft.Office.Interop.Word

Public Class WordWrapper
    Public Sub AddToAutoCorrect(ByVal entries As Dictionary(Of String, String))
        Dim oWord As Application = startWord()
        Dim value As String
        'Loop through each entry from the dictionary
        For Each key As String In entries.Keys
        entries.TryGetValue(key, value) 'get the dictionary value
        '***Add the AutoCorrect entry into Word***
        oWord.Application.AutoCorrect.Entries.Add(key, value)        
    Next
        quitWord(oWord) 'cleanup
    End Sub

    Private Function startWord() As Application
        'Setup Word
        Dim oWord As Application = New Application()
        oWord.Visible = False
        Return oWord
    End Function

    Private Sub quitWord(ByRef oWord As Application)
        'Quit Word
        oWord.Application.Quit()
    End Sub
End Class

Visual C#

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Office.Interop.Word; 

public class WordWrapper
{
    object empty = System.Reflection.Missing.Value;
        
    public void AddToAutoCorrect(Dictionary<string, string> entries)
    {
        Application oWord = startWord(); 
        string value;

        //Loop through each entry from the dictionary
        foreach (string key in entries.Keys)
        {
            //get the dictionary value 
            entries.TryGetValue(key, out value);    
            //***Add the AutoCorrect entry into Word***
            oWord.Application.AutoCorrect.Entries.Add(key, value);
        }
              quitWord(oWord); //cleanup
    }

    private Application startWord()
    {
               Application oWord = new Application();
        oWord.Visible = false;
        return oWord;
    }

    private void quitWord(Application oWord)
    {
        //Quit Word
        oWord.Application.Quit(ref empty, ref empty, ref empty);
    }
}

Removing AutoCorrect Entries from the Word Object Library

All good practical jokes hopefully leave no actual harm to your hapless victim and that's why we created a way to automate removing AutoCorrect Entries. This function is similar to the AddToAutoCorrect method in that we pass in a generic Dictionary class containing key/value pairs for AutoCorrect entries. The difference here is that we have two loops, one for each Dictionary key, and another that loops through all of the AutoCorrect entries looking for matches. We need to loop through each AutoCorrect entry and verify that the key and value object match exactly those in our dictionary so that we don't delete any incorrect AutoCorrect entries. For example, we want to delete our "Hello,World" entry but don't want to fix "helo,hello," for example. If we get an exact match on the key and value, we call the AutoCorrectEntry Delete() method to remove it.

Visual Basic

Public Sub RemoveFromAutoCorrect(ByVal entries As Dictionary(Of String, String))
    Dim oWord As Application = startWord()
    Dim value As String

    'Loop through each entry from the dictionary
    For Each key As String In entries.Keys
        entries.TryGetValue(key, value) 'get the dictionary value

        'Loop through each Word AutoCorrect entry
        For Each a As AutoCorrectEntry In oWord.AutoCorrect.Entries
            'Entries must match key and value
            If a.Name = key And a.Value = value Then
                a.Delete() 'Delete the AutoCorrect entry
            End If
        Next
    Next
    quitWord(oWord) 'cleanup
End Sub

Visual C#

public void RemoveFromAutoCorrect(Dictionary<string, string> entries)
{
    Application oWord = startWord();
    string value;

    //Loop through each entry from the dictionary
    foreach (string key in entries.Keys)
    {
        entries.TryGetValue(key, out value); //get the dictionary value 

        //Loop through each Word AutoCorrect entry
        foreach (AutoCorrectEntry a in oWord.AutoCorrect.Entries)
        {
            //Entries must match key and value
            if (a.Name == key && a.Value == value)
            {
                a.Delete(); //Delete the AutoCorrect entry 
            }
        }
    }
    quitWord(oWord); //cleanup       
}

Conclusion

AutoCorrect is a cool feature and automatically adding entries is both a great timesaver and (hopefully) humorous practical joke on your unsuspecting victim. If you're looking to modify this sample, you could add RichTextFile support so that, in addition to just changing text, you can have typed-in text be replaced by RT Text like images, colors, tables, and more. For example, you could AutoCorrect the word "horse" to a picture of Borat from the Ali G Show. That will have to wait until next year though.

Daniel Fernandez is the Lead Product Manager for Visual Studio Express in the developer division at Microsoft.  He has been with Microsoft since July 2001, previously working as a Developer Evangelist in the Mid-Atlantic district. Prior to joining Microsoft, he worked as a developer at several consulting firms including IBM Global Services specializing in web-based and mobile application development.