switch(obj.GetType()) 
{
case typeof(MyClass1):
// do something with obj
break;
case typeof(MyClass2):
// do something else with obj
break;
default:
throw new NotSupportedException();
}

class Program
{
public class BaseClass
{
}

public class InheritedClass1 : BaseClass
{
}

public class InheritedClass2 : BaseClass
{
}

public class TypeCatchBlockException : Exception
{
public static void Throw(object obj) 
{
doThrow((dynamic)obj);
}

private static void doThrow<T>(T obj)
{
throw new TypeCatchBlockException<T>();
}

/*public static void Throw(object obj)
      {
        var type=obj==null?null:obj.GetType();
        var exceptionTypeName=typeof(TypeCatchBlockException)+"`1";
        Type generic=Type.GetType(exceptionTypeName).MakeGenericType(new[]{type});
        throw (Exception)Activator.CreateInstance(generic);
      }*/
}

public class TypeCatchBlockException<T> : TypeCatchBlockException
{
}

static void Main(string[] args)
{
showObjectType(new InheritedClass2());
showObjectType(new BaseClass());
showObjectType(new InheritedClass1());
showObjectType(new object());
Console.ReadLine();
}

private static void showObjectType(object obj)
{
try
{
TypeCatchBlockException.Throw(obj);
}
catch (TypeCatchBlockException<BaseClass>)
{
Console.WriteLine("BaseClass object");
}
catch (TypeCatchBlockException<InheritedClass1>)
{
Console.WriteLine("InheritedClass1 object");
}
catch (TypeCatchBlockException<InheritedClass2>)
{
Console.WriteLine("InheritedClass2 object");
}
catch (TypeCatchBlockException)
{
Console.WriteLine("Unsupported object");
}
}
}

InheritedClass2 object
BaseClass object
InheritedClass1 object
Unsupported object

/// <summary>
/// Helper for Image objects
/// </summary>
public static class ImageHelper
{
  /// <summary>
  /// Get an image from a byte array
  /// </summary>
  /// <param name="iconBytes"></param>
  /// <returns></returns>
  public static Image GetImageFromBytes(byte[] iconBytes)
  {
    if (iconBytes == null || iconBytes.Length == 0)
      return null;
    using (MemoryStream ms = new MemoryStream(iconBytes))
    {
      try
      {
        return GetImageFromStream(ms);
      }
      catch
      {
        return null;
      }
    }
  }

  /// <summary>
  /// Get an image from a file without locking the file
  /// </summary>
  /// <param name="fileName"></param>
  /// <returns></returns>
  public static Image GetImageFromFile(string fileName)
  {
    try
    {
      using (var stream = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
      {
        return GetImageFromStream(stream);
      }
    }
    catch
    {
      return null;
    }
  }

  /// <summary>
  /// Determines if an image is indexed (with a color palette)
  /// </summary>
  /// <param name="image"></param>
  /// <returns></returns>
  public static bool IsImageIndexed(Image image)
  {
    switch (image.PixelFormat)
    {
      case PixelFormat.Format1bppIndexed:
      case PixelFormat.Format4bppIndexed:
      case PixelFormat.Format8bppIndexed:
      case PixelFormat.Indexed:
        return true;
    }
    return false;
  }

  /// <summary>
  /// Get an image from stream without locking the stream
  /// </summary>
  /// <param name="stream"></param>
  /// <returns></returns>
  public static Image GetImageFromStream(Stream stream)
  {
    try
    {
      using (var image = Image.FromStream(stream))
      {
        var srcBitmap = image as Bitmap;
        var destBitmap = new Bitmap(image.Width, image.Height,image.PixelFormat);
        if (IsImageIndexed(image)&&srcBitmap!=null)
        {
          Rectangle srcArea = new Rectangle(0, 0, image.Width, image.Height);
          BitmapData srcData = srcBitmap.LockBits(srcArea, ImageLockMode.ReadOnly, image.PixelFormat);
          Rectangle destArea = new Rectangle(0, 0, image.Width, image.Height);
          BitmapData destData = destBitmap.LockBits(destArea, ImageLockMode.WriteOnly, image.PixelFormat);

          IntPtr srcPtr = srcData.Scan0;
          IntPtr destPtr = destData.Scan0;
          byte[] buffer = new byte[srcData.Stride*image.Height];
          Marshal.Copy(srcPtr, buffer, 0, buffer.Length);
          Marshal.Copy(buffer, 0, destPtr, buffer.Length);
          srcBitmap.UnlockBits(srcData);
          destBitmap.UnlockBits(destData);
          destBitmap.Palette = srcBitmap.Palette;
        } else
        {
          using (var graphics = Graphics.FromImage(destBitmap))
          {
            graphics.DrawImage(image, 0, 0);
          }
        }
        return destBitmap;
      }
    }
    catch
    {
      return null;
    }
  }
}

var trs=document.getElementsByTagName('tr');
var l=trs.length;
for (var i=0; i<l; i++) {
  var tr=trs[i];
  var data=tr.getAttribute('data');
  if (!data||data.indexOf('inherited')==-1) continue;
  tr.style.display=tr.style.display=='none'?'':'none';
}

[DEFAULT]
BASEURL=http://msdn.microsoft.com/en-us/library/
[InternetShortcut]
URL=javascript:var trs=document.getElementsByTagName('tr');var l=trs.length;for (var i=0; i<l; i++) {  var tr=trs[i];  var data=tr.getAttribute('data');  if (data&&data.indexOf('inherited')>-1)  tr.style.display=tr.style.display=='none'?'':'none'; }; void(0);
IDList=
IconFile=http://msdn.microsoft.com/favicon.ico
IconIndex=1
[{000214A0-0000-0000-C000-000000000046}]
Prop3=19,2

javascript:var trs=document.getElementsByTagName('tr');var l=trs.length;for (var i=0; i<l; i++) {  var tr=trs[i];  var data=tr.getAttribute('data');  if (data&&data.indexOf('inherited')>-1)  tr.style.display=tr.style.display=='none'?'':'none'; }; void(0);

The latest sources are now on Github: C# 4.0 library to generate INotifyPropertyChanged proxy from POCO type. The source from the post, designed as a proof of concept, is not the same as the one from Github.

It all started from a Sacha Barber post on CodeProject, enumerating ways in which one can use Aspect Oriented Programming to mark simple automatic properties so that they get compiled into fully fledged INotifyPropertyChanged properties, thus saving us the grief of repeating the same code over and over again in each property setter. The implementations there were good, but too complex, relying on third party libraries, some of them not even free.
He completely ignored template generators like T4, but then again, that particular approach has a lot of issues associated with it, like having to either parse source files or somehow tap into the compiled assembly... before you compile it.
However, this brought forth the idea that I could do this, maybe in some other way.

Enter Felice Pollano, with his article on CodeProject detailing a method of using CodeDom generation to create at runtime the INotifyPropertyChanged object from an already existing type. This is pretty slow, but only when first creating the type, so with a cache system it would be totally usable. I liked this approach better, but I noticed there were some errors in the generated code and when I tried changing the generating code I had to look at it for half an hour just to understand where to change it. Wouldn't it be better to use some sort of template that would be easy to edit and use it to generate the proxy type?

So this is my take on generating INotifyPropertyChanged classes dynamically, avoiding the repetitive plumbing in property setters. The library contains a template for the class and a separate template for the properties. The proxy type is being generated in memory from a string that is generated from the source type and the two templates. All in all, one class, two templates, three public methods and four static methods. As easy as 1,2,3,4 :) Here is the code:

public static class TypeFactory
{
private static readonly Dictionary<Type, Type> sCachedTypes = new Dictionary<Type, Type>();

public static T GetINotifyPropertyChangedInstance<T>(params object[] arguments)
{
Type type = GetINotifyPropertyChangedType<T>();
return (T) Activator.CreateInstance(type, arguments);
}

public static Type GetINotifyPropertyChangedType<T>()
{
return GetINotifyPropertyChangedType(typeof (T));
}

public static Type GetINotifyPropertyChangedType(Type type)
{
Type result;
lock (((ICollection) sCachedTypes).SyncRoot)
{
if (!sCachedTypes.TryGetValue(type, out result))
{
result = createINotifyPropertyChangedProxyType(type);
sCachedTypes[type] = result;
}
}
return result;
}

public static bool IsVirtual(this PropertyInfo info)
{
return (info.CanRead == false || info.GetGetMethod().IsVirtual)
&&
(info.CanWrite == false || info.GetSetMethod().IsVirtual);
}


private static Type createINotifyPropertyChangedProxyType(Type type)
{
var className = "@autonotify_" + type.Name;
var properties = type.GetProperties().Where(p => p.IsVirtual());
var sourceCode = getINotifyPropertyChangedSourceCode(className, type, properties);
var assembly = generateAssemblyFromCode(sourceCode);
return assembly.GetTypes().First();
}

private static string getINotifyPropertyChangedSourceCode(string className, Type baseType,
IEnumerable<PropertyInfo> properties)
{
var classTemplate = getTemplate("INotifyPropertyChangedClassTemplate.txt");
var propertyTemplate = getTemplate("INotifyPropertyChangedPropertyTemplate.txt");
var usingsBuilder = new StringBuilder();
var propertiesBuilder = new StringBuilder();
usingsBuilder.AppendLine("using System.ComponentModel;");
usingsBuilder.AppendFormat("using {0};\r\n", baseType.Namespace);
foreach (PropertyInfo propertyInfo in properties)
{
usingsBuilder.AppendFormat("using {0};\r\n", propertyInfo.PropertyType.Namespace);

string propertyString = propertyTemplate
.Replace("{propertyType}", propertyInfo.PropertyType.FullName)
.Replace("{propertyName}", propertyInfo.Name);
propertiesBuilder.AppendLine(propertyString);
}
string sourceCode = classTemplate
.Replace("{usings}", usingsBuilder.ToString())
.Replace("{className}", className)
.Replace("{baseClassName}", baseType.Name)
.Replace("{properties}", propertiesBuilder.ToString());
#if DEBUG
Debug.WriteLine(sourceCode);
#endif
return sourceCode;
}

private static string getTemplate(string resourceName)
{
var templateAssembly = Assembly.GetAssembly(typeof (TypeFactory));
resourceName = templateAssembly.GetManifestResourceNames()
.First(name => name.EndsWith(resourceName));
using (Stream stream = templateAssembly.GetManifestResourceStream(resourceName))
{
using (var streamReader = new StreamReader(stream))
{
return streamReader.ReadToEnd();
}
}
}

private static Assembly generateAssemblyFromCode(string sourceCode)
{
var codeProvider = CodeDomProvider.CreateProvider("CSharp");
var parameters = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
var locations = AppDomain.CurrentDomain.GetAssemblies()
.Where(v => !v.IsDynamic).Select(a => a.Location).ToArray();
parameters.ReferencedAssemblies.AddRange(locations);
CompilerResults results = codeProvider.CompileAssemblyFromSource(parameters, sourceCode);
#if DEBUG
foreach (CompilerError error in results.Errors)
{
Debug.WriteLine("Error: " + error.ErrorText);
}
#endif
return results.Errors.Count > 0
? null
: results.CompiledAssembly;
}
}

As you can see, the code needs only a type that has public virtual properties in it and it will create a proxy that will inherit that class, implement INotifyPropertyChange and override each virtual property with a notifying one. The templates are so basic that I feel slightly embarrassed; I keep thinking if I should have created template entities that would stay in the same file. :) Here are the templates:

{usings}

namespace __generatedINotifyPropertyChanged
{
  public class {className} : {baseClassName},INotifyPropertyChanged
  {
    public event PropertyChangedEventHandler PropertyChanged;

    {properties}

    private void OnPropertyChanged(string propertyName)
    {
      var handler=PropertyChanged;
      if (handler != null)
      {
        handler(this, new PropertyChangedEventArgs(propertyName));
      }
    }
  }
}

public override {propertyType} {propertyName}
{
  get { return base.{propertyName}; }
  set {
    if (!Equals(value,base.{propertyName})) {
      base.{propertyName}=value;
      OnPropertyChanged("{propertyName}");
    }
  }
}

Don't forget to save the templates as Embedded Resource in the assembly.

Update: At Sacha Barber's advice I took a look at the DynamicObject solution for the INotifyPropertyChanged code smell. The link he provided is OlliFromTor's CodeProject article Using DynamicObject to Implement General Proxy Classes. While this works a lot easier than with compiling generated code, it also has a major drawback: the proxy class does not inherit from the original object and so it can only be used as such, but only in dynamic scenarios. Otherwise, it seems to be a perfect solution for proxy scenarios, if you are willing to discard the type safety.

Event Type: Error
Event Source: ASP.NET 4.0.30319.0
Description:
aspnet_wp.exe could not be started. The error code for the failure is C0000142. This error can be caused when the worker process account has insufficient rights to read the .NET Framework files. Please ensure that the .NET Framework is correctly installed and that the ACLs on the installation directory allow access to the configured account.

iisreset /stop
%windir%\Microsoft.NET\Framework\v4.0.30319\aspnet_regiis.exe -i
iisreset /start

When I first tried to do drag and drop in WPF I thought it would be something easy like DragAndDrop.IsDraggable="True". Boy,was I wrong! The mechanism for this has remained almost unchanged from the Windows Forms version. It is completely event driven and has nothing in the way of actual graphical feedback of what is going on except making the mouse cursor look different. If you want to do it using MVVM, you have another thing coming.

Disclaimer:Now, I have found a good solution for all the problems above, but the drag and drop behaviour is part of a larger framework that I have been working on and creating a separate project just for it might prove difficult. I mean, you want to show MVVM drag and drop, you should also have Views and ViewModels and base classes and helpers and everything. The solution, I guess, is to make separate articles for the main features in the framework, then present the project as a whole in the end. The framework itself is work in progress and untested in a real life project, so this might have to wait, as well. I will make sure, though, to put much code directly in this post.

First a bit of thanks to the people that inspired me to work on that. I have Sascha Barber to thank for his comprehensive articles on WPF, especially the ones about his Cinch framework. Then Lee Roth and Bea Stollnitz/Costa for the ideas about using adorners to show the drag and drop items. Finally Jason Young, for writing about MVVM Drag and Drop, but without the graphic part.

Ok then, let's define the requirements of this system. We need:

• A drag item
• A drop target
• Showing the target is being dragged
• Showing the target can or cannot be dropped
• Showing the item being dragged
• Changing the appearance of the original dragged element while dragging
• Changing the appearance of the drop target while dragging something over
• Allowing for drag and drop between Windows
• Allowing for drag and drop between applications
• Changing an application that works but has no drag and drop in an easy and maintainable way
• Using as simple a system as possible
• Doing everything using the Model-View-ViewModel pattern

From these requirements we can form a basic idea of the way we would like this to work. First of all, we need the ability to mark any element as a drag item. Also, we need a container that can be marked as a drop target. We can do this using boolean IsDragSource and IsDropTarget Attached Properties; once set they will force a bind of the drag and drop events to some special handlers that would then direct decisions to ICommands.

As we are doing it in MVVM, we don't use the elements directly, but the data they represent, so we work with dragging and dropping commands using data objects. The classes responsible with the decisions for the drop permissions and actions should be in the ViewModel. We could, of course, link all events to commands, but that would be very cumbersome to use. Besides, we want it simple, we don't really want the user of the system to care about the drag and drop inner workings. Therefore, the solution is to change the IsDragSource and IsDropTarget to DragSource and DropTarget properties that accept objects of type IDragSource and IDropTarget containing all the methods needed for the events in question:

/// <summary>
/// Holds the data of a dragged object in a drag-and-drop operation.
/// </summary>
public interface IDraggedData
{
  /// <summary>
  /// A dictionary with the format as the key and the data in that format in the value
  /// </summary>
  IDictionary<string, object> Values
  {
    get;
  }

  /// <summary>
  /// Optional object for additional information
  /// </summary>
  object Tag
  {
    get;
  }
}

/// <summary>
/// Business end of the drag source
/// </summary>
public interface IDragSource
{
  /// <summary>
  /// Gets the supported drop effects.
  /// </summary>
  /// <param name="dataContext">The data context.</param>
  /// <returns></returns>
  DragEffects GetDragEffects(object dataContext);

  /// <summary>
  /// Gets the data.
  /// </summary>
  /// <param name="dataContext">The data context.</param>
  /// <returns></returns>
  object GetData(object dataContext);
}

/// <summary>
/// Defines the handler object of a drop operation
/// </summary>
public interface IDropTarget
{
  /// <summary>
  /// Gets the effects.
  /// </summary>
  /// <param name="dataObject">The data object.</param>
  /// <returns></returns>
  DragEffects GetDropEffects(IDraggedData dataObject);

  /// <summary>
  /// Drops the specified data object
  /// </summary>
  /// <param name="dataObject">The data object.</param>
  void Drop(IDraggedData dataObject);
}

We need the methods for the effects to instruct the system about the types of operations that are allowed during drag and drop: None, Copy, Move, Scroll, All.

If you are going for the purist approach, you should use your own DragEffects enumeration, as above, since the DragDropEffects enumeration is in the System.Windows assembly, which in theory should have nothing to do with the ViewModel part of the application (one could want to use the ViewModel in a web environment, for example, or in a console application).

You will notice that the GetDropEffects method receives an IDraggedData object. This is also because the IDataObject interface and the DataObject class used in Windows drag and drop operations are also in the System.Windows assembly.

The IDraggedData interface is basically a dictionary that uses the data format as the key and the dragged data object stored in that format as the value. An important fact is that, when trying to drag and drop between applications, you need that the dragged data object be binary serializable. If not, you will only get the expected result when dragging to the same application. Here is an implementation of the interface, complete with a totally lazy way of getting the data based on which type is more "important":

/// <summary>
/// Holds data for a drag-and-drop operation
/// </summary>
public class DraggedData : IDraggedData
{
  #region Instance fields

  private Dictionary<string, Exception> mExceptions;
  private Dictionary<string, object> mValues;

  #endregion

  #region Properties

  /// <summary>
  /// A dictionary with the format as the key and the data in that format in the value
  /// </summary>
  /// <value></value>
  public Dictionary<string, object> Values
  {
    get
    {
      if (mValues == null)
      {
        mValues = new Dictionary<string, object>();
      }
      return mValues;
    }
  }

  /// <summary>
  /// A dictionary with the format as the key and the data in that format in the value
  /// </summary>
  /// <value></value>
  IDictionary<string, object> IDraggedData.Values
  {
    get
    {
      return Values;
    }
  }

  /// <summary>
  /// Optional object for additional information
  /// </summary>
  /// <value></value>
  public object Tag
  {
    get;
    set;
  }

  /// <summary>
  /// A dictionary for exceptions when retrieving the data in a specified format
  /// </summary>
  /// <value>The exceptions.</value>
  public Dictionary<string, Exception> Exceptions
  {
    get
    {
      if (mExceptions == null)
      {
        mExceptions = new Dictionary<string, Exception>();
      }
      return mExceptions;
    }
  }

  #endregion
}

In the IDragSource interface we need the GetData method to extract the data object associated with a dragged object, since the Windows drag and drop mechanism encapsulates the objects in an application agnostic way, so one can perform drag and drop between applications or to/from the operating system. Finally, we need the Drop method in the IDropTarget interface to handle in the ViewModel what happends when an item is dropped.

Let's get to the juicy part: a DragService static class that will register the attached properties that we need. Besides the DragSource and DropTarget properties we need status properties like DragOverStatus (for the target), DraggedStatus and IsDragged (for the original dragged item) as well as two properties called BringIntoViewOnDrag and ActivateOnDrag which would bring an item completely into view or activate it (if a Window) when a valid drop target. This one is long. It also contains some extension methods that would be explained later.

/// <summary>
/// Holds attached properties related to drag-and-drop operations
/// </summary>
public static class DragService
{
  #region Static Instance fields

  /// <summary>
  /// Property for the behaviour to activate a window when something is dragged over it
  /// </summary>
  public static readonly DependencyProperty ActivateOnDragProperty
      = DependencyProperty.RegisterAttached(
          "ActivateOnDrag",
          typeof (bool), typeof (DragService),
          new FrameworkPropertyMetadata(
              false)
          );

  /// <summary>
  /// Property for the behaviour to bring into view an element when something is dragged over it
  /// </summary>
  public static readonly DependencyProperty BringIntoViewOnDragProperty
      = DependencyProperty.RegisterAttached(
          "BringIntoViewOnDrag",
          typeof (bool), typeof (DragService),
          new FrameworkPropertyMetadata(
              false)
          );

  /// <summary>
  /// Property for the status of a drag-over operation
  /// </summary>
  public static readonly DependencyProperty DragOverStatusProperty
      = DependencyProperty.RegisterAttached(
          "DragOverStatus",
          typeof (DragEffects), typeof (DragService),
          new FrameworkPropertyMetadata(DragEffects.None)
          );

  /// <summary>
  /// Property for the handler of drag-source operations
  /// </summary>
  public static readonly DependencyProperty DragSourceProperty
      = DependencyProperty.RegisterAttached(
          "DragSource",
          typeof (IDragSource), typeof (DragService),
          new FrameworkPropertyMetadata(null, new PropertyChangedCallback(dragSourceChanged))
          );

  /// <summary>
  /// Property for the drag status of a drag source
  /// </summary>
  public static readonly DependencyProperty DragStatusProperty
      = DependencyProperty.RegisterAttached(
          "DragStatus",
          typeof (DragEffects), typeof (DragService),
          new FrameworkPropertyMetadata(DragEffects.None)
          );

  /// <summary>
  /// Property for the handler of drop-target operations
  /// </summary>
  public static readonly DependencyProperty DropTargetProperty
      = DependencyProperty.RegisterAttached(
          "DropTarget",
          typeof (IDropTarget), typeof (DragService),
          new FrameworkPropertyMetadata(null, new PropertyChangedCallback(dropTargetChanged)));

  /// <summary>
  /// True if element is part of the content displayed while dragging
  /// </summary>
  public static readonly DependencyProperty IsDraggedProperty
      = DependencyProperty.RegisterAttached(
          "IsDragged",
          typeof (bool), typeof (DragService),
          new FrameworkPropertyMetadata(false)
          );

  private static DependencyObject sDraggedDependencyObject;
  private static Point? sStartPoint;

  #endregion

  #region Static Public Methods

  ///<summary>
  /// Attached getter method for DragOverStatus
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static DragEffects GetDragOverStatus(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (DragEffects) element.GetValue(DragOverStatusProperty);
  }

  ///<summary>
  /// Attached setter method for DragOverStatus
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetDragOverStatus(DependencyObject element, DragEffects value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(DragOverStatusProperty, value);
  }

  ///<summary>
  /// Attached getter method for DragStatus
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static DragEffects GetDragStatus(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (DragEffects) element.GetValue(DragStatusProperty);
  }

  ///<summary>
  /// Attached setter method for DragStatus
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetDragStatus(DependencyObject element, DragEffects value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(DragStatusProperty, value);
  }

  ///<summary>
  /// Attached getter method for IsDragged
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static bool GetIsDragged(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (bool) element.GetValue(IsDraggedProperty);
  }

  ///<summary>
  /// Attached setter method for IsDragged
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetIsDragged(DependencyObject element, bool value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(IsDraggedProperty, value);
  }

  /// <summary>
  /// Try to get the dragged data in its most qualified format: 
  /// something not null and not string, string, anything else, null
  /// </summary>
  /// <param name="e"></param>
  /// <returns></returns>
  public static object GetBestDraggedDataObject(DragEventArgs e)
  {
    DraggedData draggedData = getData(e);
    object data = null;
    foreach (KeyValuePair<string, object> pair in draggedData.Values)
    {
      object value = pair.Value;
      if (value == null)
      {
        continue;
      }
      if (data == null)
      {
        data = value;
        continue;
      }
      if ((data is string) && !(value is string))
      {
        data = value;
        break;
      }
    }
    return data;
  }

  ///<summary>
  /// Attached getter method for DropTarget
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static IDropTarget GetDropTarget(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (IDropTarget) element.GetValue(DropTargetProperty);
  }

  ///<summary>
  /// Attached setter method for DropTarget
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetDropTarget(DependencyObject element, IDropTarget value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(DropTargetProperty, value);
  }

  ///<summary>
  /// Attached getter method for DragSource
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static IDragSource GetDragSource(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (IDragSource) element.GetValue(DragSourceProperty);
  }

  ///<summary>
  /// Attached setter method for DragSource
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetDragSource(DependencyObject element, IDragSource value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(DragSourceProperty, value);
  }

  ///<summary>
  /// Attached getter method for BringIntoViewOnDrag
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (FrameworkElement))]
  public static bool GetBringIntoViewOnDrag(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (bool) element.GetValue(BringIntoViewOnDragProperty);
  }

  ///<summary>
  /// Attached setter method for BringIntoViewOnDrag
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetBringIntoViewOnDrag(DependencyObject element, bool value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(BringIntoViewOnDragProperty, value);
  }

  ///<summary>
  /// Attached getter method for ActivateOnDrag
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static bool GetActivateOnDrag(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return (bool) element.GetValue(ActivateOnDragProperty);
  }

  ///<summary>
  /// Attached setter method for ActivateOnDrag
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetActivateOnDrag(DependencyObject element, bool value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(ActivateOnDragProperty, value);
  }

  #endregion

  #region Static Private Methods

  private static void dropTargetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
  {
    UIElement element = (UIElement) d;

    if (e.NewValue != null)
    {
      registerDropTarget(element);
    }
    else
    {
      unregisterDropTarget(element);
    }
  }

  private static void unregisterDropTarget(UIElement element)
  {
    element.DragOver -= dragOver;
    element.DragLeave -= elementDragLeave;
    element.Drop -= drop;
    element.AllowDrop = false;
  }

  private static void registerDropTarget(UIElement element)
  {
    element.DragOver += dragOver;
    element.DragLeave += elementDragLeave;
    element.Drop += drop;
    element.AllowDrop = true;
    element.ExecuteWhenUnloaded(() => unregisterDropTarget(element));
  }

  private static void elementDragLeave(object sender, DragEventArgs e)
  {
    DependencyObject dependencyObject = (DependencyObject) sender;
    SetDragOverStatus(dependencyObject, DragEffects.None);
  }

  private static void drop(object sender, DragEventArgs e)
  {
    DependencyObject dependencyObject = (DependencyObject) sender;
    IDropTarget dropTarget = GetDropTarget(dependencyObject);
    DraggedData data = getData(e);
    dropTarget.Drop(data);
    SetDragOverStatus(dependencyObject, DragEffects.None);
    e.Handled = true;
  }

  private static DraggedData getData(DragEventArgs e)
  {
    DraggedData data = new DraggedData();
    string[] formats = e.Data.GetFormats(false);
    foreach (string format in formats)
    {
      try
      {
        data.Values[format] = e.Data.GetData(format);
      }
      catch (Exception ex)
      {
        data.Values[format] = null;
        data.Exceptions[format] = ex;
      }
    }
    return data;
  }

  private static void dragOver(object sender, DragEventArgs e)
  {
    DependencyObject dependencyObject = (DependencyObject) sender;
    IDropTarget dropTarget = GetDropTarget(dependencyObject);

    DraggedData data = getData(e);
    DragEffects dragEffects = dropTarget.GetDropEffects(data);
    e.Effects = getEffects(dragEffects);
    if (sDraggedDependencyObject != null)
    {
      SetDragStatus(sDraggedDependencyObject, dragEffects);
    }
    SetDragOverStatus(dependencyObject, dragEffects);

    e.Handled = true;
    if (GetActivateOnDrag(dependencyObject))
    {
      Window window = Window.GetWindow(dependencyObject);
      if (window != null && !window.IsActive)
      {
        window.Activate();
      }
    }
    if (GetBringIntoViewOnDrag(dependencyObject))
    {
      FrameworkElement element = dependencyObject as FrameworkElement;
      if (element != null)
      {
        element.BringIntoView();
      }
    }
  }

  private static DragDropEffects getEffects(DragEffects effects)
  {
    DragDropEffects result;
    return Enum.TryParse(effects.ToString(), out result)
               ? result
               : (DragDropEffects) (int) effects;
  }

  private static void dragSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
  {
    UIElement element = (UIElement) d;
    if (e.NewValue != null)
    {
      registerDragItem(element);
    }
    else
    {
      unregisterDragItem(element);
    }
  }

  private static void unregisterDragItem(UIElement element)
  {
    element.PreviewMouseLeftButtonDown -= previewMouseLeftButtonDown;
    element.PreviewMouseMove -= previewMouseMove;
    element.MouseLeave -= mouseLeave;
    element.QueryContinueDrag -= elementQueryContinueDrag;
    element.GiveFeedback -= elementGiveFeedback;
  }

  private static void registerDragItem(UIElement element)
  {
    element.PreviewMouseLeftButtonDown += previewMouseLeftButtonDown;
    element.PreviewMouseMove += previewMouseMove;
    element.MouseLeave += mouseLeave;
    element.QueryContinueDrag += elementQueryContinueDrag;
    element.GiveFeedback += elementGiveFeedback;
    element.ExecuteWhenUnloaded(() => unregisterDragItem(element));
  }

  private static void elementGiveFeedback(object sender, GiveFeedbackEventArgs e)
  {
    if (sDraggedDependencyObject != null)
    {
      DragEffects dragDropEffects = getDragDropEffects(e.Effects);
      SetDragStatus(sDraggedDependencyObject, dragDropEffects);
    }
  }

  private static DragEffects getDragDropEffects(DragDropEffects effects)
  {
    DragEffects result;
    return Enum.TryParse(effects.ToString(), out result)
               ? result
               : (DragEffects) (int) effects;
  }

  private static void elementQueryContinueDrag(object sender, QueryContinueDragEventArgs e)
  {
    if (!e.KeyStates.HasFlag(DragDropKeyStates.LeftMouseButton))
    {
      DependencyObject dependencyObject = sender as DependencyObject ?? sDraggedDependencyObject;
      endDrag(dependencyObject);
    }
  }

  private static void endDrag(DependencyObject dependencyObject)
  {
    if (dependencyObject == null)
    {
      return;
    }
    SetIsDragged(dependencyObject, false);
    if (sDraggedDependencyObject != null)
    {
      SetDragStatus(sDraggedDependencyObject, DragEffects.None);
    }
    sDraggedDependencyObject = null;
  }

  private static void mouseLeave(object sender, MouseEventArgs e)
  {
    sStartPoint = null;
  }

  private static void previewMouseMove(object sender, MouseEventArgs e)
  {
    if (e.LeftButton != MouseButtonState.Pressed || sStartPoint == null)
    {
      return;
    }

    if (!hasMouseMovedFarEnough(e))
    {
      return;
    }

    FrameworkElement dependencyObject = (FrameworkElement) sender;
    object dataContext = dependencyObject.GetValue(FrameworkElement.DataContextProperty);
    IDragSource dragSource = GetDragSource(dependencyObject);

    DragDropEffects dragDropEffects = getEffects(dragSource.GetDragEffects(dataContext));
    if (dragDropEffects == DragDropEffects.None)
    {
      return;
    }
    startDrag(dependencyObject);
    DragDrop.DoDragDrop(dependencyObject,
                        getDraggedData(dragSource, dataContext),
                        dragDropEffects);
  }

  private static void startDrag(DependencyObject dependencyObject)
  {
    SetIsDragged(dependencyObject, true);
    sDraggedDependencyObject = dependencyObject;
  }

  private static object getDraggedData(IDragSource dragSource, object dataContext)
  {
    object data = dragSource.GetData(dataContext);
    DataObject dataObject = new DataObject();
    if (data != null)
    {
      if (!SerializationHelper.IsBinarySerializable(data))
      {
        DebugHelper.Warn(
            "Trying to drag a DataItem that cannot be binary serialized. It will not work across applications");
      }
      dataObject.SetData(DataFormats.Text, data.ToString());
      string typeName = data.GetType().FullName;
      if (typeName != null)
      {
        DataFormat format = DataFormats.GetDataFormat(typeName);
        dataObject.SetData(format.Name, data);
      }
    }
    return dataObject;
  }

  private static void previewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
  {
    sStartPoint = e.GetPosition(null);
  }

  private static bool hasMouseMovedFarEnough(MouseEventArgs e)
  {
    if (sStartPoint == null)
    {
      return false;
    }
    Vector delta = sStartPoint.GetValueOrDefault() - e.GetPosition(null);

    return Math.Abs(delta.X) > SystemParameters.MinimumHorizontalDragDistance ||
           Math.Abs(delta.Y) > SystemParameters.MinimumVerticalDragDistance;
  }

  #endregion
}

Most of the code here is self explanatory: you have attached property that bind to the element drag and drop events and handle them either through direct code or by delegating to the values set. There are some extension methods like ExecuteWhenLoaded and ExecuteWhenUnloaded which execute an action when the element has finished loading or when it is unloading. An important aspect here is that a window closing does not trigger the Unloaded event for its child elements, so you need to bind to the Dispatcher.StartedShutdown event as well:

/// <summary>
/// Execute an action when an element is unloaded
/// </summary>
/// <param name="element"></param>
/// <param name="action"></param>
public static void ExecuteWhenUnloaded(this UIElement element, Action action)
{
  if (element == null)
  {
    throw new ArgumentNullException("element",
                                    Resources.
                                        UIExtensions_ExecuteWhenUnloaded_Element_cannot_be_null);
  }
  RoutedEventHandler elementOnUnloaded = null;
  EventHandler dispatcherOnShutdownStarted = null;
  // ReSharper disable AccessToModifiedClosure
  elementOnUnloaded = (sender, args) =>
                        {
                          performExecution(element,
                                           dispatcherOnShutdownStarted,
                                           elementOnUnloaded,
                                           action);
                        };
  dispatcherOnShutdownStarted = (sender, args) =>
                                  {
                                    performExecution(element,
                                                     dispatcherOnShutdownStarted,
                                                     elementOnUnloaded, action);
                                  };
  // ReSharper restore AccessToModifiedClosure
  FrameworkElement frameworkElement = element as FrameworkElement;
  if (frameworkElement != null)
  {
    frameworkElement.Unloaded += elementOnUnloaded;
  }
  element.Dispatcher.ShutdownStarted += dispatcherOnShutdownStarted;
}

That is pretty much it for the drag and drop itself. You can implement IDropTarget on the ViewModel directly, but IDragSource needs to be binary serializable if you intend to drag and drop across application domains, so you usually implement it into a separate class that is a property of the dragged item view model or DataContext.

Because the DragService sets the status properties for each element, you can manipulate the appearance and behaviour of both drag source and drop target based on them. However, at this point the mouse will be the only indication that you are dragging something. You might want to actually drag something, especially since in a move operation the original element would be hidden during the drag. The problem here is that the drag source element cannot control the display of the dragged item in other applications, nor should it in its application, since it is not its responsibility. The solution: decorate an element over which you would drag something (like the root element of the entire window) with something that knows how to display dragged items:

/// <summary>
/// Decorator for an element that would respons visually to a drag-over operation
/// </summary>
public class DragAndDropAdornerDecorator : ContentControl
{
  #region Instance fields

  private DragAndDropAdorner mAdorner;

  #endregion

  #region Properties

  /// <summary>
  /// Visual content for the dragged data
  /// </summary>
  public FrameworkElement AdornerContent
  {
    get
    {
      return (FrameworkElement) GetValue(AdornerContentProperty);
    }
    set
    {
      SetValue(AdornerContentProperty, value);
    }
  }

  /// <summary>
  /// The data being dragged
  /// </summary>
  public object DraggedData
  {
    get
    {
      return GetValue(DraggedDataProperty);
    }
    set
    {
      SetValue(DraggedDataProperty, value);
    }
  }

  /// <summary>
  /// The position of the drag point in the decorator content 
  /// </summary>
  public Point Offset
  {
    get
    {
      return (Point) GetValue(OffsetProperty);
    }
    set
    {
      SetValue(OffsetProperty, value);
    }
  }

  /// <summary>
  /// Represents the point in which a dragged item has first entered the drag zone.
  /// Use it to create animations when a drop operation did not succeed.
  /// </summary>
  public Point? EntryPoint
  {
    get
    {
      return (Point?) GetValue(EntryPointProperty);
    }
    private set
    {
      SetValue(EntryPointPropertyKey, value);
    }
  }

  #endregion

  #region Constructors

  /// <summary>
  /// Initializes a new instance of the <see cref="DragAndDropAdornerDecorator"/> class.
  /// </summary>
  public DragAndDropAdornerDecorator()
  {
    Focusable = false; // By default don't want 'AdornedControl' to be focusable.

    DataContextChanged += dragAndDropAdornerDecoratorDataContextChanged;
    updateAdornerDataContext();
  }

  #endregion

  #region Protected Methods

  /// <summary>
  /// Called when the <see cref="T:System.Windows.Media.VisualCollection"/> of the visual object is modified.
  /// </summary>
  /// <param name="visualAdded">The <see cref="T:System.Windows.Media.Visual"/> that was added to the collection</param><param name="visualRemoved">The <see cref="T:System.Windows.Media.Visual"/> that was removed from the collection</param>
  protected override void OnVisualChildrenChanged(DependencyObject visualAdded,
                                                  DependencyObject visualRemoved)
  {
    UIElement element = visualRemoved as UIElement;
    if (element != null)
    {
      dettachAdorner(element);
    }
    base.OnVisualChildrenChanged(visualAdded, visualRemoved);
    element = visualAdded as UIElement;
    if (element != null)
    {
      attachAdorner(element);
      this.ExecuteWhenUnloaded(() => dettachAdorner(element));
    }
  }

  #endregion

  #region Private Methods

  private void dragAndDropAdornerDecoratorDataContextChanged(object sender,
                                                             DependencyPropertyChangedEventArgs e)
  {
    updateAdornerDataContext();
  }

  /// <summary>
  /// Update the DataContext of the adorner from the adorned control.
  /// </summary>
  private void updateAdornerDataContext()
  {
    if (AdornerContent != null)
    {
      AdornerContent.DataContext = DataContext;
    }
  }

  private void attachAdorner(UIElement element)
  {
    mAdorner = new DragAndDropAdorner(element, AdornerContent)
                 {
                     Decorator = this
                 };
    mAdorner.Attach();
    AddLogicalChild(mAdorner.AdornerLayer);
    element.AddHandler(DragEnterEvent, new DragEventHandler(elementDragEnter), true);
    element.AddHandler(DragOverEvent, new DragEventHandler(elementDragOver), true);
    element.AddHandler(DragLeaveEvent, new DragEventHandler(elementDragLeave), true);
    element.AddHandler(QueryContinueDragEvent,
                       new QueryContinueDragEventHandler(elementQueryContinueDrag), true);
    element.AddHandler(DropEvent,
                       new DragEventHandler(elementDrop), true);
    hideAdorner();
  }

  private void elementDragEnter(object sender, DragEventArgs e)
  {
    EntryPoint = e.GetPosition(this);
  }

  private void elementDrop(object sender, DragEventArgs e)
  {
    hideAdorner();
  }

  private void elementQueryContinueDrag(object sender, QueryContinueDragEventArgs e)
  {
    if (!e.KeyStates.HasFlag(DragDropKeyStates.LeftMouseButton))
    {
      hideAdorner();
    }
  }

  private void elementDragLeave(object sender, DragEventArgs e)
  {
    hideAdorner();
  }

  private void hideAdorner()
  {
    DraggedData = null;
    EntryPoint = null;
    if (mAdorner == null)
    {
      return;
    }
    mAdorner.Hide();
  }

  private void elementDragOver(object sender, DragEventArgs e)
  {
    DraggedData = DragService.GetBestDraggedDataObject(e);
    showAdorner(e.GetPosition(this));
  }

  private void showAdorner(Point position)
  {
    if (mAdorner == null)
    {
      return;
    }
    mAdorner.Show(position);
  }

  private void dettachAdorner(UIElement element)
  {
    if (mAdorner == null)
    {
      return;
    }
    RemoveLogicalChild(mAdorner.AdornerLayer);
    mAdorner.DisconnectChild();
    mAdorner.Dettach();
    mAdorner = null;
    element.RemoveHandler(DragEnterEvent, new DragEventHandler(elementDragEnter));
    element.RemoveHandler(DragOverEvent, new DragEventHandler(elementDragOver));
    element.RemoveHandler(DragLeaveEvent, new DragEventHandler(elementDragLeave));
    element.RemoveHandler(QueryContinueDragEvent,
                          new QueryContinueDragEventHandler(elementQueryContinueDrag));
    element.RemoveHandler(DropEvent, new DragEventHandler(elementDrop));
  }

  #endregion

  #region Static Instance fields

  public static readonly DependencyProperty AdornerContentProperty
      = DependencyProperty.Register("AdornerContent",
                                    typeof (FrameworkElement),
                                    typeof (DragAndDropAdornerDecorator),
                                    new FrameworkPropertyMetadata(null));

  public static readonly DependencyProperty DraggedDataProperty
      = DependencyProperty.RegisterAttached(
          "DraggedData",
          typeof (object), typeof (DragAndDropAdornerDecorator),
          new FrameworkPropertyMetadata(null,
                                        FrameworkPropertyMetadataOptions.
                                            OverridesInheritanceBehavior
                                        | FrameworkPropertyMetadataOptions.Inherits)
          );

  public static readonly DependencyPropertyKey EntryPointPropertyKey
      = DependencyProperty.RegisterReadOnly("EntryPoint",
                                            typeof (Point?), typeof (DragAndDropAdornerDecorator),
                                            new FrameworkPropertyMetadata(default(Point?)));

  public static readonly DependencyProperty EntryPointProperty =
  EntryPointPropertyKey.DependencyProperty;


  public static readonly DependencyProperty OffsetProperty
      = DependencyProperty.Register("Offset",
                                    typeof (Point), typeof (DragAndDropAdornerDecorator),
                                    new FrameworkPropertyMetadata(new Point()));

  #endregion

  #region Static Public Methods

  ///<summary>
  /// Attached getter method for DraggedData
  ///</summary>
  ///<param name="element"></param>
  ///<returns></returns>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  [AttachedPropertyBrowsableForType(typeof (UIElement))]
  public static object GetDraggedData(DependencyObject element)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    return element.GetValue(DraggedDataProperty);
  }

  ///<summary>
  /// Attached setter method for DraggedData
  ///</summary>
  ///<param name="element"></param>
  ///<param name="value"></param>
  ///<exception cref="ArgumentNullException"></exception>
  [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
  public static void SetDraggedData(DependencyObject element, object value)
  {
    if (element == null)
    {
      throw new ArgumentNullException("element");
    }
    element.SetValue(DraggedDataProperty, value);
  }

  #endregion
}

This code uses an adorner to display the dragged item over it. Nothing fancy, since the actual template for the dragged data is defined in the decorator as the content. This is not the place to discuss the adorner, though, so here is just the code:

/// <summary>
/// Adorner for the drag-and-drop operations: see DragHelper and DragAndDropDecorator
/// </summary>
public class DragAndDropAdorner : AdornerBase
{
  #region Instance fields

  private readonly FrameworkElement mChild;
  private Point mPosition;

  #endregion

  #region Properties

  /// <summary>
  /// Gets the number of visual child elements within this element.
  /// </summary>
  /// <returns>
  /// The number of visual child elements for this element.
  /// </returns>
  protected override int VisualChildrenCount
  {
    get
    {
      return 1;
    }
  }

  /// <summary>
  /// Gets an enumerator for logical child elements of this element. 
  /// </summary>
  /// <returns>
  /// An enumerator for logical child elements of this element.
  /// </returns>
  protected override IEnumerator LogicalChildren
  {
    get
    {
      yield return mChild;
    }
  }

  /// <summary>
  /// Reference to the decorator that instantiates the adorner
  /// </summary>
  public DragAndDropAdornerDecorator Decorator
  {
    get;
    set;
  }

  #endregion

  #region Constructors

  /// <summary>
  /// Instantiate an adorner for an element over which to show the dragged content
  /// </summary>
  /// <param name="adornedElement"></param>
  /// <param name="adornerContent"></param>
  public DragAndDropAdorner(UIElement adornedElement, FrameworkElement adornerContent)
      : base(adornedElement)
  {
    IsHitTestVisible = false;
    Focusable = false;
    mChild = adornerContent;
    connectChild();
  }

  #endregion

  #region Public Methods

  /// <summary>
  /// Disconnect the child element from the visual tree so that it may be reused later.
  /// </summary>
  public void DisconnectChild()
  {
    RemoveLogicalChild(mChild);
    RemoveVisualChild(mChild);
  }

  /// <summary>
  /// Hide the adorner content
  /// </summary>
  public void Hide()
  {
    Opacity = 0.0;
    Visibility = Visibility.Collapsed;
  }

  /// <summary>
  /// Show the adorner content at a certain position
  /// </summary>
  /// <param name="point"></param>
  public void Show(Point point)
  {
    mPosition = point;
    Opacity = 1.0;
    Visibility = Visibility.Visible;
    InvalidateArrange();
  }

  #endregion

  #region Protected Methods

  /// <summary>
  /// Implements any custom measuring behavior for the adorner.
  /// </summary>
  /// <returns>
  /// A <see cref="T:System.Windows.Size"/> object representing the amount of layout space needed by the adorner.
  /// </returns>
  /// <param name="constraint">A size to constrain the adorner to.</param>
  protected override Size MeasureOverride(Size constraint)
  {
    mChild.Measure(constraint);
    return mChild.DesiredSize;
  }

  /// <summary>
  /// When overridden in a derived class, positions child elements and determines a size for a <see cref="T:System.Windows.FrameworkElement"/> derived class. 
  /// </summary>
  /// <returns>
  /// The actual size used.
  /// </returns>
  /// <param name="finalSize">The final area within the parent that this element should use to arrange itself and its children.</param>
  protected override Size ArrangeOverride(Size finalSize)
  {
    double adornerWidth = mChild.DesiredSize.Width;
    double adornerHeight = mChild.DesiredSize.Height;
    double offsetX=0;
    double offsetY=0;
    if (Decorator!=null)
    {
      offsetX = -Decorator.Offset.X;
      offsetY = -Decorator.Offset.Y;
    }
    mChild.Arrange(new Rect(mPosition.X + offsetX, mPosition.Y + offsetY, adornerWidth, adornerHeight));
    return finalSize;
  }

  /// <summary>
  /// Overrides <see cref="M:System.Windows.Media.Visual.GetVisualChild(System.Int32)"/>, and returns a child at the specified index from a collection of child elements. 
  /// </summary>
  /// <returns>
  /// The requested child element. This should not return null; if the provided index is out of range, an exception is thrown.
  /// </returns>
  /// <param name="index">The zero-based index of the requested child element in the collection.</param>
  protected override Visual GetVisualChild(int index)
  {
    return mChild;
  }

  #endregion

  #region Private Methods

  private void connectChild()
  {
    AddLogicalChild(mChild);
    AddVisualChild(mChild);
  }

  #endregion
}

You would only need to decorate a view and then define the AdornerContent property for the decorator and, optionally, the grab point offset for the dragged element.

All that is left here is to show some usage examples. Let's assume we need a View over which we can drag and drop items:

<UserControl x:Class="BestPractices.Views.SecondaryView"
     [...]
     UIUtils:DragService.DropTarget="{Binding .}"
     UIUtils:DragService.BringIntoViewOnDrag="True"
     UIUtils:DragService.ActivateOnDrag="True"
     UIUtils:DragService.DragOverStatus="{Binding DragOverStatus,Mode=OneWayToSource}">

Here you have a user control view which has the drop target set to its own view model and it is set to update the DragOverStatus property of the ViewModel when its attached DragOverStatus property is changed. The status properties are inheritable, so all the children of the view have them set. It is easy to define a Button style that has its text bolded when a copy operation is allowed for a drop item:

<Style TargetType="{x:Type Button}" BasedOn="{StaticResource {x:Type Button}}" >  <Style.Triggers>
    <DataTrigger Binding="{Binding DragOverStatus}" Value="{x:Static Utils:DragEffects.Copy}">
      <Setter Property="FontWeight" Value="Bold"/>
    </DataTrigger>
</Style.Triggers
></Style>

Its content is more interesting:

<UIUtils:DragAndDropAdornerDecorator Offset="40,40">
  <UIUtils:DragAndDropAdornerDecorator.AdornerContent>
    <Controls:ContentItem
       DataContext="{Binding Path=(UIUtils:DragAndDropAdornerDecorator.DraggedData),
         RelativeSource={RelativeSource Self}}"
      Opacity="0.7"/>
  </UIUtils:DragAndDropAdornerDecorator.AdornerContent>
  <DockPanel Background="{Binding Background,
      RelativeSource={RelativeSource AncestorType={x:Type UserControl}}}">
  <Button Command="{m:CommandBinding AddItemCommand}"
          DockPanel.Dock="Top"
          >Add item</Button>
    <Button Command="{m:CommandBinding RemoveItemCommand}"
           DockPanel.Dock="Top"
          >Remove item</Button>
    <WrapPanel x:Name="ContainerPanel" >
    </WrapPanel>
  </DockPanel>
</UIUtils:DragAndDropAdornerDecorator>

The container for the items is a simple WrapPanel and it is placed in a dock panel together with add and remove item buttons. This dock panel is decorated as a drag visual container, and the content that is dragged is set to a custom control called ContentItem, with a drag point set to 40,40. The DataContext property of the item is set to the DraggedData property so that it expresses the actual dragged object.

Now we have set up a container to be a drop target for items. It displays the items as they are dragged over it. All we have left is to set up the items, the ContentItem control, to be a DragSource:

<Style TargetType="{x:Type Controls:ContentItem}">
  <Setter Property="UIUtils:DragService.DragSource" Value="{Binding DragSource}"/>
  <Setter Property="UIUtils:DragService.IsDragged" Value="{Binding IsDragged,Mode=OneWayToSource}"/>
  <Setter Property="UIUtils:DragService.DragStatus" Value="{Binding DragStatus,Mode=OneWayToSource}"/>
  <Setter Property="Background" Value="LightBlue"/>
  <Setter Property="Template">
    <Setter.Value>
      <ControlTemplate TargetType="{x:Type Controls:ContentItem}">
        <Border BorderThickness="1" BorderBrush="Blue" CornerRadius="2" Background="{TemplateBinding Background}" Width="75" Height="60">
          <TextBlock Text="{Binding Id}" HorizontalAlignment="Center" VerticalAlignment="Center" FontWeight="Bold" FontSize="22"/>
        </Border>
      </ControlTemplate>
    </Setter.Value>
  </Setter>
  <Style.Triggers>
    <DataTrigger Binding="{Binding IsDragged}" Value="True">
      <Setter Property="Background" Value="LightPink"/>
    </DataTrigger>
    <DataTrigger Binding="{Binding DragStatus}" Value="{x:Static Utils:DragEffects.Copy}">
      <Setter Property="Background" Value="Lime"/>
    </DataTrigger>
  </Style.Triggers>
</Style>

The control style defines as a drag source the DragSource property of the data context of the item and synchronizes with the data context the properties of IsDragged and DragStatus. Triggers then make is pinkish when dragged and greenish when it can be dropped. Notice that this applies to the original item, while its representation is dragged, so you have a feedback of what is going on with the item right at the source.

I won't put here the ViewModels or the data items, since they are pretty much part of the business context, not the drag and drop. Just return DragEffects. All on the effects methods and you can drag anything anywhere, for example.

That's it, folks: drag and drop completely MVVM, without as much as writing an event handler or caring about the actual elements in the viewmodel. It would be even easier if you would allow references to WPF assemblies in the ViewModels, since you could also get the source elements and do stuff with them, but that wouldn't be much of an MVVM pattern, would it?

And here is the AdornerBase class, just a simple helper class:

  /// <summary>
  /// Basic adorner class that exposes simple Attach and Dettach methods
  /// </summary>
  public abstract class AdornerBase : Adorner
  {
    #region Instance fields

    private bool mIsDettached;

    #endregion

    #region Properties

    public bool IsDettached
    {
      get
      {
        return mIsDettached;
      }
    }

    public AdornerLayer AdornerLayer
    {
      get;
      private set;
    }

    #endregion

    #region Constructors

    protected AdornerBase(UIElement adornedElement)
        : base(adornedElement)
    {
      mIsDettached = true;
    }

    #endregion

    #region Public Methods

    /// <summary>
    /// Attach the adorner to the element's adorner layer
    /// </summary>
    public void Attach()
    {
      AdornerLayer = AdornerLayer.GetAdornerLayer(AdornedElement);
      if (AdornerLayer != null)
      {
        AdornerLayer.Add(this);
        mIsDettached = false;
      }
    }

    /// <summary>
    /// Dettach the adorner from the element's adorner layer
    /// </summary>
    public void Dettach()
    {
      AdornerLayer = AdornerLayer ?? AdornerLayer.GetAdornerLayer(AdornedElement);
      if (AdornerLayer != null)
      {
        AdornerLayer.Remove(this);
        mIsDettached = true;
      }
    }

    #endregion
  }

  <system.net>
    <defaultProxy>
      <proxy
         usesystemdefault = "False"
         bypassonlocal = "False"
         />
    </defaultProxy>
  </system.net>

System.Configuration.ConfigurationErrorsException occurred
  Message=Error creating the Web Proxy specified in the 'system.net/defaultProxy' configuration section.
  Source=System
  BareMessage=Error creating the Web Proxy specified in the 'system.net/defaultProxy' configuration section.
  Line=0
  StackTrace:
       at System.Net.Configuration.DefaultProxySectionInternal.GetSection()
       at System.Net.WebRequest.get_InternalDefaultWebProxy()
       at System.Net.HttpWebRequest..ctor(Uri uri, ServicePoint servicePoint)
       at System.Net.HttpRequestCreator.Create(Uri Uri)
       at System.Net.WebRequest.Create(Uri requestUri, Boolean useUriBase)
       at System.Net.WebRequest.Create(String requestUriString)
  InnerException: System.Runtime.InteropServices.SEHException
       Message=External component has thrown an exception.
       Source=System
       ErrorCode=-2147467259 (0x80004005)
       StackTrace:
            at System.Net.UnsafeNclNativeMethods.OSSOCK.WSASocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, IntPtr protocolInfo, UInt32 group, SocketConstructorFlags flags)
            at System.Net.Sockets.Socket.InitializeSockets()
            at System.Net.NetworkAddressChangePolled..ctor()
            at System.Net.AutoWebProxyScriptEngine.AutoDetector.Initialize()
            at System.Net.AutoWebProxyScriptEngine.AutoDetector.get_CurrentAutoDetector()
            at System.Net.AutoWebProxyScriptEngine..ctor(WebProxy proxy, Boolean useRegistry)
            at System.Net.WebProxy.UnsafeUpdateFromRegistry()
            at System.Net.WebProxy..ctor(Boolean enableAutoproxy)

System.Runtime.InteropServices.SEHException occurred
  Message=External component has thrown an exception.
  Source=System
  ErrorCode=-2147467259
  StackTrace:
       at System.Net.UnsafeNclNativeMethods.OSSOCK.WSASocket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType, IntPtr protocolInfo, UInt32 group, SocketConstructorFlags flags)
       at System.Net.Sockets.Socket.InitializeSockets()
       at System.Net.IPAddress.InternalParse(String ipString, Boolean tryParse)
       at System.Net.NetworkInformation.IpAddrString.ToIPAddressCollection()
       at System.Net.NetworkInformation.SystemIPGlobalProperties.GetFixedInfo()
       at System.Net.NetworkInformation.SystemIPGlobalProperties.get_FixedInfo()
       at System.Net.NetworkInformation.SystemIPGlobalProperties.get_HostName()
       at System.Net.NclUtilities.GuessWhetherHostIsLoopback(String host)
       at System.Net.ServicePoint.get_ConnectionLimit()
       at System.Net.ConnectionGroup..ctor(ServicePoint servicePoint, String connName)
       at System.Net.ServicePoint.FindConnectionGroup(String connName, Boolean dontCreate)
       at System.Net.ServicePoint.SubmitRequest(HttpWebRequest request, String connName)
       at System.Net.HttpWebRequest.SubmitRequest(ServicePoint servicePoint)
       at System.Net.HttpWebRequest.GetResponse()

public static DependencyProperty MyAttachedCollectionProperty =
    DependencyProperty.RegisterAttached("MyAttachedCollectionInternal",
                                        typeof (ObservableCollection<MyItem>),
                                        typeof (ParentClass),
                                        new PropertyMetadata(null));

public static void SetMyAttachedCollection(UIElement element, ObservableCollection<MyItem> value)
{
  if (element != null)
  {
    element.SetValue(MyAttachedCollectionProperty, value);
  }
}

public static ObservableCollection<MyItem> GetMyAttachedCollection(UIElement element)
{
  ObservableCollection<MyItem> collection =
      (ObservableCollection<MyItem>) element.GetValue(MyAttachedCollectionProperty);
  if (collection == null)
  {
    collection = new ObservableCollection<MyItem>();
    SetMyAttachedCollection(element, collection);
  }
  return collection;
}

#region Using directives

using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Markup.Primitives;
using System.Windows.Media;

#endregion

namespace BestPractices
{
/// <summary>
/// Base class for ControlTemplate transforming classes
/// </summary>
public abstract class BaseTemplateTransformer : BaseControlTransformer
{
#region Public Methods

/// <summary>
/// Clones the ControlTemplate of a control and allows for its manipulation
/// </summary>
/// <param name="control"></param>
public override void Transform(Control control)
{
ControlTemplate template = control.Template;
if (template == null)
{
return;
}
// create new template
ControlTemplate newTemplate = new ControlTemplate(template.TargetType);
// copy the resources
foreach (object key in template.Resources.Keys)
{
newTemplate.Resources.Add(key, template.Resources[key]);
}
//get the VisualTree factory from the original template content
DependencyObject content = template.LoadContent();
newTemplate.VisualTree = getVisualTreeFactory(content);
// copy the triggers
foreach (TriggerBase trigger in template.Triggers)
{
newTemplate.Triggers.Add(trigger);
}
// allow for template manipulation
OnBeforeSeal(newTemplate);
// seal the template and set it back
newTemplate.Seal();
control.Template = newTemplate;
}

#endregion

#region Protected Methods

/// <summary>
/// Allows for the manipulation of a control template
/// </summary>
/// <param name="newTemplate"></param>
protected abstract void OnBeforeSeal(ControlTemplate newTemplate);

#endregion

#region Statics

/// <summary>
/// Transforms a DependencyObject tree into a FrameworkElementFactory tree
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
private static FrameworkElementFactory getVisualTreeFactory(DependencyObject content)
{
if (content == null)
{
return null;
}
// use the object type
FrameworkElementFactory factory = new FrameworkElementFactory(content.GetType());
// set its name
string name = content.GetValue(FrameworkElement.NameProperty) as string;
if (!string.IsNullOrWhiteSpace(name))
{
factory.Name = name;
}
// copy the properties
foreach (DependencyProperty property in getProperties(content))
{
object value = content.ReadLocalValue(property);
// use the dynamic pattern to get different behaviour 
// based on the run time type to get the value we need
// and set it to the factory
factory.SetValue(property, getRealValue((dynamic) value));
}
// do it recursively
int count = VisualTreeHelper.GetChildrenCount(content);
for (int i = 0; i < count; i++)
{
DependencyObject child = VisualTreeHelper.GetChild(content, i);
factory.AppendChild(getVisualTreeFactory(child));
}
return factory;
}

/// <summary>
/// return the TemplateBinding for a TemplateBindingExpression
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static object getRealValue(TemplateBindingExpression value)
{
return value.TemplateBindingExtension;
}

/// <summary>
/// return the BindingBase for a BindingExpressionBase
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static object getRealValue(BindingExpressionBase value)
{
return value.ParentBindingBase;
}

/// <summary>
/// return the provided value for any other type
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static object getRealValue(object value)
{
return value;
}

/// <summary>
/// get the properties (Dependency and Attached) set on a DependencyObject
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
private static IEnumerable<DependencyProperty> getProperties(DependencyObject content)
{
MarkupObject markupObject = MarkupWriter.GetMarkupObjectFor(content);
return markupObject
.Properties.Where(mp => mp.DependencyProperty != null)
.Select(mp => mp.DependencyProperty);
}

#endregion
}

}

#region Using directives

using System.Collections.Generic;
using System.ComponentModel;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Markup;

#endregion

namespace BestPractices
{
/// <summary>
/// Base class for ControlTemplate transforming classes
/// </summary>
public abstract class BaseTemplateTransformer : BaseControlTransformer
{
#region Public Methods

/// <summary>
/// Clones the ControlTemplate of a control and allows for its manipulation
/// </summary>
/// <param name="control"></param>
public override void Transform(Control control)
{
ControlTemplate template = control.Template;
if (template == null)
{
return;
}
// create new template
ControlTemplate newTemplate = new ControlTemplate(template.TargetType);
// copy the resources
foreach (object key in template.Resources.Keys)
{
newTemplate.Resources.Add(key, template.Resources[key]);
}
//get the VisualTree factory from the original template content
DependencyObject content = template.LoadContent();
newTemplate.VisualTree = OnGetElementFactory(content);
// copy the triggers
foreach (TriggerBase trigger in template.Triggers)
{
newTemplate.Triggers.Add(trigger);
}
// allow for template manipulation
OnBeforeSeal(newTemplate);
// seal the template and set it back
newTemplate.Seal();
control.Template = newTemplate;
}

/// <summary>
/// Creates a custom ControlTransformFactory for the content object.
/// Override in order to replace elements in the initial template.
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public virtual ControlTransformFactory OnGetElementFactory(DependencyObject content)
{
if (content == null)
{
return null;
}
// use the object type
ControlTransformFactory factory = new ControlTransformFactory(content, this);
return factory;
}

/// <summary>
/// Returns a safe value for setting on the control
/// </summary>
/// <param name="item">The value from the template</param>
/// <returns></returns>
public virtual object GetSafeValue(object item)
{
return getSafeValue((dynamic) item);
}

/// <summary>
/// Returns true if a property needs to be saved and set when the control loads.
/// Defaults to false, except for ColumnDefinitions and RowDefinitions
/// </summary>
/// <param name="propertyDescriptor"></param>
/// <returns></returns>
public virtual bool MustSetProperty(PropertyDescriptor propertyDescriptor)
{
return sMustSetProperties.Contains(propertyDescriptor.Name);
}

#endregion

#region Protected Methods

/// <summary>
/// Allows for the manipulation of a control template
/// </summary>
/// <param name="newTemplate"></param>
protected virtual void OnBeforeSeal(ControlTemplate newTemplate)
{
}

#endregion

#region Statics

private static readonly List<string> sMustSetProperties = new List<string>
{
"ColumnDefinitions",
"RowDefinitions"
};

/// <summary>
/// Transforms a DependencyObject tree into a FrameworkElementFactory tree
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static ControlTransformFactory CreateElementFactory(DependencyObject content)
{
if (content == null)
{
return null;
}
// use the object type
ControlTransformFactory factory = new ControlTransformFactory(content);
return factory;
}

/// <summary>
/// default return the same value
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static object getSafeValue(object value)
{
return value;
}

/// <summary>
/// try to clone ColumnDefinition objects
/// </summary>
/// <param name="columnDefinition"></param>
/// <returns></returns>
private static object getSafeValue(ColumnDefinition columnDefinition)
{
return clone(columnDefinition);
}

/// <summary>
/// try to clone RowDefinition objects
/// </summary>
/// <param name="rowDefinition"></param>
/// <returns></returns>
private static object getSafeValue(RowDefinition rowDefinition)
{
return clone(rowDefinition);
}

/// <summary>
/// Clones an item via Xaml write/parse
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
private static object clone(object element)
{
string str = XamlWriter.Save(element);
return XamlReader.Parse(str);
}

#endregion
}
}

#region Using directives

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using System.Windows;
using System.Windows.Markup.Primitives;
using System.Windows.Media;

#endregion

namespace BestPractices
{
/// <summary>
/// FrameworkElementFactory used in control template transformers
/// </summary>
public class ControlTransformFactory : FrameworkElementFactory
{
#region Nested

internal class NoTemplateTransformer : BaseTemplateTransformer
{
}

#endregion

#region Instance fields

private readonly BaseTemplateTransformer mTemplateTransformer;

private RoutedEventHandler mLoadHandler;
private List<MarkupProperty> mSimpleProperties;

#endregion

#region Properties

/// <summary>
/// List of non dependency properties that will be set when the control loads
/// </summary>
protected List<MarkupProperty> SimpleProperties
{
get
{
if (mSimpleProperties == null)
{
mSimpleProperties = new List<MarkupProperty>();
}
return mSimpleProperties;
}
}

#endregion

#region Constructors

public ControlTransformFactory(DependencyObject content,
BaseTemplateTransformer templateTransformer = null)
: base(content.GetType())
{
mTemplateTransformer = templateTransformer ?? new NoTemplateTransformer();
// set its name
string name = content.GetValue(FrameworkElement.NameProperty) as string;
if (!string.IsNullOrWhiteSpace(name))
{
Name = name;
}
// copy the properties
foreach (MarkupProperty propertyItem in getProperties(content))
{
SetProperty(propertyItem);
}
// do it recursively
int count = VisualTreeHelper.GetChildrenCount(content);
for (int i = 0; i < count; i++)
{
DependencyObject child = VisualTreeHelper.GetChild(content, i);
AppendChild(mTemplateTransformer.OnGetElementFactory(child));
}
}

#endregion

#region Public Methods

/// <summary>
/// SetValue that uses reflection to force DependencyProperties that were registered as read only
/// </summary>
/// <param name="dependencyProperty"></param>
/// <param name="value"></param>
/// <param name="forceSetReadOnly"></param>
public void SetValue(DependencyProperty dependencyProperty, object value,
bool forceSetReadOnly = false)
{
if (!forceSetReadOnly)
{
base.SetValue(dependencyProperty, value);
}
else
{
forceSetValue(dependencyProperty, value);
}
}

/// <summary>
/// Sets a value from a MarkupProperty object.
/// Dependency properties will be set via SetValue and the others via a Loaded handler on the object
/// </summary>
/// <param name="propertyItem"></param>
public void SetProperty(MarkupProperty propertyItem)
{
DependencyProperty property = propertyItem.DependencyProperty;
if (property == null)
{
setSimpleProperty(propertyItem);
}
else
{
object value = propertyItem.Value;
if (value == DependencyProperty.UnsetValue)
{
return;
}
SetValue(property, value, property.ReadOnly);
}
}

#endregion

#region Private Methods

/// <summary>
/// Force set value in the factory, even if the property is ReadOnly
/// </summary>
/// <param name="dp"></param>
/// <param name="value"></param>
private void forceSetValue(DependencyProperty dp, object value)
{
object resourceKey = getResourceKey(value);
if (resourceKey == null)
{
updatePropertyValueList(dp, value is TemplateBindingExtension
? "TemplateBinding"
: "Set", value);
}
else
{
updatePropertyValueList(dp, "Resource", value);
}
}

/// <summary>
/// Invoke the private UpdatePropertyValueList on the factory
/// </summary>
/// <param name="dp"></param>
/// <param name="propertyValueTypeName"></param>
/// <param name="value"></param>
private void updatePropertyValueList(DependencyProperty dp,
string propertyValueTypeName, object value)
{
object propertyValueType = Enum.Parse(sPropertyValueTypeType, propertyValueTypeName);
sUpdatePropertyValueListProperty.Invoke(this, new[] {dp, propertyValueType, value});
}

/// <summary>
/// Set a property to have its value set at load time
/// </summary>
/// <param name="markupProperty"></param>
private void setSimpleProperty(MarkupProperty markupProperty)
{
if (markupProperty.PropertyDescriptor == null)
{
return;
}
if (!mTemplateTransformer.MustSetProperty(markupProperty.PropertyDescriptor))
{
return;
}
SimpleProperties.Add(markupProperty);
if (mLoadHandler == null)
{
mLoadHandler = new RoutedEventHandler(simplePropertyHandler);
AddHandler(FrameworkElement.LoadedEvent, mLoadHandler);
}
}

/// <summary>
/// Handler on the Loaded event of the control
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void simplePropertyHandler(object sender, RoutedEventArgs args)
{
foreach (MarkupProperty propertyItem in SimpleProperties)
{
PropertyDescriptor propertyDescriptor = propertyItem.PropertyDescriptor;
if (propertyDescriptor == null || propertyItem.Value == null)
{
continue;
}
if (propertyDescriptor.IsReadOnly)
{
IList list = propertyItem.Value as IList;
if (list != null)
{
IList destinationList = propertyDescriptor.GetValue(sender) as IList;
if (destinationList != null)
{
foreach (object item in list)
{
destinationList.Add(mTemplateTransformer.GetSafeValue(item));
}
}
else
{
//shouldn't happend
}
}
else
{
// what now?
}
}
else
{
propertyDescriptor.SetValue(sender, mTemplateTransformer.GetSafeValue(propertyItem.Value));
}
}
FrameworkElement element = (FrameworkElement) sender;
element.RemoveHandler(FrameworkElement.LoadedEvent, mLoadHandler);
}

#endregion

#region Statics

static ControlTransformFactory()
{
// Get the types and methods that will be used in Reflection scenarios
sUpdatePropertyValueListProperty =
typeof (FrameworkElementFactory).GetMethod("UpdatePropertyValueList",
BindingFlags.NonPublic | BindingFlags.Instance);
sPropertyValueTypeType =
typeof (FrameworkElementFactory).Assembly.GetType("System.Windows.PropertyValueType");
}

private static readonly MethodInfo sUpdatePropertyValueListProperty;
private static readonly Type sPropertyValueTypeType;

/// <summary>
/// get the properties set on a DependencyObject
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
private static IEnumerable<MarkupProperty> getProperties(DependencyObject content)
{
MarkupObject markupObject = MarkupWriter.GetMarkupObjectFor(content);
return markupObject.Properties;
}

/// <summary>
/// Get the ResourceKey property from an object, if it exists
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
private static object getResourceKey(object target)
{
if (target == null)
{
return null;
}
Type type = target.GetType();
PropertyInfo property = type.GetProperty("ResourceKey");
if (property == null)
{
return null;
}
return property.GetValue(target, new object[] {});
}

#endregion
}
}

1. make a SHA256 hash of the public key embedded in the .crx file
2. take the first 128bits (16 bytes) and encode them in base16
3. use characters a-p instead of the customary 0-9,A-F

private byte[] getPublicKey(FileInfo fi)
{
  using (
      FileStream stream = File.Open(fi.FullName,
                                    FileMode.Open,
                                    FileAccess.Read,
                                    FileShare.ReadWrite))
  {
    byte[] arr = new byte[4];
    stream.Seek(8, SeekOrigin.Begin);
    stream.Read(arr, 0, arr.Length);
    var publicKeyLength = BitConverter.ToInt32(arr, 0);
    arr = new byte[publicKeyLength];
    stream.Seek(16, SeekOrigin.Begin);
    stream.Read(arr, 0, arr.Length);
    return arr;
  }
}

private string getExtensionId(byte[] publicKey)
{
  SHA256 sha = SHA256.Create();
  publicKey = sha.ComputeHash(publicKey);
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < 16; i++)
  {
    byte b = publicKey[i];
    char ch = (char)('a' + (b >> 4));
    sb.Append(ch);
    ch = (char)('a' + (b & 0xF));
    sb.Append(ch);
  }
  return sb.ToString();
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Web.Script.Serialization;
using SevenZip;

namespace ChromeExtensionInstaller
{
  internal class CrxPack
  {
    #region Instance fields

    private byte[] mContent;
    private SevenZipExtractor mExtractor;
    private dynamic mManifest;
    private Uri mUri;
    private string mPath;

    #endregion

    #region Properties

    public Exception InvalidReason
    {
      get;
      private set;
    }

    public bool IsValid
    {
      get;
      private set;
    }

    private dynamic Manifest
    {
      get
      {
        if (mManifest == null)
        {
          FileInfo fi = new FileInfo(mUri.AbsolutePath);
          mManifest = getManifest(fi);
        }
        return mManifest;
      }
    }

    public string Id
    {
      get
      {
        return getExtensionID();
      }
    }

    public string Name
    {
      get
      {
        return Manifest.name as string;
      }
    }

    public string Version
    {
      get
      {
        return Manifest.version as string;
      }
    }

    public string Path
    {
      get
      {
        return mPath;
      }
    }

    #endregion

    #region Constructors

    public CrxPack(string path)
    {
      mPath = path;
      try
      {
        checkPath(path);
        IsValid = true;
      }
      catch (Exception ex)
      {
        IsValid = false;
        InvalidReason = ex;
      }
    }

    #endregion

    #region Private Methods

    private void checkPath(string path)
    {
      mUri = ExtensionHelper.GetUri(path);
      if (mUri == null)
      {
        throw new Exception(string.Format("Parameter is not a valid URI ({0})", mPath));
      }
      mPath = mUri.AbsolutePath;
      if (!mUri.IsFile && !mUri.IsUnc)
      {
        throw new Exception(string.Format("Only file and local network paths are acceptable ({0})",
                                          mPath));
      }
      DirectoryInfo di = new DirectoryInfo(mPath);
      if (di.Exists)
      {
        throw new Exception(string.Format(
            "Loading extensions from folders is not implemented ({0})", mPath));
      }
      FileInfo fi = new FileInfo(mPath);
      if (!fi.Exists)
      {
        throw new Exception(string.Format("The file does not exist ({0})", mPath));
      }
      if (fi.Extension.ToLower() != ".crx")
      {
        throw new Exception(string.Format("The file extension must be a .crx file ({0})", mPath));
      }
      try
      {
        mExtractor = getExtractor(fi);
        if (mExtractor.Check())
        {
          return;
        }
      }
      catch (Exception ex)
      {
        throw new Exception(
            string.Format("The file could not be read as a valid .crx file ({0})", mPath), ex);
      }
      throw new Exception(string.Format("The file could not be read as a valid .crx file ({0})",
                                        mPath));
    }


    private SevenZipExtractor getExtractor(FileInfo fi)
    {
      byte[] arr;
      using (
          FileStream stream = File.Open(fi.FullName, FileMode.Open, FileAccess.Read,
                                        FileShare.ReadWrite))
      {
        arr = new byte[fi.Length];
        mContent = arr;
        stream.Read(arr, 0, arr.Length);
      }
      // force PkZip signature
      arr[0] = 0x50;
      arr[1] = 0x4B;
      arr[2] = 0x03;
      arr[3] = 0x04;
      MemoryStream ms = new MemoryStream(arr);
      return new SevenZipExtractor(ms);
    }

    private string getExtensionID()
    {
      int length = readInt(8);
      byte[] bytes = readBytes(16, length);
      SHA256 sha = SHA256.Create();
      bytes = sha.ComputeHash(bytes);
      StringBuilder sb = new StringBuilder();
      for (int i = 0; i < 16; i++)
      {
        byte b = bytes[i];
        char ch = (char) ('a' + (b >> 4));
        sb.Append(ch);
        ch = (char) ('a' + (b & 0xF));
        sb.Append(ch);
      }
      return sb.ToString();
    }

    private int readInt(int index)
    {
      byte[] bytes = readBytes(index, 4);
      return BitConverter.ToInt32(bytes, 0);
    }

    private byte[] readBytes(int index, int length)
    {
      byte[] bytes = new byte[length];
      Array.Copy(mContent, index, bytes, 0, length);
      return bytes;
    }

    private object getManifest(FileInfo fi)
    {
      SevenZipExtractor extractor = getExtractor(fi);
      string json;
      using (MemoryStream ms = new MemoryStream())
      {
        extractor.ExtractFile("manifest.json", ms);
        ms.Seek(0, SeekOrigin.Begin);
        StreamReader sr = new StreamReader(ms);
        json = sr.ReadToEnd();
      }
      JavaScriptSerializer serializer = new JavaScriptSerializer();
      serializer.RegisterConverters(new[] {new DynamicJsonConverter()});
      return serializer.Deserialize(json, typeof (object));
    }

    #endregion
  }
}

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography\Defaults\Provider\Microsoft Enhanced RSA and AES Cryptographic Provider]
"Image Path"="rsaenh.dll"
"Type"=dword:00000018
"SigInFile"=dword:00000000

<Style x:Key="StyleRequiredUnderline" TargetType="{x:Type Line}">
  <Setter Property="HorizontalAlignment" Value="Left"/>
  <Setter Property="Stretch" Value="Fill"/>
  <Setter Property="X1" Value="0"/>
  <Setter Property="X2" Value="1"/>
  <Setter Property="Y1" Value="0"/>
  <Setter Property="Y2" Value="0"/>
  <Setter Property="MaxWidth" Value="200"/>
</Style>

<Grid>
  <TextBlock x:Name="TextBlock" />
  <Line Name="RequiredUnderline" Style="{StaticResource StyleRequiredUnderline}"
        />
</Grid>

<Grid>
  <TextBlock x:Name="TextBlock" />
  <Line Name="RequiredUnderline" Style="{StaticResource StyleRequiredUnderline}"
        Width="{Binding ActualWidth,ElementName=TextBlock}" />
</Grid>

public class ClipContainer : ContentControl
{
 protected override Size MeasureOverride(Size availableSize)
  {
    base.MeasureOverride(availableSize);
    return new Size(0, 0);
  }
}

<Grid>
  <TextBlock x:Name="TextBlock" />
  <local:ClipContainer>
    <Line Name="RequiredUnderline" Style="{StaticResource StyleRequiredUnderline}" />
  </local:ClipContainer>
</Grid>

[AttachedPropertyBrowsableForType(typeof (object))]