Well I wrote a note taking app using mvvm light, if you wanna check the code:

[ApuntaNotas][1]

It&#39;s true that MVVM Light is lacking of big examples... We need to create that examples :)


  [1]: http://apuntanotas.codeplex.com/

There are not many **public** applications using the MVVM Light Toolkit. I know a few applications that use it, but I cannot always talk about it unfortunately. Probably it is just too new.

I am currently very busy writing a Silverlight book, but my plan is, as soon as I will be done writing, to create a reference application on Codeplex and to implement it in WPF and in Silverlight. In the mean time, if anyone else wants to create samples, let me know :)

Laurent

I have T4 code templates that generate your view/viewmodel for mvvm light and also other tricks. [Download here][1]

[Also see this example using MVVM Light and MEF][2]


  [1]: http://nuget.org/Packages/Packages/Details/MVVMT4-1-0-0-0
  [2]: http://rickrat.wordpress.com/2011/01/24/using-mef-to-link-view-model-locator-and-load-assembly-uis-dynamically/

[http://www.codeproject.com/KB/silverlight/IssueVisionForSilverlight.aspx][1]


  [1]: http://www.codeproject.com/KB/silverlight/IssueVisionForSilverlight.aspx

Laurent, MVVM Light&#39;s author wrote an article in the latest MSDN Magazine: [Using the MVVM Pattern in Windows 8][1]


  [1]: http://msdn.microsoft.com/en-us/magazine/jj651572.aspx

Hmm, I don&#39;t have any code myself but have a look at Shawn Wildermuth&#39;s blog, he has done an example app http://wildermuth.com/ 
It&#39;s Silverlight and also uses RIA services, but hte basics should be on target.

John Papa occassional has sone stuff up as well http://johnpapa.net.

I have written a **Coding Dojo** for Silverlight - Blend and MVVMLight.

http://www.alphablog.org/2011/08/07/coding-dojo-silverlight/

Take a look and see if it fits to your needs.

So, we have an existing Rails 2.3.5 app that does not support Internationalization at all. Now, I&#39;m well familiar with Rails I18n stuff, but we have a LOT of output strings inside `/javascripts/`. I&#39;m not a huge fan of this approach, but unfortunately it is too late to fix it now.

How might we internationalize strings stored in JS files in a Rails app? Rails doesn&#39;t even serve the JS files...

I&#39;m thinking I could always have the Rails app serve up the JS files, but that seems pretty gross. Are there plugins to do this?

Rails: Internationalization of Javascript Strings?

I have a large database with over 150 tables that I&#39;ve recently been handed.  I&#39;m just wondering if there is an easy way to view all foreign key constraints for the entire DB instead of on a per-table basis.

View all foreign key constraints for entire MySQL database

Does anyone know opensource WPF applications created using MVVM Light Toolkit? Or any samples?

MVVM Light Toolkit samples

<p>Does anyone know opensource WPF applications created using MVVM Light Toolkit? Or any samples?</p>


The following code does not exit the application. How can I exit the application and make sure all the running threads are closed?

    foreach (Form form in Application.OpenForms)
    {
        form.Close();
    }
    Application.Exit();



How to exit all running threads?

Is is wrong to have a return statement in a catch block?
What are the alternatives?  
i.e:



    public bool SomeFunction()
    {
        try
        {
            //somecode
            return true;
        }
        catch(Exception ex)
        {
            MessageBox.Show(ex.message);
            return false;
        }
        
    }

Return in catch block?

C# 4.0 introduced a new type called &#39;dynamic&#39;. It all sounds good, but what would a programmer use it for?

Is there a situation where it can save the day?


What is the &#39;dynamic&#39; type in C# 4.0 used for?

Typically the main use of the question mark is for the conditional, `x ? &quot;yes&quot; : &quot;no&quot;`.

But I have seen another use for it but can&#39;t find an explanation of this use of the `?` operator, for example.

    public int? myProperty
    {
       get;
       set;
    }



What is the purpose of a question mark after a type (for example: int? myVariable)?

When a method returns `IEnumerable&lt;T&gt;` and I do not have anything to return, we can use `Enumerable.Empty&lt;T&gt;()`.

Is there an equivalent to the above for a method returning `IQueryable&lt;T&gt;`

Enumerable.Empty&lt;T&gt;() equivalent for IQueryable

I am a beginner when it comes to programming but I was sure that one of the universal rules was that a program starts with Main(). I do not see one when I create a WPF project. Is Main() simply named something differently in WPF?

No Main() in WPF?

I&#39;m trying to attach an image on a button in WPF, however this code fails.  Seems strange after similar code would work perfectly in Mozilla XUL.

    &lt;Button Height=&quot;49.086&quot; Margin=&quot;3.636,12,231.795,0&quot; Name=&quot;button2&quot; 
            VerticalAlignment=&quot;Top&quot; Grid.Column=&quot;1&quot; Click=&quot;button2_Click&quot; 
            Source=&quot;Pictures/apple.jpg&quot;&gt;Disconnect from Server&lt;/Button&gt;

WPF Button with Image

I have a WPF Toolkit DataGrid with one DataGridTemplateColumn. I&#39;ve specified in a grid attribute that I wish all columns to be sortable, but the DataGridTemplateColumn won&#39;t allow it. All other columns do allow sorting. I&#39;ve even tried explicitly setting CanUserSort to true for that column, but no luck. Is it even possible to sort a template column? I&#39;ve provided a custom sorter that works for all columns, but the header won&#39;t allow a sort click.

    &lt;Controls:DataGrid ItemsSource=&quot;{Binding Events}&quot; AutoGenerateColumns=&quot;False&quot; 
                                   CanUserSortColumns=&quot;True&quot; 
                                   CanUserReorderColumns=&quot;False&quot; 
                                   Sorting=&quot;DataGrid_Sorting&quot; 
                                   x:Name=&quot;EventsGrid&quot;&gt;
                    &lt;Controls:DataGrid.Columns&gt;
                        &lt;Controls:DataGridTemplateColumn Header=&quot;Type&quot; Width=&quot;42&quot; CanUserResize=&quot;False&quot;&gt;
                            &lt;Controls:DataGridTemplateColumn.CellTemplate&gt;
                                &lt;DataTemplate&gt;
                                    &lt;Image Source=&quot;{Binding EventTypeImage, Mode=OneWay}&quot; HorizontalAlignment=&quot;Center&quot; Width=&quot;16&quot;/&gt;
                                &lt;/DataTemplate&gt;
                            &lt;/Controls:DataGridTemplateColumn.CellTemplate&gt;
                        &lt;/Controls:DataGridTemplateColumn&gt;
                        &lt;Controls:DataGridTextColumn Header=&quot;Source&quot; 
                                               Binding=&quot;{Binding Source, Mode=OneWay}&quot; /&gt;
                        &lt;Controls:DataGridTextColumn Header=&quot;Details&quot; MinWidth=&quot;175&quot; 
                                               Binding=&quot;{Binding Details, Mode=OneWay}&quot; /&gt;
                        &lt;Controls:DataGridTextColumn Header=&quot;Timestamp&quot; MinWidth=&quot;175&quot;  
                                               Binding=&quot;{Binding Timestamp, Mode=OneWay}&quot; 
                                               IsReadOnly=&quot;True&quot;/&gt;
                    &lt;/Controls:DataGrid.Columns&gt;
                &lt;/Controls:DataGrid&gt;

How can I sort a DataGridTemplateColumn on a WPF Toolkit DataGrid?

How do I put a border on my grid in C#/WPF?

This is what I would like it to be, but puts a border around the whole thing instead of the grid control I put in my application.

    &lt;Grid&gt;
        &lt;Border BorderBrush=&quot;Black&quot; BorderThickness=&quot;2&quot;&gt;
            &lt;Grid Height=&quot;166&quot; HorizontalAlignment=&quot;Left&quot; Margin=&quot;12,12,0,0&quot; Name=&quot;grid1&quot; VerticalAlignment=&quot;Top&quot; Width=&quot;479&quot; Background=&quot;#FFF2F2F2&quot; /&gt;
        &lt;/Border&gt;
    ... and so on ...

How could I put a border on my grid control in WPF?

I have an `ItemsControl` containing a list of data that I would like to virtualize, however `VirtualizingStackPanel.IsVirtualizing=&quot;True&quot;` does not seem to work with an `ItemsControl`.

Is this really the case or is there another way of doing this that I am not aware of?

To test I have been using the following block of code:

    &lt;ItemsControl ItemsSource=&quot;{Binding Path=AccountViews.Tables[0]}&quot;
                  VirtualizingStackPanel.IsVirtualizing=&quot;True&quot;&gt;
    &lt;ItemsControl.ItemTemplate&gt;
        &lt;DataTemplate&gt;
            &lt;TextBlock Initialized=&quot;TextBlock_Initialized&quot;  
                       Margin=&quot;5,50,5,50&quot; Text=&quot;{Binding Path=Name}&quot; /&gt;
        &lt;/DataTemplate&gt;
    &lt;/ItemsControl.ItemTemplate&gt;
    &lt;/ItemsControl&gt;

If I change the `ItemsControl` to a `ListBox`, I can see that the `Initialized` event only runs a handful of times (the huge margins are just so I only have to go through a few records), however as an `ItemsControl` every item gets initialized. 

I have tried setting the `ItemsControlPanelTemplate` to a `VirtualizingStackPanel` but that doesn&#39;t seem to help.


Virtualizing an ItemsControl?

Is orthodox MVVM implementation pointless?  I am creating a new application and I considered Windows Forms and WPF.  I chose WPF because it&#39;s future-proof and offer lots of flexibility.  There is less code and easier to make significant changes to your UI using XAML.  

Since the choice for WPF is obvious, I figured that I may as well go all the way by using MVVM as my application architecture since it offers blendability, separation concerns and unit testability.  Theoretically, it seems beautiful like the holy grail of UI programming.  This brief adventure; however, has turned into a real headache.
As expected in practice, I’m finding that I’ve traded one problem for another.  I tend to be an obsessive programmer in that I want to do things the right way so that I can get the right results and possibly become a better programmer.   The MVVM pattern just flunked my test on productivity and has just turned into a big yucky hack!

The clear case in point is adding support for a Modal dialog box. The correct way is to put up a dialog box and tie it to a view model.  Getting this to work is difficult.  In order to benefit from the MVVM pattern, you have to distribute code in several places throughout the layers of your application.  You also have to use esoteric programming constructs like templates and lamba expressions.  Stuff that makes you stare at the screen scratching your head.  This makes maintenance and debugging a nightmare waiting to happen as I recently discovered.   I had an about box working fine until I got an exception the second time I invoked it, saying that it couldn’t show the dialog box again once it is closed.  I had to add an event handler for the close functionality to the dialog window, another one in the IDialogView implementation of it and finally another in the IDialogViewModel.  I thought MVVM would save us from such extravagant hackery!

There are several folks out there with competing solutions to this problem and they are all hacks and don’t provide a clean, easily reusable, elegant solution.   Most of the MVVM toolkits gloss over dialogs and when they do address them, they are just alert boxes that don’t require custom interfaces or view models.

I’m planning on giving up on the MVVM view pattern, at least its orthodox implementation of it.  What do you think?  Has it been worth the trouble for you if you had any?  Am I just a incompetent programmer or does MVVM not what it&#39;s hyped up to be?


Is MVVM pointless?

I&#39;d like to handle the `Closing` event (when a user clicks the upper right &#39;X&#39; button) of my window in order to eventually display a confirm message or/and cancel the closing.

I know how to do this in the code-behind: subscribe to the `Closing` event of the window then use the `CancelEventArgs.Cancel` property.
 
But I&#39;m using MVVM so I&#39;m not sure it&#39;s the good approach.

I think the good approach would be to bind the `Closing` event to a `Command` in my ViewModel.

I tried that:

    &lt;i:Interaction.Triggers&gt;
        &lt;i:EventTrigger EventName=&quot;Closing&quot;&gt;
            &lt;cmd:EventToCommand Command=&quot;{Binding CloseCommand}&quot; /&gt;
        &lt;/i:EventTrigger&gt;
    &lt;/i:Interaction.Triggers&gt;

With an associated `RelayCommand` in my ViewModel but it doesn&#39;t work (the command&#39;s code is not executed).

Handling the window closing event with WPF / MVVM Light Toolkit

I&#39;m giving a presentation on using MVVM in real world applications and I&#39;m including a section on the &lt;strike&gt;religious wars&lt;/strike&gt; design decisions involved when using MVVM as a pattern in your application. In an MVVM application there are two main ways (that I know of) to instantiate a new View/ViewModel pair:

 1. **View-First** in which you create a view and it creates its own ViewModel and sets it to its DataContext.
 2. **ViewModel-First** in which you create new view models and create new views in response to changes in ViewModel properties, usually with ItemsControls and/or DataTemplates.

In your experience what are the pros and cons of each method? What do they enable and what problems do you run into with each?

  
### Result Summary ###
___

* **View First** - Pros
    - Easy to track which ViewModel is used by a View
* **View First** - Cons
    - Doesn&#39;t allow a single View to be easily used with multiple ViewModels
    - Requires extra events to handle communication between Views and ViewModels
* **ViewModel First** - Pros
    - Allows more complete testing of logic to open new Views and ViewModels
    - Tends to be DRYer as applications get larger
    - View and ViewModel are more independent and can be worked on separately more easily
* **ViewModel First** - Cons
    - More difficult to set up in Silverlight without DataTemplateSelector and typed DataTemplates.

What are the pros and cons of View-first vs. ViewModel-first in the MVVM pattern

I lately had the problem of creating add and edit dialogs for my wpf app.

All I want to do in my code was something like this. (I mostly use viewmodel first approach with mvvm)

ViewModel which calls a dialog window:

    var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);
    // Do anything with the dialog result

How does it work?

First, I created a dialog service:

    public interface IUIWindowDialogService
    {
        bool? ShowDialog(string title, object datacontext);
    }

    public class WpfUIWindowDialogService : IUIWindowDialogService
    {
        public bool? ShowDialog(string title, object datacontext)
        {
            var win = new WindowDialog();
            win.Title = title;
            win.DataContext = datacontext;

            return win.ShowDialog();
        }
    }

`WindowDialog` is a special but simple window.  I need it to hold my content:

    &lt;Window x:Class=&quot;WindowDialog&quot;
        xmlns=&quot;http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot; 
        Title=&quot;WindowDialog&quot; 
        WindowStyle=&quot;SingleBorderWindow&quot; 
        WindowStartupLocation=&quot;CenterOwner&quot; SizeToContent=&quot;WidthAndHeight&quot;&gt;
        &lt;ContentPresenter x:Name=&quot;DialogPresenter&quot; Content=&quot;{Binding .}&quot;&gt;
        
        &lt;/ContentPresenter&gt;
    &lt;/Window&gt;

A problem with dialogs in wpf is the `dialogresult = true` can only be achieved in code.  That&#39;s why I created an interface for my `dialogviewmodel` to implement it. 

    public class RequestCloseDialogEventArgs : EventArgs
    {
        public bool DialogResult { get; set; }
        public RequestCloseDialogEventArgs(bool dialogresult)
        {
            this.DialogResult = dialogresult;
        }
    }

    public interface IDialogResultVMHelper
    {
        event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
    }

Whenever my ViewModel thinks it&#39;s time for `dialogresult = true`, then raise this event.

    public partial class DialogWindow : Window
    {
        // Note: If the window is closed, it has no DialogResult
        private bool _isClosed = false;

        public DialogWindow()
        {
            InitializeComponent();
            this.DialogPresenter.DataContextChanged += DialogPresenterDataContextChanged;
            this.Closed += DialogWindowClosed;
        }

        void DialogWindowClosed(object sender, EventArgs e)
        {
            this._isClosed = true;
        }

        private void DialogPresenterDataContextChanged(object sender,
                                  DependencyPropertyChangedEventArgs e)
        {
            var d = e.NewValue as IDialogResultVMHelper;

            if (d == null)
                return;

            d.RequestCloseDialog += new EventHandler&lt;RequestCloseDialogEventArgs&gt;
                                        (DialogResultTrueEvent).MakeWeak(
                                            eh =&gt; d.RequestCloseDialog -= eh;);
        }

        private void DialogResultTrueEvent(object sender, 
                                  RequestCloseDialogEventArgs eventargs)
        {
            // Important: Do not set DialogResult for a closed window
            // GC clears windows anyways and with MakeWeak it
            // closes out with IDialogResultVMHelper
            if(_isClosed) return;

            this.DialogResult = eventargs.DialogResult;
        }
     }

Now at least I have to create a `DataTemplate` in my resource file(`app.xaml` or something):

    &lt;DataTemplate DataType=&quot;{x:Type DialogViewModel:EditOrNewAuswahlItemVM}&quot; &gt;
            &lt;DialogView:EditOrNewAuswahlItem/&gt;
    &lt;/DataTemplate&gt;

Well thats all, I can now call dialogs from my viewmodels:

     var result = this.uiDialogService.ShowDialog(&quot;Dialogwindow Title&quot;, dialogwindowVM);

Now my question, do you see any problems with this solution?


Edit: for completeness. The ViewModel should implement `IDialogResultVMHelper` and then it can raise it within a `OkCommand` or something like this:

    public class MyViewmodel : IDialogResultVMHelper
    {
        private readonly Lazy&lt;DelegateCommand&gt; _okCommand;

        public MyViewmodel()
        {
             this._okCommand = new Lazy&lt;DelegateCommand&gt;(() =&gt; 
                 new DelegateCommand(() =&gt; 
                     InvokeRequestCloseDialog(
                         new RequestCloseDialogEventArgs(true)), () =&gt; 
                             YourConditionsGoesHere = true));
        }

        public ICommand OkCommand
        { 
            get { return this._okCommand.Value; } 
        }

        public event EventHandler&lt;RequestCloseDialogEventArgs&gt; RequestCloseDialog;
        private void InvokeRequestCloseDialog(RequestCloseDialogEventArgs e)
        {
            var handler = RequestCloseDialog;
            if (handler != null) 
                handler(this, e);
        }
     }


EDIT 2: I used the code from here to make my EventHandler register weak:  
http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx  
(Website no longer exists, [WebArchive Mirror][1])


    public delegate void UnregisterCallback&lt;TE&gt;(EventHandler&lt;TE&gt; eventHandler) 
        where TE : EventArgs;

    public interface IWeakEventHandler&lt;TE&gt; 
        where TE : EventArgs
    {
        EventHandler&lt;TE&gt; Handler { get; }
    }

    public class WeakEventHandler&lt;T, TE&gt; : IWeakEventHandler&lt;TE&gt; 
        where T : class 
        where TE : EventArgs
    {
        private delegate void OpenEventHandler(T @this, object sender, TE e);

        private readonly WeakReference mTargetRef;
        private readonly OpenEventHandler mOpenHandler;
        private readonly EventHandler&lt;TE&gt; mHandler;
        private UnregisterCallback&lt;TE&gt; mUnregister;

        public WeakEventHandler(EventHandler&lt;TE&gt; eventHandler,
                                    UnregisterCallback&lt;TE&gt; unregister)
        {
            mTargetRef = new WeakReference(eventHandler.Target);

            mOpenHandler = (OpenEventHandler)Delegate.CreateDelegate(
                               typeof(OpenEventHandler),null, eventHandler.Method);

            mHandler = Invoke;
            mUnregister = unregister;
        }

        public void Invoke(object sender, TE e)
        {
            T target = (T)mTargetRef.Target;

            if (target != null)
                mOpenHandler.Invoke(target, sender, e);
            else if (mUnregister != null)
            {
                mUnregister(mHandler);
                mUnregister = null;
            }
        }

        public EventHandler&lt;TE&gt; Handler
        {
            get { return mHandler; }
        }

        public static implicit operator EventHandler&lt;TE&gt;(WeakEventHandler&lt;T, TE&gt; weh)
        {
            return weh.mHandler;
        }
    }

    public static class EventHandlerUtils
    {
        public static EventHandler&lt;TE&gt; MakeWeak&lt;TE&gt;(this EventHandler&lt;TE&gt; eventHandler, 
                                                        UnregisterCallback&lt;TE&gt; unregister)
            where TE : EventArgs
        {
            if (eventHandler == null)
                throw new ArgumentNullException(&quot;eventHandler&quot;);

            if (eventHandler.Method.IsStatic || eventHandler.Target == null)
                throw new ArgumentException(&quot;Only instance methods are supported.&quot;,
                                                &quot;eventHandler&quot;);

            var wehType = typeof(WeakEventHandler&lt;,&gt;).MakeGenericType(
                              eventHandler.Method.DeclaringType, typeof(TE));

            var wehConstructor = wehType.GetConstructor(new Type[] 
                                 { 
                                     typeof(EventHandler&lt;TE&gt;), typeof(UnregisterCallback&lt;TE&gt;) 
                                 });

            IWeakEventHandler&lt;TE&gt; weh = (IWeakEventHandler&lt;TE&gt;)wehConstructor.Invoke(
                                            new object[] { eventHandler, unregister });

            return weh.Handler;
        }
    }


  [1]: http://web.archive.org/web/20140319163345/http://diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx

Good or bad practice for Dialogs in wpf with MVVM?

I have a `Button` that closes my window when it&#39;s clicked:

    &lt;Button x:Name=&quot;buttonOk&quot;  IsCancel=&quot;True&quot;&gt;Ok&lt;/Button&gt;

That&#39;s fine until I add a `Command` to the `Button` i.e.

    &lt;Button x:Name=&quot;buttonOk&quot; 
            Command=&quot;{Binding SaveCommand}&quot; 
            IsCancel=&quot;True&quot;&gt;Ok&lt;/Button&gt;

Now it doesn&#39;t close presumably because I am handling the `Command`. I can fix this by putting an `EventHandler` in and calling `this.Close()` i.e. 

    &lt;Button x:Name=&quot;buttonOk&quot; 
            Click=&quot;closeWindow&quot; 
            Command=&quot;{Binding SaveCommand}&quot; 
            IsCancel=&quot;True&quot;&gt;Ok&lt;/Button&gt;

but now I have code in my code behind i.e. the method `SaveCommand`. I am using the MVVM pattern and `SaveCommand` is the only code in my code behind. 

How can I do this differently so as not to use code behind?

WPF MVVM: How to close a window

Can someone give me a quick summary of what a ViewModelLocator is, how it works, and what the pros/cons are for using it compared to DataTemplates?

I have tried finding info on Google but there seems to be many different implementations of it and no striaght list as to what it is and the pros/cons of using it.

What is a ViewModelLocator and what are its pros/cons compared to DataTemplates?

I could not understand `BorderThickness=&quot;{TemplateBinding BorderThickness}`.
Here the code:

    &lt;ControlTemplate TargetType=&quot;{x:Type wpftoolkit:DataGridCell}&quot;&gt;
        &lt;Border Padding=&quot;{TemplateBinding Padding}&quot; 
                BorderBrush=&quot;{TemplateBinding BorderBrush}&quot; 
                BorderThickness=&quot;{TemplateBinding BorderThickness}&quot; 
                Background=&quot;{TemplateBinding Background}&quot; 
                SnapsToDevicePixels=&quot;True&quot;&gt;
            &lt;ContentPresenter SnapsToDevicePixels=&quot;{TemplateBinding SnapsToDevicePixels}&quot;/&gt;
        &lt;/Border&gt;
    &lt;/ControlTemplate&gt;


Also please explain other types of binding.



What is the template binding vs binding?

I&#39;m revamping my software which has messy `Messenger.Default(...)` bits.

Is there any cheat sheet to know MVVMLight SimpleIoc usage (not general IoC description)?

how to use MVVMLight SimpleIoc?

I got a **WPF application** that shows a button bound to a command like that:

    &lt;Button Command=&quot;{Binding Path=TestrunStartCommand}&quot; Content=&quot;GO!&quot;&gt;

The command is defined like that:

    public ICommand TestrunStartCommand
    {
        get { return new RelayCommand(TestrunStartExecute, () =&gt; !IsTestrunInProgress); }
    }

    public bool IsTestrunInProgress
    {
    	get{
    		return _isTestrunInProgress;
    	}
    	set{
    		_isTestrunInProgress = value;
    		RaisePropertyChanged(IsTestrunInProgressPropertyName);
    	}
    }	

The problem is, the button won&#39;t be enabled immediately after I set `IsTestrunInProgress` to false, but _only after I click inside the application window_.

Could you help me understand this behaviour and show me how to fix this?

**Further reading:**
[wpf command pattern - when does it query canexecute][1]


  [1]: https://robburke.net/wpf-command-pattern-when-does-it-query-canexecute/

Content Type	Original Author	Original Content on Stackoverflow
Question	Neir0	View Question on Stackoverflow
Solution 1 - C#	Jesus Rodriguez	View Answer on Stackoverflow
Solution 2 - C#	LBugnion	View Answer on Stackoverflow
Solution 3 - C#	Rick Rat	View Answer on Stackoverflow
Solution 4 - C#	Thomas	View Answer on Stackoverflow
Solution 5 - C#	Sean	View Answer on Stackoverflow
Solution 6 - C#	Doobi	View Answer on Stackoverflow
Solution 7 - C#	alphamax	View Answer on Stackoverflow

MVVM Light Toolkit samples

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

Solution 5 - C#

Solution 6 - C#

Solution 7 - C#

View all foreign key constraints for entire MySQL database

Rails: Internationalization of Javascript Strings?

Attributions