Currently I am using Windows 7 as my hub machine, and I have two Media Center Extenders: an XBox 360 in one room and a Linksys DMA2200 in the other. For the most part, this setup works flawlessly.

Lately, however I have been noticing some issues with the Music Library on both of the Media Center Extenders. A large number of newly added music tracks appear under the artist name "Unknown Artist", even though the tracks are all tagged properly and show up correctly in both Songbird (my media player of choice) and on the Media Center interface of the main computer.

At this point I should also mention that my main source of purchasing music lately has been the Amazon MP3 store. It's comparable to iTunes in the selection and pricing, but the main advantage are the DRM-free tracks.

Initially, I thought maybe a corrupt music library was the problem, so I tried to wipe out and completely rebuild the libraries for both extenders. Unfortunately, this did nothing to solve the problem.

I started looking through different posts online and also looking at some of the tracks that were having issues on my computer. One thing that stood out was that the track detail was not showing up in Windows Explorer (the first copy of track 5 on the list):

I tried to edit the track detail from explorer and received the message "Error 0x8007000D: The data is invalid.":

As it turns out, Windows 7 (and Vista) do not support ID3 v2.4 standard, they support ID3 v2.3. So the cause of my problem was two sources: First, on some occasions when I was making metadata changes in Songbird, the ID3 tag was being updated to the 2.4 version. Second, it appears that the Amazon mp3 store also uses ID3 v2.4 tag, so everything that I purchased was not being added correctly.

Fortunately, identifying the problem was much more difficult than fixing it. The easiest solution is a piece of software called MP3Tag. This is a free download, but if it solves your problems like it has solved mine then you should consider making a donation to the developers to thank them for their work.

Once you have MP3Tag installed, open the program. From the Tools menu, select Options. On the left side of the Options page, select Mpeg under the tags section and verify that ID3v2 is checked, and that the radio button labeled ID3v2.3 UTF-16 is the selected option:

Click OK to save your changes.

Now, select Change Directory from the File menu in MP3Tag. Navigate to any folder on your computer that contains problematic tracks. Make any tag changes you need by using the fields on the left, and then click Save on the toolbar to update the tag information. You can make changes to an entire set of files by highlighting them all an entering in the shared information. After you have saved your changes, the tracks should now appear correctly in Windows Explorer and in your Media Center extenders.

Overall, I spent about an hour re-tagging invalid tracks, but now that I know the cause it should be relatively easy to check new music as I purchase it. I hope this helps others as well!

View Usnwc 6/19 in a larger map

From looking at the above map, it would appear that I stopped and checked my stats pretty frequently. I can't imagine a bike ride where that would be considered fun. Fortunately, thanks to my Android phone and Google's My Tracks application, this isn't the case.

For starters, you will obviously need an Android device that is GPS capable, and also the My Tracks application itself. If you are on your Android phone right now and have access to the market, click here to go directly to the download.

You can also scan the code below with your phone if you have Barcode Scanner installed:

Once you have my tracks installed and you are ready to ride/walk/track, open the My Tracks application. Depending on the activity, you may want to change a few settings. To do so, press Menu and then tap Settings.

In my case, I found that the default tracking settings didn't work well for tight trails with lots of switchbacks, so here are the settings I am currently using:

Assuming you have no changes to make, you can now start recording your track by pressing Menu and tapping Record Track. Now for the hard part. ride, walk or run!

It's important to note that GPS can take a lot of life from your battery quickly. Make sure you start your rides with 100% battery life so that you don't run out of juice. you definitely want to be able to call for help if you need it! I personally wouldn't do this at all for remote or extended rides. I only use it for local trails to help keep track of my trail times and average moving speed.

My favorite part of using My Tracks is the announcements. When this is enabled, you will get audio reports every so often telling you your total distance and average speed. this is a huge motivator for me, it's like being able to race yourself every time you ride.

The next best part of My Tracks are the splits. If you click on any of the yellow pins in the map above, you will notice that statistics are inserted at each interval. In addition to distance and average speed, you can also view elevation, grade, and maximum speed for each split.

Once you have completed a ride, you end the track by pressing Menu and then tapping Stop Recording. You will be prompted to enter details about the track:

At this point you can just keep the saved the track on your phone, or you can send the track to My Maps on Google.

You can also review all of the information about the current track on your phone. Tap either of the onscreen arrows (left or right) to switch between map, statistics, and elevation views:

Map View	Statistics View	Elevation and Speed View (speed is blue, elevation is green)

There is also a My Maps Editor application for Android, where you can edit the map. Editing features include the ability to add new markers and/or change the map's title and description.

Once you choose to upload your map, you can also share it via several options, including Gmail, Twitter, Facebook, and also in GPX or KML formats.

This is an excellent application for any outdoor activity and has a wide variety of uses, from trail marking to personal fitness tracking. Be sure to check it out if you spend any time outdoors!

This article builds on the original code and demonstrates how to apply style and value formatting to the cells inside the workbook.

To enable value and text formatting for the resulting workbook, I have created new helper methods.

Setting Colors and Styles

This first method will create a new Font object and add it to the stylesheet collection within the workbook:

1. private UInt32Value createFont(
2.             Stylesheet styleSheet,
3.             string fontName,
4.             Nullable<double> fontSize,
5.             bool isBold,
6.             System.Drawing.Color foreColor)
7.         {
8.  
9.             Font font = new Font();
10.             
11.             if (!string.IsNullOrEmpty(fontName))
12.             {
13.                 FontName name = new FontName()
14.                 {
15.                     Val = fontName
16.                 };
17.                 font.Append(name);
18.             }
19.  
20.             if (fontSize.HasValue)
21.             {
22.                 FontSize size = new FontSize()
23.                 {
24.                     Val = fontSize.Value
25.                 };
26.                 font.Append(size);
27.             }
28.  
29.             if (isBold == true)
30.             {
31.                 Bold bold = new Bold();
32.                 font.Append(bold);
33.             }
34.  
35.             if (foreColor != null)
36.             {
37.                 Color color = new Color()
38.                 {
39.                     Rgb = new HexBinaryValue()
40.                     {
41.                         Value =
42.                             System.Drawing.ColorTranslator.ToHtml(
43.                                 System.Drawing.Color.FromArgb(
44.                                     foreColor.A,
45.                                     foreColor.R,
46.                                     foreColor.G,
47.                                     foreColor.B)).Replace("#", "")
48.                     }
49.                 };
50.                 font.Append(color);
51.             }
52.             styleSheet.Fonts.Append(font);
53.             UInt32Value result = styleSheet.Fonts.Count;
54.             styleSheet.Fonts.Count++;
55.             return result;
56.         }

The return value of the method above is the index number of the newly added Font object.

Next is the createFill method. This method works exactly like the createFont method and also returns a new index value after the Fill has been added to the workbook's styles collection:

1. private UInt32Value createFill(
2.     Stylesheet styleSheet,
3.     System.Drawing.Color fillColor)
4. {
5.     Fill fill = new Fill(
6.         new PatternFill(
7.             new ForegroundColor()
8.             {
9.                 Rgb = new HexBinaryValue()
10.                 {
11.                     Value =
12.                     System.Drawing.ColorTranslator.ToHtml(
13.                         System.Drawing.Color.FromArgb(
14.                             fillColor.A,
15.                             fillColor.R,
16.                             fillColor.G,
17.                             fillColor.B)).Replace("#", "")
18.                 }
19.             })
20.         {
21.             PatternType = PatternValues.Solid
22.         }
23.     );
24.     styleSheet.Fills.Append(fill);
25.  
26.     UInt32Value result = styleSheet.Fills.Count;
27.     styleSheet.Fills.Count++;
28.     return result;
29. }

 

Finally, once you have created a Font and/or Fill, you need to create a CellFormat object and add it to your styles collection:

1. private UInt32Value createCellFormat(
2.     Stylesheet styleSheet,
3.     UInt32Value fontIndex,
4.     UInt32Value fillIndex,
5.     UInt32Value numberFormatId)
6. {
7.     CellFormat cellFormat = new CellFormat();
8.     
9.     if (fontIndex != null)
10.         cellFormat.FontId = fontIndex;
11.     
12.     if (fillIndex != null)
13.         cellFormat.FillId = fillIndex;
14.  
15.     if (numberFormatId != null)
16.     {
17.         cellFormat.NumberFormatId = numberFormatId;
18.         cellFormat.ApplyNumberFormat = BooleanValue.FromBoolean(true);
19.     }
20.  
21.     styleSheet.CellFormats.Append(cellFormat);
22.  
23.     UInt32Value result = styleSheet.CellFormats.Count;
24.     styleSheet.CellFormats.Count++;
25.     return result;
26. }

 

Once you have created your CellFormat objects, you can apply them to any cell value by setting the StyleIndex property for the Cell object. This code demonstrates using all of the methods above to create a header format for the first row of the resulting workbook:

The final piece of the solution is to add the styleIndex parameter to the createTextCell method and set the StyleIndex property on the Cell:

Formatting Cell Values Correctly

The fourth parameter for the createCellFormat method allows you to format cell values based on your data types. Although you can create custom cell formats in the same manner that you build the font and background color, the OpenXML specification (detailed in the section 8.8.30 of of the Standard ECMA-376 Office Open XML File Formats second edition draft) has a set of implied cell formats, meaning you can reference them without explicitly adding them to the StyleSheet. Here is a list of the implied formats from the draft:

If you run the sample code provided in the first article, one thing you will notice about the resulting Excel document is that even cells with numeric values are treated as text. Anyone familiar with Excel has seen this pop-up tag on many occasions:

Error correction in Excel highlights the values that are stored as text.

The reason behind this was due to the way cell values were added in the createTextCell method. Because the DataType of the cell is set to InlineString, the content passed into the cell was always treated as text. To overcome this limitation, I created another new method, createValueCell. First, I created three new basic styles using the createCellFormat method (using the cell formats from the table above):

You will notice in the code above that each "style" was created using the same createCellFormat method; the font and fill values have just been omitted.

Now while the table rows are being iterated through, we can check the data type of each value and decide whether or not to apply one of the formatted styles to each cell:

In most cases, you will know when to apply the correct styles to each value based on your source data. In either case, the createValueCell method will store the cell content correctly, and also allow you to format those values as needed:

The final result looks much more professional than the original:

This code does a lot to expand on the original article, but it still only covers a small percentage of what is possible within the OpenXML SDK. Hopefully these samples will help you become familiar with how the SDK works and you can customize your own solutions to fit your requirements. I am also providing an updated sample Visual Studio 2008 project with this article so you can review the entire solution.

With the release of the Office 2007 Suite, Microsoft changed the core document format for the entire Office line to be based on the Office OpenXML standard. As of December 2009 the technology preview of the OpenXML SDK 2.0 has been released and is freely available to download. The OpenXML SDK allows .Net developers to create and manipulate Office documents. This is an especially large step forward for web developers, who have traditionally had few options for exporting data into Excel directly from their applications.

Getting Started with the OpenXML SDK 2.0

Be sure to review the System Requirements for the SDK. The .Net Framework 3.5 SP1 is required.

First, you will need to download the OpenXML SDK 2.0 package. If you are in a hurry and have no intention of diving deep into the SDK, then just download the smaller package (this is only the assembly you will need to make this work).

For those of you interested in moving beyond the scope of this article, I suggest also installing the tools package once you have installed the assemblies (more on this later).

This tutorial (and sample code) does not assume any knowledge of the DataTable. There can be any number of columns and rows supplied and the export will still work correctly. I'm sure you have seen many examples of exporting DataTable objects to CSV format that take the same approach.

Create A Visual Studio Project

Once you have installed the SDK, create a new project in Visual Studio; in this tutorial I am using an ASP .Net web application project with C#, although this code will work with any project type.

Once the project is created, right-click on the project and select Add Reference in Visual Studio. Click on the Browse tab and navigate to the OpenXML SDK installation folder (the default installation path is C:\Program Files\Open XML SDK\V2.0). Select the assembly DocumentFormat.OpenXML.dll located in the lib folder and click OK.

The OpenXML SDK 2.0 also requires a reference to the WindowsBase assembly (WindowsBase.dll) in order to use the System.IO.Packaging namespace. Repeat the same steps as above and add a reference to WindowsBase from the .Net tab.

Create the ExcelDocument Class

The ExcelDocument class only exists to generate a new empty Excel spreadsheet document. The code to create a new document can be extensive, but this is where the Tools installation of the SDK comes in very handy:

Locate and run the OpenXmlSdkTool.exe application in the Tools folder if you have installed the tools package. This will launch the OpenXML productivity tool:

Select Open File from the menu or the toolbar and navigate to any Excel 2007 document you would like to use as a template. Once you load the document, you will see the structure outlined on the left side of the application. Now click Reflect Code on the toolbar. The right frame should now display a complete C# class for the document:

Paste this code into a new file in your project called ExcelDocument.cs. The downloadable sample for this article includes this file. The template I used is a default Excel workbook.

You can also save time and gain more granular control over the template by using a template file at runtime. To create a template file, create a new Excel 2007 document. Save the document to your project folder. Instead of executing the CreatePackage method generated in ExcelDocument.cs, create a copy of the template file at runtime:

File.Copy(templateFilePath, exportFilePath, true);

One advantage of this approach is that you can set custom properties in your Excel template like corporate headers or cell. Once you create the blank workbook, save it your project folder.

If you do not have the ability to generate new Excel documents, there is a blank workbook included in the sample code with this post.

Create the ExcelExport Class

Now create a new class file called ExcelExport.cs in your project. Add the following references to the beginning of the file:

using System;
using System.Data;
using System.Linq;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;

Next, add the following method to the file:

public void ExportDataTable(
            DataTable table, 
            string exportFile)
        {
            //create the empty spreadsheet template and save the file
            //using the class generated by the Productivity tool
            ExcelDocument excelDocument = new ExcelDocument();
            excelDocument.CreatePackage(exportFile);

            //populate the data into the spreadsheet
            using (SpreadsheetDocument spreadsheet =
                SpreadsheetDocument.Open(exportFile, true))
            {
                WorkbookPart workbook = spreadsheet.WorkbookPart;
                //create a reference to Sheet1
                WorksheetPart worksheet = workbook.WorksheetParts.Last();
                SheetData data = worksheet.Worksheet.GetFirstChild<SheetData>();

                //add column names to the first row
                Row header = new Row();
                header.RowIndex = (UInt32)1;
                
                foreach (DataColumn column in table.Columns)
                {
                    Cell headerCell = createTextCell(
                        table.Columns.IndexOf(column) + 1, 
                        1, 
                        column.ColumnName);

                    header.AppendChild(headerCell); 
                }
                data.AppendChild(header);

                //loop through each data row
                DataRow contentRow;
                for (int i = 0;i < table.Rows.Count; i++)
                {
                    contentRow = table.Rows[i];
                    data.AppendChild(createContentRow(contentRow, i + 2));
                }
            }            
        }

The method above starts by using the ExcelDocument class created earlier to create a new file, which is saved to the location specified in the exportFile argument. Once the file is created, there are two main loops that occur. The first loops iterates through the DataTable object's columns and creates a Cell object for each column name using the createTextCell method:

private Cell createTextCell(
    int columnIndex,
    int rowIndex,
    object cellValue)
{
    Cell cell = new Cell();

    cell.DataType = CellValues.InlineString;
    cell.CellReference = getColumnName(columnIndex) + rowIndex;

    InlineString inlineString = new InlineString();
    Text t = new Text();

    t.Text = cellValue.ToString();
    inlineString.AppendChild(t);
    cell.AppendChild(inlineString);

    return cell;
}

Next, each row is appended to the worksheet using the createContentRow method:

private Row createContentRow(
    DataRow dataRow,
    int rowIndex)
{
    Row row = new Row

    {
        RowIndex = (UInt32)rowIndex
    }; 

    for (int i = 0; i < dataRow.Table.Columns.Count; i++)
    {
        Cell dataCell = createTextCell(i + 1, rowIndex, dataRow[i]);
        row.AppendChild(dataCell);
    }
    return row;
}

The createTextCell method uses one additional supporting method to do the job of mapping the rows and columns to the correct cell reference, the method getColumnName:

private string getColumnName(int columnIndex)
{
    int dividend = columnIndex;
    string columnName = String.Empty;
    int modifier;

    while (dividend > 0)
    {
        modifier = (dividend - 1) % 26;
        columnName = 
            Convert.ToChar(65 + modifier).ToString() + columnName;
        dividend = (int)((dividend - modifier) / 26);
    }

    return columnName;
}

This method provides a quick an easy way to map a column index number to an Excel column name (A-Z). The Cell object in the OpenXML SDK requires a valid Excel cell reference (ex. A1, C2) to be specified, so this method is combined with a row index reference to create the cell reference. It is important to note that the indexes here are not zero-based.

Finally, to implement the class above, use the following code:

//create DataTable from sample data
DataSet sampleDataSet = new DataSet();
sampleDataSet.ReadXml(context.Server.MapPath("~/sampleData.xml"));
DataTable productsTable = sampleDataSet.Tables[0];
string exportFile = context.Server.MapPath("~/excelExport.xslx");

ExcelExport export = new ExcelExport();
export.ExportDataTable(productsTable, exportFile);

The export file referenced is saved to disk automatically, so once the ExportDataTable method completes the file is available to be passed to the user.

You can download a complete project example here if you would like to try the sample code for yourself. The sample projects includes all of the code shown above, a sample XML data file, and a generic handler that runs the example code.

I hope you have enjoyed this post, please feel free to post comments below if you have feedback or questions!

A new and improved version of Songbird is now available. The new release has a completely new look, but more importantly for Android users, has a new option for syncing music to your device: the MSC Add-on. This is probably the closest thing Android user now have to the iTunes experience for managing music on your device.

If you haven't seen it yet, the new Songbird look is quite impressive (this is the Purple Rain feather):

Even more impressive is how easy the new synchronization option is to implement and configure.

Install Songbird 1.4 

Install Songbird 1.4.3 if you have not already (you must have Songbird 1.4 or higher). During the installation, the MSC Add-on should appear as a recommended extension.

If you want to verify that the extension is already installed, you can select Add-Ons from the Tools menu. If you do not see MSC Device Support listed, click the link on the lower right of the screen labeled Get Extensions. Enter MSC in the search box on the top right of the screen.

On the search results page, locate the entry labeled MSC Device Support. You should see a download button on the right side of the screen, click this button to begin the installation process:

Click Install Now. Once the installation is finished, you will be prompted to restart Songbird:

Connect Your Android Device

Once you restart Songbird, you can plug your Android device into your computer. Pull down the notification bar and select the USB Device Connected alert, then tap  Mount on your device when prompted; this will enable USB storage mode.

At this point, you should see your device in the left frame of the Songbird window. The first time you connect your device Songbird will prompt you for a name.

Create or Manage Playlists

If you are like me and have a large music library and a small SD card, you will want to only sync specific content. Instead of manually dragging music to the phone while connected, this is what I recommend:

Configure Device Options

Now, select your Android device on the left side of the screen, you will see something like the following:

To limit your synchronized content, click the radio button labeled Selected playlists, then place a check next to each playlist you want to synchronize to your phone; click Save.

There are options to format your SD card and perform a device repair on the Tools tab. I haven't tried either option, and I wouldn't recommend it: there is no guide that explains these options (that I can find), and although the format option is self-explanatory, it's difficult to say what the second option would do to your device.

The Settings tab has some additional options:

You can limit the amount of space used for music on the card to prevent it from becoming full. You can also control what the folder structure looks like for music on your device, the default configuration uses the format Artist\Album\Track.

Finally, there are three controls on the upper right hand side of the screen:

The first one will display information about the current device:

The second button will eject your device so it can be safely removed from your computer. The last button will perform a manual sync (required if you disable automatic syncing). If you have automatic synchronization, Songbird will immediately begin a sync every time you connect your device.

By comparison to the previous method, this is an easier and faster solution, and it's certainly a testament to the rapid evolution of the Android platform; every day brings better integration between Android and the other devices and software I rely on.

These solutions would work well, but I also remembered that in the past I have been able to easily create .Net Color structures using the following code:

System.Drawing.Color color = System.Drawing.ColorTranslator.FromHtml("#435b9c");

The System.Drawing.ColorTranslator class provides several useful methods for dealing with color conversion. The method I needed was the inverse of the above example, the ToHtml method. This method takes a .Net Color structure and returns the hexadecimal color code as a string object:

string htmlString = System.Drawing.ColorTranslator.ToHtml(System.Drawing.Color.Beige);

This is an easy conversion method, but it still doesn't provide a single line solution for creating the same string from RGB. However, you can combine the method above with the FromArgb method found in the System.Color structure to achieve the one-line conversion:

string htmlString = System.Drawing.ColorTranslator.ToHtml(System.Drawing.Color.FromArgb(85, 120, 50));

The FromArgb method used above is a specific overload that only passes the red, green and blue values to the color object. It is important to note that even if you set an alpha value (the level of opacity in the color) lower than 255 on the color structure, the alpha value is ignored when the ColorTranslator.ToHtml method returns the hexadecimal code for the color object. So these two lines of code produce the same hexadecimal result (#465a9b):

string htmlString = System.Drawing.ColorTranslator.ToHtml(System.Drawing.Color.FromArgb(70, 90, 155));
string htmlString = System.Drawing.ColorTranslator.ToHtml(System.Drawing.Color.FromArgb(125, 70, 90, 155));

These methods have been available in .Net at least since the 1.1 release; if you are like me and deal mostly with the System.Web and System.Data namespaces on a daily basis, it is easy to overlook some of the simple solutions provided by the other libraries in .Net.

There are many extensions for Chrome that will display new message notifications for a specific service, like your GMail or Google Wave account. One Number eliminates the need for multiple extensions by showing you a single number when you have new messages. This single number combines all of the following services together:

• GMail
• Google Reader
• Google Voice
• Google Wave

Any time you open Chrome, the One Number extension will display the total number of new messages:

The extension icon displays the new message count. As you can see in the screenshot above, you can view messages per service by hovering over the icon. You can also click on the icon to show an expanded view:

The expanded view allows you to manually refresh the list to check for new messages and provides quick links for each service. You can also select the Open Unread link  to load each service with unread content into a new Chrome tab.

There are a lot of customization options for One Number as well. To change options, open the customize menu (the wrench icon) in Chrome and select Extensions.

Locate the entry for one number and select Options on the right to customize the extension. You can control the refresh interval, notification colors, and options for each service individually.

This is a great extension, the interface and combination of features are a great example of why extensions are so popular in the browser community.

Extensions are small add-ons that can be installed on top of the core browser. Extensions range from simple shortcuts on your toolbar to utilities like instant page translation or scripts to share content in your favorite social media site.

Once you have updated your Chrome installation, you can find extensions by selecting Extensions from the tools menu. Click on the link at the bottom of the page that says Get more extensions to load this site:

https://chrome.google.com/extensions

To mark the occasion, I am going to post a few of my favorite extensions. The first one in the series is the IE Tab extension. This is a very useful tool for web developers.

If you work in web development or design, multiple browser testing is a must. IE Tab allows you to immediately open the page you are viewing in Chrome (in a new Chrome tab). The new tab uses Internet Explorer to display the same content. This lets you quickly test the differences in content and layout between Chrome and IE without having to switch windows.

Once you install the extension, you will see a new toolbar item in Chrome:

Any time you are viewing a page and would like to switch between Chrome and Internet Explorer, click this button to open the same page in Internet Explorer:

You will notice that there is a second control strip located just below the normal Chrome toolbars. This is where you have access to  Internet Explorer options, bookmarks, and other controls.

Bookmarks that you add while in the IE tab will automatically re-open in Internet Explorer.

It is important to note that the Internet Explorer windows do not share cookies, passwords, or other user-specific information with Chrome, this is definitely a good thing.

As the developer of IE Tab also states, this is not only a useful tool for web developers and testers, but it also allows you to use applications that require Internet Explorer, I currently deal with two companies that have Internet Explorer-specific applications.

This probably isn't a common situation, but there are arguable cases where you may want to share files between projects in a single solution. In my example, I had the following solution structure:

/Solution
/SharedControls
/Project1
/Project2
(etc)

In the SharedControls project, I had stylesheets, theme content, scripts, and some common user controls that both of the other projects were using. It wouldn't be too difficult to manually copy this content to each project, but it's an extra step to remember and to track updates to each file.

When I was working on this solution setup locally, I found an easy way to address this problem, courtesy of Scott Guthrie; start by following the tutorial here:

http://webproject.scottgu.com/CSharp/UserControls/UserControls.aspx

The summary of the tutorial above is to create a web application project: SharedControls. Then add SharedControls as a project reference in each of your other projects. After that, add a copy command line event to the Pre-Build event in each project to copy the shared files from the SharedControls project.

This is a great solution for a single developer, but it does have a few issues:

• The build time is increased, especially if you are copying a lot of files.
• Each file is copied when you  debug, build, or publish a project/solution. even if it is unchanged.
• You have to make sure any changes in the shared files are made in the SharedControls project only.

Now, fast forward to my current team's implementation of Visual Studio Team Foundation Server. A solution like the one above was added into source control so that multiple developers could begin working on the projects. The first time someone tried to build a project, they received a failure message:

The command "copy "C:\Projects\Articles\Solution\SharedControls\Controls\*.ascx" "C:\Projects\Articles\Solution\Project2\Controls\"" exited with code 1.

The build operation was failing because of the pre-build event. When using TFS, your local workspace files are marked as read-only unless you have the file checked out, so the copy command is unable to overwrite the existing files, even with the force flag specified.

A Solution

I was able to address the build failures and also come up with a much better way to manage this type of setup in the process.

First, instead of copying the shared files to each project, you just set up linked files instead:

Add a reference in each project to the SharedControls project (just like in the original tutorial). Right click on the project file and select Add Reference:

Select the Projects tab and select the SharedControls project, and click OK:

In Visual Studio, right-click the Project folder or any folder in the project and select Add > Existing Item:

Navigate to the SharedControls project folder and select the file(s) you would like to link. Click the arrow next to the Add button and select Add As Link:

Now, any time you change the file from any project, all of the linked copies stay in sync. The linked file is just a reference to the copy in the SharedControls folder. If you publish your project now, you will also see that a physical copy of each linked file will be added to the target directory, this is exactly what we wanted!

Now, we're all set. except if you try to debug your project. more errors?!?

If you have linked control files, aspx pages, scripts, or images you will notice that all of them are missing when you start the project in debug mode. This is because the integrated development server points to the project folder, and the physical versions of the files no longer exist in your working project directory, even though they are part of the build.

So you need to make sure that a physical version of the file exists. Since Team Server no longer manages the project files that have been linked in each project, the copy operation should no longer fail.

I mentioned the limitations of Scott Guthrie's solution for copying files during pre-build. This is the script I used in place of his original:

xcopy "$(SolutionDir)SharedControls\Controls\*.ascx" "$(ProjectDir)Controls\" /D /Y
xcopy "$(SolutionDir)SharedControls\App_Themes\*" "$(ProjectDir)App_Themes\" /D /Y /S

So you still create physical copies in the development folder of each linked file, but they are no longer part of the project itself.

The /D flag will only copy the file from the shared projects folder if it is a more recent version than the one that already exists in the destination folder. The /Y option forces an overwrite if the file already exists. The /S option will perform a recursive copy operation.

Right-click on the Project and select Properties. Click on the Build Events tab on the left and add the xcopy command(s) to the Pre-build event command line field:

Now if you build your project again, you should be able to debug without any issues.

One final note: When you drag and drop a linked control to your page in design mode, it will show up in the source view like this:

<%@ Register src="../SharedControls/Controls/SampleControl.ascx" tagname="SampleControl"

 tagprefix="uc1" %>

The src tag is referencing the path to the physical file; You just need to update this tag to reflect the control's  "location" in the current project:

<%@ Register src="Controls/SampleControl.ascx" tagname="SampleControl" tagprefix="uc1" %>

There are many different ways to manage shared content between projects, and this is one of the more basic approaches. If you are working under limited resources and cannot dedicate a user to creating control libraries, this is definitely an approach to consider. You can minimize duplication of work, and make sure that you are able to manage your projects in a consistent manner.

You can download a sample solution here to review how this is set up.

This Windows Mobile theme is a tribute to default theme used in the new XBox experience, now available to all XBox 360 owners. Three landscape wallpapers are included in this theme, and can be used with any other theme currently on your device.

Need installation help? Click here.