SupportedOrientation specifies the orientations (landscape or portrait or both) that are supported by the app. For example, you rotate your phone – does the app respond to change in orientation?  If set SupportedOrientation to “PortraitOrLandscape”, the app would rotate when you change orientation. 

Setting Orientation

XAML  (This property is set on PhoneApplicationPage)

Orientation="Portrait"

Code

this.Orientation = PageOrientation.Portrait;

Setting SupportedOrientation

XAML (This property is set on PhoneApplicationPage)

SupportedOrientations="PortraitOrLandscape"

Code

this.SupportedOrientations = SupportedPageOrientation.PortraitOrLandscape;

-          Once we modify the content of a particular cell (cell validation)

-          Once we modify the content of a particular datagrid row (would like to commit changes to row) (Row Validation)

In this blog, I will try to give an intro both cell validation and row validation by using examples.

Cell Validation

Cell Validation can be done in two ways

-          Raising ValidationException in the property setter

-          Using ValidationAttributes and calling ValidateProperty in property setter

Cell Validation by throwing ValidationException in the property setter

In order to understand this concept, let’s consider that our datagrid is populated with a collection of Employee (with the following properties) objects  on which we want to do Cell Validation

        public String firstName;

        public String lastName;

        public int age;

        public String phone;

        public String city;

        public String state;

The validations that we want to do on these properties are

-          Firstname, lastname,  phone, city, state should not be null or empty

-          Age has to be in the range  18 to 50

We define validation rules for these properties (in the setter properties) in the following way.  The ValidationException (belonging to System.ComponentModel.DataAnnotations ) thrown is displayed as Cell Validation Error.

        public string LastName

        {

            get { return lastName; }

            set

            {

                if (value != lastName)

                {

                    if (value == null || value == string.Empty)

                    {

                        throw new ValidationException("Last Name cannot be empty");

                    }

                    lastName = value;

                    NotifyPropertyChanged("LastName");

                }

            }

        }

        public int Age

        {

            get { return age; }

            set

            {

                if (value != age)

                {

                    if (value < 18 || value > 50 )

                    {

                        throw new ValidationException("Age should be between 18 and 50");

                    }

                    age = value;

                    NotifyPropertyChanged("Age");

                }

            }

        }

Using Validation Attributes and calling ValidateProperty in property setter

The properties on which we want to do validation are decorated by validation attributes and we call the validationobject.validateproperty method in the setter of the property.  This tells the validator to verify on the decorated validation attribute when validateProperty is called. 

In the following code snippet,  the Required, Range and RegularExpression validation attributes are used.  The image below them shows the validation error when a validation rule is not met

        [Required]

        public string FirstName

        {

            get { return firstName; }

            set

            {

                if (value != firstName)

                {

                    Validator.ValidateProperty(value, new ValidationContext(this, null, null) { MemberName = "FirstName" });

                    firstName = value;

                    NotifyPropertyChanged("FirstName");

                }

            }

        }

        [Required]

        [Range(18,50)]

        public int Age

        {

            get { return age; }

            set

            {

                if (value != age)

                {

                    Validator.ValidateProperty(value, new ValidationContext(this, null, null) { MemberName = "Age" });

                    age = value;

                    NotifyPropertyChanged("Age");

                }

            }

        }

        [Required]

        [RegularExpression("\\d{3}[-]\\d{3}[-]\\d{4}")] // (e.g - "999-999-1234")

        public string Phone

        {

            get { return phone; }

            set

            {

                if (value != phone)

                {

                    Validator.ValidateProperty(value, new ValidationContext(this, null, null) { MemberName = "Phone" });

                    phone = value;

                    NotifyPropertyChanged("Phone");

                }

            }

        }

Row Validation

In addition to doing validation when we edit a particular cell, we can perform validation when we commit a particular row or entity in the datagrid.  In order to do this,we decorate our BusinessObject class with the CustomValidation attribute that specifies the Validation class and the method that are used for validation. The row validation errors are shown at the bottom of the data grid in a error listbox.  Clicking on an error in the listbox focuses on the cell that that has validation error. Resolving the validation error dynamically removes the error from the listbox.

        [Required]

        public string FirstName

        {

            get { return firstName; }

            set

            {

                if (value != firstName)

                {

                    firstName = value;

                    NotifyPropertyChanged("FirstName");

                }

            }

        }

I will use the Employee class with the following properties as an example.  Note that I also show the decorated validation attributes on the properties of Employee just for demo purpose (In actuality the property definition looks similar to the above).

        [Required]

        public string FirstName

        [Required]

        public string LastName

        [Required]

        public DateTime? BirthDate

        [Required]

        [Range(18,50)]

        public int? Age

        [Required]

        public String City

        [Required]

        public String State

        [Required]

        [RegularExpression("\\d{3}[-]\\d{3}[-]\\d{4}")] // (e.g - "999-999-1234")

        public string Phone

Please note that we are not explicity calling the Validator.ValidateObject method or throwing ValidationExceptions in the setter for invalid values (Doing so will show cell validation errors).

The business object Employee class is decorated with the following customvalidation attributes

    [CustomValidation(typeof(EmployeeValidator), "IsValidBirthDay")]

    [CustomValidation(typeof(EmployeeValidator), "IsValidBirthDayAge")]

    public class Employee : INotifyPropertyChanged

The EmployeeValidator Class is static and we define validation methods inside it.  The class looks like below for this particular example.

    public static class EmployeeValidator

    {

        public static bool IsValidBirthDay(object employeeObject, ValidationContext context, out ValidationResult validationResult)

        {

            validationResult = null;

            Employee employee = employeeObject as Employee;

            DateTime date = employee.BirthDate.Value;

            int dateComparison = date.CompareTo(DateTime.Today);

            if (dateComparison > 1)

            {

                List<string> properties = new List<string>() { "BirthDate" };

                validationResult = new ValidationResult("Birthday cannot be further than today!", properties);

            }

            return !(dateComparison > 1);

        }

        public static bool IsValidBirthDayAge(object employeeObject, ValidationContext context, out ValidationResult validationResult)

        {

            validationResult = null;

            Employee employee = employeeObject as Employee;

            DateTime date = employee.BirthDate.Value;

            int age = DateTime.Today.Year - date.Year;

            if (age != employee.Age)

            {

                List<string> properties = new List<string>() { "Age", "BirthDate" };

                validationResult = new ValidationResult("Age does not match with Birthday! Your age should be " + age, properties);

            }

            return (age == employee.Age);

        } 

    }

If you observe the IsValidBirthDay validation method above, this checks if the propertry “Birthdate” is not further from today.     In the following code snippet

List<string> properties = new List<string>() { "BirthDate" };

                validationResult = new ValidationResult("Birthday cannot be further than today!", properties);

As you can see, developers can use these validation features that datagrid supports to develop compeling apps.

Specifying SortDescriptions in XAML

<UserControl x:Class="SortDescriptions3.MainPage"

    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

    xmlns:scm="clr-namespace:System.ComponentModel;assembly=System.Windows"

    >

    <Grid x:Name="LayoutRoot" Background="White">

        <data:DataGrid x:Name="dg">

            <data:DataGrid.SortDescriptions>               

                <scm:SortDescription PropertyName="City" Direction="Descending" />

                <scm:SortDescription PropertyName="Department" Direction="Ascending" />

            </data:DataGrid.SortDescriptions>

        </data:DataGrid>

    </Grid>

</UserControl>

In the above code, we specified the column “City” to be sorted in Descending order, and the column “Department” to be sorted in Ascending order.

Specifying SortDescriptions through code

Defining SortDescriptions on PagedCollectionView

            List<Employee> list = PopulateData(100);

            PagedCollectionView cv = new PagedCollectionView(list);

            cv.GroupDescriptions.Add(new PropertyGroupDescription("City"));

            dg.ItemsSource = cv;

            cv.SortDescriptions.Add(new SortDescription("FirstName", ListSortDirection.Ascending));

            cv.SortDescriptions.Add(new SortDescription("Department", ListSortDirection.Descending));

We can combine sort Descriptions as well as  GroupDescriptions (to specify column grouping) as indicated in the above code.

Defining SortDescriptions on datagrid

            List<Employee> list = PopulateData(100);

            dg.ItemsSource = list;

            dg.SortDescriptions.Add(new SortDescription("City", ListSortDirection.Descending));

            dg.SortDescriptions.Add(new SortDescription("Department", ListSortDirection.Ascending));

Hooking up the code pieces together and building the application and running it will show us sorting in datagrid. 

Silverlight 3 Beta has got a very  good response at Mix 09 conference.  There have been some additions to datagrid since Silverlight 2 RTW.  One of them  is support for Grouping – developers can specify columns by which they want to group by. 

The Group definitions can be added through XAML as well as through Code. 

Adding Group Definitions through xaml

    <UserControl x:Class="GroupingQuickStart.MainPage"

    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"

    xmlns:compmod="clr-namespace:System.Windows.Data;assembly=System.ComponentModel"

    Width="700" Height="700">

    <Grid x:Name="LayoutRoot" Background="White">

        <data:DataGrid x:Name="dg" >

            <data:DataGrid.GroupDescriptions>

                <compmod:PropertyGroupDescription PropertyName="Department" />

                <compmod:PropertyGroupDescription PropertyName="City" />

            </data:DataGrid.GroupDescriptions>

        </data:DataGrid>

    </Grid>

</UserControl>

In the above example we are grouping data on “Department” column and then by "City" column.  PropertyGroupDescription class in the System.Widows.Data namespace of System.ComponentModel assembly takes care of this.

Before, we see how we add grouping through code, we should make a note of PagedCollectionView class.  This implements the IPagedCollectionView interface and allows grouping, sorting, etc… on the data collection.  The most common way of populating data in a pagedcollectionview class is through a collection object like list that implements IEnumerable

Adding Group Descriptions through Code

We can add grouping through code in two ways

Defining group descriptions on the PagedCollectionView

            PagedCollectionView collectionView = new PagedCollectionView(PopulateData(100));

            collectionView.GroupDescriptions.Add(new PropertyGroupDescription("Department"));

            collectionView.GroupDescriptions.Add(new PropertyGroupDescription("City"));

            dg.ItemsSource = collectionView;

 Defining group descriptions on the datagrid

            List<Employee> list = PopulateData(100);

            dg.GroupDescriptions.Add(new PropertyGroupDescription("Department"));

            dg.GroupDescriptions.Add(new PropertyGroupDescription("City"));

            dg.ItemsSource = list;

PopulateData method that I used in the above code snippet populates a list collection with Employee Class objects. The Employee class implements INotifyPropertyChanged and exposes the following properties

        public String FirstName;

        public String LastName;

        public String City;

        public String Department;

        public String State;

Hooking up these code pieces together and building the application and running it will show us groups in datagrid. 

Using the ObservableCollection gets this functionality comes free of cost/extra code for us.  The observable collection implements InotifyCollectioChanged which notifies the underlying control whenever anything has changed in the list.

Here is the page.xaml snippet

Here is the page.xaml.cs snippet

    public partial class Page : UserControl

    {

        ObservableCollection<Customer> clist = new ObservableCollection<Customer>();

        public Page()

        {

            InitializeComponent();

            int count = 25;

            for (int i = 0; i < count; i++)

            {

                Customer cust1 = new Customer("custfname" + i, "custlastname" + i, i, "address" + i, "city" + i, "country" + i);

                clist.Add(cust1);

            }

            dg.ItemsSource = clist;

        }

        private void addbutton_Click(object sender, RoutedEventArgs e)

        {

            int count = clist.Count;

            Customer cust1 = new Customer("custfname" + count, "custlastname" + count, count, "address" + count, "city" + count, "country" + count);

            clist.Add(cust1);

            dg.ScrollIntoView(clist[clist.Count-1], dg.Columns[5]);

        }

        private void deletebutton_Click(object sender, RoutedEventArgs e)

        {

            int deleteIndex = clist.Count - 1;

            clist.RemoveAt(deleteIndex);

            dg.ScrollIntoView(clist[clist.Count - 1], dg.Columns[5]);

        }

    }}

Thus, using the ObservableCollection helps us view in datagrid without any writing extra code the changes made to the underlying collection.

More about Silverlight ObservableCollection at https://msdn.microsoft.com/en-us/library/ms668604(VS.95).aspx 

Lets see an example

Page.xaml is defined in this way showing a datagrid and a button

    <Grid x:Name="LayoutRoot" Background="White">

        <Grid.RowDefinitions>

            <RowDefinition Height="400"/>

            <RowDefinition Height="50"/>

        </Grid.RowDefinitions>

        <data:DataGrid x:Name="dg" Grid.Row="0">

        </data:DataGrid>

        <Button x:Name="button1" Content="Add" Click="button1_Click" Grid.Row="1"></Button>

    </Grid>

            clist = new List<Customer>();

            int count = 25;

            for (int i = 0; i < count; i++)

            {

                Customer cust1 = new Customer("custfname" + i, "custlastname" + i, i, "address" + i, "city" + i, "country" + i);

                clist.Add(cust1);

            }

            dg.ItemsSource = clist;

In the button click event, a new Customer object is added to the list

            int count = clist.Count;

                Customer cust1 = new Customer("custfname" + i, "custlastname" + i, i, "address" + i, "city" + i, "country" + i);

            clist.Add(cust1);

            dg.ItemsSource = null;

            dg.ItemsSource = clist;

When the button is clicked, the row is added to the end of the datagrid.  We have to manually scroll down to the bottom of list to see the added row.

To scroll to the added row programmatically, we can use the ScrollIntoView function

dg.ScrollIntoView(clist[count], dg.Columns[5]);

The first argument is the row object that should be visible and the 2^nd argument specifies the column

As you can see, with the scroll into view added to the button click event, we can see the added row and also the column specified is brought into view

Happy DataGrid’ing!

Part1 : WebService Creation

1. Open VS
2. Create new ASP.net Web Service Application
3. Open Server Explorer
4. Add connection to “pubs” database from the Server Explorer
5. Add a DataSet to the Solution
6. From the Server Explorer Window, drop the authors table of the Server explorer onto the DataSet Designer
7. Build the Solution.
8.  Open Service1.asmx file in the designer
9. Drop the DataSet1, authorsTableAdapter components from the toolbox onto the Service1’s designer
10. Build the App
11. Add the following code to the Service1 class
1.         [WebMethod]
2.         public DataSet1 getDS()
3.         {
4.             InitializeComponent();
5.             this.authorsTableAdapter1.Fill(dataSet11.authors);
6.             return dataSet11;
7.         }
12. Build the Application.

Part II. WebService Deployment on the server

The web service can be deployed using iis (Internet Information Server). 

The following steps have to be followed.

1. Copy the Web service to the inetpub\wwwroot folder
2. Type ‘inetmgr’ in the run window. Internet Information Services Window appears
3. Browse to the folder containing the asmx file of the web service (Internet Information Services -> Computer Name -> Web Sites -> Default Web Site -> WebService1 -> WebService1)
4. Right click on the WebService1 node and click on properties. “WebService1 Properties” dialog appear
5. Click the “Create” button to create the application. Click “Apply” and then “ok” buttons
6. Now WebService1 Application is created on the server.
7. Exit iis
8. Restart iis using the following commands
1. aspnet_regiis –i –enable
2. iisreset
9. from run command, type inetmgr

Part III. Accessing from the Client

This is described in my previous blog post

https://blogs.msdn.com/nagasatish/archive/2007/10/17/adding-a-web-reference-to-a-vs-2008-windows-forms-project.aspx

Part IV Binding to Winforms Controls

After Doing the steps in step III, you will be able to bind winforms controls to the dataset returned from the web service.

In the project from step3,after building the project

1. Drop  “Service1” from the toolbox onto the form
2. Drop “DataSet” under the Data area from the toolbox on to the form. Select TypedDataSet with name “WindowsApplicationName.WebServerName.DataSet1”
3. Drop a textbox onto the form. Bind to the author’s table au_id field.

In this way you can access a web service and bind to windows forms controls.

VS2005

In Visual 2005 (Whidbey), adding a Web Reference is pretty straight forward.

From Project -> Add Web Reference ..., (From Solution Explorer, Right Click on Project, From the drop down Menu, Select Add Web Reference)

Add Web Reference Dialog Comes up.

In the Text box for URL, you specify url for the Web Service.

Click Go

Then a preview of the service is shown.  You have the option of renaming the service.

Click the "Add Reference ..." Button.

Web Service is added to the solution.  You can see it under "Web References"

What Changed in Orcas

From Project -> Add Service Reference ..., (From Solution Explorer, Right Click on Project, From the drop down Menu, Select Add Service Reference)

Click Advanced Button

Service Reference Setting Dialog Comes up. Click "Web Reference" button here.   Web Reference dialog comes up. The rest of the steps are same as in VS2005

In my previous blog, I talked about a new WindowsForms Control “ElementHost” to host WPF controls inside a WindowsForms Project.  On the contrary, “WindowsFormsHost” is used to host winforms controls inside a WPF application.  WindowsFormsHost is a very important control to get the rich capabilities of WinForms world into WPF.  WPF does not have a story yet for some of the controls like DataGridView, ToolStrips etc which have lots of uses.

In this blog, I will concentrate on getting a DataGridView getting displayed inside a WPF application.  I will make use of databinding to get data from the Customers Table of the SaveNorthWind Database.

The steps would be as follows

1. Create a new WPF Application in C#
2. Add reference to System.Windows.Forms.dll
3. Add the “WindowsFormsHost” control from the toolbox onto the WPF window.
4. From the Data Menu on the toolbar “Select Add New Data Source “ and connect to the Customers Table of SaveNorthWind database
1. After successfully doing this step, you can see SaveNorthWindDataSet added to the application
5. In the Window1.xaml.cs file, create the following function. (This basically does the plumbing work to get the data from the customers table in the form of a bindingsource object)

        BindingSource dataBindingPrep()

        {

            SaveNorthwindDataSet dataset = new SaveNorthwindDataSet();

            dataset.DataSetName = "SaveNorthwindDataSet";

            dataset.SchemaSerializationMode = System.Data.SchemaSerializationMode.IncludeSchema;

            SaveNorthwindDataSetTableAdapters.CustomersTableAdapter tableadapter = new WpfApplication1.SaveNorthwindDataSetTableAdapters.CustomersTableAdapter();

            BindingSource bs = new BindingSource();

            bs.DataMember = "Customers";

            bs.DataSource = dataset;

            tableadapter.ClearBeforeFill = true;

            // filling the table

            tableadapter.Fill(dataset.Customers);

            return bs;

        }

6. Create a DataGridView control, set its datasource property
7. set the child property of windowsformshost to the datagridview

        public Window1()

        {

            InitializeComponent();

            //adding the datagridview

            DataGridView dgv = new DataGridView();

            dgv.DataSource = dataBindingPrep();

            //setting the child property

            windowsFormsHost1.Child = dgv;

            //hooking events to DGV

            dgv.CellContentClick += new DataGridViewCellEventHandler(dgv_CellContentClick);

        }

when you run your app, you can see the wpf window showing the data from the customers table in a datagridview.

You can also try to add events to the datagridview.  In my example, I choose to show a messagebox when I click on the column1 of the DGV. I can do this by implementing the  cellcontentclick event as follows.

        void dgv_CellContentClick(object sender, DataGridViewCellEventArgs e)

        {

            DataGridView dgv = (DataGridView)sender;

            if (e.ColumnIndex == 0)

            {

                System.Windows.MessageBox.Show("Clicked on " + dgv.Rows[e.RowIndex].Cells[e.ColumnIndex].Value);

            }

        }