I am trying to keep it simple, so no RelayCommand, no factory abstraction, etc, etc... But this makes it pretty simple to understand how the moving pieces fit together in MVVM, while touching a bit of Commanding. Here it goes:

First the Page that will contain it all:

<phone:PhoneApplicationPage 
    x:Class="Memo.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"
    FontFamily="{StaticResource PhoneFontFamilyNormal}"
    FontSize="{StaticResource PhoneFontSizeNormal}"
    Foreground="{StaticResource PhoneForegroundBrush}"
    SupportedOrientations="Portrait" Orientation="Portrait"
    shell:SystemTray.IsVisible="True">

    <!--LayoutRoot is the root grid where all page content is placed-->
    <Grid x:Name="LayoutRoot" Background="Transparent">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <!--TitlePanel contains the name of the application and page title-->
        <StackPanel x:Name="TitlePanel" Grid.Row="0" Margin="12,17,0,28">
            <TextBlock x:Name="PageTitle" Text="Memo" Margin="9,-7,0,0" Style="{StaticResource PhoneTextTitle1Style}"/>
        </StackPanel>

        <!--ContentPanel - place additional content here-->
        <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
        </Grid>
    </Grid>

</phone:PhoneApplicationPage>

So far its just what VS12 created on its own. Below I added the view to the ContentPanel Children collection. I don't really like this, but just so I don't have to spend time trying to figure out how to make a ContentPresenter take all available space. And no, using Stretch won't work.

using Microsoft.Phone.Controls;
using Memo.Views;

namespace Memo
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
            ContentPanel.Children.Add(new MemoView());
        }
    }
}

Now to the View. MVVM, as we all know means MODEL-VIEW-VIEW MODEL. Below is the VIEW part of the pattern. For  this to be more agnostic, we would have a framework injecting the ViewModel in the View DataContext. Or we could have done that on App, or Page. But for this example, this is simple enough:

<UserControl x:Class="Memo.Views.MemoView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
             mc:Ignorable="d"
             FontFamily="{StaticResource PhoneFontFamilyNormal}"
             FontSize="{StaticResource PhoneFontSizeNormal}"
             Foreground="{StaticResource PhoneForegroundBrush}"
             HorizontalAlignment="Stretch"
             VerticalAlignment="Stretch"
             d:DesignHeight="480"
             d:DesignWidth="480">

    <Grid x:Name="LayoutRoot"
          Background="{StaticResource PhoneChromeBrush}">
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
        <TextBox x:Name="txtMemoText"
                 Grid.Row="0"
                 Text="{Binding Mode=TwoWay, Path=MemoText}"
                 TextWrapping="Wrap" />
        <Button Command="{Binding SaveCommand}"
                Grid.Row="1"
                CommandParameter="{Binding}">Save</Button>
    </Grid>
</UserControl>

and the code behind does nothing but set the DataContext. This could easily be done in XAML as well.

using System.Windows.Controls;
using Memo.ViewModels;

namespace Memo.Views
{
    public partial class MemoView : UserControl
    {
        public MemoView()
        {
            InitializeComponent();
            DataContext = new MemoViewModel();
        }
    }
}

Above we set the View's DataContext to the ViewModel. Here is a simple view model that works well for this exercise:

using System.ComponentModel;

namespace Memo.ViewModels
{
    public class MemoViewModel : INotifyPropertyChanged
    {


        private string memoText;
        public string MemoText
        {
            get
            {
                return memoText;
            }
            set
            {
                if (memoText != value)
                {
                    memoText = value;
                    OnPropertyChanged("MemoText");
                }

                // If text is empty cannot execute save command
                if (saveCommand != null)
                {
                    if (memoText != null && memoText.Length > 0)
                        saveCommand.Enabled = true;
                    else
                        saveCommand.Enabled = false;
                }
            }
        }

        private Command saveCommand;
        public Command SaveCommand
        {
            get
            {
                if (saveCommand == null)
                    saveCommand = new Command(SaveMemo);
                return saveCommand;
            }
            set
            {
                saveCommand = value;
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

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

        private void SaveMemo()
        {
            // Does stuff here to save the memo to memory;
        }
    }
}

I used a custom Command classs that implements ICommand. I will love to hear the comments on the Enabled property. This works, but even keeping simplicity, I feel it could be better:

using System;
using System.Windows.Input;

namespace Memo
{
    public class Command : ICommand
    {

        private readonly Action executeAction;

        private bool enabled;
        public bool Enabled
        {
            get
            {
                return enabled;
            }
            set
            {
                if (enabled != value)
                {
                    enabled = value;

                    if (CanExecuteChanged != null)
                        CanExecuteChanged(this, new EventArgs());
                }
            }
        }

        public Command(Action executeAction)
        {
            this.executeAction = executeAction;
        }

        public bool CanExecute(object parameter)
        {
            return enabled;
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            executeAction();
        }
    }
}

And finally a simple Model. I should have passed the Command all the way over here and the model executes, for better separation of concerns, but really want to keep it simple. Still I believe very useful for those trying to understand the MVVM pattern.

using System.ComponentModel;

namespace Memo.Models
{
    class MemoModel : INotifyPropertyChanged
    {

        public event PropertyChangedEventHandler PropertyChanged;

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

        private string memoText;
        public string MemoText
        {
            get
            {
                return memoText;
            }
            set
            {
                if (memoText != value)
                {
                    memoText = value;
                    OnPropertyChanged("MemoText");
                }
            }
        }
    }
}

There it is. It worked on my box. Let me know your thoughts.

Thanks!

Mauricio Feijo

This is an ages old exercise but every time a do it I feel it gets a bit cleaner and better.

With no more delay, here is the code:

using System;

namespace LinkedListExample
{
    public class List
    {

        public class Node
        {
            public object NodeContent;
            public Node Next;
        }

        private int size;
        public int Count
        {
            get
            {
                return size;
            }
        }

        /// <summary>
        /// The head of the list.
        /// </summary>
        private Node head;

        /// <summary>
        /// The current node, used to avoid adding nodes before the head
        /// </summary>
        private Node current;

        public List()
        {
            size = 0;
            head = null;
        }


        /// <summary>
        /// Add a new Node to the list.
        /// </summary>
        public void Add(object content)
        {
            size++;

            // This is a more verbose implementation to avoid adding nodes to the head of the list
            var node = new Node()
            {
                NodeContent = content
            };

            if (head == null)
            {
                // This is the first node. Make it the head
                head = node;
            }
            else
            {
                // This is not the head. Make it current's next node.
                current.Next = node;
            }

            // Makes newly added node the current node
            current = node;


            // This implementation is simpler but adds nodes in reverse order. It adds nodes to the head of the list

            //head = new Node()
            //{
            //    Next = head,
            //    NodeContent = content
            //};

        }

        /// <summary>
        ///  Throwing this in to help test the list
        /// </summary>
        public void ListNodes()
        {
            Node tempNode = head;

            while (tempNode != null)
            {
                Console.WriteLine(tempNode.NodeContent);
                tempNode = tempNode.Next;
            }
        }



        /// <summary>
        /// Returns the Node in the specified position or null if inexistent
        /// </summary>
        /// <param name="Position">One based position of the node to retrieve</param>
        /// <returns>The desired node or null if inexistent</returns>
        public Node Retrieve(int Position)
        {
            Node tempNode = head;
            Node retNode = null;
            int count = 0;

            while (tempNode != null)
            {
                if (count == Position - 1)
                {
                    retNode = tempNode;
                    break;
                }
                count++;
                tempNode = tempNode.Next;
            }

            return retNode;
        }

        /// <summary>
        /// Delete a Node in the specified position
        /// </summary>
        /// <param name="Position">Position of node to be deleted</param>
        /// <returns>Successful</returns>
        public bool Delete(int Position)
        {
            if (Position == 1)
            {
                head = null;
                current = null;
                return true;
            }

            if (Position > 1 && Position <= size)
            {
                Node tempNode = head;

                Node lastNode = null;
                int count = 0;

                while (tempNode != null)
                {
                    if (count == Position - 1)
                    {
                        lastNode.Next = tempNode.Next;
                        return true;
                    }
                    count++;

                    lastNode = tempNode;
                    tempNode = tempNode.Next;
                }
            }

            return false;
        }
    }
}

I added a client console app to test the linked list. Here is how it turned out:

using LinkedListExample;
using System;

namespace LinkedListExampleClient
{
    class Program
    {
        static void Main(string[] args)
        {
            List list = new List();
    
            list.Add("A");
            list.Add("B");
            list.Add("C");
            list.Add("D");
            list.Add("E");
            list.Add("F");
            list.Add("G");
            list.Add("H");

            list.ListNodes();
            Console.WriteLine();

            Console.WriteLine();
            Console.WriteLine("Deleting node 8");
            list.Delete(8);
            list.ListNodes();
            
            Console.WriteLine();
            Console.WriteLine("Position 5: " + list.Retrieve(5).NodeContent);

            Console.WriteLine();
            Console.WriteLine("Deleting node 5");
            list.Delete(5);

            Console.WriteLine();
            Console.WriteLine("Position 5: " + list.Retrieve(5).NodeContent);

            Console.WriteLine();
            list.ListNodes();

            Console.ReadLine();

        }
    }
}

So running the client, we can see the linked list adding nodes ( In the correct order. See the Add method in code for details on that.), Listing, deleting and retrieving.

This was a fun little implementation, so I thought I'd share.

I appreciate  your comments. Thanks!

I will not mention best patterns and practices here. You can read all about that at http://msdn.microsoft.com/en-us/library/windowsphone/develop/ff967552(v=vs.105).aspx

Here is how it happens: When Windows Phone 8 starts your app it chooses which AppResources file to use when we access the AppResources class in code. BAM! That is it!

All we have to do at development time is use that class instead of a literal.

In C# instead of:

saveButton.Text = "Save" ;

we use

saveButton.Text = AppResources.SaveButtonText;

When typing the resource name of your choice, in my example "SaveButtonText", you will notice Visual Studio puts a red squiggle underneath the name. It is because you still haven't created the resource. To do that open AppResourcex.resx under "Resource" in solution explorer and add the resource name and value to the list. Once the resource name is entered in the list, the red squiggle disappears and you are good to go. 

Lets take a look at XAML as well. Most times XAML is what you will be using. In XAML it is a bit more verbose, but not rocket surgery either:

<ApplicationBarIconButton Text="Save" ... />

we use

<ApplicationBarIconButton Text="{Binding Path=LocalizedResources.SaveButtonText, Source={StaticResource LocalizedStrings}}" ... />

You can now build and run your app and all should work as it did before we started localizing.

Adding languages:

Now go to the Properties page of your project, under "Supported Cultures" , and select which languages and culture will be supported. I started with Portuguese and Spanish. English was already checked.

After making that change and saving visual studio will have created one AppResources.resx file for each culture/language you added. You can now open those and change the values to the values on each specific language.

I may be wrong, but it seems Visual Studio copies the AppResources.resx file from the default language to each new language, so you might want to do this as the very last minute, after your app is ready, or you may need to enter each resource manually on each resx file. Unless there is some sort of refresh functionality I am not aware of.

So in bullet points:

• Use AppResource instead of "text"
• Create each resource as you go on the default resource file
• Choose your languages at the project Properties page
• Translate each resource on their language specific resx files.

Done! Easy huh?

Hope this helps some people. As usual, let me know if I screwed up something. Thanks!

I am not really sure if it will work on  WP7. Hopefully it will. If you try let us know the results.

The app I am working on have 2 states, and on each state the user will see a different set of buttons and menu items on the app bar.

I didnt want to write the app bar completely in C#, for I always choose XAML over C# when possible. Otherwise we would just write it all in C#! 

I started by creating the buttons as app resources in APP.XAML. Note that some buttons overlap both app bars, so this approach avoids having 2 buttons that do the same thing.

<Application.Resources>
<shell:ApplicationBarIconButton x:Key="ChooseButton" IconUri="/Images/ChooseButton.png" Text="choose">
...
</shell:ApplicationBarIconButton>

 I then added both app bars to APP.XAML resource as well, referencing the buttons as StaticResources

<shell:ApplicationBar x:Key="AppBarState1" IsVisible="True" Opacity="0.5">
<shell:ApplicationBar.Buttons>
<StaticResource ResourceKey="ChooseButton" />
...
</shell:ApplicationBar.Buttons>
</shell:ApplicationBar>
 

Now on the page code behind comes the inevitable C#. I feel this is perfectly OK as it has to do with procedure and intelligence rather then declaration.

var chooseButton = (ApplicationBarIconButton)App.Current.Resources["ChooseButton"];
chooseButton.Click += ChooseButtonClick;
...

After setting up the button handlers we will decide which app bar to show and assign it to the page's ApplicationBar property:

ApplicationBar = (IApplicationBar)App.Current.Resources["AppBarState1"]; // choose based on app state
 

 I hope this helps some folks. If you think of a more elegant or appropriate way of achieving the same , please let us know.

Here is one that I still haven't fully resolved: Should I use the Geolocator.PositionChanged event handler to update location or should I use the Geolocator.GetGeopositionAsync async method (using await to call) and test if the location changed by a given threshold before I make updates, to a map, for example?

I initially went for the direct call method. It worked well but seemed counter intuitive when I realized I could simply use an event handler and define the DesiredAccuracy to filter only good reads.

I then modified my code to use the event handler. All worked well, except that the reads are sporadic. Regardless of setting Geolocator.ReportInterval or the Geolocator.MovementThreshold the event fires at will.

I am working on this and will post developments.

I used Infragistics controls, but this could be the same code using either other vendor or WPF neat.

I have been trying to keep things as code based as possible, assuming if anyone have interest for details they would ask.

Here is the XAML

<igRibbon:XamRibbonWindow x:Class="HumanIdeas.GUI.Shell"
                          xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:igRibbon="http://infragistics.com/Ribbon"
                          xmlns:igDock="http://infragistics.com/DockManager"
                          xmlns:Themes="clr-namespace:Infragistics.Windows.Themes;assembly=InfragisticsWPF3.v10.3"
                          xmlns:HI="http://schemas.HumanIdeas.com/HumanIdeas/windows"
                          MinHeight="600"
                          MinWidth="800"
                          FontFamily="Segoe UI"
                          HI:WindowSettings.Save="True"
                          Loaded="XamRibbonWindowLoaded"
                          Closed="XamRibbonWindowClosed"
                          >

    <igRibbon:XamRibbonWindow.Resources>
        <ResourceDictionary>
            <ObjectDataProvider x:Key="themeManager"
                                ObjectType="Themes:ThemeManager"
                                MethodName="GetThemes" />
        </ResourceDictionary>
    </igRibbon:XamRibbonWindow.Resources>

    <igRibbon:XamRibbonWindow.Title>
        <Binding Path="Title">
            <Binding.FallbackValue>Human Ideas</Binding.FallbackValue>
            <Binding.TargetNullValue>Human Ideas</Binding.TargetNullValue>
        </Binding>
    </igRibbon:XamRibbonWindow.Title>

    <igRibbon:RibbonWindowContentHost>

        <igRibbon:RibbonWindowContentHost.Ribbon>

            <igRibbon:XamRibbon Theme="{Binding ElementName=cboThemes, Path=SelectedValue, UpdateSourceTrigger=PropertyChanged}">
                <igRibbon:XamRibbon.ApplicationMenu>
                    <igRibbon:ApplicationMenu Caption="Layout">
                        <igRibbon:ApplicationMenu.Items>
                            
                            <StackPanel Orientation="Horizontal">
                                <TextBlock VerticalAlignment="Center"
                                           Text="Theme: " />
                                <ComboBox x:Name="cboThemes"
                                          VerticalAlignment="Center"
                                          IsEditable="False"
                                          
                                          MinWidth="100"
                                          SelectedIndex="0"
                                          ItemsSource="{Binding Source={StaticResource themeManager}}" />
                            </StackPanel>
                            
                            <Button Content="Reset Docking Layout"
                                    VerticalAlignment="Center"
                                    MinWidth="100"
                                    Click="ResetLayoutButtonClick" />

                        </igRibbon:ApplicationMenu.Items>
                    </igRibbon:ApplicationMenu>
                </igRibbon:XamRibbon.ApplicationMenu>

                <igRibbon:XamRibbon.Tabs>
                    <igRibbon:RibbonTabItem Header="Main">
                        <!--<igRibbon:RibbonGroup>
                        </igRibbon:RibbonGroup>-->
                    </igRibbon:RibbonTabItem>
                </igRibbon:XamRibbon.Tabs>
                
            </igRibbon:XamRibbon>

        </igRibbon:RibbonWindowContentHost.Ribbon>

        <igDock:XamDockManager x:Name="dockingManager"
                               Background="Transparent">
            <igDock:XamDockManager.Panes>
                <igDock:SplitPane x:Name="treePanel"
                                  igDock:XamDockManager.InitialLocation="DockedLeft">
                    <igDock:ContentPane x:Name="treePanelC"
                                        Background="Transparent"
                                        Header="Tree"
                                        AllowClose="False">

                    </igDock:ContentPane>
                </igDock:SplitPane>
                <igDock:SplitPane x:Name="summaryPanel"
                                  igDock:XamDockManager.InitialLocation="DockedTop">
                    <igDock:ContentPane x:Name="summaryPanelC"
                                        Background="Transparent"
                                        Header="Summary"
                                        AllowClose="False" />
                </igDock:SplitPane>
                <igDock:SplitPane x:Name="middlePanel"
                                  igDock:XamDockManager.InitialLocation="DockedTop">
                    <igDock:ContentPane x:Name="middlePanelC"
                                        Background="Transparent"
                                        Header="TBD"
                                        AllowClose="False" />
                </igDock:SplitPane>
                <igDock:SplitPane x:Name="ordersPanel"
                                  igDock:XamDockManager.InitialLocation="DockedTop">
                    <igDock:ContentPane  x:Name="ordersPanelC"
                                         Background="Transparent"
                                         Header="Orders"
                                         AllowClose="False" />
                </igDock:SplitPane>
            </igDock:XamDockManager.Panes>
        </igDock:XamDockManager>

        <igRibbon:RibbonWindowContentHost.StatusBar>
            <StatusBar>
                <TextBlock Text="Ready" />
            </StatusBar>
        </igRibbon:RibbonWindowContentHost.StatusBar>

    </igRibbon:RibbonWindowContentHost>

</igRibbon:XamRibbonWindow>

...and the code behind:

using System;
using System.IO;
using HumanIdeas.GUI.Properties;

namespace HumanIdeas.GUI
{
    /// <summary>
    /// Interaction logic for Shell.xaml
    /// </summary>
    public partial class Shell {
        private void ResetLayoutButtonClick(object sender, System.Windows.RoutedEventArgs e)
        {
            LoadDefaultLayout();
        }

        private void XamRibbonWindowLoaded(object sender, System.Windows.RoutedEventArgs e)
        {
            LoadLayout();
        }

        private void XamRibbonWindowClosed(object sender, EventArgs e)
        {
            SaveLayout();
        }        

        private void LoadDefaultLayout()
        {
            try
            {
                using (var fs = new FileStream(@"Data\defaultLayout.xml", FileMode.Open, FileAccess.Read))
                {
                    dockingManager.LoadLayout(fs);
                }

            }
            catch (FileNotFoundException)
            {
            }

        }

        private void LoadLayout()
        {
            var curTheme = Settings.Default.CurrentTheme;
            if (curTheme == null | curTheme == String.Empty)  cboThemes.SelectedIndex = 0;
            else cboThemes.SelectedValue = curTheme;

                try
                {
                    using (var fs = new FileStream(@"Data\layout.xml", FileMode.Open, FileAccess.Read))
                    {
                        dockingManager.LoadLayout(fs);
                    }

                }
                catch (FileNotFoundException)
                {
                    LoadDefaultLayout();
                }
        }

        private void SaveLayout()
        {
            Settings.Default.CurrentTheme = cboThemes.SelectedValue.ToString();
            Settings.Default.Save();

            using (var fs = new FileStream(@"Data\layout.xml", FileMode.Create, FileAccess.Write))
            {
                dockingManager.SaveLayout(fs);
            }

        }

    }
}

I use this in a semaphore type of application, changing the color of the first ellipse with triggers.

                <Viewbox >
                        <Grid Height="50" Width="50" Margin="5" ToolTip="SOF" >  
                        <Grid Margin="0">
                            <Ellipse Fill="Red">
                            <Ellipse.Stroke>
                                    <LinearGradientBrush StartPoint="0.5,0"
                                                         EndPoint="0.5,1"
                                                         ColorInterpolationMode="ScRgbLinearInterpolation">
                                        <GradientStop Color="Black"
                                                      Offset="0" />
                                        <GradientStop Color="Silver"
                                                      Offset="1" />
                                    </LinearGradientBrush>
                                </Ellipse.Stroke>
                            </Ellipse>
                            <Ellipse Margin="1">
                                <Ellipse.Stroke>
                                    <RadialGradientBrush Opacity="0.8"
                                                         ColorInterpolationMode="ScRgbLinearInterpolation">
                                        <GradientStop Offset="0.85"
                                                      Color="Transparent" />
                                        <GradientStop Offset="1"
                                                      Color="Black" />
                                    </RadialGradientBrush>
                                </Ellipse.Stroke>
                                <Ellipse.Fill>
                                    <RadialGradientBrush  Opacity="0.6"
                                                          GradientOrigin="0.5,1.2"
                                                          ColorInterpolationMode="ScRgbLinearInterpolation">
                                        <GradientStop Offset="1"
                                                      Color="#00000000" />
                                        <GradientStop Offset="0.4"
                                                      Color="White" />
                                    </RadialGradientBrush>
                                </Ellipse.Fill>
                            </Ellipse>
                            <Ellipse Margin="1.5"
                                     RenderTransformOrigin="0.5,0">
                                <Ellipse.RenderTransform>
                                    <ScaleTransform ScaleY="0.4"
                                                    ScaleX="0.7" />
                                </Ellipse.RenderTransform>
                                <Ellipse.Fill>
                                    <LinearGradientBrush Opacity="0.85"
                                                         StartPoint="0.5,0"
                                                         EndPoint="0.5,1"
                                                         ColorInterpolationMode="ScRgbLinearInterpolation">
                                        <GradientStop Color="White"
                                                      Offset="0.3" />
                                        <GradientStop Color="Transparent"
                                                      Offset="1" />
                                    </LinearGradientBrush>
                                </Ellipse.Fill>
                            </Ellipse>
                        </Grid>
                        <TextBlock TextWrapping="NoWrap"
                                   Opacity=".75"
                                   FontWeight="Bold"
                                   TextAlignment="Center"
                                   HorizontalAlignment="Center"
                                   VerticalAlignment="Center"
                                   Text="SOF"
                                   TextBlock.FontSize="15"
                                   Margin="2,0,0,0" />
                        </Grid>
                </Viewbox>

Many of us prefer to disable the designer when editing XAML, mostly for performance reasons. If you experience a big delay when opening and even making changes to XAML files, you might want to disable the designer. Of course if you use the designer, this fix is not for you.

To disable the designer, make sure there are no XAML files open on VS 2010:

1 – Right click on a XAML file on solution explorer

2 – Select “Open with…” from context menu

3 – Select “Source Code (Text) Editor”

4 – Click on “Set as Default” button

Mario Done!

I will include the code from home today.

private void utgGrid_SelectionDrag( object sender, CancelEventArgs e)

this.DoDragDrop(((UltraGrid)sender).Selected.Rows[0].Cells["ItemID"].Text, DragDropEffects.Copy);

Now we are waiting for the user to move the mouse over the tree.  We will capture that on the DragEnter event of the tree, check to see if what is being dragged is what we want and set e.Effect to DragDropEffects.Copy if we want to allow the drop or to DragDropEffects.None if we don't want to allow the drop.

private void utrTree_DragEnter(object sender, DragEventArgs e)

if (e.Data.GetDataPresent(DataFormats.StringFormat))

   e.Effect = DragDropEffects.Copy;

else

   e.Effect = DragDropEffects.None;

private void utrTree_DragDrop(object sender, DragEventArgs e)

//Below you call whatever method you want to process the drop, include the item on the tree  or whatever you need to do.

ProcessDrop((String)e.Data.GetData(DataFormats.StringFormat), utrTree.GetNodeFromPoint(utrTree.PointToClient(new Point(e.X,e.Y))));