class Fruit {}
class Banana : Fruit {}

[Test]
public void CanAssignBananaToFruit()
{
 var fruit = typeof (Fruit);
 var banana = typeof (Banana);
 Assert.IsTrue(fruit.IsAssignableFrom(banana));
}

[Test]
public void CanNotAssignFruitToBanana()
{
 var fruit = typeof(Fruit);
 var banana = typeof(Banana);
 Assert.IsFalse(banana.IsAssignableFrom(fruit));
}

I really hate this API because it always seems backward to me. Here is how i really want to use it:

Assert.IsTrue(banana.CanBeAssignedTo(fruit));
Assert.IsFalse(fruit.CanBeAssignedTo(banana));

With the aid of an extension method we can easily achieve this:

public static bool CanBeAssignedTo(this Type sourceType, Type destinationType)
{
 return destinationType.IsAssignableFrom(sourceType);
}

class Program
{
 [STAThread]
 static void Main()
 {
  var itunes = new iTunesApp();
  itunes.DeleteTracksThatDoNotExist();
 }
}

public static class ITunesExtensions
{
 public static void DeleteTracksThatDoNotExist(this IiTunes itunes)
 {
  var tracksThatDoNotExist = FindTracksThatDoNotExist(itunes);
  foreach (var track in tracksThatDoNotExist) track.Delete();
 }

 public static IEnumerable<IITFileOrCDTrack> FindTracksThatDoNotExist(this IiTunes iTunes)
 {
  return iTunes.LibraryPlaylist.Tracks
   .OfType<IITFileOrCDTrack>()
   .Where(track => !File.Exists(track.Location));
 }
}

foreach (UIElement child in LinksStackPanel.Children)
{
 var hb = child as HyperlinkButton;
 if (hb != null && hb.NavigateUri != null)
 { .. }
}

Resharper proposed to write this as following:

foreach (var hb in LinksStackPanel.Children
 .Select(child => child as HyperlinkButton)
 .Where(hb => hb != null && hb.NavigateUri != null)) 
{ .. }

Here is what i wrote instead:

foreach (var hb in LinksStackPanel.Children
 .OfType<HyperlinkButton>()
 .Where(hb => hb.NavigateUri != null)) 
{ .. }

Anway, in order to avoid such a situation you could organize your solution in such a way that all the dependencies (libraries and tools) are part of it. A typical folder structure would look like this:

In order to get those files out of the installer and in your solution (instead of installed under %Program Files%) you could do an administrative install of the msi (eg: msiexec /a Blah.msi) but i find it easier to use Qwerty.Msi.

Here are a couple of settings you may want to add to your build configuration in order to make your self-contained build work:

<!-- Configure solution directories -->
<BasePath Condition="'$(BasePath)'==''">$(MSBuildThisFileDirectory)..</BasePath>
<BuildPath>$(BasePath)\build</BuildPath>
<SourcePath>$(BasePath)\src</SourcePath>
<ToolsPath>$(BasePath)\tools</ToolsPath>
		
<!-- Configure tool directories -->
<!-- the ending \ is required for the extension pack -->
<ExtensionTasksPath>$(ToolsPath)\MSBuild.ExtensionPack\</ExtensionTasksPath>
<MSBuildCommunityTasksPath>$(ToolsPath)\MSBuildCommunityTasks</MSBuildCommunityTasksPath>	
<ILMergeToolPath>$(ToolsPath)\ILMerge</ILMergeToolPath>
<SvnToolPath>$(ToolsPath)\Subversion\bin</SvnToolPath>	
<!-- wix will use this property to determine the location of other files -->
<WixToolPath>$(ToolsPath)\Wix</WixToolPath>
		
<!-- Configure target file paths -->
<CommonTargetsPath>$(BuildPath)\common.targets</CommonTargetsPath>
<MSBuildCommunityTasksTargetsPath>$(MSBuildCommunityTasksPath)\MSBuild.Community.Tasks.Targets</MSBuildCommunityTasksTargetsPath>
<ExtensionPackTargetsPath>$(ExtensionTasksPath)MSBuild.ExtensionPack.tasks</ExtensionPackTargetsPath>

<!-- Configure WIX -->
<WixTargetsPath>$(WixToolPath)\Wix.targets</WixTargetsPath>
<WixTasksPath>$(WixToolPath)\WixTasks.dll</WixTasksPath>
<WixTargetsPath>$(WixToolPath)\Wix.targets</WixTargetsPath>
<WixTasksPath>$(WixToolPath)\WixTasks.dll</WixTasksPath>
<LuxTargetsPath>$(WixToolPath)\Lux.targets</LuxTargetsPath>
<LuxTasksPath>$(WixToolPath)\LuxTasks.dll</LuxTasksPath>
<LuxTargetsPath>$(WixToolPath)\Lux.targets</LuxTargetsPath>
<LuxTasksPath>$(WixToolPath)\LuxTasks.dll</LuxTasksPath>

With this solution in place the next ‘new guy’ does not have to waste time trying to figure out where those dependencies are

<!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Other similar extension points exist, see Microsoft.Common.targets. -->
<Import Project="$(MSBuildProjectDirectory)\config.msbuild" />
<Target Name="BeforeBuild">
 <CallTarget Targets="GenerateConfigurationFiles" />
</Target>

And each of these config.msbuild files looked as following:

<TemplateFile Template="web.template.config" OutputFileName="web.config" Tokens="@(TemplateTokens)" />
<TemplateFile Template="Config\WcfClients.config" OutputFileName="Config\WcfClients.config" Tokens="@(TemplateTokens)" />
</Target>

As you can notice the convention here is that each template file has ‘.template.’ in it’s name, and the name of an output file is the template file name without ‘.template.’.

 <!-- valide input -->
 <Error Condition="'$(SourceFile)'==''" Text="Missing SourceFile" />
 <!-- calculate destination file -->
 <RegexReplace Input="$(SourceFile)" Expression="(\.template)\." Replacement="." Count="1">
  <Output TaskParameter="Output" PropertyName="DestinationFile" />
 </RegexReplace>
 <!-- generate file -->
 <TemplateFile Template="$(SourceFile)" OutputFileName="$(DestinationFile)" Tokens="@(TemplateTokens)" />
</Target>

Now that we can do it for one file, we can do it for many files too:

 <!-- valide input -->
 <Error Condition="'$(SourceDir)'==''" Text="Missing SourceDir" />
 <!-- find all template files -->
 <ItemGroup>
  <TemplateFiles Include="$(SourceDir)\**\*.template.*" Exlude="$(SourceDir)\**\*.svn*" />
 </ItemGroup>
 <!-- process each template file -->
 <MSBuild Projects="$(MSBuildProjectFile)" Targets="ProcessTemplate" Properties="SourceFile=%(TemplateFiles.FullPath)" />
</Target>

After these core improvements we wrote a common.proj.targets file as following:

 <!-- import global variables -->
 <Import Project="$(MSBuildThisFileDirectory)\configuration.proj" />

 <PropertyGroup>
  <BuildDependsOn>CommonBeforeBuild;$(BuildDependsOn);CommonAfterBuild</BuildDependsOn>
 </PropertyGroup>

 <Target Name="CommonBeforeBuild">
  <MSBuild Projects="$(CommonTargetsPath)" Targets="ProcessTemplates" Properties="SourceDir=$(MSBuildProjectDirectory)" />
 </Target>

 <Target Name="CommonAfterBuild">
  <!--<MSBuild Projects="$(CommonBuildTargetsPath)" Targets="PEVerify" Properties="SourceFile=$(TargetPath)" />-->
 </Target>
</Project>

Now we only need to import our common.proj.targets file in projects that have template files and focus on real business problems

The following attempts did not work:

// A method can not have both WebGet and WebInvoke attributes
[OperationContract]
[WebGet]
[WebInvoke(Method="HEAD")]
public Stream Download(string token) { }

// A method can not have multiple WebInvoke attributes
[OperationContract]
[WebInvoke(Method="GET")]
[WebInvoke("HEAD")]
public Stream Download(string token) { }

The trick is to use * as Method and handle the method related logic in your code:

[OperationContract]
[WebInvoke(Method="*")]
public Stream Download(string token) 
{
 var method = WebOperationContext.Current.IncomingRequest.Method;
 if (method == "HEAD") return ProcessHead();
 if (method == "GET") return ProcessGet();
 throw new ArgumentException(method + " is not supported.");   
}

foreach (var name in Enum.GetNames(typeof(Environment.SpecialFolder)))
{
 var specialFolder = (Environment.SpecialFolder)Enum.Parse(typeof(Environment.SpecialFolder), name);
 Console.WriteLine("{0,25} => {1}", name, Environment.GetFolderPath(specialFolder));
}

public static class IsolatedStorageFileExtensions
{
 public static string GetRootDirectory(this IsolatedStorageFile isf)
 {
  var property = isf.GetType().GetProperty("RootDirectory", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.GetProperty);
  return (string)property.GetValue(isf, null);
 }
}

Here is a real world example of using SharpBITS.NET to download a file to IsolatedStorage:

class Program
{
 static void Main()
 {
  var mgr = new BitsManager();
  mgr.OnJobError += mgr_OnJobError;
  mgr.OnJobTransferred += mgr_OnJobTransferred;

  var job = mgr.CreateJob("job@" + DateTime.Now, JobType.Download);
  var src = @"http://localhost/";
  var dst = Path.Combine(GetIsfRoot(), "test.html");
  job.AddFile(src,dst);
  job.Resume();

  Console.WriteLine("running...");
  Console.ReadKey();
 }

 static void mgr_OnJobTransferred(object sender, NotificationEventArgs e)
 {
   e.Job.Complete();
   Console.WriteLine("completed: " + e.Job.DisplayName);
  }

 static void mgr_OnJobError(object sender, ErrorNotificationEventArgs e)
 {
  Console.WriteLine("error: " + e.Error.Description);
 }

 static string GetIsfRoot()
 {
  using (var f = IsolatedStorageFile.GetUserStoreForAssembly())
  {
   return f.GetRootDirectory();
  }
 }
}

interface IMapper<TEntity>
{
 TEntity FromObjectList(List<object> objectList);
 List<object> ToObjectList(TEntity entity);
}

My initial implementation (using EnumerableEx operators from Reactive Extensions) looked like this:

public TEntity FromObjectList(List<object> objectList)
{
 var entity = new TEntity();

 properties
  .Zip(objectList, (property, value) => AssignValueToProperty(entity, property, value))
  .Run();

 return entity;
}

int AssignValueToProperty(object entity, PropertyInfo property, object value)
{
 property.SetValue(entity, value, null);
 return 0;
}

public List<object> ToObjectList(TEntity entity)
{
 return properties
  .Select(property => property.GetValue(entity, null))
  .ToList();
 }

And the consumer code looks like this:

var person = new Person {  Id = 2, Score = 1.3, Name = "Tim", Title = "Sir" };

var personMapper = new Mapper<Person>()
 .Map(x => x.Id)
 .Map(x => x.Score)
 .Map(x => x.Name)
 .Map(x => x.Title);

var data = personMapper.ToObjectList(person);
var clonedPerson = personMapper.FromObjectList(data);

Wait a minute, in most situations we simply want to map all properties on the object. Let’s create a mapper for this:

class AutoMapper<TEntity> : Mapper<TEntity> where TEntity : new()
{
 public AutoMapper()
 {
  typeof(TEntity).GetProperties().Run(property => Map(property));
 }
}

And now we don’t have to waste time doing the same thing over and over again! Because we always need to map all properties of our types we ended up with the following:

public static class Mapper
{
 public static List<Object> ToObjectsList<TEntity>(this TEntity entity)
 {
  return entity.GetType().GetProperties()
   .Select(property => property.GetValue(entity, null))
   .ToList();
  }

 public static TEntity ToEntity<TEntity>(this List<Object> objectsList) where TEntity : new()
 {
  TEntity entity = new TEntity();
  entity.GetType().GetProperties()
   .Zip(objectsList, (property, value) =>{ property.SetValue(entity, value,null); return 0;})
   .Run();
  return entity;
 }
}