A few weeks ago I blogged about a Visual Studio extension, Farticus, which I’m working on with Mads Kristensen. In that post I described how the default compression of a .vsix (the artifact that is created for a Visual Studio Package) is not as small as it could be. It’s better to get a fully compressed VSIX because when users install the component the download time can be significantly reduced. In that post I described how you could use the Zip task from the MSBuild Extension Pack to have a fully compressed .vsix file. I will now show you how I’ve simplified this.

Since my previous post I’ve created a NuGet package, VsixCompress which simplifies this greatly. If you have an existing Visual Studio package and want to have a fully compressed .vsix file then all you need to do is install the VsixCompress package.

After you install this package the following happens.

1. NuGet package is downloaded and installed to the packages folder
2. The project is edited to include an import for a new .targets file
3. The build process is extended to compress the .vsix file automatically

After installing this package once you build the generated .vsix is much smaller than before. In the default case where you select to create a new C# VS Package the created .vsix is 17kb. After adding VsixCompress the resulting .vsix is only 9kb. That’s almost half the size. That’s all you need to know for local development. If you have a build server setup then there are a couple of additional steps. Let’s go over those now.

Build Server Support

I have blogged before about issues of shipping build updates in NuGet. To briefly summarize, when leveraging NuGet Package Restore you have to be careful if any of those NuGet packages have build updates. When using Package Restore the NuGet packages which contain the imported .targets file(s) are restored after the build starts. What this means is that the .targets files will never be imported (or an old copy is imported in the case the file exists from a previous build). The only way to work around this is to restore the packages before the .sln/.csproj file themselves are built. You can read the full details at http://sedodream.com/2012/12/24/SlowCheetahBuildServerSupportUpdated.aspx. I have a NuGet package, PackageRestore, which can help here. Take a look at my previous post How to simplify shipping build updates in a NuGet package. Now that we’ve discussed all the details that you need let’s discuss what my plans are going forward with this.

Plans going forward

I’m hoping to add the following features over the course of the next few weeks.

• Automatically bump version number when building in VS
• Add an option to accept the compression level as an MSBuild property
• Add an option to opt in/out of compressing the VSIX as an MSBuild property

FYI VsixCompress is open source so you can take a look at the code, or better yet contribute at https://github.com/sayedihashimi/vsix-compress.

Please let me know what you think of this!

Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

Have you ever wanted to ship build updates in a NuGet package? If so then you may have noticed that there are issues if you need to import a .targets file which is contained in a NuGet package. To be brief, the issue is that by the time the .targets file is being restored with NuGet it’s already too late because the build has already started. So we need an easy way to invoke NuGet package restore for a given project before the build for the solution/project starts. In this entry you will see how we can use a generated build script to help with this.

A few months back I discovered this issue and blogged about it at SlowCheetah build server support updated. The solution that I implemented was to create a new build script, packageRestore.proj, which is placed in the root of the project when the SlowCheetah NuGet package is installed. If you want to invoke the package restore from a build server then you can just add packageRestore.proj to the list of items to build before the .sln/.csproj file which you are intending to build. I’ve now refactored this into its own NuGet package, PackageRestore.

Here is how you can try it out.

1. Create a new project
2. Add a few NuGet packages to the project
3. Enable NuGet package restore
4. Add the PackageRestore package (the command you can use is Install-Package PackageRestore –pre)
5. Close solution
6. Delete packages folder
7. Execute the command msbuild.exe packageRestore.proj

After executing the command you will see that the packages folder along with all its content will be restored. For CI servers when you define your build script all you do is build packageRestore.proj before you build the target .sln/.csproj file.

If you are shipping build updates through NuGet and want to be able to enable package restore in a similar way a SlowCheetah then when you create your NuGet package add PackageRestore as a dependency.

This is an open source project so you can view the source, and help contribute, at https://github.com/sayedihashimi/package-restore.

Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

The easiest way to publish a Visual Studio web project from the command line is to follow the steps below.

1. Open VS
2. Right click on the Web project and select Publish
3. Import your .publishSettings file (or manually configure the settings)
4. Save the profile (i.e. .pubxml file)
5. From the command line publish with the command line passing in PublishProfile

For more details on this you can see ASP.NET Command Line Deployment. This is pretty simple and very easy, but it does require that you manually create the .pubxml file. In some cases you’d just like to download the .publishsettings file from your hosting provider and use that from the command line. This post will show you how to do this.

In order to achieve the goal we will need to extend the build/publish process. There are two simple ways to do this; 1. Place a .wpp.targets file in the same directory as the web project or 2. Pass an additional property indicating the location of the .wpp.targets file. I’ll first go over the technique where you place the file directly inside of the directory where the project is. After that I’ll show you how to use this file from a well known location.

One way to do this is to create a .wpp.targets file. This .wpp.targets file will be imported into the build/publish process automatically. This .targets file will enable us to pass in PublishSettingsFile as an MSBuild property. It will then read the .publishsettings file and output the properties needed to execute the publish process.

.wpp.targets in the project directory

Let’s take a look at the .targets file and then we will discuss it’s contents. Below you will find the contents of the full file.

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 
  
  <!--
  When using this file you must supply /p:PublishSettingsFile as a parameter and /p:DeployOnBuild=true
  -->  
  <PropertyGroup Condition=" Exists('$(PublishSettingsFile)')">
    <!-- These must be declared outside of a Target because they impact the Import Project flow -->
    <WebPublishMethod>MSDeploy</WebPublishMethod>
    <DeployTarget>WebPublish</DeployTarget>
  
    <PipelineDependsOn>
      GetPublishPropertiesFromPublishSettings;
      $(PipelineDependsOn);
    </PipelineDependsOn>
  </PropertyGroup>

  <Target Name="GetPublishPropertiesFromPublishSettings" BeforeTargets="Build" Condition=" Exists('$(PublishSettingsFile)')">
    <PropertyGroup>
      <_BaseQuery>/publishData/publishProfile[@publishMethod='MSDeploy'][1]/</_BaseQuery>
      <!-- This value is not in the .publishSettings file and needs to be specified, it can be overridden with a cmd line parameter -->
      <!-- If you are using the Remote Agent then specify this as RemoteAgent -->
      <MSDeployPublishMethod>WMSVC</MSDeployPublishMethod>
    </PropertyGroup>

    <ItemGroup>
      <_MSDeployXPath Include="WebPublishMethod">
        <Query>$(_BaseQuery)@publishMethod</Query>
      </_MSDeployXPath>

      <_MSDeployXPath Include="MSDeployServiceURL">
        <Query>$(_BaseQuery)@publishUrl</Query>
      </_MSDeployXPath>

      <_MSDeployXPath Include="SiteUrlToLaunchAfterPublish">
        <Query>$(_BaseQuery)@destinationAppUrl</Query>
      </_MSDeployXPath>

      <_MSDeployXPath Include="DeployIisAppPath">
        <Query>$(_BaseQuery)@msdeploySite</Query>
      </_MSDeployXPath>

      <_MSDeployXPath Include="UserName">
        <Query>$(_BaseQuery)@userName</Query>
      </_MSDeployXPath>

      <_MSDeployXPath Include="Password">
        <Query>$(_BaseQuery)@userPWD</Query>
      </_MSDeployXPath>
    </ItemGroup>

    <XmlPeek XmlInputPath="$(PublishSettingsFile)"
             Query="%(_MSDeployXPath.Query)"
             Condition=" Exists('$(PublishSettingsFile)')">
      <Output TaskParameter="Result" PropertyName="%(_MSDeployXPath.Identity)"/>
    </XmlPeek>
  </Target>
</Project>

You can place this file in the root of your project (next to the .csproj/.vbproj file) with the name {ProjectName}.wpp.targets.

This .targets file is pretty simple. It defines a couple properties and a single target, GetPublishPropertiesFromPublishSettings. In order to publish your project from the command line you would execute the command below.

msbuild.exe MyProject /p:VisualStudioVersion=11.0 /p:DeployOnBuild=true /p:PublishSettingsFile=<path-to-.publishsettings>

Here is some info on the properties that are being passed in.

The VisualStudioVersion property indicates that we are using the VS 2012 targets. More info on this at http://sedodream.com/2012/08/19/VisualStudioProjectCompatabilityAndVisualStudioVersion.aspx.

DeployOnBuild, when true it indicates that we want to publish the project. This is the same property that you would normally pass in.

PublishSettingsFile, this is a new property which the .targets file recognizes. It should be set to the path of the .publishSettings file.

The properties at the top of the .targets file (WebPublishMethod and DeployTarget) indicate what type of publish operation is happening. The default values for those are MSDeploy and WebPublish respectively. You shouldn’t need to change those, but if you do you can pass them in on the command line.

The GetPublishPropertiesFromPublishSettings target uses the XmlPeek task to read the .publishsettings file. It then emits the properties required for publishing.

OK this is great an all, but it still requires that an additional file (the .wpp.targets file) be placed in the directory of project. It is possible to avoid this as well. Let’s move to that

.wpp.targets from a well known location

If you’d like to avoid having to place the .wpp.targets file in the directory of the project you can easily do this. Place the file in a well known location and then execute the same msbuild.exe call adding an additional property. See the full command below.

msbuild.exe MyProject /p:VisualStudioVersion=11.0 /p:DeployOnBuild=true /p:PublishSettingsFile=<path-to-.publishsettings> /p:WebPublishPipelineCustomizeTargetFile=<path-to.targets-file>

Once you do this you no longer need to create the Publish Profile in VS if you want to publish from the command line with a .publishsettings file.

FYI you can find the complete sample at https://github.com/sayedihashimi/publish-samples/tree/master/PubWithPublishSettings.

Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

Have you ever wanted to use Visual Studio to manage project artifacts but wanted to have a fully custom build process? The recommend way to do this is to build a Custom Visual Studio Project System, but there is a much easier way for lightweight needs. In this post I’ll show you how to take an existing project and “replace” the build process used? For example, wouldn’t it be cool if you could develop a Chrome Extension with VS? When you do a build it would be great to generate the .zip file to for the Chrome Gallery in the output folder. Doing this is way easier than you might think.

Before I go over the steps to do this let me explain the “contract” between Visual Studio and MSBuild. The primary interactions around build in Visual Studio include the following actions in VS. Including what VS does when the action is invoked.

• Build – VS invokes the DefaultTarget for the project file
• Rebuild – VS invokes the “Rebuild” target
• Clean – VS invokes the “Clean” target

For more details you can read Visual Studio Integration (MSBuild). The easiest way to completely customize the VS build process is to do the following:

1. Create the correct project based on the artifacts you plan on using (i.e. if you’re going to be editing .js files then create a web project)
2. Edit the project file to not import any of the .targets files
3. Define the following targets; Build, Rebuild and Clean

After that when you invoke the actions inside of VS the correct action will be executed in your project.

Let’s look at a concrete example. I’ve been working on a Chrome extension with Mads Kristensen the past few days. The entire project is available on github at https://github.com/ligershark/BestPracticesChromeExtension. When it came time to try out the extension or to publish it to the Chrome store we’d have to manually create it, which was annoying. We were using a standard web project to begin with. Here is how we made the workflow simple. Edited the project file to disable the Import statements. See below.

<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" 
    Condition="false" />
<Import Project="$(VSToolsPath)\WebApplications\Microsoft.WebApplication.targets" 
    Condition="false and '$(VSToolsPath)' != ''" />
<Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v10.0\WebApplications\Microsoft.WebApplication.targets" 
    Condition="false" />

For each of these targets I added/updated the condition to ensure that the .targets file would never be loaded. The reason why I did not simply remove these is because in some cases VS may get confused and try to “upgrade” the project and re-insert the Import statements.

After that I added the following statements to the .csproj file.

  <PropertyGroup>
    <LigerShareChromeTargetsPath>$(BuildFolder)\ligersharek.chrome.targets</LigerShareChromeTargetsPath>
  </PropertyGroup>
  <Import Project="$(LigerShareChromeTargetsPath)" Condition="Exists($(LigerShareChromeTargetsPath))" />

Here I defined a new property to point to a custom .targets file and a corresponding Import statement. Now let’s take a look at the ligershark.chrome.targets file in its entirety.

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <UseHostCompilerIfAvailable>false</UseHostCompilerIfAvailable>
  </PropertyGroup>
  <ItemDefinitionGroup>
    <AppFileNameItem>
      <Visible>false</Visible>
    </AppFileNameItem>
    <AppFolderItem>
      <Visible>false</Visible>
    </AppFolderItem>
  </ItemDefinitionGroup>
  
  <UsingTask AssemblyFile="$(BuildLib)MSBuild.ExtensionPack.dll" TaskName="MSBuild.ExtensionPack.Compression.Zip" />
  
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" />
    
    <ItemGroup>
      <_AppCandidateFilesToZip Remove="@(_AppCandidateFilesToZip)" />
      <_AppCandidateFilesToZip Include="@(Content);@(None)" />
    </ItemGroup>
    
    <FindUnderPath Path="$(AppFolder)" Files="@(_AppCandidateFilesToZip)">
      <Output TaskParameter="InPath" ItemName="_AppFilesToZip" />
    </FindUnderPath>
    <Message Text="App files to zip: @(_AppFilesToZip->'%(RelativeDir)%(Filename)%(Extension)')" />

    <PropertyGroup>
      <_AppFolderFullPath>%(AppFolderItem.FullPath)</_AppFolderFullPath>
    </PropertyGroup>

    <Message Text="Creating package .zip at [%(AppFileNameItem.FullPath)]" Importance="high" />
    <MSBuild.ExtensionPack.Compression.Zip 
      TaskAction="Create" 
      CompressFiles="@(_AppFilesToZip)" 
      ZipFileName="%(AppFileNameItem.FullPath)" 
      RemoveRoot="$(_AppFolderFullPath)" 
      CompressionLevel="BestCompression" />
  </Target>
  
  <PropertyGroup>
    <RebuildDependsOn>
      Clean;
      Build;
    </RebuildDependsOn>
  </PropertyGroup>
  <Target Name="Rebuild" DependsOnTargets="$(RebuildDependsOn)" />
  <Target Name="Clean">
    <!-- delete all the files in the output folder -->
    <ItemGroup>
      <_FilesToDelete Remove="@(_FilesToDelete)" />
      <_FilesToDelete Include="$(OutputPath)**\*" />
    </ItemGroup>
    <Message Text="Deleting files: @(_FilesToDelete)" />
    <Delete Files="@(_FilesToDelete)" />
  </Target>
</Project>

As you can see I defined the following targets; Build, Rebuild, and Clean. This is what we discussed earlier as the requirements. Now when I click the Build button in VS a .zip file containing the Chrome Extension is created in the bin\ folder. Additionally no other step (i.e. any typical build step) is performed here. The only thing happening is what is defined in the Build target here. Similarly when I Rebuild or Clean the Rebuild or Clean target is invoked respectively. This is  a pretty neat way to modify an existing project to completely replace the build process to suit your needs.

There are a few things in the .targets file that I’d like to point out.

UseHostCompilerIfAvailable

In the .targets file I have set the property declaration <UseHostCompilerIfAvailable>false</UseHostCompilerIfAvailable>. When you are working with a project in Visual Studio there is a compiler, the host compiler, that Visual Studio has which can be used. For performance reasons in most cases this compiler is used. In this case since we do not want any standard build actions to be executed this performance trick is undesired. You can easily disable this by setting this property to false.

After this MSBuild will always be invoked when performing any build related action.

Visible metadata for Item Lists

When using MSBuild you typically represent files as values within an item list. One issue that you may encounter when modifying a project which will be loaded in VS is that the files inside of those item lists will show up in Visual Studio. If you want to disable this for a particular value in an item list you can add the well known metadata <Visible>false</Visible>. For example you could have the following.

<ItemGroup>
    <IntermediateFile Include="cache.temp">
        <Visible>false</Visible>
    </IntermediateFile>
</ItemGroup>

If you don’t want to add this to every value in the item list then you can set the default value using an ItemDefinitionGroup.  For example take a look at the elements below.

<ItemDefinitionGroup>
  <AppFileNameItem>
    <Visible>false</Visible>
  </AppFileNameItem>

  <AppFolderItem>
    <Visible>false</Visible>
  </AppFolderItem>
</ItemDefinitionGroup>

After this declaration is processed if the Visible metadata is accessed for AppFileNameItem or AppFolderItem on a value which does not declare Visible, then false is returned.

The rest of the content of the .targets file is pretty straightforward. This post shows a basic example of how you can take an existing Visual Studio project and completely replace the build process.

This project is open source at https://github.com/ligershark/BestPracticesChromeExtension.

Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

Lately I’ve been working with Mads Kristensen on a cool new Visual Studio Extension, Farticus, and wanted to share with you guys one of the things that I learned.

When you are developing Visual Studio extension on of the things you should keep in mind is the download size of the extension. This is the size of the .vsix file which you upload to the gallery. If the download size is too large typically people may get impatient and cancel the install. Because of this it’s a good idea to try and get your .vsix to the smallest size possible.

The good news here is that the .vsix file is already compressed. It’s actually a .zip file renamed to .vsix. If you want to see what’s in a .vsix just rename it to .zip and extract it out. The bad news is that the CreateZipPackage task used by the Microsoft.VsSdk.targets file does not perform the best compression. Fortunately there are tasks to create Zip files that we can use. I have chosen to use the Zip task from the MSBuild Extension Pack.

Before I go over all the details let’s take a look at what the final result will be after we compress with the MSBuild Extension Pack. See the table below for the comparison for two different projects.

From the table above we can see that we can gain a significant amount of additional compression by using the MSBuild extension pack.

Below is the content that I pated into the .csproj file. I’ll paste it in it’s entirety and then explain.

<PropertyGroup>
  <EnableCompressVsix Condition=" '$(EnableCompressVsix)'=='' ">true</EnableCompressVsix>
  <BuildLib Condition=" '$(BuildLib)'=='' ">$(MSBuildProjectDirectory)\..\Build\Lib\</BuildLib>

</PropertyGroup>
<UsingTask AssemblyFile="$(BuildLib)MSBuild.ExtensionPack.dll" TaskName="MSBuild.ExtensionPack.Compression.Zip"/>

<Target Name="CompressVsix" 
        AfterTargets="CreateVsixContainer" 
        DependsOnTargets="PrepareReplceVsixTemp" 
        Condition=" '$(EnableCompressVsix)'=='true' ">
    
  <!-- copy the file to the obj folder and then party on it -->
  <MakeDir Directories="$(_TmpVsixDir);$(_TmpVsixDir)\Extracted\"/>

  <Copy SourceFiles="$(TargetVsixContainer)"
        DestinationFolder="$(_TmpVsixDir)">
    <Output TaskParameter="CopiedFiles" ItemName="_TmpVsixCopy"/>
  </Copy>
    
  <!-- extract out the .zip file -->
  <MSBuild.ExtensionPack.Compression.Zip 
    TaskAction="Extract" 
    ExtractPath="$(_TmpVsixDir)Extracted\" 
    ZipFileName="@(_TmpVsixCopy->'%(FullPath)')"/>

  <ItemGroup>
    <_FilesToZip Remove="@(_FilesToZip)"/>
    <_FilesToZip Include="$(_TmpVsixDir)Extracted\**\*"/>
  </ItemGroup>

  <MSBuild.ExtensionPack.Compression.Zip
    TaskAction="Create"
    CompressFiles="@(_FilesToZip)"
    ZipFileName="%(_TmpVsixCopy.FullPath)"
    RemoveRoot="$(_TmpVsixDir)Extracted\"
    CompressionLevel="BestCompression" />

  <Delete Files ="$(TargetVsixContainer)"/>
  <Copy SourceFiles="%(_TmpVsixCopy.FullPath)" DestinationFiles="$(TargetVsixContainer)" />
</Target>

<Target Name="PrepareReplceVsixTemp" DependsOnTargets="CreateVsixContainer">
  <ItemGroup>
    <_VsixItem Remove="@(_VsixItem)"/>
    <_VsixItem Include="$(TargetVsixContainer)" />

    <_TmpVsixPathItem Include="$(IntermediateOutputPath)VsixTemp\%(_VsixItem.Filename)%(_VsixItem.Extension)"/>
  </ItemGroup>
    
  <PropertyGroup>
    <_TmpVsixDir>%(_TmpVsixPathItem.RootDir)%(_TmpVsixPathItem.Directory)</_TmpVsixDir>
  </PropertyGroup>

  <RemoveDir Directories="$(_TmpVsixDir)"/>  
</Target>  

The snippet above perform the following actions.

1. Remove the old VsixTemp folder from any previous build if it exists
2. Copy the source .vsix to the intermediate output path (i.e. obj\debug or obj\release)
3. Extract out the contents to a folder
4. Re-zip the file using MSBuild extension pack
5. Replace the output .vsix with the compressed one

When building now the .vsix in the output folder should be smaller than it was before.

In my case I have copied the necessary assemblies from the MSBuild Extension pack and placed them in the projects repository. For the Zip task you’ll need the following files.

• MSBuild.ExtensionPack.dll
• Ionic.Zip.DLL

In my case I’ve placed them in a folder named Build\lib\.

You should be able to copy/paste what I have here into your VSIX projects. You’ll need to update the path to the MSBuild extension pack assemblies if you put them in a different location. Note: I’ve only tested this with Visual Studio 2012.

The MSBuild elements used here is pretty straight forward. If you have any questions on this let me know.

You can find the source for the Farticus project at https://github.com/ligershark/Farticus/. Please send us a Pull (my finger) Request.

Thanks,
Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

I’m happy to say that my Supplement to Inside the Microsoft Build Engine book (co-author William Bartholomew) has now been published. In fact it’s already in stock and ready to be shipped by Amazon.com.

This book is a small addition (118 pages) to the previous book, Inside the Microsoft Build Engine 2nd edition. It has a small price too, MSRP is $12.99 but it’s selling on Amazon.com for $8.99! In this book we cover the updates to MSBuild, Team Build and Web Publishing in Visual Studio 2012. The foreword was written by Scott Hanselman, and you can read the entire foreword online.

Check out how thin the supplement is in comparison to the 2^nd edition #ThinIsIn.

If you already own the 2^nd edition then you’ll love this update.

Table of Contents

Chapter 1: What's new in MSBuild

1. Visual Studio project compatibility between 2010 and 2012
2. Out of Process Tasks
3. NuGet
4. XML Updates with SlowCheetah
5. Cookbook

Chapter 2: What's new in Team Build 2012

1. Installation
2. Team Foundation Service
3. User interface (UI) enhancements
4. Visual Studio Test Runner
5. Pausing build definitions
6. Batching
7. Logging
8. Windows Workflow Foundation 4.5
9. Cookbook

Chapter 3: What's new in Web Publishing

1. Overview of the new Publish Web Dialog
2. Building web packages
3. Publish profiles
4. Database publishing support
5. Profile-specific web.config transforms
6. Cookbook

The book has been available in e-book form for a few weeks. Just long enough for us to get our first review. It was 5 stars :).

Please let us know what you think of this book!

You can download all the samples and learn more at msbuildbook.com.

Sayed Ibrahim Hashimi | http://msbuildbook.com | @SayedIHashimi

OK seriously this is not really my first date with Comcast as I’ve been a long time customer, but it was the initial setup for a new account. While visiting my family in Florida, I decided to upgrade the internet at my parents house. They were using another ISP and the connection was very slow. This post is a story of the experience that I had after that.

Before I get into all the details of what really upsets me, let me say that when the Comcast technician left my house I would have given the setup 3 stars out of five. The reasons why I would give the 3 star rating are below. The issues here are pretty minor, I never would have blogged/tweeted about these issues as I encounter these types of things everyday.

The tech wore his shoes while going in and out of the house

At this house we, like many other foreigners, take our shoes of either outside or at the entrance. The Comcast tech did not have the respect to even ask if we cared to have shoes removed or not. He freely went in and out with his shoes on. I didn’t care enough to mention anything to him, but I did take notice of this. I know that several other companies have their techs/reps wear “booties” to ensure that there is no dirt tracked into the house. I’ve also had others simply take their shoes off after asking. Comcast should care more about the wishes of their customers to ask what the policy is at the given house.

The tech moved furniture to install the modem but never moved it back

While the tech was here, there was a dresser which was blocking the outlet. When he was installing the modem he moved the dresser and did the work necessary. When he left he didn’t care to move the dresser back. He also did not ask me if I would like to have him move the dresser back.

I found this to be extremely rude. If you go to a job and move something, it needs to be moved back to its original location before you leave. Even with this I didn’t say anything because I knew that I could simply move the item back to its original location. This is concerning for the older Comcast customers though. I know if it had been my mom or dad here alone they would have had significant issues getting that piece of furniture back in it’s original location. I am hoping that the tech which visited my home would have taken the age of my parents into consideration and moved the item back before leaving.

The tech disabled my wireless and never re-enabled it

While troubleshooting the cable modem, the tech disabled my wireless adapter on my computer. When he returned my computer to me, he had not re-enabled it. Once again, not a big deal for me as I can re-enable it quicker then I could complain to him about it. The bigger issue goes back to what if it was my parents here? If the tech disabled wireless on my dad’s notebook and returned it to him, my dad would be calling me telling me how his computer was hosed. Not a phone call I like to receive.

Comcast, please if you mess with someone’s settings have the decency to revert them back to the original settings.

For these reasons I would have given the experience 3 stars out of 5. Sure the tech did a few things to piss me off, but in the end they were small insignificant issues for me. I totally understand that for others this may not be the case, and those are the customers which Comcast needs to be more careful with.

Comcast is victimizing non-tech folks by hijacking their machines

After the tech left the house, I got back on my notebook and discovered a few really shocking things. This was the same computer the tech was using to configure the modem. I immediately took notice that there were three new shortcuts on my desktop for Xfinity. I inspected them and they looked like they were just internet shortcuts. I simply deleted them. Comcast, its my desktop not yours. Don’t litter my desktop.

After that I started up Chrome and immediately was taken to some Xfinity page. WTF, really you changed my default homepageto Xfinity? I understand you are trying to get some extra traffic to your site, but this is completely unacceptable. To top it off it was not only Chrome, it was all the browsers which I had installed on my machine. This was incredibly frustrating. Once again, what if this was my parents (or your parents perhaps)? My dad’s homepage is configured to take him to BBC Persian newspaper. My dad couldn’t figure out how to do that initially, how is he supposed to fix it after the tech left? Comcast, do you think this is OK? How would have your parents felt after this?

After further investigation, I also discovered that the search provider for my browser was changed to Xfinity. OMG this is ridiculous, what the hell else has been updated? Comcast, these are my settings on my machine. These are personal and you have no right to change these, especially with out any type of consent.

Here is the result after opening Firefox.

Wow, you’ve got some balls to set 4 different home pages on my browser. I do agree that this is a wonderful way to drive traffic to your site. Especially for those customers who do not know how to change these.

Also take a look in the image to see what happened to my favorites.

I don’t use favorites that much as you can see, but there are now 8 Xfinity related favorites here. OK seriously, this getting out of hand. These are not your favorites they are mine. Do you not understand the concept that these do not belong to you?

I looked to see if there was an Xfinity/Comcast installer in Add Remove programs but there wasn’t. Comcast doesn’t even have the decency to provide a way for users to undo all the damage that they have caused without asking me. Comcast, this is the worst first date ever!

The biggest issue that I have with this is the fact that I was never given an opportunity to opt out of this. And at this point I’m not even sure if I’ve successfully reverted back to the previous state.

I’m not the only one who cares about this

Immediately as I discovered these issues I tweeted about it. What else was I supposed to do?!

Below are some responses from those in my twitter network.

After a bit of searching around I also found many others who were similarly upset with these actions. Below are a few of the better ones.

Remember when I mentioned my parents, and that they would be lost in correcting these actions. Look at these people on the Firefox forums crying for help.

This could be my mom or dad, or yours. Do the Comcast execs making these decisions all have tech savvy parents that would never run into this? I find that hard to believe. You can find some other links I put together here.

Wow, its very clear that these customers do not want the homepage(s) that were set for them. I feel sorry for these guys, they sign up for a service and all of a sudden things change and they feel helpless. These are not the only two instances of this. Comcast, your customers are speaking why are you not listening?

What’s next?

At this point you might be wondering what I’m going to do about this? Am I going to cancel the account I setup for my parents? Cancel my own account in Seattle? Call to get my money back? I’m not going to be doing any of that. Since I’ll only be in Florida for this week it would be difficult to get another ISP hooked up here. More importantly I don’t hate Comcast, most of the time I don’t mind them. I’ve had their service for years  and this won’t change that.

My goals here are not to get money back (although I did have to pay $50 for this “service”) or anything like that. What I’d like is for Comcast to change their policies when setting up internet/cable services for new customers. Comcast, you must respect peoples property (both digitally and physically) more than you do today. This behavior is unacceptable and it should not continue. Minimally people need to be informed when a technician is making changes to ones machine, and have the ability to opt out of it. There should also be a mechanism for a clean rollback. I trusted your tech and did not watch over him. I know better for next time. When installing malicious software on a machine to set the home page(s) it’s clear that you are acting in Comcast’s best interest. You need to start putting customers first.

I’m especially concerned with elderly clients. If my parents had received the same treatment that I did, they would not be in a good spot. My dad’s homepage would have been changed from BBC Persian to Xfinty, his wireless would have been disabled, his dresser would have been displaced, his favorites cramped, his desktop cluttered and he would have been performing internet with Xfinity. Because of that I’ll be sharing this letter with the following.

1. As many Comcast execs that I can find on twitter/email – I have personally witnessed how impactful it is for a customer to email a VP, now its time for me to use that technique
2. Better Business Bureau – these types of business practices are not OK, they need to stop
3. Federal Trade Commission – they are an advocate for the consumer, hopefully others have informed them of this previously
4. AARP – the older community needs to be informed and protected here

If there are any Comcast guys out there you can reach me at sayed.hashimi@gmail.com or on twitter.

Sayed Ibrahim Hashimi | @SayedIHashimi | http://msbuildbook.com/

Today on twitter @nunofcosta asked me roughly the question “How do I publish one web project from a solution that contains many?”

The issue that he is running into is that he is building from the command line and passing the following properties to msbuild.exe.

    /p:DeployOnBuild=true
    /p:PublishProfile='siteone - Web Deploy'
    /p:Password=%password%

You can read more about how to automate publishing at http://sedodream.com/2013/01/06/CommandLineWebProjectPublishing.aspx.

When you pass these properties to msbuild.exe they are known as global properties. These properties are difficult to override and are passed to every project that is built. Because of this if you have a solution with multiple web projects, when each web project is built it is passed in the same set of properties. Because of this when each project is built the publish process for that project will start and it will expect to find a file named siteone – Web Deploy.pubxml in the folder Properties\PublishProfiles\. If the file doesn’t exist the operation may fail.

Note: If you are interested in using this technique for an orchestrated publish see my comments at http://stackoverflow.com/a/14231729/105999 before doing so.

So how can we resolve this?

Let’s take a look at a sample (see links below). I have a solution, PublishOnlyOne, with the following projects.

1. ProjA
2. ProjB

ProjA has a publish profile named ‘siteone – Web Deploy’, ProjB does not. When trying to publish this you may try the following command line.

    msbuild.exe PublishOnlyOne.sln /p:DeployOnBuild=true /p:PublishProfile=’siteone – Web Deploy’ /p:Password=%password%

See publish-sln.cmd in the samples.

If you do this, when its time for ProjB to build it will fail because there’s no siteone – Web Deploy profile for that project. Because of this, we cannot pass DeployOnBuild. Instead here is what we need to do.

1. Edit ProjA.csproj to define another property which will conditionally set DeployOnBuild
2. From the command line pass in that property

I edited ProjA and added the following property group before the Import statements in the .csproj file.

<PropertyGroup>
  <DeployOnBuild Condition=" '$(DeployProjA)'!='' ">$(DeployProjA)</DeployOnBuild>
</PropertyGroup>

Here you can see that DeployOnBuild is set to whatever value DeployProjA is as long as it’s not empty. Now the revised command is:

    msbuild.exe PublishOnlyOne.sln /p:DeployProjA=true /p:PublishProfile=’siteone – Web Deploy’ /p:Password=%password%

Here instead of passing DeployOnBuild, I pass in DeployProjA which will then set DeployOnBuild. Since DeployOnBuild wasn’t passed to ProjB it will not attempt to publish.

You can find the complete sample at https://github.com/sayedihashimi/sayed-samples/tree/master/PublishOnlyOne.

Sayed Ibrahim Hashimi | @SayedIHashimi | http://msbuildbook.com/

On twitter @vishcious asked me a question related to publishing. The question was

Note: If you are publishing from VS and don’t care about packaging then you can use profile specific transforms as a simpler way to achieve this result. The rest of the post here assumes you specifically want MSDeploy parameters. To learn more about profile specific transforms see my short video at http://www.youtube.com/watch?v=HdPK8mxpKEI

If you are not familiar you can create custom MSDeploy parameters when you publish/package your application by creating an XML file named parameters.xml in the root of the project. A good resource on this is Vishal’s blog post. I have  created a sample (links below) which demonstrates how to accomplish what the task. Below are the project artifacts that I’ve created to setup the parameters.

web.config

<?xml version="1.0"?>
<configuration>
  <appSettings>
    <add key="email" value="default@example.com"/>
    <add key="url" value="example.com"/>
  </appSettings>
</configuration>

Parameters.xml

<?xml version="1.0" encoding="utf-8" ?>
<parameters >

  <parameter name="email" description="description">
    <parameterEntry kind="XmlFile" 
                    scope="\\web.config$" 
                    match="/configuration/appSettings/add[@key='email']/@value" />
  </parameter>

  <parameter name="url" description="description">
    <parameterEntry kind="XmlFile" 
                    scope="\\web.config$" 
                    match="/configuration/appSettings/add[@key='url']/@value" />
  </parameter>

</parameters>

In the parameters.xml file I have defined two new MSDeploy parameters., email and url. This file should be placed in the root of the project directory and it will automatically be picked up by the web publish process. If you are familiar with this you may have noticed that I have left off the DefaultValue attribute here. More to come on that later. Now that we have our parameters defined let’s see what customizations need to be made to the publish profiles (.pubxml files).

You can override the values by populating the MsDeployDeclareParameters item list. Let’s see how to do that. When you create a publish profile in Visual Studio a .pubxml file is written to the folder Properties\PublishProfiles. These are MSBuild files and they are consumed during the build+publish operation. You can customize these files in order to fine tune the publish process. In my sample project I have two publish profiles created; siteone and sitetwo. Both of these are web profiles pointing to Azure Web Sites. In the publish profiles with the samples you will find two sets of elements; properties for publishing and  my parameter customizations. You can see the content of these profiles below, I’ve left off the MSDeploy settings for brevity. Those profiles are shown below.

siteone.pubxml

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <!-- Web deploy settings here -->  

  <ItemGroup>
    <MsDeployDeclareParameters Include="email">
      <DefaultValue>one@email.com</DefaultValue>
    </MsDeployDeclareParameters>
    <MsDeployDeclareParameters Include="url">
      <DefaultValue>http://one.example.com/</DefaultValue>
    </MsDeployDeclareParameters>
  </ItemGroup>
</Project>

sitetwo.pubxml

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!-- Web Deploy settings here -->

  <ItemGroup>
    <MsDeployDeclareParameters Include="email">
      <DefaultValue>two@email.com</DefaultValue>
    </MsDeployDeclareParameters>
    <MsDeployDeclareParameters Include="url">
      <DefaultValue>http://two.example.com/</DefaultValue>
    </MsDeployDeclareParameters>
  </ItemGroup>
</Project>

In these profiles you can see that I’ve  added a usage of MSDeployDeclareParameters for both parameters in parameters.xml. In each case the value for the Include attribute is the name of the parameter (matches the name attribute in parameters.xml). Along with that I’ve declared a value for the DefaultValue metadata. This will contain the value of the parameter when it is published using that profile.

After publishing siteone the values for the app settings are below.

• email = one@email.com
• url = http://one.example.com/

When publishing with sitetwo the values

• email = two@email.com
• url = http://two.example.com/

That’s it. Now let’s move on to the comment I made previously regarding the DefaultValue attribute that I left off of the parameters.xml file.

DefaultValue

When you create parameters and set their values there are a few different places that these can come from including; parameters.xml, auto generated from con strings and custom declared parameters in MSBuild. Because of this the Web Publishing Pipeline has a mechanism to prioritize parameters when there are duplicates. This is facilitated by a Priority metadata value on the MSDeployDeclareParameters item list. If you want to Declare a DefaultValue inside of the parameters.xml file you can do that, but you have to be aware of the impact of that. When you add a DefaultValue parameter in parameters.xml by default those values will take precedence over the items in MSDeployDeclareParameters. Because of that you’ll have to add a Priority value. The way the Priority works is that the item with the lowest priority value for a given parameter will win. The default priority value for params from parameters.xml is –50 (defined in Microsoft.Web.Publishing.targets). Because of that we have to add priority less than –50. For example.

<ItemGroup>
  <MsDeployDeclareParameters Include="email">
    <DefaultValue>two@email.com</DefaultValue>
    <Priority>-100</Priority>
  </MsDeployDeclareParameters>
  <MsDeployDeclareParameters Include="url">
    <DefaultValue>http://two.example.com/</DefaultValue>
    <Priority>-100</Priority>
  </MsDeployDeclareParameters>
</ItemGroup>

In this case when I publish these values will override the default value from the parameters.xml.

You can see the latest version of this at https://github.com/sayedihashimi/publish-samples/tree/master/AppSettingsPerProfile.

Sayed Ibrahim Hashimi | @SayedIHashimi | http://msbuldbook.com

Earlier today Scott Guthrie blogged about the release of ASP.NET 2012.2 and Web Tools 2012.2. Between this release and the previous publish update in October we have added some really cool publishing features. Today I created some videos of my favorite features. Take a look below.

Quick Publishing

In this video I will show some productivity enhancements that we’ve made to publish that you are going to absolutely love!

New publish support for web site project

Do you use web site projects in Visual Studio? The video below shows how we have unified the publish support for both web application project and web site project.

Updates regarding web.config transforms

We have added some really cool features related to web.config transforms. To be more specific; profile specific transforms and transform previewing. See the video below for more details.

I hope you guys like these features as much as I do. Please let me know what you think.

Sayed Ibrahim Hashimi | @SayedIHashimi | http://msbuildbook.com/