I usually need the MouseDown / MouseUp Events of the Button for several use cases.
Therefore I just created a simple behavior which contains two command properties (on for the MouseUp and one for the MouseDown event).

The MouseCommandBehavior class looks like this

public static class MouseCommandBehavior
  {
    #region Commands

    ///
    /// The comamnd which should be executed when the mouse is down
    ///
    public static readonly DependencyProperty MouseDownCommandProperty =
        DependencyProperty.RegisterAttached("MouseDownCommand",
            typeof(ICommand),
            typeof(MouseCommandBehavior),
            new FrameworkPropertyMetadata(null, (obj, e) => OnMouseCommandChanged(obj, (ICommand)e.NewValue, false)));

    ///
    /// Gets the MouseDownCommand property
    ///
    public static ICommand GetMouseDownCommand(DependencyObject d)
    {
      return (ICommand)d.GetValue(MouseDownCommandProperty);
    }

    ///
    /// Sets the MouseDownCommand property
    ///
    public static void SetMouseDownCommand(DependencyObject d, ICommand value)
    {
      d.SetValue(MouseDownCommandProperty, value);
    }

    ///
    /// The comamnd which should be executed when the mouse is up
    ///
    public static readonly DependencyProperty MouseUpCommandProperty =
        DependencyProperty.RegisterAttached("MouseUpCommand",
            typeof(ICommand),
            typeof(MouseCommandBehavior),
            new FrameworkPropertyMetadata(null, new PropertyChangedCallback((obj, e) => OnMouseCommandChanged(obj, (ICommand)e.NewValue, true))));

    ///
    /// Gets the MouseUpCommand property
    ///
    public static ICommand GetMouseUpCommand(DependencyObject d)
    {
      return (ICommand)d.GetValue(MouseUpCommandProperty);
    }

    ///
    /// Sets the MouseUpCommand property
    ///
    public static void SetMouseUpCommand(DependencyObject d, ICommand value)
    {
      d.SetValue(MouseUpCommandProperty, value);
    }

    #endregion

    ///
    /// Registeres the event and calls the command when it gets fired
    ///
    private static void OnMouseCommandChanged(DependencyObject d, ICommand command, bool isMouseUp)
    {
      if (command == null) return;

      var element = (FrameworkElement)d;

      if(isMouseUp)
          element.PreviewMouseUp += (obj, e) => command.Execute(null);
      else
          element.PreviewMouseDown += (obj, e) => command.Execute(null);
      }
    }
  }

I hardcoded in this class these two events. But you could even add your own ones

In the XAML-Code you can use it like that

        <button>

If you want a even more flexible approach where you can register just one Command then you can use the behavior of Sacha Barber.
Check this out WPF : Attached Commands

I attached a zip file (remove the .doc extension) which contains a complete project. It is slightly different then what I explained above but the idea is the same.

WpfApplication2.zip

Before .Net 4 we either used the BackgroundWorker or a Thread (from the ThreadPool).

In the good old days we have even been happy with them but when you see the new tasks then you will not like them anymore
With the tasks you can do much more than just running a piece of code in a worker thread but it does not guarantee that the task is not run in the GUI thread.

If that happens it can block the application which could be really annoying for us and also for the user.

In order to guarantee that the task is run in a non GUI thread we have to build our own TaskScheduler.
In the samples for the parallel programming with .net 4 is already a custom TaskScheduler (called StaTaskScheduler) http://code.msdn.microsoft.com/ParExtSamples

Usually you start your task like in this example

Task.Factory.StartNew(() => DoLongRunningOperation());

If you want to use the custom TaskScheduler (called StaTaskScheduler) then you have to start the task like in the following example

var scheduler = new StaTaskScheduler(5);
Task.Factory.StartNew(() => DoLongRunningOperation(),
                                        CancellationToken.None,
                                        TaskCreationOptions.None,
                                        scheduler);

Now we have a way in which we can be sure that our tasks are not run in the GUI thread.

With the number (5 in my example) we can define how much threads should be used by the TaskScheduler to execute our actions.

If there are not enough threads (ex. if we have 5 tasks and just 2 threads) then the tasks will automatically wait until a thread is free.

The type reference cannot find a public type named ‘MyType’

So after a few hours of testing and searching I finally found the solution. I just had to remove the assembly from the import of the namespace.

Now lets have a look at a simple demonstration of the problem

This is the type I want to assign to the DataTemplate

namespace MyWpfApp
{
    public class MyType
    {
        private string _description;

        public MyType(string description)
        {
            _description= description;
        }

        public string Description
        {
            get { return _description; }
        }
    }
}

In the UI I defined a DataTemplate for this type

<Window x:Class="MyWpfApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:me="clr-namespace:MyWpfApp;assembly=MyWpfApp"
    Title="MainWindow">    
    <Window.Resources>
        <DataTemplate DataType="{x:Type me:MyType}"> <!-- Here it displays the error message -->
            <StackPanel Orientation="Vertical">
                <TextBlock Text="Description" FontWeight="Bold" Margin="5"/>
                <TextBlock Text="{Binding Description}" Margin="5"/>
            </StackPanel>
        </DataTemplate>
......

This code results in the error message I talked about before.

But if you change the import of the MyWpfApp namespace then it works without problems.

<Window x:Class="MyWpfApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:me="clr-namespace:MyWpfApp" <!-- REMOVED the assembly in the namespace import to fix the problem -->
    Title="MainWindow">    
    <Window.Resources>
        <DataTemplate DataType="{x:Type me:MyType}">
            <StackPanel Orientation="Vertical">
                <TextBlock Text="Description" FontWeight="Bold" Margin="5"/>
                <TextBlock Text="{Binding Description}" Margin="5"/>
            </StackPanel>
        </DataTemplate>
......

Have fun

But I found a wonderful blog post which contains the links to offline installers of all framework version.
Here it is: .NET offline installers

Have fun!

If you try to do it as usual then you will receive an exception.
An example would be

var myType = typeof (double);
var list = (List<myType>) Activator.CreateInstance(typeof (List<myType>), null);

The compiler tells you that a type or namespace is expected and not myType!

In order to do that you can use the MakeGenericType method to add the generic types to the List and after that you can create the instance

var myGenericType = typeof(List<>).MakeGenericType(new []{typeof(double)});
var myList = (List<double>)Activator.CreateInstance(myGenericType);

Note that the MakeGenericType method only creates the type which then is used to create an object in the next line

When “raising” (fire) an event it is really annoying that we always have to check if the event is not null.
This results in a quite long code and we have always to repeat the same thing again.

Example:

public event EventHandler<EventArgs> MyEvent;

protected void RaiseMyEvent()
{
   if(MyEvent != null)
      MyEvent(this, EventArgs.Empty);
}

Using this extension method

/// <summary>
/// This method raises the given event with the given sender and EventArgs
/// </summary>
/// <typeparam name="T">The type of the event handler</typeparam>
/// <param name="eventHandler">The event handler</param>
/// <param name="sender">The sender</param>
/// <param name="e">The event args</param>
public static void Raise<T>(this EventHandler<T> eventHandler, Object sender, T e) where T : EventArgs
{
	if (eventHandler != null)
	{
		eventHandler(sender, e);
	}
}

it is possible to raise the event with that

public event EventHandler MyEvent<EventArgs>;

MyEvent.Raise(this, EventArgs.Empty);

Another example where Extension Methods are really useful is when you want to ensure that an action / function is executed in the right thread.
Usually you have to check whether you actually are in the right thread and invoke if necessary.

example:

public void MyMethod()
{
     if(myDispatcher.CheckAccess())
     {
        DoSomething();
     }
     else
     {
        myDispatcher.Invoke(new Action(MyMethod));
     }
}

		/// <summary>
		/// This method automatically executes the given action in
		/// the correct thread.
		/// </summary>
		/// <param name="source">The source of the method call</param>
		/// <param name="func">The function which should be executed in the right thread</param>
		public static void Dispatch(this Dispatcher source, Action func)
		{
			if (source.CheckAccess())
				func();
			else
				source.Invoke(func);
		}

And here an example how to call it

myDispatcher.Dispatch(DoSomething);

More useful extension methods will follow…

If you want to adjust the width of all scrollbars in your application you can put this piece of code into you resources

        <Style x:Key="{x:Type ScrollBar}" TargetType="{x:Type ScrollBar}">          
                <Setter Property="MinWidth" Value="35" />
                <Setter Property="Width" Value="35" />
        </Style>

Visual Studio 2010 has been released a few hours ago.
You can download it here:

maybe you ever had the problem that you wanted to create a custom validationrule but you need some kind of an extra parameter.
But it seems that there is no straightforward way to do that.

So I used this workaround in order to achieve that.
In this example I will validate a string. The parameter gives the length if the string is shorter then it is valid else not.

First of all we have to create our custom ValidationRule

public class MyStringLengthValidationRule : ValidationRule
  {
    /// <summary>
    /// Gets or sets the maximal length of the string
    /// </summary>
    public int Length { get; set; }

    /// <summary>
    /// Checks if the string is valied
    /// </summary>
    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
      if (value.ToString().Length <= Length)
         return new ValidationResult(true, null);
      return new ValidationResult(false, "The string is to long");
    }
  }

All right. Here you see this simple ValidationRule with our additional property (Length).
We can not use DependencyProperties because ValidationRule does not extend DependencyObject therefore we have to use this property.

The second step is to assign our ValidationRule to a control

        <TextBox>
            <TextBox.Text>
                <Binding Path="MyText">
                    <Binding.ValidationRules>
                        <utils:MyStringLengthValidationRule Length="{Binding MyLength}" />
                    </Binding.ValidationRules>
                </Binding>
            </TextBox.Text>
        </TextBox>

The version using the proxy looks like this

<utils:Proxy In="{Binding MyLength, Mode=OneWay,UpdateSourceTrigger=PropertyChanged}" Out="{Binding ElementName=strLengthValidationRule, Path=Length}" /> 
<TextBox>
  <TextBox.Text>
     <Binding Path="MyText">
         <Binding.ValidationRules>
            <utils:MyStringLengthValidationRule x:Name="strLengthValidationRule" />
          </Binding.ValidationRules>
       </Binding>
  </TextBox.Text>
</TextBox>

All right now it should work.

I attached the demo project. Where you can specify the maximal length (upper TextBox) of the string in the TextBox at the bottom.
Note that the Validation will only be updated when the value of the TextBox was changed!

The attached file is a rar file. I just have to add the doc extension because else I can not upload it.
Change the extension in .rar then you can extract it. (It contains the demo project as a VS 2010 Beta solution)
ValidatorWithParameter.rar (doc)

if you tried to create a Grid, Canvas or a DockPanel in C# problem than you probably had the problem that you do not know how to add the children to a specific column, row or whatever.

These properties are so called Attached Properties. And you can not see them if you call textBox.Grid.Row in the C# code.

Here an example

<Grid>
   <TextBox Grid.Row="0" Grid.Column="0" />
</Grid>

But you can not do the following in your C# Code

<pre>Grid grid = new Grid();
TextBox txt = new TextBox();
txt.Grid.Column = 1; //Not possible!

But you can do the following

//Set the Grid.Row Attached Property of the TextBox txt to 0
Grid.SetRow(txt, 0);
//Set the Grid.Column Attached Property of the TextBox txt to 0
Grid.SetColumn(txt,0);

It works in the same way for all other Attached Properties