vbCity Blogs

Visual Basic 2008 - Create a DataTable From Linq Query Results

Mike McIntyre — Fri, 06 Nov 2009 15:40:00 GMT

Below is a class that contains a method that can create a DataTable object form Linq Query Results. I find the LINQToDataTable method really handy when I am creating Crystal reports. Crystal Reports love to report on DataTables.

The Imports are essential to the LINQToDataTable method in the LinqUtilities class.

Imports System.Data

Imports System.Linq

Imports System.Reflection

Public Class LinqUtilities

    Friend Shared Function LINQToDataTable(Of T)(ByVal iEnumerableList As IEnumerable(Of T)) As DataTable

        Dim newDataTable As New DataTable()

        Dim thePropertyInfo As PropertyInfo() = Nothing

        If iEnumerableList Is Nothing Then

            Return newDataTable

        End If

        For Each item As T In iEnumerableList

            If thePropertyInfo Is Nothing Then

                thePropertyInfo = (DirectCast(item.[GetType](), Type)).GetProperties()

                For Each propInfo As PropertyInfo In thePropertyInfo

                    Dim columnDataType As Type = propInfo.PropertyType

                    If (columnDataType.IsGenericType) AndAlso (columnDataType.GetGenericTypeDefinition() Is GetType(Nullable(Of ))) Then

                        columnDataType = columnDataType.GetGenericArguments()(0)

                    End If

                    newDataTable.Columns.Add(New DataColumn(propInfo.Name, columnDataType))

                Next

            End If

            Dim dr As DataRow = newDataTable.NewRow()

            For Each pi As PropertyInfo In thePropertyInfo

                dr(pi.Name) = If(pi.GetValue(item, Nothing) Is Nothing, DBNull.Value, pi.GetValue(item, Nothing))

            Next

            newDataTable.Rows.Add(dr)

        Next

        Return newDataTable

    End Function

End Class

Below is example code that uses Linq to query for all the buttons on a Windows Forms form and calls the LINQToDataTable method to put the query results into a DataTable.

Dim newDataTable As DataTable = _

        LinqUtilities.LINQToDataTable(From btn In Me.Controls _

            Where TypeOf (btn) Is Button Select btn)

Mike McIntyre's .Net Journal

getdotnetcode.com

Controlling TreeView Item Visibility

XTab — Fri, 06 Nov 2009 00:37:00 GMT

An interesting question came up recently, where someone wanted to have a TreeView in which:

Each TreeViewItem consisted of two separate lines of content
but the second line may be hidden, depending on its content.

This was actually a Windows Forms question, but I wondered if this would be a good candidate for harnessing the graphical power of WPF to solve a tough WinForms problem. My idea was to create a WPF UserControl that had the features described above and then host this User Control in an ElementHost in the Windows Form.

It seemed like a reasonable proposition and here's how I went about it.

Data Source
First of all I need some data, so will use a simple Person class.

 
Imports System.ComponentModel
Imports System.Collections.ObjectModel
 
Public Class Person
    Implements INotifyPropertyChanged
 
    Sub New(ByVal personname As String, ByVal personstatus As String, ByVal personcategory As String)
        Me.FullName = personname
        Me.Status = personstatus
        Me.Category = personcategory
    End Sub
 
    Private _name As String
    Public Property FullName() As String
        Get
            Return _name
        End Get
        Set(ByVal value As String)
            _name = value
            OnPropertyChanged(New PropertyChangedEventArgs("FullName"))
        End Set
    End Property
 
 
    Private _status As String
    Public Property Status() As String
        Get
            Return _status
        End Get
        Set(ByVal value As String)
            _status = value
            OnPropertyChanged(New PropertyChangedEventArgs("Status"))
        End Set
    End Property
 
 
    Private _Category As String
    Public Property Category() As String
        Get
            Return _Category
        End Get
        Set(ByVal value As String)
            _Category = value
            OnPropertyChanged(New PropertyChangedEventArgs("Category"))
        End Set
    End Property
 
 
    Public Sub OnPropertyChanged(ByVal e As PropertyChangedEventArgs)
        If Not PropertyChangedEvent Is Nothing Then
            RaiseEvent PropertyChanged(Me, e)
        End If
    End Sub
 
 
    Public Event PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs) Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
 
 
    Public Shared Function GetPersons() As List(Of Person)
        Dim GP As New List(Of Person)
        GP.Add(New Person("Ged Mead", "Busy", "VB City"))
        GP.Add(New Person("Joe Brown", "On Site", "Work Colleagues"))
        GP.Add(New Person("Serge Baliansky", "North Office", "VB City"))
        GP.Add(New Person("Fran Pickman", "East Centre", "Family"))
        GP.Add(New Person("Elaine Jones", "Not Available", "Work Colleagues"))
        GP.Add(New Person("Matt Bianca", "South Office", "VB City"))
        Return GP
    End Function
 
End Class

As you see, this class implements INotifyPropertyChanged, so that changes to instance properties can be caught and any appropriate action taken as a result. I also included a basic method to generate some dummy data.

The Basic TreeView
The TreeView will be a WPF UserControl, so it is necessary to create this inside the Windows Forms project. Use the Project > Add New Item menu for this, then select WPF from the selection window that appears and name the WPF UserControl:

In the code-behind, you create a DataContext which will be the source of the data that is used to populate the TreeView:

Partial Public Class TwoLineTreeView
    Dim Contacts As New List(Of Person)
 
 
    Private Sub TwoLineTreeView_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
    End Sub
 
End Class 

An easy way to package up the two line content display is to use two TextBlocks inside a StackPanel. These would all be stored in a DataTemplate that the TreeView will use for its ItemTemplate property. Here's the first pass at the DataTemplate which I have placed in the Resources section of the UserControl named TwoLineTreeView.

  <UserControl.Resources>
     <DataTemplate x:Key="TVVis" >
      <TreeViewItem IsExpanded="True">
 
        <StackPanel>
          <TextBlock Text="{Binding Path=FullName}"
                  Margin="2,0,0,1"></TextBlock>
          <TextBlock Text="{Binding Path=Status}"
                  Margin="8,3,2,2"></TextBlock>
        </StackPanel>
      </TreeViewItem>
    </DataTemplate>
  </UserControl.Resources> 

The first TextBlock binds to the Person's name and the second one binds to their Status.

We can test this early stage by adding a TreeView control to the UserControl:

  <Grid>
    <TreeView ItemsSource="{Binding}" 
         ItemTemplate="{StaticResource TVVis}"   >
    </TreeView>
 
  </Grid> 

The Grid is inserted in the UserControl by default and although we don't really need it in this example there's no great value in deleting it.

If you now move to the Windows Form, you can add an ElementHost and populate it with this data bound user control. You can either find the ElementHost control in the Toolbox and drag an instance of it on to the surface of the form. If it hasn't been added to the Toolbox (and as it is a Windows Forms project it doesn't always appear by default) you can simply find the UserControl itself in the Toolbox and drag this on to the Form.

When you do so, an ElementHost will be created for you on the Form and will automatically offer you the TwoLineTreeView user control as the Child of that ElementHost. Run the project and you will see:

Enabling and Disabling Visibility of the Second TextBlock

The easiest way of hiding or showing the second item of data (the status of the Person) is to use a ValueConverter. I've written several blogs describing the use of these and you can check them out if you need more detail on how they work. An introduction to a simple ValueConverter is covered here and a more complex verion here and here.

Here is the Converter class used in this project:

Imports System.Windows.Data
 
Public Class StatusToVisibilityConverter
    Implements IValueConverter
 
    Public Function Convert(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        Select Case value.ToString
            Case "Busy", "Not Available", "En Route"
                Return "Collapsed"
           
            Case Else
                Return "Visible"
        End Select
    End Function
 
    Public Function ConvertBack(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class 

It tests the value of the Status property and if it finds it is set to Busy, Not Available or En Route it will not display the line. It will display it in all other cases.

The UserControl requires a namespace mapping before we can use this class to create and use a converter in the XAML pane.

   xmlns:local="clr-namespace:HostedTreeView"

With that in place, a converter is created inside the UserControl's Resources collection:

    <local:StatusToVisibilityConverter x:Key="StatusConverter" />

The final step is to use the converter in the markup for the second TextBlock, specifically to hide or show it based on the content. Here is the amended TextBlock markup:

         <TextBlock Text="{Binding Path=Status}"
           Visibility="{Binding Path=Status, Converter={StaticResource StatusConverter}}"  
           Margin="8,3,2,2"></TextBlock> 

Now when the project is run, the two Person instances that contain Busy or Not Available as their Status will not display the second line.

You can of course take this basic approach and use alternatives or weave a much more complex set of interconnections - perhaps replacing the Status text with another message altogether or totally hiding a Person and their Status if their Status has a particular value. Or whatever other variation meets your needs. They key task was to create a two line node in which you could control the visibility of the lines.

You can download the project used in this blog from here.

SQL Join Summary Query Example

Mike McIntyre — Thu, 05 Nov 2009 02:57:00 GMT

Heres a short exmaple to get you thinking about how query results can be joined to tables for purposes such as attaching summary data.

The example below shows how a query that sums total sales for a product can be joined to a query that selects product ID and product name from the Products table in Microsoft's Adventure Works sample database.

SELECT
PROD.ProductID,
PROD.[Name],
ISNULL(SALES.ProductSales,0) ProductSales
FROM Production.Product PROD
LEFT JOIN
(
SELECT ProductId,
SUM(LineTotal) ProductSales
FROM Sales.SalesOrderDetail SOD
GROUP BY ProductID
) SALES
ON PROD.ProductID = SALES.ProductID

The SELECT query within the parentheses returns a result with two columns: 1) ProductID and 2) ProductSales.

The query within parentheses is assigned the alias 'SALES' which is used to construct the ON clause that joins SALES to the Product table.

Because the SALES query returns ProductID (SALES.ProductID) it can be joined to PROD.ProductID.

Mike McIntyre's .Net Journal

getdotnetcode.com

Create and Use a Custom Command - Follow-Up

XTab — Wed, 04 Nov 2009 01:09:00 GMT

In this earlier blog, I explained how you can create and use a Command to carry out a task based on a variety of user actions. These actions included key presses, mouse actions and key/mouse combinations, as well as clicking on WPF controls. At the time I said that if you didn't want to have the Image move unless the right mouse button was clicked directly on the Image itself (as opposed to clicking anywhere in the Window or on its other children) then you could use Bubbling and Tunneling. When I came to test this theory, however, I couldn't find an obvious way of achieving this. I could stop a right click on the Image working, but that was the exact opposite of what I was trying to do!

Whether this failure is due to the way the Command infrastructure works or (more likely) my inability to grasp the finer nuances of routing, I've had to admit defeat - at least temporarily. So I thought I should at least post up a workaround for anyone who read that blog item and did want the right click to work only on the Image itself.

The 'fix', such as it is, is to ditch the InputGesture for MouseAction.RightClick in the InputGestureCollection and use a standard event handler purely for the Image MouseDown event.

So, the MoveItCommand code becomes:

Public Class MoveItCommand2
 
    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property
 
    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        ' UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
        '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
    End Sub
 
End Class

You'll notice that I've renamed the class to MoveItCommand2.

The code behind for the Window now takes an event handler for the Image MouseDown:

    Private Sub MoveableImage_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Input.MouseButtonEventArgs) Handles MoveableImage.MouseDown
        If e.ChangedButton = MouseButton.Right Then
            CommandBinding_Executed(MoveableImage, Nothing)
        End If
    End Sub

The code in that event handler simply calls the execution code for the original Command (so at least we retain some semblance of coordination).

Finally, the markup for the Image in the XAML Pane includes a pointer to the new MouseDown event handler:

      <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
       Canvas.Left="0" Canvas.Top="0" 
       MouseDown="MoveableImage_MouseDown" 
         />

To avoid confusion, I'll show all the revised markup below, as all references to the Command now have '2' appended to them, and they are easy to miss!

<Window x:Class="Window4"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:local="clr-namespace:GetValue"
   Title="Right Mouse Test" Height="300" Width="300">
 
  <Window.CommandBindings>
    <CommandBinding Command="local:MoveItCommand2.MoveIt"
                   Executed="CommandBinding_Executed" 
                   CanExecute="CommandBinding_CanExecute"/>
  </Window.CommandBindings>
 
  <Grid x:Name="MainGrid">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="218*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
 
    <!--  Canvas in the main middle section -->
    <Canvas x:Name="MainCanvas" Grid.Row="1"
        >
      <Image x:Name="MoveableImage" Width="55" 
       Source="questionmark2.jpg"
       Canvas.Left="0" Canvas.Top="0" 
       MouseDown="MoveableImage_MouseDown" />
    </Canvas>
 
    <!-- Menu at the top -->
    <Menu Grid.Row="0" Margin="3">
      <MenuItem Header="Move It" Margin="5"
        Command="local:MoveItCommand2.MoveIt" />
    </Menu>
 
    <ToolBar Grid.Row="2" >
      <Button Content="Move It" 
       Command="local:MoveItCommand2.MoveIt"  />
    </ToolBar>
 
    <Button Grid.Row="1" VerticalAlignment="Bottom"
             HorizontalAlignment="Right" Width="100"
             Height="33" Content="Move It" Margin="0,0,4,2"
             Command="local:MoveItCommand2.MoveIt" />
  </Grid>
</Window>
 

Visual Studio 2010 - Changes to Help System

Mike McIntyre — Tue, 03 Nov 2009 15:01:00 GMT

There are changes to the Visual Studio 2010 help system that you'll want to learn about.

For example, the new 'Manage Help Settings' menu item:

The menu item opens the new 'Help Library Manager' dialog:

From MSDN: "The Help Library Manager (HLM) application allows you to manage product documentation in the local Microsoft Help 3.0 content store. Using HLM, you can find and install new content from the web or from media, go online to get updates for your offline content, and remove offline content. The Help Library Manager also manages settings that allow you to customize your help experience."

How To Create and Use a Custom Command in WPF

XTab — Mon, 02 Nov 2009 04:45:00 GMT

I've got to be honest and admit up front that initially I wasn't completely sold on the idea that WPF Commands are the great leap forward that they are sometimes billed as. OK, so I get that they can reduce the repetition of event handling code, but even their most ardent supporters aren't going to be able to claim that the required code is particularly intuitive. I will agree though that the availability of CanExecute is useful sometimes when multiple controls are bound to a Command. As a WinForms developer moving to WPF, I still find that in many cases I'm happy to use event handlers and, where necessary, a utility method or two.

So, having got that caveat out of the way, let's look at a basic situation where we want a range of different user actions to trigger the same task.

I've decided to use the scenario that I covered in this blog. It's maybe not the most realistic scenario, but it does give an opportunity to use a wide range of user inputs and gestures to move the image across the screen. It also allows the use of the CanExecute event.

In the earlier blog, the user had to click on an image to make it move from left to right across a Canvas. This can soon become tiresome, so by means of a Command we'll give her several other options. In order to make the use of CanExecute realistic, we will say that once the image reaches the far right edge of the Canvas, it must stay there. So the image move will be allowed to happen (i.e. CanExecute) as long as it hasn't reached the right hand edge of the canvas.

Creating the User Interface
The following XAML will create an updated version of the Canvas-and-Image UI used previously. This version includes various controls that will be bound to the Command.

<Window x:Class="Window3"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 
   Title="Using A Command" Height="300" Width="300">
 
 
    <Grid x:Name="MainGrid">
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="218*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
 
 
      <!--  Canvas in the main middle section -->
    <Canvas x:Name="MainCanvas" Grid.Row="1">
      <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
 
        Canvas.Left="0" Canvas.Top="0" />
    </Canvas>
 
    <!-- Menu at the top -->
    <Menu Grid.Row="0" Margin="3">
      <MenuItem Header="Move It" Margin="5"
 
               ></MenuItem>
    </Menu>
 
    <ToolBar Grid.Row="2" >
      <Button Content="Move It" 
              />
    </ToolBar>
 
      <Button Grid.Row="1" VerticalAlignment="Bottom"
             HorizontalAlignment="Right" Width="100"
             Height="33" Content="Move It" Margin="0,0,4,2"
              />
  </Grid>
</Window>

(If you've looked at the markup closely and think that the order of elements is haphazard, you would be wrong. Try moving the MenuItem to what seems a more logical position above the Canvas and you will get an Error when the code is completed. As you will see, the code behind for the MenuItem will eventually have a link to the Image. So therefore the Image must be created first in the top down XAML file, before the MenuItem can know about it . I often think that it's these little potential Gotchas that make the WinForms-to-WPF learning curve so difficult.)

This is what it should look like:

Creating the Command
Let's start by creating a new Command Class called MoveItCommand. It will have a single property named MoveIt, a backing field named _move it and a parameterless constructor. The property and field are of type RoutedUICommand, but apart from that are standard and really don't need any additional explanation:

    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property

The constructor is used to create the various keyboard and mouse gestures that can be used to move the image. For the purposes of demonstration, I've gone totally overboard on these and have included four variations in the final version. But for clarity, I am only showing one in the code snippet below:

Shared Sub New()

        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
 
         '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
 
    End Sub 

The constructor begins by creating a new empty collection of mouse gestures.
The second line creates and stores a gesture which takes the Alt and M keys as the combination to be used to fire this command. Notice the order of the keys used as arguments - effectively it is "M & Alt" which isn't the way we usually think of the combination. If you switch the order and place the Modifier key first, you will get a runtime error. Trust me, I've been there, done that!
Finally, a new RoutedCommand is created, containing descriptive text, its name, owner type (which is this custom command class - MoveItCommand), and the collection of Gestures that will work with this command.

Note that all the members of this class are Shared, ensuring that only instance of the Command will be in use in the application when it runs.

Additional Gestures
If you are happy with how the Class and its Constructor works, I'll now add in those other gestures I mentioned. These include F12 on its own, a mouse click on its own and finally a combination of mouse click and key press. Here's the revised code:

    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
         '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
    End Sub

The first gesture is Alt and M, which I've already covered.
The second gesture is the F12 key on its own. Note that you must include Modifiers.None. if you don't, you will get a runtime error.
The third gesture will fire the command when the mouse is right clicked anywhere in the Window. Because of the way that WPF and RoutedCommands work, this effectively means that you can still click on the Image to make it move. If you wanted to limit the mouse click to the Image only, you could harness the power of Bubbling and Tunneling events to trap the mouse button press at the Image level. I haven't done that in this example.
The final gesture takes a combination of both the mouse left button click together with holding down the Shift key. Quite awkward to use and only included to demonstrate the range of available gestures.

Command Bindings
Having created the custom Command Class, if we want to use it in the XAML - and we do - then it is necessary to create an XML namespace mapping. Without this link, the XAML markup would have no idea about the existence of the class and its property. The syntax is fairly simple:

   xmlns:local="clr-namespace:GetValue" 

The alias of 'local' is used as the key which is mapped to the namespace in which the MoveItCommand class resides. The namespace is the same as the name of the project and in this case the project is named 'GetValue'.

Given this namespace mapping, we can now set up the CommandBinding in the XAML pane:

  <Window.CommandBindings>
    <CommandBinding Command="local:MoveItCommand.MoveIt"
                   Executed="CommandBinding_Executed" 
                   CanExecute="CommandBinding_CanExecute"/>
  </Window.CommandBindings>

As you see from the snippet above, you create a new CommandBinding inside a CommandBindings collection. The Command property of the CommandBinding points to that MoveIt property created in the MoveItCommand class.

The Executed and CanExecute properties point to two methods which we will create next in the code-behind.

Executing The CommandBinding The task of the CommandBinding_Executed method is to carry out whatever tasks we want to have actioned when the command is invoked. In this demonstration project, this task is simply to shunt the image a few units to the right. So the code is as follows:

    Private Sub CommandBinding_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        '  Move the image 5 units to the right
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 5)
 
    End Sub 

(If you are not sure about how the GetValue and SetValue functions work, you can read up on it in my blog here).

CanExecute
CanExecute is an optional feature which can be quite useful. In this demonstration, we will only allow the Command to work (and therefore only allow the Image to continue moving to the right) if it hasn't reached the right hand edge of the Canvas. More subtly, if CanExecute becomes set to False, any controls that are bound to the Command will automatically be disabled. I will add Command Bindings to the buttons, etc shortly.

First, here is the code for the CanExecute method:

    Private Sub CommandBinding_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        '  Only allow execution of the command if the image
        '  has not yet reached the right hand edge.
        e.CanExecute = MoveableImage.GetValue(Canvas.LeftProperty) < (MainCanvas.ActualWidth - MoveableImage.Width)
 
    End Sub 

It tests the current position of the Image to see if it has reached the right hand edge of the Canvas. CanExecute will be set to True if there is still space to the right side of the Image, otherwise it will be set to False.

The complete code behind for the Window and the Custom Command class together now looks like this:

Partial Public Class Window3
 
    Private Sub CommandBinding_Executed(ByVal sender As System.Object, ByVal e As System.Windows.Input.ExecutedRoutedEventArgs)
        '  Move the image 5 units to the right
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 5)
 
    End Sub
 
    Private Sub CommandBinding_CanExecute(ByVal sender As System.Object, ByVal e As System.Windows.Input.CanExecuteRoutedEventArgs)
        '  Only allow execution of the command if the image
        '  has not yet reached the right hand edge.
        e.CanExecute = MoveableImage.GetValue(Canvas.LeftProperty) < (MainCanvas.ActualWidth - MoveableImage.Width)
 
    End Sub
End Class
 
Public Class MoveItCommand
 
    Private Shared _moveit As RoutedUICommand
    Public Shared ReadOnly Property MoveIt() As RoutedUICommand
        Get
            Return _moveit
        End Get
    End Property
 
    Shared Sub New()
        '  Add keyboard and mouse gestures
        Dim UserInputs As New InputGestureCollection()
        UserInputs.Add(New KeyGesture(Key.M, ModifierKeys.Alt))
        UserInputs.Add(New KeyGesture(Key.F12, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.RightClick, ModifierKeys.None))
        UserInputs.Add(New MouseGesture(MouseAction.LeftClick, ModifierKeys.Shift))
         '  Assign these gestures to the _moveit field (and thereby to the MoveIt property)
        _moveit = New RoutedUICommand("Move Element", "Move", GetType(MoveItCommand), UserInputs)
    End Sub
 
End Class 

At this point, you can run the project and use any of those four gestures to move the Image. Once the Image hits the right hand edge, it will stop moving. The menu item, the two buttons don't play any part in the action yet - that is, clicking them will have no effect and they won't become disabled when the Image reaches the right hand limit.

Binding the Command to the Controls
All that remains to do is to bind this custom command to the menu item and the two buttons. Now things really do become simple and you can begin to see the potential benefit of using a Command. The following piece of markup is added to the MenuItem, the Button in the Toolbar and the Button in the Canvas:

        Command="local:MoveItCommand.MoveIt" 

With those bindings in place, you can move the Image by any of the seven methods included - the four input gestures and by clicking on any of the three controls. Note now that once the Image hits the right hand edge, those three controls all become disabled.

So, there is a fairly simple example of using your own Command. You can see the final version of the XAML markup here, and also the code behind here.

Project Communication

LarryBlake — Fri, 30 Oct 2009 18:44:00 GMT

The most successful projects, software or otherwise, are the ones where everyone has a good idea of what they're doing and why. A healthy organization communicates its goals, successes and failures, and has well-informed employees.

A really good illustration of the importance of communication is given by Nobel-winning physicist Richard Feynman in his lecture Los Alamos From Below . (This lecture is also a chapter in his very entertaining autobiography, Surely You're Joking, Mr. Feynman .) During the second world war, Feynman was part of the Manhattan Project, building an atomic bomb in Los Alamos, New Mexico. This was a top-secret project, but it employed a number of civilians who were not in on the details.

One day, Feynman was doing some work around the civilian area, and he noticed that some explosive materials were being handled in a very casual way. He realized that there could be a dangerous accident unless the personnel got proper training. When the army finally agreed to allow Feynman to train them, there was also an enormous improvement in productivity. "We're trying to develop an important weapon before they do? Why didn't you tell us?" All kinds of new ideas started pouring in. And of course, the immediate danger was avoided.

Sometimes it's really easy for a manager or a business person to tell a programmer "I need a program to do X and I need it Thursday", without explaining why X, and how X fits into the larger picture. This has several risks:

1. By not discussing it, no one ever thinks of Y, which would be much better for the organization. Opportunity lost.
2. Eventually, someone will think of Y and insist that it be done. At that point, much of the effort on X was a waste of resources.
3. The programmer might be diverted from working on a new release which could easily have incorporated X. Would it have been better to wait and not need a retrofit?

And finally, the programmer doesn't feel valued. When employees believe that management just leads them around, often changing course and reversing earlier decisions, it's easy to feel that it's just a job, just a paycheck, no thought necessary, why bother. People stagnate.

I recently attended a project management seminar where the speaker said teams that communicate well are 43% more productive. I'm not sure how you measure that, but it's an enormous number. Isn't it worth a few minutes to really discuss what you're doing?

How To Edit Items in a Windows Forms ListView

XTab — Thu, 29 Oct 2009 11:52:00 GMT

As I was finishing off the previous blog item on the Windows Forms ListView, it occurred to me that there isn't much documentation around to explain how to edit the ListView items. So I thought it might be useful to cover a couple of approaches in this blog.

If you're disappointed that there isn't a built-in way to edit all the items and sub items, the thing to bear in mind is that ListView is essentially a display control, rather than an editing one. That said, there is one built-in tool that you can use - but only as long as you are content to edit items in the first column exclusively.

Edit First Column Only
What you can do is set the ListView's LabelEdit property to True. You can set this via the Properties Window or in code, ideally in the Load Event:

    Private Sub Form2_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        LVMVPs.LabelEdit = True
    End Sub

Now, if you click on an item in the first column on any row, the data in the first column of the selected row will become editable. I actually found that I had to triple-click, but I'm not sure if this is just a reflection of my mouse click speed settings or is the default requirement:

If you have the FullRowSelect property set to True, you can click anywhere along the row and the item in the first column will become editable as shown in the screenshot above. If FullRowSelect is set to False then you do need to click directly on the first column.

Edit Any Column
You have to do a bit of work yourself if you want to be able to edit any cell in the ListView, but there isn't really much to it. To demonstrate the technique, I've added three TextBoxes and an Update button to the Form:

The code below will allow the user to Right-click on any row and this will cause the three items of data in that row to be displayed in the three TextBoxes.

Dim ItemSelected As ListViewItem

   Private Sub LVMVPs_MouseDown(ByVal sender As Object, _
    ByVal e As MouseEventArgs) Handles LVMVPs.MouseDown
        '  Test that user wants to edit
        If e.Button = Windows.Forms.MouseButtons.Right Then
            '  Identify the selected ListViewItem
            ItemSelected = LVMVPs.GetItemAt(e.X, e.Y)
 
            ' Display in TextBoxes to allow editing
            If (ItemSelected IsNot Nothing) Then
                TextBox1.Text = (ItemSelected.SubItems(0).Text)
                TextBox2.Text = (ItemSelected.SubItems(1).Text)
                TextBox3.Text = (ItemSelected.SubItems(2).Text)
            End If
        End If
    End Sub

As you can see, it first tests that the Right mouse button has been clicked and if it has then each of the sub items is pasted into an individual TextBox below. The key feature in this block of code is the GetItemAt method of the ListView. This is the magic ingredient that allows you to easily identify exactly which row the user wants to deal with (and if you've spent a lot of fruitless time trying to work out how to use other ListView selection methods, you'll be pleased that you landed here!). Note that ItemSelected (the variable I am using to hold the current selection) is a ListViewItem object, not an index number - which is where most people seem to get caught.

The Confirm code is also very simple.

    Private Sub btnConfirm_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnConfirm.Click
        '  Update ListView
        ItemSelected.SubItems(0).Text = TextBox1.Text
        ItemSelected.SubItems(1).Text = TextBox2.Text
        ItemSelected.SubItems(2).Text = TextBox3.Text
        '  Avoid confusion by clearing TextBoxes
        TextBox1.Clear()
        TextBox2.Clear()
        TextBox3.Clear()
 
    End Sub

The content of each TextBox is transferred back to the relevant ListView sub item (regardless of whether it has been changed - although you could of course build in a filter here if you wanted to). The TextBoxes are then cleared.

And for a simple project, that's really all there is to it. As you can see, I did also add a button to clear the ListView, but that was just for my own convenience, so I could test multiple consecutive edits without duplicating the data in the file.

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        LVMVPs.Clear()
    End Sub

Not so obviously, I did also make a change to the file save code. I wanted to ensure that there wasn't a new blank line at the end of the text file, which might have caused a problem, so I tweaked the btnSave Click event as shown below:

    Private Sub btnSave_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSave.Click
        '  Create FileStream and StreamWriter to access and write to file
        Dim FS As New FileStream(TextFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
        Dim SW As New StreamWriter(FS)
 
        Try
            '  Loop through all rows
            For Index As Integer = 0 To LVMVPs.Items.Count - 1
                '  Internally loop through all columns, gathering items
                For SubIndex As Integer = 0 To LVMVPs.Items(Index).SubItems.Count - 1
                    SW.Write(LVMVPs.Items(Index).SubItems(SubIndex).Text & Chr(9))
                Next
                '  Create new line ready for next row
                '  except for final entry
                If Index = LVMVPs.Items.Count - 1 Then
                    Exit For
                Else
                    SW.Write(Environment.NewLine)
                End If
 
            Next
        Catch ex As Exception
 
            MsgBox("Error saving to file." & ex.Message)
 
        Finally
 
            SW.Close()
            FS.Close()
 
        End Try
 
    End Sub

To avoid errors when there is no data in the TextBoxes, you might also want to disable and enable the Confirm button when appropriate. The sample project which you can download from here, includes this feature.

XML, take 4

LarryBlake — Wed, 28 Oct 2009 15:49:00 GMT

I just got a note from Visual Basic MVP Steele Price, who pointed out a fourth way of writing XML. Unlike the three in my last post, this method will not work in C#.

As I should have mentioned, VB allows you to put XML directly in your code, which is great if you don't need to do a lot of dynamic modification to the XML. Now with LINQ, you can also insert variables, using a syntax resembling Classic ASP.

Since Steele was nice enough to send me a good example, I'll just post his.

Sub xml5(ByVal peoplepairs As IList(Of KeyValuePair(Of Integer, String)))
     'convert the List to XML
     Try
            Dim thelist = _
            <People>
                <%= From p In peoplepairs _
                    Select _
                    <Person id=<%= p.Key.ToString %>><%= p.Value %></Person> %>
            </People>

' Start document and write header
Dim xd As New XDocument(New XDeclaration("1.0", "UTF-8", "yes"), thelist)

            Try
                'Save the file
                xd.Save("MyXML.xml")

            Catch ex2 As Exception
                'do something here if the save fails
            End Try

        Catch ex1 As Exception
            'do something here if the conversion fails
        End Try
End Sub

There's always more ways to skin the cat. Steele's website is http://blog.steeleprice.net/ . Thanks!

WPF: How To Move Controls and Elements At Runtime

XTab — Mon, 26 Oct 2009 22:16:00 GMT

XAML is brilliant for creating user interfaces at design time, but if you need to make changes dynamically at runtime, this can sometimes be a problem. To take an example, let's say that you need to allow an Image to move to a different location on screen in response to some user action.

To demonstrate this, we can use an Image which is housed in a Canvas. So the first step is to create a Canvas in a WPF Window, place the Image inside the Canvas and assign a value to the Source property of the Image:

<Window x:Class="Window2"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="Image In A Canvas" Height="300" Width="300">
  <Canvas x:Name="MainCanvas">
    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg" />
  </Canvas>
</Window>

We can then have the Image move a few units to the right each time it receives a mouse click. The WPF Image doesn't support the Click event, but MouseDown is available for the same purpose. So the next step is to wire up an event handler for this:

    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
        MouseDown="Image_MouseDown" />

Here's the first pass at the Image_MouseDown event in the code-behind to move the Image 10 units to the right on each mouse down:

    Private Sub Image_MouseDown(ByVal sender As System.Object, ByVal e As System.Windows.Input.MouseButtonEventArgs)
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
 
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
 
    End Sub

This seems straightforward enough, doesn't it? The variable named LeftPos reads the value that is currently stored as the attached Canvas.Left property of the Image, then it increments that value by 10. If you were to run this project, you would expect that the Image would jump 10 units to the right when the mouse is clicked on it. But if you try this code, you will find that nothing happens when the Image is clicked.

There's a little WPF Gotcha lurking in the canvas, just waiting to confuse you. When you create this layout, as you can see from the screenshot below, the Image appears in the top left hand corner of the Canvas by default:

You would be forgiven for assuming that the attached Canvas.Left and Canvas.Top values of the Image are set to zero. It's a reasonable assumption to make, especially as you can see the Image in exactly that location. However, it doesn't actually work like that. By default the Left and Top attached properties are in fact set to Double.NaN - Not A Number. This is effectively a null value that is assigned in order to allow the Canvas to make use of its own built-in layout intelligence for more complex scenarios.

The fix is simple - you just have to assign values to the Canvas.Left and Canvas.Top properties in the XAML when you create the Image element, but it's something that isn't obvious. Not only does it mean that the expected movement of the Image doesn't happen, but it will actually cause your application to crash if you try and reset the value in code to move the Image back to the start position (which we will do later).

So, here's the amended XAML for the Image:

    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
        MouseDown="Image_MouseDown" 
        Canvas.Left="0" Canvas.Top="0" /> 

With that change in place, the Image will now move when it is clicked.

In this kind of situation, you probably won't want the Image to either get stuck at the right hand side of the Canvas or, possibly even worse, move out of sight. A simple If/Then statement will fix this:

        If LeftPos < (MainCanvas.ActualWidth - MoveableImage.Width) Then
            MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
        Else
            MoveableImage.SetValue(Canvas.LeftProperty, CDbl(0))
        End If 

As you can see, the first line tests if there is still enough width remaining for the Image to be moved 10 elements to the right and still be visible. If there is, then the 10 unit jump takes place. If not, then the Image is shunted back to far left of the Canvas. Note that this will fail if you haven't set the initial value of the Canvas.Left property as described earlier.

It will also fail if you don't cast the value (in this example, zero) to a Double. This is because the second parameter of the SetValue method is a generic Object Type and the Canvas.Left property requires a Double.

Moving the Image downwards follows the same kind of logic. You set an initial value on the Canvas.Top property then increment this when the MouseDown event fires. Perhaps you want to build in a feature where the left mouse button causes the Image to move left and the right mouse button to move it down.

If you are moving from Windows Forms to WPF, you may expect to find the Button property of the MouseEventArgs. You would then use code along the lines of:

        If e.Button = Windows.Forms.MouseButtons.Left Then
            ' Do Something
        End If

WPF is (again) slightly different. It uses the System.Windows.Input.MouseButtonEventArgs class in place of the Windows Forms version and it has a ChangedButton property, not a Button property. So the WPF version of the previous snippet will start with:

 If e.ChangedButton = MouseButton.Left Then 

The following code snippet combines the use of either the left or right mouse button to move the Image left or down respectively:

    Private Sub Image_MouseDown(ByVal sender As System.Object, ByVal e As System.Windows.Input.MouseButtonEventArgs)
 
        If e.ChangedButton = MouseButton.Left Then
 
            Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
 
            If LeftPos < (MainCanvas.ActualWidth - MoveableImage.Width) Then
                MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
            Else
                MoveableImage.SetValue(Canvas.LeftProperty, CDbl(0))
            End If
 
 
        ElseIf e.ChangedButton = MouseButton.Right Then
            Dim TopPos As Double = MoveableImage.GetValue(Canvas.TopProperty)
 
            If TopPos < (MainCanvas.ActualHeight - MoveableImage.Width) Then
                MoveableImage.SetValue(Canvas.TopProperty, TopPos + 10)
            Else
                MoveableImage.SetValue(Canvas.TopProperty, CDbl(0))
            End If
        End If
 
    End Sub

Finally, of course, you can combine the horizontal and vertical movement of the Image - maybe by using the Middle mouse button:

        ElseIf e.ChangedButton = MouseButton.Middle Then
            MoveableImage.SetValue(Canvas.LeftProperty, MoveableImage.GetValue(Canvas.LeftProperty) + 10)
            MoveableImage.SetValue(Canvas.TopProperty, MoveableImage.GetValue(Canvas.TopProperty) + 10)
        End If

The above snippet can be expanded to have the tests for reaching the outer edges built in also.

The main issues I particularly wanted to cover in this blog item were the GetValue and SetValue methods, which are a very useful tool in these kind of situations. I also wanted to flag up the various WPF Gotchas that might trip up the unwary WinForms developer. In a follow-up blog, I plan to take this task a step further and look at ways of giving the user several ways of achieving the Image movement - all of which loop back to a single piece of code

Populating a WinForms ListView from a Text File

XTab — Sun, 25 Oct 2009 16:20:00 GMT

The Windows Forms ListView is designed to display data. You can use a simple text file as the data source of a Windows Forms ListView. Let's start with a scenario where you have a txt file that contains the data. Each line of the text file represents one row of data to be displayed in the ListView. The content for each column item (or cell) is delimited by the use of a TAB character.

A simple text file along these lines might contain the following entries:

Ged Mead UK
Serge Baranovsky USA
Larry Blake USA
Scott Waletzko USA
Mark Dryden UK
Dave Jeavons UK
Chris Manning USA

(The uneven layout is caused by the use of the TAB as the delimiter)

Reading data from a file
An easy way of transferring this data from the file to the ListView is to:

Use a StreamReader which accesses the text file and then reads it line by line.
As each new line is read, it is split by means of the TAB character and temporarily stored in a String array.
Next, the first element is pulled out of the String array and used as the item for the first column of the ListView (the ListViewItem).
Then the remaining two elements are pulled out of the String array in turn and assigned as the SubItems of the ListViewItem.

Here's the code that carries out those steps:

  ' Variable for file to hold data
    Dim TextFile As String = "F:\MVPs.txt"
 
    Private Sub btnGet_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnGet.Click
 
        Try
            ' Declare StreamReader and pass the Path of the text file to be read as a Parameter 
            Dim SR As New StreamReader(TextFile)
            '  Variable to hold data as it is read line by line
            Dim strTemp() As String
 
            Do While SR.Peek <> -1 ' Use Peek to read the file until there are no more lines 
                '  Create a variable for the ListViewItems
                Dim LVItem As New ListViewItem
                '  Read the next line in file and Split it using the TAB. 
                strTemp = SR.ReadLine.Split(Chr(9))
                '  Pull out the first element in the line and assign it as
                '  the data for the first column.
                LVItem.Text = strTemp(0).ToString
                '  Add the item to the ListView
                LVMVPs.Items.Add(LVItem)
                '  Assign elements 2 & 3 as the subitems.
                LVItem.SubItems.Add(strTemp(1).ToString)
                LVItem.SubItems.Add(strTemp(2).ToString)
            Loop
 
            SR.Close() ' Close the StreamReader 
 
        Catch ex As Exception
 
            MsgBox("Error reading file." & ex.Message)
 
        End Try
 
    End Sub

You'll see that I've used a variable to hold the path to the file that contains the data. You will also need to include an Imports statement for System.IO at the top of the Class file.

Although the above code will successfully access the file, read and split the data and then populate the ListView, the result you will see may not be what you expect or want:

The first problem is that the View Property of the ListView needs to be set to Details. By default it is set to LargeIcon, with the result you see in the screenshot. You can make this change via the Properties Window or in code.

        LVMVPs.View = View.Details 

Make that change, run the project, hit the 'Get From File' button and you will see:

Again, definitely not what you want! The problem here is that the ListView won't automatically create columns for you, even though you might expect that it would based on the data you are feeding in. As it is traditional to have some header text at the top of each column, you can create this at the same time as you create the column itself .

        LVMVPs.Columns.Add("First Name", 76)
        LVMVPs.Columns.Add("Surname", 96)
        LVMVPs.Columns.Add("Location", 56) 

Now, when you run the project again you will see the data neatly tabulated in the ListView.

I have also set the width property of each column in the code above, because the default width would result in some of the longer strings being truncated otherwise.

If you don't want to hard code those column headers, you can change the text file structure and have the column headers written to the first line of the file. You would then pull these out first and assign them to the columns, before using the Do While loop to read and display the rest of the file.

Writing data to a file
Although a ListView's key purpose is to display existing data, there may be times when you have edited the content and want to save it back to a text file. The steps involved in doing this are as follows:

Use a FileStream to set up the file you are going to write to.
Use a StreamWriter to access the chosen file.
Loop through each row of the ListView, pull the text data from each column in turn and write it to the text file, adding a TAB character after each item.
Add a new line at the end of each loop.

The code for this process is:

   Private Sub btnSave_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSave.Click
        '  Create FileStream and StreamWriter to access and write to file
        Dim FS As New FileStream(TextFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
        Dim SW As New StreamWriter(FS)
 
        Try
            '  Loop through all rows
            For Index As Integer = 0 To LVMVPs.Items.Count - 1
                '  Internally loop through all columns, gathering items
                For SubIndex As Integer = 0 To LVMVPs.Items(Index).SubItems.Count - 1
                    SW.Write(LVMVPs.Items(Index).SubItems(SubIndex).Text & Chr(9))
                Next
                '  Create new line ready for next row
                SW.Write(Environment.NewLine)
 
            Next
        Catch ex As Exception
 
            MsgBox("Error saving to file." & ex.Message)
 
        Finally
 
            SW.Close()
            FS.Close()
 
        End Try
 
    End Sub

For many simple scenarios where you want to display tabulated text in a ListView (and optionally save it back to a file), the above approaches will work just fine. There will of course be times when you need something more sophisticated and I will look at some of those in later blogs.

Silverlight 3 - Enabling the Silverlight 'Out of Browser' Experience

Mike McIntyre — Fri, 23 Oct 2009 13:09:00 GMT

Silverlight 3 applications can be installed as local applications on PCs and MACs.

This is a brief 'how to' for enabling, installing, and removing a Silverlight 3 out of browser applications.

1. Use Visual Studio 2008 or 2010 to create a Silverlight 3 project.

2. Open the Silverlight 3 project's properties dialog. Select the 'Silverlight' tab. Check the 'Enable running application out of the browser'. Click the 'Out-of-Browser Settings...' button.

3. The 'Out-of-Browser Settings' dialog opens. Use it to configure your Silverlight 3 application for out of browser installation.

4. Run your application. Right-click a page in your application and select 'Install..' menu item.

5. The 'Install application' dialog opens. Use it to install short cuts to your application.

6. The Silverlight 3 out of browser application short cut on the desktop:

7. Use the short cut to launch the application on the computer. Here's a screen shot of my sample application running locally on my computer:

8 To remove the Silverlight 3 out of browser application from your computer: run it, right-click a page in the application, and select the 'Remove this application...' menu item.

Three ways of writing an XML file

LarryBlake — Wed, 21 Oct 2009 04:51:00 GMT

I just got back from the "Code Camp" of the Boston .Net User Group. It was a really good event, and I saw Joseph Anderson's presentation about using LINQ and XML. Basically, he talked about XElement and XDocument, which are new in .Net 3.5. They're part of the LINQ namespace, and you can do some really interesting things with them.

But I just want to talk about how they simplify writing an XML file. I recently had occasion to do this, and I did something like this:

Private Sub Xml1()

' Start document
Dim fs As New FileStream("MyXML.xml", FileMode.Create)
Dim w As New XmlTextWriter(fs, Encoding.GetEncoding("UTF-8"))

' Write header
w.WriteStartDocument()
w.WriteStartElement("People")

' Write a person
w.WriteStartElement("Person")
w.WriteAttributeString("id", "5")
w.WriteValue("John Smith")
w.WriteEndElement()

' Close top element
w.WriteEndElement()

w.Close()
End Sub

I really don't like this code. I kept it short for this example, but it's easy to forget your end elements. Anything more complex gets very verbose. Also, when you type this code in, the IDE corrects your indentation, which might otherwise make it a little easier to read.

You could also use a method like this, which I think is slightly better:

Private Sub Xml2()

' Start document
Dim xd As New XmlDocument()

' Write header
xd.AppendChild(xd.CreateXmlDeclaration("1.0", "UTF-8", "no"))

Dim peop As XmlElement = xd.CreateElement("People")

' Write a person
Dim pers As XmlElement = xd.CreateElement("Person")
Dim id As XmlAttribute = xd.CreateAttribute("id")
id.Value = "5"
pers.Attributes.Append(id)
pers.InnerText = "John Smith"

peop.AppendChild(pers)

' Write top element
xd.AppendChild(peop)

' Write to file
Dim fs As New FileStream("MyXML.xml", FileMode.Create)
Dim w As New XmlTextWriter(fs, Encoding.GetEncoding("UTF-8"))
xd.WriteContentTo(w)
w.Flush()
End Sub

But best of all is the LINQ way, with XElement and XDoc. Much more concise and readable.

Sub Xml3()

' Start document and write header
Dim xd As New XDocument(New XDeclaration("1.0", "UTF-8", "yes"))
Dim peop As New XElement("People")

' Write a person
Dim pers As New XElement("Person", "John Smith", New XAttribute("id", "5"))
peop.Add(pers)

' Write top element
xd.Add(peop)

' Write to file
Dim fs As New FileStream("MyXML.xml", FileMode.Create)
Dim w As New XmlTextWriter(fs, Encoding.GetEncoding("UTF-8"))
xd.WriteTo(w)
w.Flush()
End Sub

All of these methods produce the same file. I'ts up to you.

Visual Basic 2010 and .NET Framework 4 Deliver Beta 2 in Final Stretch to March 22 Launch

Mike McIntyre — Tue, 20 Oct 2009 14:44:00 GMT

Read all about it at: Final Stretch

Search for Files with a Specific Extension in and below a System Special Folder

Mike McIntyre — Thu, 15 Oct 2009 02:19:00 GMT

The Visual Basic My.Computer.FileSystem GetFiles method can be used to search for files with a specific extension in or below a specific directory: Below is a function for that purpose: ...(read more)

Validation and the Windows Forms ErrorProvider

Mike McIntyre — Sun, 11 Oct 2009 03:03:00 GMT

Download source code here -> Validation and the Windows Forms ErrorProvider Component

I've noticed that not a lot of people take advantage of the Windows Forms built in user interface for indicating that a control on a form has an error associated with it - the ErrorProvider component.

The ErrorProvider presents a simple mechanism for indicating to the end user that a control on a form has an error associated with it. If an error description string is specified for the control, an icon appears next to the control. The icon flashes in the manner specified by BlinkStyle, at the rate specified by BlinkRate. When the mouse hovers over the icon, a ToolTip appears showing the error description string.

Typically, you use ErrorProvider in association with data-bound controls. When using ErrorProvider with data-bound controls, you must specify the ContainerControl, either in the constructor or by setting the ContainerControl property.

The Visual Studio project download at the link above demonstrates how to combine validation with the ErrorProvider.

Mike McIntyre's .Net Journal

getdotnetcode.com

Visual Basic 2010 - Nullable Optional Parameters

Mike McIntyre — Sat, 10 Oct 2009 20:40:00 GMT

Nullable types were a welcome addition to Visual Basic 2008. In Visual Basic 2010 you can use them as parameters. Here are two examples:

' Assign Nothing as the default value for nullable optional parameter.

Sub Add(ByVal x As Integer, ByVal y As Integer, Optional ByVal z As Integer? = Nothing)

' code removed for brevity

End Sub

' Assign an integer value to a nullable optional paramter of type Double.

Sub Process(ByVal x As Integer, ByVal y As Integer, Optional ByVal z As Double? = 4)

' code removed for brevity

End Sub

Mike McIntyre's .Net Journal

getdotnetcode.com

Visual Basic 2010 - Array Literals

Mike McIntyre — Thu, 08 Oct 2009 20:30:00 GMT

Visual Basic 2010 array litererals provide a shortcut mechanism for declaring and filling arrays for types that can be inferred by the compiler. Here a three examples: ' Examples Dim a = {1, 2, 3} 'infers Integer() Dim b = {1, 2, 3.5} 'infers Double() Dim c = {"1", "2", "3"} 'infers String() Becareful not to mix in types the compiler can not infer: ' WARNING: Make sure you used types that can be inferred. ' The next example will generation a warning if OPTION STRICT ON ' or infer a type of Object if OPTION STRICT OFF Dim d = {1, "123"} 'infers Object() (warning with Option Strict On) Create multidimensional arrays with array literals: ' Create multidimensional arrays by nesting array array literals: 'Nested array literals can be used to produce multidimensional arrays: Dim f = {{1, 2, 3}, {4, 5, 6}} 'infers Integer(,) Dim g = {({1, 2, 3}), ({4, 5, 6})} 'infers Integer()() (jagged array) ...(read more)

Visual Basic 2010 - Multiline Function Lambdas

Mike McIntyre — Tue, 06 Oct 2009 20:07:00 GMT

A multiline Function lambda is a lambda expression that represents a Function containing one or more statements. The “Function” keyword can be used to create a multiline lambda that returns a value. The following examples how to create mutiline Function lambdas. The first creates a multiline Function lambda and assigns it to a variable. The second uses a multiline Function lamda inline. ...(read more)

Visual Basic 2010 - Multiline Sub Lambdas

Mike McIntyre — Mon, 05 Oct 2009 19:52:00 GMT

A multiline Sub lambda is a lambda expression that represents a Sub containing one or more statements. Visual Basic 9.0 only supported lambdas that were a single expression that returned a value; for example, the following line was an error: 'Error - Console.WriteLine doesn't return a value Array.ForEach(nums, Function(n) Console.WriteLine(n)) With Visual Basic 10.0, lambdas can now contain expressions that do not return a value: ...(read more)

VB 20010 - Continuing a Statement over Multiple Lines after a Comma

Mike McIntyre — Sun, 04 Oct 2009 18:35:00 GMT

Visual Basic 2010 provides mechanisms to continue lines of a statment without the traditional _ (underline) character. One mechanism is to contiue the statement on a new line after a comma...... ...(read more)

MS SQL Server - Use Transact SQL CASE Expression To Sort Query Results

Mike McIntyre — Tue, 29 Sep 2009 03:00:00 GMT

The transact SQL 'CASE' expression is useful for a lot of things but did you know you can use it to sort your query results in special ways? Here's a simple example......(read more)

Case Insentive Comparrisons with Visual Basic

Mike McIntyre — Sun, 27 Sep 2009 17:50:00 GMT

The .Net String class' ToUpper function can be used with Visual Basic code for case insensitve comparrisons. Here's an example:...(read more)

Sorting and Grouping Items in a WPF ListBox - Part 2

XTab — Sun, 27 Sep 2009 10:13:00 GMT

Introduction
In the first part, I outlined the sample application and said that it:

will create a collection of Person objects and databind them to a ListBox.
will use very simple DataTemplates to format two properties of the Person class - FullName and Status.
will use a GroupStyle HeaderTemplate to display a third property of the Person class - Category.
groups the Person objects by their Category property.
sorts the Categories and displays them in alphabetical order.
sorts the Persons by name inside the Category groups and displays them in alphabetical order.

The first five tasks are all covered in that previous part. You can download the project up to this point from here.

Sorting the Categories
In the same way that I used a Group Description to group items together, WPF offers the SortDescription to allow data inside the CollectionView to be sorted. The following code in the Window Loaded event is all that's needed:

        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))

The SortDescription takes two parameters. The first is the name of the property that you want to sort on. The second is one of two choices for the sort direction.

For completeness, this is the full code so far in the Window Loaded event (which creates the DataContext, the View, the GroupDescription and the SortDescription):

    Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
 
        Dim currentView As ICollectionView
        currentView = CollectionViewSource.GetDefaultView(Contacts)
 
        '  Group
        currentView.GroupDescriptions.Add(New PropertyGroupDescription("Category"))
 
        '   Sort Categories
        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))
 
    End Sub

The sorted Categories will look like this:

Sorting the ListItems
As you can see, the Categories are now in alphabetical order. The names of the Person objects however are still shown in the relative order in which they were created. To create this secondary sort, the same kind of code is used:

        currentView.SortDescriptions.Add(New SortDescription("FullName", ListSortDirection.Ascending))

The resulting display is:

The clearest example is where you can see the three items in the 'Work Colleagues' Category. They are now sorted alphabetically.

Note that the order that you list the sorting tasks is important. If you were to reverse the order:

       '   Sort individual names
        currentView.SortDescriptions.Add(New SortDescription("FullName", ListSortDirection.Ascending))
 
        '   Sort Categories
        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))
 

You would effectively lose the Category sort.

It is possible to create and apply the grouping and sorting in XAML, but I always try as far as possible to handle these kind of tasks in code-behind. Equally, I try and use XAML for the actual graphical display. There isn't a clear line between the two sometimes, of course, and you have to allow for individual preferences, but I try and keep to this approach as a general rule.

Read a Comma Delimited File with the Visual BasicTextFieldParser Class

Mike McIntyre — Sat, 26 Sep 2009 14:42:00 GMT

This blog post provides an example that shows how to use the VisualBasic TextFieldParser class to read in data from a comma delimited files....(read more)