The window options enable you to specify the text that should appear in the title bar of the OOB window, and the window's initial width and height (it will default to 800×600 without these options set, and will be resizable unless you turn off the default window chrome by using custom chrome). By default, the application will center itself in the screen, but by selecting the "Set window location manually" check box you can specify exactly where on the screen you want your application to appear.

The install options enable you to specify the name of the shortcut that will be created on the user's desktop and/or start menu, a description of the application (that will appear in the tooltip on the application's shortcuts), and a number of icons of varying sizes. These icons will be used for the application's shortcuts, and will also be displayed in the install dialog, the title bar of the window, and as the taskbar/dockbar icon. If no image files are assigned to these settings, default Silverlight icons will be used instead.

The various other miscellaneous options include enabling GPU acceleration for cached compositions, whether an install option should appear in the context menu when the user right-clicks on the application, whether the application requires elevated trust when running outside the browser, and whether the application should use custom chrome (via the "Window style" option).

Using the reference to the window, you can close it using its Close method:

Application.Current.MainWindow.Close();

You can detect when the window is being closed, and cancel it by handling its Closing event. Start by adding an event handler to the event:

Application.Current.MainWindow.Closing += MainWindow_Closing;

And then you can handle it (and cancel the window being closed) like so:

private void MainWindow_Closing(object sender, ClosingEventArgs e)
{
    if (e.IsCancelable)
    {
        MessageBoxResult result = MessageBox.Show("Are you sure you wish to quit?",
                                    "AdventureWorks", MessageBoxButton.OKCancel);
        e.Cancel = (result != MessageBoxResult.OK);
    }
}

You can use the WindowState property of the window to maximize it, minimize it, or return it to normal. It accepts/returns an enumeration of type WindowState, which has the following possible values: Maximized, Minimized, and Normal. For example:

Application.Current.MainWindow.WindowState = WindowState.Maximized;

You can set the size of the window using its Width and Height properties:

Application.Current.MainWindow.Width = 600;
Application.Current.MainWindow.Height = 800;

You can set the position of the window using its Top and Left properties. However, at runtime you can only set these properties if the "Set window location manually" check box was selected in the Out-Of-Browser Settings window (shown in Figure 14-2), and they must be set before the end of the application's Startup event (after this, any changes to their values will be ignored).

You can set the window to be a topmost window (where it always appears on top of other windows regardless of whether or not it has the focus) by setting it's TopMost property to true. For example:

Application.Current.MainWindow.TopMost = true;

You can determine whether a window is active by interrogating its IsActive property, and you can activate it (i.e. bring it to the forefront of the various open windows and give it the focus) using its Activate method. For example:

Application.Current.MainWindow.Activate();

The easiest way to persist and retrieve data from an isolated storage store is by using the IsolatedStorageSettings class (that can be found under the System.IO.IsolatedStorage namespace). This class enables you to easily maintain a collection of settings in isolated storage as key/value pairs that can be maintained as a file in either of the two stores (application and site) discussed earlier. Instead of having to manage serializing and deserializing the settings to and from a file, this class abstracts that away from you so that you only need to maintain the settings as a collection of key/value pairs, and it will handle persisting and retrieving the collection to/from isolated storage for you.

The IsolatedStorageSetting. ApplicationSettings property provides a means to maintain settings in the application store, and the IsolatedStorageSetting.SiteSettings property provides a means to maintain settings in the site store. Both of these properties return an object of type IsolatedStorageSettings that is a wrapper around a Dictionary of type <string, object>. Both are used in exactly the same manner as a Dictionary (and hence each other), so you will focus on demonstrating maintaining application settings here.

IsolatedStorageSettings.ApplicationSettings["Key"] = "Value";

IsolatedStorageSettings.ApplicationSettings.Save();

if (IsolatedStorageSettings.ApplicationSettings.Contains("Key"))
{
    string value = IsolatedStorageSettings.ApplicationSettings["Value"].ToString();
    // Do something with the value
}

string value;
bool settingExists =
    IsolatedStorageSettings.ApplicationSettings.TryGetValue("Key", out value);

<TextBox Name="Setting1TextBox" Text="{Binding [Setting1], Mode=TwoWay}" />

Setting1TextBox.DataContext = IsolatedStorageSettings.ApplicationSettings;

foreach (string key in IsolatedStorageSettings.ApplicationSettings.Keys)
{
    object value = IsolatedStorageSettings.ApplicationSettings[key];
    // Do something with the value
}

IsolatedStorageSettings.ApplicationSettings.Remove("Key");

IsolatedStorageSettings.ApplicationSettings.Clear();

Isolated storage is a virtual file system, meaning that you can create directories and files within isolated storage in much the same way as you would with the operating system's file system. For example, you may wish to store images, documents, and even .xap files downloaded from the server (providing dynamically loaded content, as will be discussed in Chapter 15: Application Deployment) in isolated storage. Let's look at how to perform some of these tasks in an isolated storage store.

using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
{
    // Work with the files and directories in the store here
}

store.CreateDirectory("Images");

store.CreateDirectory(@"ImagesIcons");

bool dirExists = store.DirectoryExists("Images");

string[] directories = store.GetDirectoryNames();

string[] directories = store.GetDirectoryNames(@"Images*");

string[] fileNames = store.GetFileNames();

string[] fileNames = store.GetFileNames(@"Images*");

bool fileExists = store.FileExists("Test.txt");

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("Test.txt", FileMode.Create))
{
    using (StreamWriter writer = new StreamWriter(fileStream))
    {
        writer.WriteLine("Text written from Silverlight");
        writer.Close();
    }

    fileStream.Close();
}

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("Test.jpg", FileMode.Create))
{
    fileStream.Write(fileContents, 0, fileContents.Length);
    fileStream.Close();
}

string fileContents = null;

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("Test.txt", FileMode.Open))
{
    using (StreamReader reader = new StreamReader(fileStream))
    {
        fileContents = reader.ReadToEnd();
        reader.Close();
    }

    fileStream.Close();
}

// Do something with the file contents

byte[] fileContents = null;

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("Test.jpg", FileMode.Open))
{
    fileContents = new byte[fileStream.Length];
    fileStream.Read(fileContents, 0, (int)fileStream.Length);
    fileStream.Close();
}

// Do something with the file contents

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("ProductCollection.xml", FileMode.Create))
{
    DataContractSerializer serializer =

new DataContractSerializer(typeof(List<Product>));
    serializer.WriteObject(fileStream, productCollection);
}

using (IsolatedStorageFileStream fileStream =
    store.OpenFile("ProductCollection.xml", FileMode.Open))
{
    DataContractSerializer serializer =
        new DataContractSerializer(typeof(List<Product>));
    List<Product> productCollection =
        serializer.ReadObject(fileStream) as List<Product>;

    // Do something with the collection

    fileStream.Close();
}

When a Silverlight application is first run, it is given a quota of 1MB of space to use in its isolated storage store. This quota is assigned on a per-domain basis, meaning that the quota is shared between all the Silverlight applications originating from the same domain (even though each application has its own separate isolated storage store). Attempting to exceed this quota will result in an exception being raised.

You can determine how much quota you have free by checking the AvailableFreeSpace property of the IsolatedStorageFile object. This value returns the number of bytes still available for use in the isolated storage store:

long freeSpace = store.AvailableFreeSpace;

You can also retrieve the total quota assigned to the domain via the store's Quota property, and retrieve the amount of quote already used via the store's UsedSize property.

When a Silverlight application is installed to run outside the browser, its quota will be automatically increased from the initial 1MB to 25MB. However, you can request additional space at any time if it is required. This requires that the user provide permission for the domain to be assigned further quota by displaying a dialog (as shown in Figure 14-6).

Figure 14.6. The dialog for the application requesting increased isolated storage quota

To request additional quota, you can simply call the IncreaseQuotaTo method of the IsolatedStorageFile object, passing it the amount of space that you want (in bytes). For example, you can use the following code to request your quota to be increased to 50MB of isolated storage space:

bool increasePermitted = store.IncreaseQuotaTo(50 * 1024 * 1024);

The method returns a Boolean value indicating whether permission for the additional space has been permitted or denied by the user. Requesting a smaller quota than that already granted will throw an ArgumentException exception stating that "The new quota must be larger than the old quota", so be prepared for this scenario and put the call in a try/catch block (or make sure the value you are setting is greater than that of the store's Quota property).

Something to be aware of when writing data to isolated storage is that it is easily accessible by burrowing into the user's profile folders. The isolated storage store is maintained in a hidden folder with the exact same file/directory structure as they were created in the store, as demonstrated in Figure 14-7.

Figure 14.7. An isolated storage folder on disk

The location of the isolated storage stores on disk differs between operating systems, but in Windows Vista/7 you can find the area by typing "%userprofile%AppDataLocalLowMicrosoftSilverlightis" into the Windows Explorer address bar. When you write files to isolated storage, you are simply writing them to a folder somewhere underneath this path.

As you can see, from Figure 14-7, the path to the isolated storage store is somewhat obfuscated, but if you create a file in the isolated storage store with a unique name, you can find it fairly easily (and hence the isolated storage store) using the search functionality in Windows Explorer. You can then open the files and inspect their contents (and modify them) if you wish.

The point you need to note from this exercise is that nothing you write to isolated storage should be considered secure, and thus you should not write sensitive data to isolated storage, or assume that it can't be modified outside your application.

You may wish to consider encrypting your files in order to help prevent these sorts of issues if they are of concern to you. The following MSDN article should point you in the right direction for doing so: http://msdn.microsoft.com/en-au/library/dd153755(VS.95).aspx.

With a default quota of 1MB, depending on the type and number of files you want to cache in isolated storage, you may wish to consider attempting to make the most efficient use of the available space within isolated storage by compressing the files (saving the need to request additional quota from the user so soon).

Silverlight doesn't have any built-in compression routines, but you can use an open source library that provides this functionality instead. Two of the best options available to you are Silverlight ports of the SharpZipLib and DotNetZip projects. The SharpZipLib has a GPL license, whilst the DotNetZip has a less restrictive Ms-PL license.

You can download the Silverlight port of the SharpZipLib project from http://slsharpziplib.codeplex.com, however the DotNetZip project has no official port attempt (the original project can be found here: http://dotnetzip.codeplex.com). If you download the Document Toolkit Extensions project however, you will find a Silverlight port of both projects in it that is available here: http://documenttoolkit.codeplex.com.

Refer to the documentation of the project that you choose to use for details of how to use it.

Not available at the time of this writing, but worth looking into, is the Sync Framework for Silverlight. This is a framework for synchronizing data between a Silverlight application and the server, providing a range of new possibilities for occasionally connected Silverlight applications. Data will be maintained in a local store for use by the Silverlight application while it is offline, and changes in the data during the time offline will be synchronized back with the server once it's back online (and vice versa). The homepage for the Sync Framework on the Microsoft web site can be found at http://msdn.microsoft.com/en-us/sync/default.aspx.

The code to display the open file dialog is as follows:

OpenFileDialog dialog = new OpenFileDialog();
bool? fileSelected = dialog.ShowDialog();

if (fileSelected.HasValue && fileSelected.Value)
{
    // Code to open and read the file goes here
}

The ShowDialog method is the code that actually displays the dialog, and returns a nullable Boolean indicating whether the user selected a file or cancelled the operation. This variable will be set to true if the user selected a file and then clicked the Open button.

You can limit the dialog to displaying files of only a given type (or types), by specifying one or more file filters using the Filter property of the dialog object. Unfortunately, the way to assign these filters is somewhat archaic, but aligns to what you may be used to when configuring file filters for dialogs in other technologies such as Windows Forms. For example, to limit files to just text files (in other words, files with a .txt extension), you can use the following syntax (before opening the dialog):

dialog.Filter = "Text Files|*.txt";

This string is split into two sections, separated by a pipe character. The first section denotes the text to display representing the filter in the drop-down list, and the second section denotes the actual filter to apply to limit the files displayed.

You can extend this filter to include a number of file types/extensions by separating the file extensions in the second section of the filter string with a semi-colon, as demonstrated below:

dialog.Filter = "Documents|*.doc;*.docx;*.rtf";

Alternatively, you can have multiple filters that the user can select from in the dialog, like so:

dialog.Filter = "Word 2002/2003 Documents|*.doc|Word 2007/2010 Documents|*.docx";

As you can see, another pipe character is used to separate each entry. If the first entry is not the one you want to use as the default selection, you can specify a different one using the FilterIndex property. This is a one-based index, so you would set this property to 2 in order to select the Word 2007/2010 Documents filter (in other words, the second filter) from the example above.

Once the user has selected a file, you can retrieve the FileInfo object that it has created. When running in sandbox mode, you will only be able to view limited information about the selected file. Attempting to access file properties such as its directory or its attributes will be denied, resulting in a SecurityException being thrown. You can get its name from the FileInfo's Name property, and its size from its Length property.

The FileInfo object is assigned only limited permissions for the actions you can perform on it, but it does allow you to open the file and read its contents. There are two methods on the object that you can use to do so-the OpenText method, and the OpenRead method.

string fileContents = null;

using (StreamReader fileStream = dialog.File.OpenText())
{
    while (!fileStream.EndOfStream)
    {
        fileContents = fileStream.ReadLine();
        // Do something with the line contents
    }

    fileStream.Close();
}

// Do something with the file contents

string fileContents = null;

using (StreamReader fileStream = dialog.File.OpenText())
{
    fileContents = fileStream.ReadToEnd();
    fileStream.Close();
}

// Do something with the file contents

byte[] fileContents = null;

using (FileStream fileStream = dialog.File.OpenRead())
{
    fileContents = new byte[dialog.File.Length];
    fileStream.Read(fileContents, 0, (int)dialog.File.Length);
    fileStream.Close();
}

// Do something with the file contents

const int chunkSize = 4096; // 4kb blocks

using (FileStream fileStream = dialog.File.OpenRead())
{
    byte[] chunk = new byte[chunkSize];
    int bytesRead = 0;
    int position = 0;

    do
    {

bytesRead = fileStream.Read(chunk, 0, chunkSize);

        // Do something with the chunk

        position += bytesRead;
    } while (bytesRead > 0);

    fileStream.Close();
}

using (FileStream fileStream = dialog.File.OpenRead())
{
    BitmapImage image = new BitmapImage();
    image.SetSource(fileStream);

    // Assign the BitmapImage object to the Source property of an Image control
    imageControl.Source = image;

    fileStream.Close();
}

By default, the user can only select a single file from the open file dialog. However, you can set its Multiselect property to true in order to enable the user to select multiple files at the same time. The File property will only return the first file selected, but you can use the Files property instead. That returns an array of FileInfo objects that you can loop through and read as required.

The code to display the open file dialog is as follows:

SaveFileDialog dialog = new SaveFileDialog();
bool? fileEntered = dialog.ShowDialog();

if (fileEntered.HasValue && fileEntered.Value)
{
    // Code to open and write the file goes here
}

You'll note that this is very similar to how the OpenFileDialog class is used.

Like the OpenFileDialog class, you can set various filters to limit the files displayed in the dialog. If you specify one or more filters and the user does not enter an extension with the file name that they enter, then the extension associated with the selected filter will be automatically appended to the file name. If no filter is specified, or it is an All Files (*.*) type filter, then the value assigned to the DefaultExt property of the OpenFileDialog class will be appended to the file name instead (if provided).

Create a new (empty) file with the name and path provided by the user by calling the OpenFile method that creates and opens the file for writing. You will note that unlike the OpenFileDialog class (which has separate methods for reading files as text or binary), the SaveFileDialog class has only this single method. We'll discuss how to write text or binary data to the file shortly.

Unfortunately, you can't set a default name for the file in the dialog. You can however get the name of the file (excluding path information) from the dialog class's SafeFileName property.

using (Stream stream = dialog.OpenFile())
{
    using (StreamWriter writer = new StreamWriter(stream))
    {
        writer.WriteLine("Text written from Silverlight");
        writer.Close();
    }

    stream.Close();
}

using (Stream stream = dialog.OpenFile())
{
    stream.Write(fileContents, 0, fileContents.Length);
    stream.Close();
}

To access a file for reading or writing, you first have to determine the location of the file (a task performed by the user via the open/save file dialogs in the examples detailed earlier in this chapter). You only have access to the folders within the user's profile, but need to find out what the paths to these folders are. To do so, you can use the GetFolderPath method of the Environment class, passing it a value from the Environment.SpecialFolder enumeration that denotes the folder you are after. The code below demonstrates obtaining the path to the user's Documents folder:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

Once you've obtained a folder's path, you can enumerate through the files and directories within the folder.

To enumerate through the files within a folder, you can create a DirectoryInfo object (passing in the path to its constructor), and use the methods that it exposes. For example, you can enumerate through the files within the user's Documents folder like so:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
DirectoryInfo docPathInfo = new DirectoryInfo(docPath);

IEnumerable<FileInfo> docPathFiles = docPathInfo.EnumerateFiles();

foreach (FileInfo file in docPathFiles)
{
    // Work with the FileInfo object here as required
}

Likewise, you can enumerate through the directories within the folder like so:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
DirectoryInfo docPathInfo = new DirectoryInfo(docPath);

IEnumerable<DirectoryInfo> docPathSubdirectories =
    docPathInfo.EnumerateDirectories();

foreach (DirectoryInfo directory in docPathSubdirectories)
{
    // Work with the DirectoryInfo object here as required
}

You can return both files and directories within a folder in a single method call using the EnumerateFileSystemInfos method (in the same manner as described for the other two methods), which returns a collection of FileSystemInfo objects instead.

You can determine whether a file exists by using the Exists method on the File class. For example, the following code determines whether a file named "Test.txt" exists under the user's Documents folder:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
bool fileExists = File.Exists(Path.Combine(docPath, "Test.txt"));

In a similar fashion, you can determine whether a folder exists by using the Exists method on the Directory class. For example, the following code determines whether a folder named "Test" exists under the user's Documents folder:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
bool folderExists = Directory.Exists(Path.Combine(docPath, "Test"));

You can read text or binary data from a file in the same manner as was demonstrated previously when discussing the open file dialog, after obtaining or creating a FileInfo object pointing to the file.

Elevating trust permissions opens up a number of other methods of reading data from a file that are somewhat easier to use than the previously described methods. From the File class, you now have access to the ReadAllText, ReadLines, ReadAllBytes, OpenText, and OpenRead methods. Each of these reduces the amount of code required to read data from a file. For example, the following code demonstrates reading the entire contents of a text file into a string:

string fileContents = File.ReadAllText(filePath);

As with reading data from a file, having elevated trust permissions opens up a number of other easier methods of writing data to a file. From the File class, you now have access to the WriteAllText, WriteAllLines, WriteAllBytes, OpenWrite, OpenText, CreateText, and Create methods. For example, the following code demonstrates writing "Hello" to a text file:

File.WriteAllText(filePath, "Hello");

The File class also exposes the AppendText, AppendAllLines, AppendAllText methods that enable you to append text to a file. If the given file doesn't exist, it will create it for you. For example, you may wish to keep a log file containing all of the errors experienced on the client for later analysis. These methods will enable you to implement that behavior. For example, the following code demonstrates appending "Hello" to a file:

File.AppendAllText(filePath, "Hello");

You can create a new folder within the user's profile via the CreateDirectory method of the Directory class. For example, to create a folder named "Test" under the user's Documents folder, you would use the following code:

string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
Directory.CreateDirectory(Path.Combine(docPath, "Test"));

You can delete a file either via the Delete method of a FileInfo object, or the Delete method of the File class. For example:

File.Delete(filePath);

You can copy a file to a folder using either the CopyTo method of a FileInfo object, or the Copy method of the File class. For example:

File.Copy(sourceFilePath, destinationFilePath);

Moving a file is a very similar process, using either the MoveTo method of a FileInfo object, or the Move method of the File class:

File.Move(sourceFilePath, destinationFilePath);

It's worth noting that once you are running with elevated trust permissions, you are able to access the file attributes (such as creation time, directory, etc) that you were unable to access from the FileInfo objects returned from the OpenFileDialog class when running in the normal sandboxed mode. However, even with elevated trust, selecting a file located outside the user's profile folders via the OpenFileDialog class will still deny access to its file attributes-file attributes will only be accessible if the file resides in the user's profile folders, regardless of trust level.

Before attempting to call COM, you should perform a basic check to ensure that you are actually able to do so. In order to access a COM component, you must be running in OOB mode, with elevated trust, and on a Windows operating system. The IsAvailable property of the AutomationFactory class (found under the System.Runtime.InteropServices.Automation namespace) will return a Boolean value indicating whether these conditions are satisfied, denoting that the application is able to access COM automation.

bool canAccessCOM = AutomationFactory.IsAvailable;

Once you know that you have access to COM automation, you need to create or obtain an instance of the COM component you wish to automate. You can do so using either the CreateObject or the GetObject methods of the AutomationFactory class. You can use the CreateObject method to create a new instance of the COM object, and you can use the GetObject to obtain an existing instance of the COM object. For example, if you wanted to interact with a running instance of Word, you could use the GetObject method to get that existing instance (returning the most recent instance if there are multiple instances running), or you could use the CreateObject method to start a new instance.

In order to create or obtain a COM object instance, you need to know its programmatic identifier (most commonly known as its progID). Every COM component has a GUID that uniquely identifies that component, known and referred to as a CLSID. This is a unique identifier that the COM component is registered in Windows with. However, this CLSID is not particularly "human friendly", so each COM component has a corresponding meaningful string that can be used to access it by-its progID. For example, the progID to automate Word is Word.Application.

Once you have obtained an instance of a COM object, you need to assign it to a variable. However, you have no assembly reference providing the types that you can cast the instance to (since you can't add any sort of reference to those types in Silverlight), creating a problem. Therefore, if you assign the instance to a variable of type object, the only way to call methods on the COM object and access properties is via reflection. Help is at hand however, with the dynamic keyword (new in .NET Framework 4 and Silverlight 4).

The dynamic keyword enables you to assign an object instance to a variable and, and call methods/access properties on that object-without needing to cast it to a particular type first. This is particularly useful when interacting with COM components, as you don't know their type, and cannot cast an object instance to one. Essentially, a variable's type is resolved at runtime (as opposed to the var keyword that resolves a variable's type at compile time)-a concept known as late binding.

Putting it all together now, let's create a new instance of a Word application (that has a progID of Word.Application):

using (dynamic word = AutomationFactory.CreateObject("Word.Application"))
{
    // Put code to interact with Word here
}

Obtaining an existing instance of Word is almost identical to the previous example, simply replacing the CreateObject method with GetObject instead:

using (dynamic word = AutomationFactory.GetObject("Word.Application"))
{
    // Put code to interact with Word here
}

One of the downsides of defining a variable as a dynamic type is that you don't get any help from IntelliSense in the Visual Studio code editor. Therefore, it may be worth writing the code somewhere where you do (such as creating an application using the full .NET Framework and using the Visual Studio Tools for Office to write the initial code, then translating it to run in Silverlight instead)-making the code-writing process much easier and less trial-and-error.

There's no way to tell if a COM component is registered on the system or not, without attempting to create or get an instance of the component. For example, you may want to interact with Word, but the user may not have Word installed on their machine (or may not have the right version of Word).

When attempting to create or get an instance of a COM component, a generic Exception exception will be raised, stating that no object was found registered with the specified progID. Therefore, always wrap your calls to COM components in a try/catch block, as there's no guarantee that the COM component will actually be available on the user's machine.

The Windows Script Host is a COM component built into Windows that is generally used to script and automate administrative tasks. It contains a number of COM objects that you can use to perform tasks such as running applications, reading from and writing to the registry, and creating shortcuts, to name a few.

For example, you can launch an application using the Run method of the WScript.Shell COM object. The following code demonstrates launching the Windows Calculator application:

using (dynamic shell = AutomationFactory.CreateObject("WScript.Shell"))
{
    shell.Run("calc.exe");
}

A complete range of file system access functions are available via the Scripting.FileSystemObject COM component built into Windows, without the limitations imposed by Silverlight's built-in functions (that only enable you to access files and folders underneath the user's profile folders).

For example, the following code demonstrates obtaining the path to the user's Program Files folder (which it uses the Windows Script Host described previously to do), creating a sub-folder within that folder, and creating a simple text file in that sub-folder (none of this was possible with Silverlight's built-in file system access classes and methods):

using (dynamic shell = AutomationFactory.CreateObject("WScript.Shell"))
{
    // Get the user's Program Files path
    string programFilesPath = shell.ExpandEnvironmentStrings("%ProgramFiles%");

    using (dynamic fso =
        AutomationFactory.CreateObject("Scripting.FileSystemObject"))
    {
        string appPath = Path.Combine(programFilesPath, "MyApp");
        string filePath = Path.Combine(appPath, "Test.txt");

        // Create the folder if it doesn't exist
        if (!fso.FolderExists(appPath))
            fso.CreateFolder(appPath);

        // Create a text file within the folder
        dynamic file = fso.CreateTextFile(filePath, true);
        file.WriteLine("Hello");
        file.Close();
    }
}

As discussed earlier, you can automate Word by creating/obtaining an instance of it using its progID of Word.Application. The example below demonstrates creating a new instance of Word, adding a document, and inserting some text into it:

using (dynamic word = AutomationFactory.CreateObject("Word.Application"))
{
    dynamic document = word.Documents.Add();
    document.Content = "This was inserted by Silverlight";
    word.Visible = true;
}

You can automate Excel in a very similar fashion, by creating/obtaining an instance of it using its progID of Excel.Application. The example below demonstrates creating a new instance of Excel, adding a worksheet, and inserting some text into its first cell:

using (dynamic excel = AutomationFactory.CreateObject("Excel.Application"))
{
    dynamic workbook = excel.Workbooks.Add();
    dynamic cell = workbook.ActiveSheet.Cells[1, 1];
    cell.Value = "This was inserted by Silverlight";
    excel.Visible = true;
}

Integration with the Office applications is one of the more common uses that you will have for COM with your business applications in Silverlight. This will allow the user to extract data from the system and manipulate it for their own uses, such as producing reports and letters in Word, and charts in Excel.

You can handle events raised by COM components using the GetEvent method of the AutomationFactory class. You pass the object and the name of the event to handle to this method, and it will return an AutomationEvent object, whose EventRaised event will be raised in turn when the COM object's event is raised.

For example, following on from the previous example of opening Excel and creating a new workbook, you could handle the BeforeClose event of the Workbook object returned from the excel.Workbooks.Add method, like so:

AutomationEvent beforeClosingEvent =
    AutomationFactory.GetEvent(workbook, "BeforeClose");

beforeClosingEvent.EventRaised += (s1, e1) =>

{
        System.Diagnostics.Debug.WriteLine("The workbook is closing!");
    };

This will write a line to the Output window in Visual Studio when the workbook is about to be closed in Excel.

As discussed earlier in this chapter, there's no built-in client-side database that can be used by Silverlight to store data locally on the user's machine. However, COM automation enables you to read and write data to an existing database on the user's machine. For example, the following code demonstrates reading data from a local SQL Server database using ADO:

using (dynamic connection = AutomationFactory.CreateObject("ADODB.Connection"))
{
    using (dynamic rs = AutomationFactory.CreateObject("ADODB.RecordSet"))
    {

        string connectionString = @"Provider=SQLNCLI10.1;Data Source=.SQL2008;" +
                             "Database=AdventureWorks2008;Integrated Security=SSPI";
        connection.Open(connectionString);

        rs.Open("SELECT TOP 5 ProductID, Name FROM Production.Product", connection);

        while (!rs.EOF)
        {
            int productID = (int)rs.Fields.Item("ProductID").Value;
            string name = rs.Fields.Item("Name").Value;

            // Write out the data to Visual Studio's Output window
            System.Diagnostics.Debug.WriteLine("{0} - {1}", productID, name);
            rs.MoveNext();
        }

        rs.Close();
    }

    connection.Close();
}

And the following code demonstrates inserting a row into the database:

using (dynamic connection = AutomationFactory.CreateObject("ADODB.Connection"))
{
    using (dynamic command = AutomationFactory.CreateObject("ADODB.Command"))
    {
        string connectionString = @"Provider=SQLNCLI10.1;Data Source=.SQL2008;" +
                             "Database=AdventureWorks2008;Integrated Security=SSPI";
        connection.Open(connectionString);

command.ActiveConnection = connection;
        command.CommandText = "INSERT INTO ErrorLog(ErrorTime, UserName, " +
            "ErrorNumber, ErrorSeverity, ErrorState, ErrorProcedure, ErrorLine, " +
            "ErrorMessage)" +
            "VALUES (GETDATE(), 'UserName', 0, 0, 0, 'None', 0, 'Test Insert!')";
    }

    connection.Close();
}

With Silverlight 4, you now have built-in access to the webcam, microphone, and printer, but what if you have other hardware devices attached locally that you want to access? If these hardware devices are accessible via a COM component then this is entirely possible. Windows also provides a generic automation layer for some device types that you can take advantage of to gain access to devices. For example, Windows includes an automation layer that enables access to the Windows Image Acquisition (WIA) platform, which provides access to imaging hardware such as cameras and scanners. Features of its associated COM component include enabling you to enumerate the connected cameras and scanners, and take pictures/scan images.

For example, the following code demonstrates displaying the Acquire Image dialog, and saving the acquired image to the user's Pictures folder:

using (dynamic acquireDialog = AutomationFactory.CreateObject("WIA.CommonDialog"))
{
    dynamic image = acquireDialog.ShowAcquireImage();

    if (image != null)
    {
        string path =
            Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);

        image.SaveFile(Path.Combine(path, "ScannedImage.jpg"));
    }
}

The built-in COM components demonstrated here provide a wide array of additional functionality that you can access from your Silverlight application, but there is also the potential for you to create your own COM component providing further native functionality, and have that downloaded and registered by your application (if the available Windows privileges allow it, or otherwise preinstalled by an administrator).

You can expose classes from projects targeting the full .NET Framework by making their corresponding assemblies COM-Visible. This would enable you to implement features not possible in Silverlight and make them available to Silverlight applications. An excellent article written by Elton Saulsberry on doing so is published here: www.codeproject.com/KB/silverlight/Silverlight4COM.aspx.

The downsides of this particular method is that it requires the user to have the full .NET Framework installed on their machine, in which case the application may be better completely implemented in WPF (for example). Alternatively, you may wish to develop the component using Visual C++ and ATL in order to avoid this requirement. You can find an old (but helpful) article written by C. Lung in 1999 on doing so here: www.codeguru.com/cpp/com-tech/atl/tutorials/article.php/c17.

To enable the window to be moved, let's create a custom title bar using the following XAML:

<Rectangle Name="TitleBar" Height="15" Fill="#D8727272" VerticalAlignment="Top"
           MouseLeftButtonDown="TitleBar_MouseLeftButtonDown" />

Note that you are handling the MouseLeftButtonDown event on the Rectangle. You will use this event to initiate the window move, as per the following code:

private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    Application.Current.MainWindow.DragMove();
}

That's all there is to it. The DragMove method on the window will tell the window to move based upon the position of the mouse (relative to its current position), and it will automatically continue to do so until the left mouse button is released.

To enable the window to be resized, let's create a handle that will appear in the bottom right-hand corner of the window that the user can click and drag to resize it, using the following XAML:

<Path Name="ResizeGlyph" Data="M20,0 L20,20 L0,20 z" Fill="#D8727272"
      Grid.Row="2" HorizontalAlignment="Right" VerticalAlignment="Bottom"
      Height="20" Width="20" Cursor="SizeNWSE"
      MouseLeftButtonDown="ResizeGlyph_MouseLeftButtonDown" />

Note that you are handling the MouseLeftButtonDown event of the Path. You will use this event to initiate the window resizing, as per the following code:

private void ResizeGlyph_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    Application.Current.MainWindow.DragResize(WindowResizeEdge.BottomRight);
}

This works in exactly the same way as moving the window, where the DragResize method on the window will tell the window to resize based upon the position of the mouse (relative to its current position), and it will automatically continue to do so until the left mouse button is released. Note that you need to specify (as the parameter to the DragResize method) what edge of the window the user is resizing, such that the resizing can be handled accordingly.