Data Binding To GridView Controls in XAML?

Data Binding

Data Binding is the process of taking some data and associating it to visual elements on user interface (UI).

Overview of Data Binding

We will take any object and with their properties present each instance of object in collection on screen to user in “Grid “like fashion. We get to create a little template of how each individual instance of object is represented in the user interface .The “ListView” is also same but it works in single column fashion.

Create a Project in Visual Studio 2015

In order to perform data binding , you need to create a project in Visual Studio 2015, steps are simple:

Select “Universal” as shown by arrow.
Select “Blank App” as shown in circle.
Name your solution, for instance “BindDataExample“.

Designer Window

A designer window will open once you create the project with name”MainPage.xaml“. in this window there is a designer surface and you can also write your XAML code …now for instance we select our object a “Book” and in order to perform data binding simply create a user interface in XAML . The code is shown in the following image in rectangle sharpe.

Create Data Model

Go to “Solution Explorer” shown by circle.
Right click the “BindDataExample” shown by arrow.
Add new folder, name it “Models” shown by circle.

Create C# class in Models Folder

Go to Models folder.
Right click and select add new item.
Select Class and name it “Book.cs“.

Book Class with Properties

Once you perform all the above mentioned tasks, there will be a c# class open for us and our object which in this case is a book, we can create its class and define its properties in that very C# class we have.

Create a class “Book“.
Define its properties.
Copy the C# code in red rectangular box.

Creating New Instances & Add in Collection

After you created your Book class and set its properties, now its time to create instances of your class and populate it into a collection, list of book. We will generate another class , name it “BookManager” in the same file, for this purpose. And then return the list to caller. The following code will help you out.

Add GridView, Bind to data from BookManager Class

Our next step is after we created the instances, storing them in collection is to bind the data in GridView from that very class. For this we will return to our “MainPage.xaml” and create a template that how each individual item will appear on the screen. The template code is in red box .

Add XAML namespace

In order to reference the class in XAML, we need to reference its namespace in XAML. Here you go, shown by red arrow.

Create Public Property in MainPage.xaml.cs

After we create the template, our next step will be to create a public property in “mainpage.xaml.cs “and populate it with Books.

Add public property as shown in circular region.
Make sure you add a namespace if it is not there as shown by arrow.
Initialize it with “Books=BookManager.GetBooks();.”, this will return list of books.

Run your Application.

After completion of all the steps, run you application and the final result will be shown something like the following,

Working on Alignment

You can change the alignment and margin again. Here's a simple step to do,

Overview

In nutshell, the alignment will make display much better.

ListView, data binding and ItemTemplate in XAML ?

it's about separating data from layout. So, let's try binding some data to a ListView:

using System;
using System.Collections.Generic;
using System.Windows;

namespace WpfTutorialSamples.ListView_control
{
        public partial class ListViewDataBindingSample : Window
        {
                public ListViewDataBindingSample()
                {
                        InitializeComponent();
                        List<User> items = new List<User>();
                        items.Add(new User() { Name = "John Doe", Age = 42 });
                        items.Add(new User() { Name = "Jane Doe", Age = 39 });
                        items.Add(new User() { Name = "Sammy Doe", Age = 13 });
                        lvDataBinding.ItemsSource = items;
                }
        }

        public class User
        {
                public string Name { get; set; }

                public int Age { get; set; }
        }
}

We populate a list of our own User objects, each user having a name and an age. The data binding process happens automatically as soon as we assign the list to the ItemsSource property of the ListView, but the result is a bit discouraging:

A simple ListView control, using data binding

Each user is represented by their type name in the ListView. This is to be expected, because .NET doesn't have a clue about how you want your data to be displayed, so it just calls the ToString() method on each object and uses that to represent the item.

We can use that to our advantage and override the ToString() method, to get a more meaningful output. Try replacing the User class with this version:

public class User
{
        public string Name { get; set; }

        public int Age { get; set; }

        public override string ToString()
        {
                return this.Name + ", " + this.Age + " years old";
        }
}

A simple ListView control, using data binding and a ToString method on the source object

This is a much more user friendly display and will do just fine in some cases, but relying on a simple string is not that flexible. Perhaps you want a part of the text to be bold or another color? Perhaps you want an image? Fortunately, WPF makes all of this very simple using templates.

ListView with an ItemTemplate

WPF is all about templating, so specifying a data template for the ListView is very easy. In this example, we'll do a bunch of custom formatting in each item, just to show you how flexible this makes the WPF ListView.

Download sample

<Window x:Class="WpfTutorialSamples.ListView_control.ListViewItemTemplateSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ListViewItemTemplateSample" Height="150" Width="350">
    <Grid>
                <ListView Margin="10" Name="lvDataBinding">
                        <ListView.ItemTemplate>
                                <DataTemplate>
                                        <WrapPanel>
                                                <TextBlock Text="Name: " />
                                                <TextBlock Text="{Binding Name}" FontWeight="Bold" />
                                                <TextBlock Text=", " />
                                                <TextBlock Text="Age: " />
                                                <TextBlock Text="{Binding Age}" FontWeight="Bold" />
                                                <TextBlock Text=" (" />
                                                <TextBlock Text="{Binding Mail}" TextDecorations="Underline" Foreground="Blue" Cursor="Hand" />
                                                <TextBlock Text=")" />
                                        </WrapPanel>
                                </DataTemplate>
                        </ListView.ItemTemplate>
                </ListView>
        </Grid>
</Window>

How to use Class Binding in XAML and Windows phone application?

Data binding is that robust way to connect your properties with any data source. In this tutorial we will dig into class binding step-by-step. If you are already familiar with class binding then you can skip this tutorial.

Class Binding

Class Binding provides high-level access to the definition of a binding that connects the properties of the binding target objects and any data source (for example, a database, an XML file, or any object that contains data). It is so strong and easy that one can easily interact with data within the application and can bind the data with any of the properties of the objects.

Let's Dig

To understand class binding we will go through the following procedure for easy comprehension. First we will create a simple Windows 8.1 Silverlight application. This application will show the data of the object bound with the items of the Listbox.

Fig:1. Creating the Project.

Give the project a good name. Once you have created the project, you will see the following screen:

create project

Now for the class binding, we will create a class first, in this case I will create a class named Country:

class name country

We will add some Plain Old CLR Objects (POCOs) to our class:

class

After creating the class, we will move the MainPage.xaml and will add the Listbox to the Content Panel as in the following:

main page

Then, it would be noteworthy to specify how to customize the items in the listbox, so customizing the listbox item Template and as our class has three data members, we will add three controls to each item, in this case I will use two textblocks and one checkbox for the bool data member.

You can see in this figure that the checkbox and the textblocks are being bound with the data members of the class (Country), so basically the XAML code that actually binds the class is as in the following:

<CheckBox IsChecked="{Binding IsMember}"/>
<TextBlock Grid.Column="1" Name="CountryName" Text="{Binding CountryName}"/>
<TextBlock Grid.Column="2" Name="txtShortName" Text="{Binding ShortName}"/>

Now to load some dummy data into the Country class we will create the load event and add some data on the load event of the Page, for that we will need to create the list and add some objects of class Country to that list and then make this list the source for the listbox. Here is the C# code of that:

cs code

And now you can run the project, we are done with the simple class binding.

demo

How to Changing the Foreground Colour of an XAML Control Using a Binding Convertor?

The great thing about XAML is that you can easily change the foreground colour of controls, such as a TextBlock, to be exactly what you want it to be. Whether that is through the built-in colour names or a HEX colour is completely your choice.

However there may be times when you simply wish to change the colour of a control dependent on the value that it is displaying. In this example we will be using a TextBlock that has it's Text value assigned to it using data context binding.

MainPage.xaml

MainPage.xaml.cs

using System.Collections.ObjectModel;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
namespace CSharpCornerTestProject
{
public class Fruit
{
public string Name
{
get;
set;
}
public string Ripeness
{
get;
set;
}
}
public sealed partial class MainPage: Page
{
private ObservableCollection < Fruit > fruitList = new ObservableCollection < Fruit > ();
public MainPage()
{
this.InitializeComponent();
fruitList.Add(new Fruit()
{
Name = "Apple", Ripeness = "Ok"
});
fruitList.Add(new Fruit()
{
Name = "Banana", Ripeness = "Bad"
});
fruitList.Add(new Fruit()
{
Name = "Kiwi", Ripeness = "Rotten"
});

listViewTest.ItemsSource = fruitList;
}
private void listViewUpdated(ListViewBase sender, ContainerContentChangingEventArgs args) {
if (listViewTest.Items.Count == 0)
{
listViewNoItems.Visibility = Visibility.Visible;
listViewTest.Visibility = Visibility.Collapsed;
}
else
{
listViewNoItems.Visibility = Visibility.Collapsed;
listViewTest.Visibility = Visibility.Visible;
}
}
private void clearFruitBasket(object sender, RoutedEventArgs e)
{
// clear the fruit list!
if (fruitList != null) fruitList.Clear();
}
}
}

As I stated above, this is the code base that we used in my previous article about displaying a message once a ListView control no longer has any items in it. We will slightly modify this now so that the ripeness of the fruit in our fruit basket is colour-coded depending on its value.

The first thing we need to do is to create a convertor class for us to use when binding data to the list view. This is a very simple affair and just requires you to add a new "Class file" to your project.

FruitBasketConvertor.cs

using System;
using Windows.UI;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Media;
namespace CSharpCornerTestProject.Convertors
{
public class fruitBasketRipenessForegroundConvertor: IValueConverter
{
public object Convert(object value, Type targetType, object parameter, string language)
{
string ripeness = (value as string);
if (ripeness == "Ok") return new SolidColorBrush(Colors.ForestGreen);
else if (ripeness == "Bad") return new SolidColorBrush(Colors.OrangeRed);
else if (ripeness == "Rotten") return new SolidColorBrush(Colors.DarkRed);
// default return value of lime green
return new SolidColorBrush(Colors.LimeGreen);
}
public object ConvertBack(object value, Type targetType, object parameter, string language)
{
throw new NotImplementedException();
}
}
}

That is all there is to our file, just those 30 lines. Do take note, however, that we have placed the convertors under their own namespace, CSharpCornerTestProject.Convertors.

Using convertors isn't all as daunting as it seems. You create your own custom class, making sure that it derives from IValueConvertor. Then all we need are two functions.

public object Convert(object value, Type targetType, object parameter, string language)
{
// your convertor code goes here
}
public object ConvertBack(object value, Type targetType, object parameter, string language)
{
// your convert back code goes here
}

The Convert function takes the raw value of your binding and allows you to access anything associated with that, whether it is a class, a string, or anything of your choosing.

The ConvertBack function is generally not used all that often and so in our example we are leaving it asthrow new NotImplementedException();. Its main use would be if you wanted to convert the value back to its original state.

Returning to the Convert function, this is very simple and there isn't all that much to it at all. All we do here is take the object value and store it into our string variable, ripeness.

public object Convert(object value, Type targetType, object parameter, string language)
{
string ripeness = (value as string);
if (ripeness == "Ok") return new SolidColorBrush(Colors.ForestGreen);
else if (ripeness == "Bad") return new SolidColorBrush(Colors.OrangeRed);
else if (ripeness == "Rotten") return new SolidColorBrush(Colors.DarkRed);
// default return value of lime green
return new SolidColorBrush(Colors.LimeGreen);
}

Since we have different forms of Ripeness in our Fruit class, we have three separate if statements to determine which colour we should return for our Foreground colour.

When converting a Foreground (or Background) XAML member, it expects a SolidColorBrush to be returned and so that is what we are giving it.

That is everything that we need to do for the code side of things with our convertor, the next step is much simpler and only requires us to add three new lines of code to the existing MainPage.xaml file that we have.

In our Page control, we need to add a new member, highlighted in bold Green.

This will allow us to access the custom convertor class that we just created in FruitBasketConvertor.cs.

Now that we have done that, we need to add our convertor function as a page resource and provide it a key. This will allow us to access it when using the binding convertor. Once again, the addition is highlighted in bold Green.

<Page.Resources>
<utils:fruitBasketRipenessForegroundConvertor x:Key="ripenessConvertor"/>
<DataTemplate x:Key="listViewItems">
<StackPanel>
<TextBlock
Margin="5,5,5,5"
Text="{Binding Name}"
Style="{StaticResource BaseTextBlockStyle}"/>
<TextBlock
Margin="5,5,5,5"
Text="{Binding Ripeness}"
Style="{StaticResource BaseTextBlockStyle}"/>
</StackPanel>
</DataTemplate>
</Page.Resources>

Now that we have given our convertor a key, we can access it anywhere in the MainPage.xaml file when we are binding items. We just have one last thing to do now, that is to add a Foreground member to the TextBlock control that is telling us how ripe our fruit is.

That is everything that we need to do to start dynamically changing the foreground colour of our XAML controls dependent on what the value they're displaying is. If you run the app your fruit basket should now show the Ripeness of each fruit in the three different colours that we assigned earlier on whilst creating our convertor function.

Used Material Design Themed TimePicker and Clock Controls for WPF and Windows Phone Application?

I've managed to get the existing WPF controls; DatePicker & Calendar themed as part of Material Design in XAML Toolkit as described in this blog post.

But the fun part was cranking a couple of brand new controls to build the Material Design time picker experience:

TimePicker
Clock

These are sibling controls to the existing DatePicker and Calendar controls. I wanted to keep the API experience similar so you can dive straight in without any kind of learning curve. The Clock can be used in isolation, or use the DatePicker for an easy picker/popup/drop down behaviour.

Here's a static glimpse at the picker:

And here's a gif of the clock in action:

There's nothing complicated about using these, but you will need to get Material Design In XAML Toolkit referenced and set up in your app. Follow the initial tutorial, and head over to GitHub to download the source/examples project.

How to use XAML RepeatButton in WPF?

XAML RepeatButton in WPF

XAML RepeatButton represents a set of repeat buttons. This article shows how to use a RepeatButton control in WPF using XAML and C#.

Creating a RepeatButton

The RepeatButton XAML element represents a WPF RepeatButton control.

<Button/>

The Width and Height attributes represent the width and the height of a RepeatButton. The Content property sets the text of the button. The Name attribute represents the name of the control, that is a unique identifier of a control.

The code snippet in Listing 1 creates a Button control and sets its name, height, width and content.

Listing 1

The default property of a button is Content. The code snippet in Listing 2 creates the same button as created by Listing 1.

Listing 2

The output looks as in Figure 1.

Figure 1

Delay and Interval

The Delay and Interval properties make a RepeatButton different from a normal button.

A RepeatButton is a button that fires Click events repeatedly when it is pressed and held. The rate and aspects of repeating are determined by the Delay and Interval properties that the control exposes.

The code snippet in Listing 3 sets the Delay and Interval properties.

Listing 3

Adding a Button Click Event Handler

The Click attribute of a RepeatButton element adds the click event handler and it keeps firing the event for the given Interval and delay values. The code in Listing 4 adds the click event handler for a Button.

<Button x:Name="DrawCircleButton" Height="40" Width="120"
Canvas.Left="10" Canvas.Top="10"
Content="Draw Circle"
VerticalAlignment="Top"
HorizontalAlignment="Left">
Click="DrawCircleButton_Click"
</Button>

Listing 4

The code for the click event handler looks as in following.

private void GrowButton_Click(object sender, RoutedEventArgs e)
{
}

Okay, now let's write a useful application.

We will build an application with the two buttons Grow and Shrink and a rectangle. The application looks as in Figure 2.

When you click and continue pressing the Grow button, the width of the rectangle will continue to grow and when you click on the Shrink button, the width of the rectangle will shrink continuously.

Figure 2

The final XAML code is listed in Listing 5.

<Window x:Class="RepeatButtonSample.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Window1" Height="300" Width="300">

<Grid Name="LayoutRoot">
<RepeatButton Margin="10,10,0,0" VerticalAlignment="Top"
HorizontalAlignment="Left"
Name="GrowButton" Width="80" Height="30"
Delay="500" Interval="100"
Click="GrowButton_Click">
Grow
</RepeatButton>
<RepeatButton Margin="100,10,0,0" VerticalAlignment="Top"
HorizontalAlignment="Left"
Name="ShrinkButton" Width="80" Height="30"
Delay="500" Interval="100"
Click="ShrinkButton_Click">
Shrink
</RepeatButton>

<Rectangle Name="Rect" Height="100" Width="100" Fill="Orange"/>

</Grid>
</Window>

Listing 5

Listing 6 is the click event handlers for the buttons that change the width of the rectangle.

private void GrowButton_Click(object sender, RoutedEventArgs e)
{
Rect.Width += 10;
}

private void ShrinkButton_Click(object sender, RoutedEventArgs e)
{

Listing 6

How To Create And Use A CustomResource In XAML?

In this article you will learn how to create and use a CustomResource in XAML.

Open a new Visual C# windows project.
Add a new class named say CustomResourceTest.cs in the project folder.
Derive this class from CustomXamlResourceLoader Class(Case sensitive) like below:
You will get a Namespace not found error. Resolve it by using Windows.UI.Xaml.Resources Namespace.
Override the GetResource Member of the parent class as below. Use the intellisense to select the member.
Replace the Code inside the GetResource Method as: (this is just a simple example). We are returning a text. We plan to show this text inside a TextBlock’s Text Property.
Inside the MainPage.cs . Add the following line of code inside the MainPage Constructor to reference the CustomResouceTest.cs Class from the Page’s XAML.

Correct the NameSpace not found error by resolving it.
Now go to the MainPage.xaml Page and Add a TextBlock as follows. Notice the Text property of the TextBlock.
This results in the following output when you save, build and run the project.
What is happening here?
- We created a CustomResourceClass where we inherited the Class called CustomXamlResourceLoader.
- We override the GetResourceProperty. Don’t focus on the parameters of this method for now.
- We replaced the code inside this method by simply returning a text.
- To access this CustomResource from XAML we have to define the CustomXamlResourceLoader. Current property to the new instance of the Class we created. We have to do this inside the Constructor of the Codebehind page where we want to use the CustomResource.
- We then simply assigned the value of the Text property of the textblock to the CustomResource as seen on Step 8.

Example 2:

Now we will try a different example where we want to display the Text of the TextBlock based on the value we pass on. Change the text of the Mainpage.xaml as:
The 'sayHello' string is passed as a string to the CusomResourceTest.cs class as ResourceID parameter of the overridden class. This will be more clear as you see in the next step.
In the CustomResourceTest.cs class , change the code as follows:
The thing to understand is how we pass the ResourceID from the Text Property of the TextBlock. It is passed as the resourceID parameter. So, based on the ResourceID, we return the appropriate text we want to display on the output screen.
So now we get output as.
If we change the text property as sayByeBye.
We get the following output:

How to use Type converter in XAML ( Windows Applications )?

We're going to discuss about Automatic Type converters in XAML.

Whenever you make some control in XAML you set its properties. For example in following screen shot we are making a button in XAML and setting its properties like:

Name

Horizontal Alignment

Margin

Background

Vertical Alignment

Horizontal Alignment

Background Color etc , you are shown a list of given option through Intellisense like below:

So you have limited options as shown in above screenshot. you've to select 1 position from 4 given options . These options are infect enums.

have you ever noticed that when you type in for setting the properties like ,

Now I'm going to show you the alternate way to set properties using C# syntax. To make a button from C# write following code in Page Load Event in program.

When you make a control from C# code. You've to set all of its properties in code. In this case we've set its

HorizontalAlignment
Background properties

You selected the background color and Horizontal Alignment from a strongly typed enumeration for the button. So the question is ! How these properties are mapped to strongly typed enumeration, when you type a string which is "left" in the case of alignment property and "Red" in case of color selection.

Answer is ! XAML parser does this job.

XAML parser convert string value into a strongly typed version of that value. So when you set the properties like < horizontalAllignment = "Left" > , the string "Left" will be mapped to the strongly typed enum by the XAML parser.

Data Binding To GridView Controls in XAML?

Your comment on this post:

Related Articles

ListView with an ItemTemplate