http://stackoverflow.com/questions/58739/interview-questions-wpf-developer

What should every WPF developer know?

Entry Level

• Strong .NET 2.0 Background & willing to learn!
• Explain dependency properties?
• What's a style?
• What's a template?
• Binding
• Differences between base classes: Visual, UIElement, FrameworkElement, Control
• Visual vs Logical tree?
• Property Change Notification (INotifyPropertyChange and ObservableCollection)
• ResourceDictionary - Added by a7an
• UserControls - Added by a7an
• difference between bubble and tunnel routing strategies - added by Carlo

Mid-level

• Routed Events & Commands
• Converters - Added by Artur Carvalho
• Explain WPF's 2-pass layout engine?
• How to implement a panel?
• Interoperability (WPF/WinForms)
• Blend/Cider - Added by a7an
• animations and storyboarding
• ClickOnce Deployment
• Skinning/Themeing
• Custom Controls
• How can worker threads update the UI?

Senior

• Example of attached behavior?
• What is PRISM,CAL & CAG?
• How can worker threads update the UI?
• WPF 3D - Added by a7an
• Differences between Silverlight 2 and WPF
• MVVM/MVP - Added by a7an
• WPF Performance tuning
• Pixel Shaders
• Purpose of Freezables

http://joyfulwpf.blogspot.com/2009/05/mvvm-invoking-command-on-attached-event.html
http://jacokarsten.wordpress.com/2009/03/27/applying-command-binding-to-any-control-and-any-event/

http://devlicio.us/blogs/christopher_bennage/archive/tags/ChumChase/default.aspx

http://geekswithblogs.net/claraoscura/archive/2008/10/17/125901.aspx

“The solution I have found is to put each radio button in a different group and link their checked/unchecked values via the converter. Like this:”

       <RadioButton 
                Grid.Row="1" Grid.Column="0" GroupName="rbGroupSuccess" Margin="8,0,0,0" VerticalAlignment="Center" Content="Success" x:Name="rbSuccess" IsChecked="{Binding
Path=IsSuccess, Mode=TwoWay, Converter={StaticResource nullableBooleanConverter},
ConverterParameter=true}" /> <RadioButton Grid.Row="1" Grid.Column="1" GroupName="rbGroupFailure" Margin="8,0,0,0" VerticalAlignment="Center" Content="Failure" x:Name="rbFailure" IsChecked="{Binding
Path=IsSuccess, Mode=TwoWay, Converter={StaticResource nullableBooleanConverter},
ConverterParameter=false}" />

    [ValueConversion(typeof(bool?), typeof(bool))] publicclass SuccessConverter
: IValueConverter { publicobject Convert(objectvalue,
Type targetType, object parameter, CultureInfo culture)
{ bool param = bool.Parse(parameter.ToString()); if (value == null)
{ returnfalse; } else { return !((bool)value ^
param); } } publicobject ConvertBack(objectvalue,
Type targetType, object parameter, CultureInfo culture)
{ bool param = bool.Parse(parameter.ToString()); return !((bool)value ^
param); } }

http://wpf.codeplex.com/Thread/View.aspx?ThreadId=44358

http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/03972347-969f-4704-9b54-2d13c265fb8f

DataGrid Master/Details http://mtaulty.com/CommunityServer/blogs/mike_taultys_blog/archive/2008/10/01/10798.aspx

Explicitly Load Related Objects http://msdn.microsoft.com/en-us/library/bb896249.aspx

http://www.codeproject.com/KB/WPF/WpfMatrix.aspx

Sachabarber’s extension method http://sachabarber.net/?p=411 (Five start solution)

http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/82c6451d-d37b-4380-aa11-d75c2f759ba7/

XAML:
<Window x:Class="WindowsApplication1.Window1" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="Testing
BackgroundWorker" Height="300" Width="300" >
<Grid> <Button HorizontalAlignment="Left" Margin="8,25,0,0" x:Name="_btnStart" VerticalAlignment="Top" Width="87" Height="27" Content="Start" Click="StartWorker"/>
<Button IsEnabled="False" Margin="99,25,102,0" x:Name="_btnCancel" VerticalAlignment="Top" Height="27" Content="Cancel" Click="CancelWorker"/>
<ProgressBar Margin="8,0,8,107" x:Name="_progressBar" VerticalAlignment="Bottom" Height="23" Maximum="10"/>
</Grid> </Window> 

C#:
using System.ComponentModel; using System.Threading; using System.Windows; namespace WindowsApplication1
{ /// <summary> /// Interaction
logic for Window1.xaml /// </summary> publicpartialclass Window1
: System.Windows.Window { private BackgroundWorker _worker; public Window1()
{ InitializeComponent(); } privatevoid StartWorker(object sender,
RoutedEventArgs e) { int N = 10; _worker = new BackgroundWorker();
_worker.WorkerReportsProgress = true; _worker.WorkerSupportsCancellation
= true; _worker.DoWork += delegate(object s,
DoWorkEventArgs args) { BackgroundWorker worker = s as BackgroundWorker; for (int i
= 0; i < N; i++) { if (worker.CancellationPending) {
args.Cancel = true; return; }
Thread.Sleep(1000); worker.ReportProgress(i + 1); } }; _worker.ProgressChanged += delegate(object s,
ProgressChangedEventArgs args) { _progressBar.Value = args.ProgressPercentage; };
_worker.RunWorkerCompleted += delegate(object s,
RunWorkerCompletedEventArgs args) { _btnStart.IsEnabled = true;
_btnCancel.IsEnabled = false; _progressBar.Value = 0; };
_worker.RunWorkerAsync(); _btnStart.IsEnabled = false; _btnCancel.IsEnabled
= true; } privatevoid CancelWorker(object sender,
RoutedEventArgs e) { _worker.CancelAsync(); } } } 

Coroutines with IEnumnberable and yield return http://incrediblejourneysintotheknown.blogspot.com/2008/04/coroutines-with-ienumerable-and-yield.html

Forcing Update of UI before my function exists http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/6fce9b7b-4a13-4c8d-8c3e-562667851baa/

“

          An even easier method has just occurred to me: just call this method
after setting UI properties: void AllowUIToUpdate() { DispatcherFrame
frame = new DispatcherFrame(); Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Render, new DispatcherOperationCallback(delegate(object parameter)
{ frame.Continue = false; returnnull;
}), null); Dispatcher.PushFrame(frame); } If my understanding
of DispatcherPriority is correct, this will
allow all render level messages to be processed, and will then return.
This feels a little like a WPF equivalent of Application.DoEvents, and I know their
are dangers with that. Anybody with a deeper understanding of WPF threading got any
thoughts on this?
        

“

http://www.blender.org/

http://www.codeplex.com/xamlexporter

http://www.erain.com/products/zam3d/screenshots/

http://www.erain.com/products/zam3d/Examples/worldclock/worldclock.asp

Home http://expression.microsoft.com/en-us/default.aspx

Expression Design tutorial http://www.lynda.com/home/DisplayCourse.aspx?lpk2=339

Integrating 3D into Expression Blend with ZAM 3D http://expression.microsoft.com/en-us/dd567847.aspx

http://marlongrech.wordpress.com/2008/12/13/attachedcommandbehavior-v2-aka-acb/

2 new features

- Support for Collection of binding to commands
- Support for Light weight Commands or as I call them Action

http://www.ageektrapped.com/blog/staticresource-does-not-mean-static/

http://wpfwonderland.wordpress.com/2007/08/11/mixing-external-mergeddictionaries-with-local-resources-in-appxaml/

Adding local application resources

Even though it is easy to add external resources it’s likely that you’ll want to have a style or other resource that you don’t intend to shared across applications.  You could isolated these resources within a single page (Page.Resources) or element (DockPanel.Resources)  But what if you want to add  them to <Application.Resources> tag?  You can do it as long as you know the correct location. They have to go between the </ResourceDictionary.MergedDictionaries> and </ResourceDictionary> tags.

    <Application.Resources>
      <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
          <ResourceDictionary Source="WorkshopHelpers/MainResources.xaml"/>
        </ResourceDictionary.MergedDictionaries>
        <!--
Place here...--> <Style TargetType="Rectangle" > <Setter Property="Width"
Value="100"/> <Setter Property="Height" Value="80"/> </Style> </ResourceDictionary>
</Application.Resources> </Application> 

-Walt Ritscher

          
  1: m_DispatcherTimer = new DispatcherTimer() 
          
  2: {

          
  3: Interval = TimeSpan.FromSeconds(0.25),

          
  4: IsEnabled = true
          
  5: };

          
  6: 

          
  7: m_DispatcherTimer.Tick += delegate
          
  8: {

          
  9: CommandManager.InvalidateRequerySuggested();

          
 10: };

          
 11: 
        

http://robburke.net/2008/04/23/wpf-command-pattern-when-does-it-query-canexecute/

http://www.hardcodet.net/2009/01/combinding-wpf-validation-rules-and-idataerrorinfo-to-validate-conversion-errors

Related:

http://karlshifflett.wordpress.com/mvvm/input-validation-ui-exceptions-model-validation-errors/

http://www.hardcodet.net/2008/04/wpf-custom-binding-class

http://joshsmithonwpf.wordpress.com/2008/11/14/using-a-viewmodel-to-provide-meaningful-validation-error-messages/

http://blogs.msdn.com/wpfsdk/archive/2007/01/16/someone-s-been-sitting-in-my-chair-property-changed-detection-mechanisms-in-wpf.aspx

Part1: http://blogs.msdn.com/wpfsdk/archive/2007/03/16/how-do-i-programmatically-interact-with-template-generated-elements-part-i.aspx

part2: http://blogs.msdn.com/wpfsdk/archive/2007/04/16/how-do-i-programmatically-interact-with-template-generated-elements-part-ii.aspx

http://www.xamltemplates.net/

http://www.nukeation.com/

Feature walkthrough http://windowsclient.net/wpf/wpf35/wpf-35sp1-toolkit-datagrid-feature-walkthrough.aspx

http://blogs.msdn.com/vinsibal/archive/2008/08/11/net-3-5-sp1-and-wpf-datagrid-ctp-is-out-now.aspx

MVVM Grouping with the DataGrid http://blogs.msdn.com/vinsibal/archive/2009/01/21/exploring-mvvm-grouping-with-the-datagrid.aspx

Dabbling around http://blogs.msdn.com/jaimer/archive/2008/08/13/dabbling-around-the-new-wpf-datagrid-part-1.aspx

FluidKit  http://www.codeplex.com/fluidkit  

WPF Futures http://www.codeplex.com/wpf/Release/ProjectReleases.aspx?ReleaseId=14962

http://weblogs.asp.net/thomaslebrun/archive/2009/03/24/wpf-how-to-develop-and-editable-textblock.aspx

MVVM Routed and Relay Command  http://stackoverflow.com/questions/650010/mvvm-routed-and-relay-command

MVVM in Silverlight 2 Apps http://msdn.microsoft.com/en-us/magazine/dd458800.aspx

[MVVM + Mediator + ACB = cool WPF App] http://marlongrech.wordpress.com/2009/04/08/mvvm-mediator-acb-cool-wpf-app-the-mvvm/

WPF & Silverlight Line of Business UI Design Pattern Home Page http://karlshifflett.wordpress.com/mvvm/   (*****)

Mediator v2 for MVVM WPF and Silverlight applications http://marlongrech.wordpress.com/2009/04/16/mediator-v2-for-mvvm-wpf-and-silverlight-applications/

CommandSink (Using RoutedCommands with a ViewModel in WPF) http://www.codeproject.com/KB/WPF/VMCommanding.aspx

Mapping commands in WPF http://www.codeproject.com/KB/WPF/MapperCommandBinding.aspx

From Josh Smith

“Use CommandSink if you must use routed commands. Otherwise, use RelayCommand. Routed commands should not be your first choice when choosing how to set up commanding, because it’s unnecessarily complicated and heavy for most use cases.”

Using Comand Binding to Enhance Any WPF Control http://www.dev102.com/2008/12/10/using-command-binding-to-enhance-any-wpf-control/

http://interactiveasp.net/blogs/natesstuff/archive/2009/01/21/6-things-i-bet-you-didn-t-know-about-data-binding-in-wpf.aspx

http://www.tozon.info/blog/post/2009/02/16/Binding-to-Enums.aspx

I’ve seen numerous questions regarding data binding to Enums, together with many solutions on how to do it, but the question I’m asking myself is – do I really want to bind anything to an Enum?

I like to think about Enums purely as a coding aid – to help programmer code with some descriptive names instead of messing with pure numeric values. Similar to what constants are for, except Enums provide a set of values for describing a single parameter.

Instead of:

product.Quality = 3;

the programmer would write:

product.Quality = Quality.Good;

… providing that Quality Enum is declared something like:

public enum Quality
{
    JustBad, Poor, OK, Good, Excellent
}

Of course, you could set your enum values to some concrete numbers, like:

public enum Quality
{
    JustBad = 1, Poor = 2, OK = 3, Good = 4, Excellent = 5
}

… but in most cases you shouldn’t need to. Like I said, I see Enums only as a before-compilation, human <-> code communication, and therefore I believe no part of Enum should ever see the light of day (i.e. be exposed to the UI). And with that, there goes the need for binding to Enums…

Why would I want to bind to Enums anyway? Enum enumerators have no description (other than their names). If you need to provide spaces or even support localized descriptions, you’ll need to extend them significantly, so why not create a new class anyway? Here’s what I use instead of an Enum:

public sealed class Quality
{
    public const int JustBad = 1;
    public const int Poor = 2;
    public const int OK = 3;
    public const int Good = 4;
    public const int Excellent = 5;

    public Dictionary<int, string> Collection { get; private set; }

    public Quality()
    {
        Collection = new Dictionary<int, string>()
        {
            {JustBad,   "Just bad :("},
            {Poor,      "Poor"},
            {OK,        "OK"},
            {Good,      "Good"},
            {Excellent, "Excellent!"},
        };
    }
}

The programmer would still write:

product.Quality = Quality.Good;

so it makes it easy to refactor existing code. Additionally, you can put in any description for the values, support localization, and it’s easy bindable in Xaml - declare the class instance as a local resource:

<local:Quality x:Key="quality" />

<ListBox DisplayMemberPath="Value" 
         ItemsSource="{Binding Collection, Source={StaticResource quality}}" />

http://possemeeg.wordpress.com/2007/09/06/minimize-to-tray-icon-in-wpf/

http://www.codeproject.com/KB/WPF/WPF_TaskbarNotifier.aspx

http://msdn.microsoft.com/en-us/ms741997(VS.85).aspx

          // Begins the storyboard.
          private
          void beginButton_Clicked(object sender,
RoutedEventArgs args) { // Specifying "true" as the second Begin
parameter// makes this storyboard controllable. myStoryboard.Begin(this, true);
} // Pauses the storyboard.privatevoid pauseButton_Clicked(object sender,
RoutedEventArgs args) { myStoryboard.Pause(this); } //
Resumes the storyboard.privatevoid resumeButton_Clicked(object sender,
RoutedEventArgs args) { myStoryboard.Resume(this); } //
Advances the storyboard to its fill period.privatevoid skipToFillButton_Clicked(object sender,
RoutedEventArgs args) { myStoryboard.SkipToFill(this); } //
Updates the storyboard's speed.privatevoid setSpeedRatioButton_Clicked(object sender,
RoutedEventArgs args) { // Makes the storyboard progress three times
as fast as normal. myStoryboard.SetSpeedRatio(this,
3); } // Stops the storyboard.privatevoid stopButton_Clicked(object sender,
RoutedEventArgs args) { myStoryboard.Stop(this); } 

http://www.code-magazine.com/article.aspx?quickid=0803061&page=1

http://mikescodeblog.blogspot.com/2007/12/wpf-progress-bars.html

http://nayyeri.net/blog/viewbox-and-viewport-in-windows-presentation-foundation/

http://www.vinull.com/Post/2008/03/21/wpf-using-viewbox-and-canvas-to-create-.aspx

http://www.codeproject.com/KB/WPF/WPFJoshSmith.aspx

http://msdn.microsoft.com/en-us/library/ms771277.aspx 

http://msdn.microsoft.com/en-us/library/ms745183.aspx(EditBox in GridView)

http://msdn.microsoft.com/en-us/library/ms747117.aspx

http://www.codeproject.com/KB/WPF/SmartTextBox.aspx

http://www.codeproject.com/KB/WPF/WPFBusinessAppsPartTwo.aspx

To solve this, we have to manually add the mouse event handler onto the controls and set the handled parameter to true.

this.tbId.AddHandler(TextBox.MouseDownEvent, new RoutedEventHandler(tb_mouseDown), true);

_strandGroup = this.listViewGroups.SelectedItem as StrandGroup;

<GridViewColumn Header="Strand Type">
     <GridViewColumn.CellTemplate>
             <DataTemplate>
                    <ComboBox SelectedValue="{Binding Path=StrandId}" SelectedValuePath="Id" DisplayMemberPath="Name" Width="120" GotFocus="ComboBox_GotFocus" SelectionChanged="ComboBoxStrandType_SelectionChanged"
                                            ItemsSource="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:LongitudinalStrandGroupsAssist}},Path=MPrestressedStrands}"/>
             <DataTemplate>
     </GridViewColumn.CellTemplate>
</GridViewColumn>

http://msdn.microsoft.com/en-us/magazine/cc700358.aspx

By Josh Smith

From http://dotnet.org.za/rudi/archive/2008/03/25/10-things-i-didn-t-know-about-wpf-data-binding.aspx

1) Binding path "(TextBox.Text)" vs "Text"?

If you bind to a path called Text, WPF uses reflection to resolve the name. If you use the class-qualified name, binding avoids the reflection performance hit. Class-qualified names also allows binding to attached properties!

2) WPF doesn't raise exceptions to notify you about data binding problems

All binding errors are output as trace information and NOT exceptions!

Beatriz Costa (Who else) has a excellent article about this

3) Why use OneWayToSource binding mode?

Well, the target object must always be a DP! The most common use of OneWayToSource mode is to by-pass this restriction! The source doesn't need to be a DP and effectively using OneWayToSource reverses the binding direction.

A perfect example is Run, it's text property is not backed by a DP!

4) Default binding mode?

Not all DP's have the same default binding mode!!!

If the binding mode is two-way, but the CLR property that it is bound to is read-only... will cause problems! just keep in mind that you can't assume what the binding mode is!!!

It is always a good idea to explicitly specify your binding mode. Also remember that OneWay is slightly lighter than TwoWay!

5) RelativeSourceMode.PreviousData

If you bind to a collection of prices and need to show the change from the previous price to the current price then this little trick can be very useful... Pass the current item and the following binding into a IMultiValueConverter converter

{Binding RelativeSource={RelativeSource PreviousData}}

The multi value converter now just need to work out what the difference is!

6) RelativeSourceMode.FindAncestor

This is a very cool hack I found... Lets assume that you have a ListBox showing data. Normally if you have a TextBlock inside your DataTemplate and you don't supply it with a foreground color, then it would inherit the parents Foreground property. What is cool about this is that then when you click on the item, the font color would change from black to white! Now assume that your DataTemplate also contains a custom control that do not rely on the Foreground property to determine its color (As a example, I will use a Ellipse which has a Fill and not a Foreground/Background). If I add a Ellipse to this DataTemplate and  I do not set its fill, it would stay blank. Even if I give it a Fill color, it will fill with this color but if I now select this ListBox item, it will stay the provided color!

So how do I make my ellipse inherit the Foreground color and more importantly, how do I make it change to white once selected? Binding its Fill with the following

{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ListBoxItem}}, Path=Foreground}

Now, it will inherit the parents Foreground and also change once selected...

7) Binding a ListBox to a custom object, What gets displayed in the ListBox?

When binding to a custom object, determining what is displayed in the ListBox can be one of 3 options

1. Set the DisplayMemberPath on the ListBox to a path
2. Create a DataTemplate
3. Override the ToString() on the custom object. If no DisplayMemberPath or DataTemplate is found, the ToString() is called on the custom object.

8) {Binding Path=/}

Bind to the current item in the view! Just remember to set IsSynchronizedWithCurrentItem to true

[UPDATE] While reading Ian Griffiths blog, I found a entry detailing this behaviour in WPF databinding

9) Binding has a constructor that take Path as a parameter

This is just a small shortcut

{Binding Path=Name}

Can be written like this

{Binding Name}

10) {Binding}

This looks a little weird but all this means is that the source is defined somewhere up the tree... common place is Window.DataContext. By setting the DataContext to a collection, I can now add a ListBox to the visual tree and then binding this ListBox's ItemsSource to {Binding}. This will tell the ListBox that its ItemsSource is the DataContext of the Window!

From BenCon's WebLog:

I http://blogs.msdn.com/bencon/archive/2006/01/05/509991.aspx

II http://blogs.msdn.com/bencon/archive/2006/01/06/510355.aspx

III http://blogs.msdn.com/bencon/archive/2006/01/07/510530.aspx

IV http://blogs.msdn.com/bencon/archive/2006/12/09/iscrollinfo-tutorial-part-iv.aspx

http://geekswithblogs.net/thibbard/archive/2008/05/20/wpf---collectionviewsource-that-updates-automatically.aspx

          public
          class AutoRefreshCollectionViewSource
: CollectionViewSource { protectedoverridevoid OnSourceChanged(object oldSource, object newSource)
{ if (oldSource != null) { SubscribeSourceEvents(oldSource, true);
} if (newSource != null) { SubscribeSourceEvents(newSource, false);
} base.OnSourceChanged(oldSource, newSource); } privatevoid Item_PropertyChanged(object sender,
PropertyChangedEventArgs e) { bool refresh = false; foreach (SortDescription
sort in SortDescriptions) { if (sort.PropertyName
== e.PropertyName) { refresh = true; break;
} } if (!refresh) { foreach (GroupDescription
group in GroupDescriptions) { PropertyGroupDescription propertyGroup
= group as PropertyGroupDescription; if (propertyGroup
!= null && propertyGroup.PropertyName == e.PropertyName)
{ refresh = true; break; } } } if (refresh)
{ View.Refresh(); } } privatevoid Source_CollectionChanged(object sender,
NotifyCollectionChangedEventArgs e) { if (e.Action == NotifyCollectionChangedAction.Add)
{ SubscribeItemsEvents(e.NewItems, false); } elseif (e.Action
== NotifyCollectionChangedAction.Remove) { SubscribeItemsEvents(e.OldItems, true);
} else { // TODO: Support this Debug.Assert(false);
} } privatevoid SubscribeItemEvents(object item, bool remove)
{ INotifyPropertyChanged notify = item as INotifyPropertyChanged; if (notify
!= null) { if (remove) { notify.PropertyChanged
-= Item_PropertyChanged; } else { notify.PropertyChanged
+= Item_PropertyChanged; } } } privatevoid SubscribeItemsEvents(IEnumerable
items, bool remove) { foreach (object item in items)
{ SubscribeItemEvents(item, remove); } } privatevoid SubscribeSourceEvents(object source, bool remove)
{ INotifyCollectionChanged notify = source as INotifyCollectionChanged; if (notify
!= null) { if (remove) { notify.CollectionChanged
-= Source_CollectionChanged; } else { notify.CollectionChanged
+= Source_CollectionChanged; } } SubscribeItemsEvents((IEnumerable)source, remove);
} }

Using the CollectionViewSource is a good way of binding to a datasource and letting the XAML determine the sorting and grouping of the data. However, as your datasource changes, the grouping and sorting is not automatically "re-calculated", forcing your code to be smarter that it should be. I found a class today on MSDN forums that inherits from CollectionViewSource and adds automatic refresh capabilities. This code is smart enough to resort your items, regroup your items and even add new groupings as needed.
Some good CollectionViewSource links:

• MSDN documentation

• Basic grouping and sorting
• custom grouping using IValueConverter
• Custom sorting using IComparer

http://msdn.microsoft.com/en-us/library/aa970677.aspx

http://www.cnblogs.com/pincelee/archive/2006/09/07/497259.html

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2509360&SiteID=1

http://msdn.microsoft.com/en-us/library/system.windows.controls.virtualizingpanel.aspx

1. http://blogs.msdn.com/dancre/archive/2006/02/06/implementing-a-virtualized-panel-in-wpf-avalon.aspx

2. http://blogs.msdn.com/dancre/archive/2006/02/13/531550.aspx

3. http://blogs.msdn.com/dancre/archive/2006/02/14/532333.aspx

4. http://blogs.msdn.com/dancre/archive/2006/02/16/533870.aspx

http://msdn.microsoft.com/en-us/library/aa969773.aspx#

Databinding issue in WPF: with solution

http://www.lhotka.net/weblog/DataBindingIssueInWPFWithSolution.aspx#a89bf0c78-2bfc-4872-89b3-5499c4cbd0ae

(Important: set UpdateSourceTrigger to LostFocus for textbox)

http://www.codeproject.com/KB/WPF/wpfvalidation.aspx

http://www.codeproject.com/KB/WPF/RegexValidationInWPF.aspx

http://www.codeproject.com/KB/WPF/WPFBusinessAppsPartTwo.aspx

First, make sure the OpenHandCursor.cur file is marked as Resource (not EmbeddedResource) in the referenced assembly.

Code Block

// use resource in local assembly

// new Uri("pack://application:,,,/folder/filename.cur")

// use resource in referenced assembly

// new Uri("yourAssemblyName;component/folder/filename.cur"
// ,UriKind.Relative)

Stream cursorStream =

Application.GetResourceStream(new Uri    ("CursorLib;component/cursors/help.cur",
UriKind.Relative)).Stream;

this.Cursor = new Cursor(cursorStream);

How to uninstall an application when it does not appear in Add/Remove Programs

http://blogs.msdn.com/astebner/archive/2005/10/30/487096.aspx

http://blogs.msdn.com/varungupta/archive/2007/12/04/visual-studio-2008-setup-troubleshooting-guide.aspx

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2519361&SiteID=1

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2519361&SiteID=1

http://www.codeproject.com/KB/WPF/WPFBusinessAppsPartOne.aspx

http://msdn2.microsoft.com/en-us/library/ms752347.aspx#data_validation

http://blogs.msdn.com/wpfsdk/archive/2007/10/02/data-validation-in-3-5.aspx

ListView FAQ

11th December 2007, 02:19 pm by Matthias Shapiro

• How do I get grid lines to show up in the ListView?
• How do I style a specific column in a ListView?
• How do I make it so that, instead of cutting off the text in my column when I shorten it, my text displays ellipsis?
• How do I make it so that my text wraps when I shorten my columns?
• How do I center something in my ListView column?
• How do I wrap text in a ListView header?
• How do I embed ListView Columns in another Column? (Columns with Categories) 
• How do I style the ListView column gripper? (the gripper is also called a “splitter” and a “seperator”)