Eclipsed4utoo's Blog
Not Your Ordinary Programmer

Posts Tagged ‘Silverlight 4’

Silverlight 4 – Creating a Custom Modal Dialog

Fri ,23/07/2010

For a Silverlight application I did recently, I wanted to do a custom modal dialog box for showing informational messages, error messages, or other messages to the user.  This dialog box would have no title bar or “X” button, and would have rounded corners.

For this tutorial, we will use Blend 4 to accomplish our task.

First, create a new Silverlight 4 application.  I named mine CustomDialog.

Image1

Once the project has been created, we are going to add a new item to our Silverlight project.  This item will be a ChildWindow.  I named mine DialogPopup.

Image2

The ChildWindow will handle the modal dialog part of our window.  However, there are parts of the ChildWindow that I didn’t like and wanted to remove/change, such as the window chrome.  I also wanted to round the corners of the window.   To do this, we need to edit the template for the window.  In the Objects and Timeline window, right-click on the ChildWindow parent –> Edit Template –> Edit a Copy

Image3

We are going to keep it simple and save the new style to the ChildWindow document.

Image4

So first, we are just going to delete the window chrome from the window.  The window chrome is the title bar and the “X” used to close the window.  Drill-down in the treeview until you find the Chrome entry.  Right-click, and choose Delete.

Image5

Next, we need to delete some of the Borders.  These give the window a grey border that I didn’t want.

Image11

Next, we are going to round the corners of the window.  Drill-down and click on the Border shown below.

Image12

In the Properties window, set the CornerRadius to 20.

Image7

Move down to the next Border,

Image13

And set it’s CornerRadius to 20.

Image9

With the same Border selected, in the Properties window, set the Background Brush to a color of your choice.

Image10

The window “jazz” is now complete.  Next, we are going to move to the XAML.

First, we need to give our window a name so we can handle binding.  I named mine myCustomPopup.

<sdk:ChildWindow
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk"
   x:Class="CustomDialog.DialogPopup"
   x:Name="myCustomPopup"
   Title="DialogPopup"
   Width="400" Height="300">

Now we need to add a TextBlock to the window to hold our message.

<TextBlock
    Text="{Binding Message, ElementName=myCustomPopup}"
    Margin="51,88,57,113"
    TextWrapping="Wrap"
    Foreground="#FF1D1515"
    FontWeight="Bold"
    TextAlignment="Center"/>

You may notice that we are binding to a property called Message.  This is a custom DependencyProperty that will correspond to a public property that we will set when we create an instance of the window.

/// <summary>
/// Creates a public property for the TextBlock to bind to
/// </summary>
public static DependencyProperty MessageProperty = DependencyProperty.Register("Message", typeof(string), typeof(DialogPopup), new PropertyMetadata(""));
public string Message
{
     get { return (string)GetValue(MessageProperty); }
     set { SetValue(MessageProperty, value); }
}

This will complete our work for the window.  To show off the new window, lets add a Button to the MainPage.xaml, create an EventHandler for the Click event.

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

     <Button
        x:Name="btnShowMessage"
        Content="Click Me"
        Click="btnShowMessage_Click"
        Margin="251,207,289,236"  />
</Grid>

And the code for the Click event…

private void btnShowMessage_Click(object sender, System.Windows.RoutedEventArgs e)
{
     DialogPopup dialog = new DialogPopup();
     dialog.Message = "Our message";
     dialog.Show();
}

And that will complete our tutorial.  Run the application from Blend using F5, and you should see this..

Image14

Silverlight 4 – Publishing Application to Remote Server

Thu ,22/07/2010

This blog post will talk about the steps needed to publish a Silverlight 4 applications that uses WCF RIA Services for communication.  There were a number of issues that I ran into trying to publish, so I decided to do a blog post to keep other’s from having to search and hunt for the fixes.

NOTE:  These steps are for IIS running on Windows Server 2003 SP2.  Steps may be different for other versions of IIS.

1.  First, you will need to fix your web.config file as I have noted in this blog post.  This is not added by default.

2. (Optional) If you are running a .Net 2.0 or .Net 3.5 website on this same server, you will need to create a new AppPool in IIS.  This is required because an AppPool can only run one version of the .Net CLR.  With .Net 4, Microsoft created a new CLR.  Therefore, you will need an AppPool for the .Net 2.0 and .Net 3.5 websites, and an AppPool for the .Net 4 websites.  NOTE:  This may have changed in later versions of IIS.

3.  Next, in Visual Studio 2010, you will need to set a number of the references of the .Web project to Copy to Local.  I had to do it for all of the System.ServiceModel references.  You may not have all of these references, and that is fine.

SLImage4

Then go to the Properties window, and set Copy Local equal to True.

SLImage5

4.  Next, you need to add a new MIME type for both the .XAP extension and the .XAML extension.

Open the IIS Management console.  Drill-down until you get to your domain/default website.  Right-click and click Properties.
SLImage1

Next, go to the HTTP Headers tab, then click on the Mime Types… button.
SLImage2

Now add the two new mime types..
SLImage3

Now simply publish your web project to your server, and you should be ready to go.

NOTE: This blog post does not talk about creating a Virtual Directory or making the Virtual Directory an application.  There are plenty of other blog posts that can walk you through that.  However, make sure the Virtual Directory is set to the AppPool for .Net 4(if it was required for your setup).

Silverlight 4 – Connecting To Remote Database With WCF

Fri ,14/05/2010

This tutorial will show how to connect to a database that is located on the deploy server from a Silverlight application.

I will be using Visual Studio 2010 and Silverlight 4.

So first, we will create a Silverlight 4 application.

Thumb1

Image2

Next, we are just going to put a DataGrid on our MainPage.xaml.


<UserControl x:Class="SilverlightWCFTutorial.MainPage"
   
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   
xmlns:d="http://schemas.microsoft.com/exp ression/blend/2008"
   
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
   
mc:Ignorable="d"
   
d:DesignHeight="300" d:DesignWidth="400" xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk">

   
<Grid x:Name="LayoutRoot" Background="White">
       
<sdk:DataGrid
           
Name="dataGridPerson"
           
AutoGenerateColumns="True"
           
Height="206"
           
HorizontalAlignment="Left"
           
Margin="12,44,0,0"  
           
VerticalAlignment="Top"
           
Width="376"
           
ItemsSource="{Binding}">
       
</sdk:DataGrid>
   
</Grid>
</UserControl>

So for the Grid, we are simply going to show a list of names that are in a database table.  I have a database table setup as:

Table Name:   Person

Columns:
ID
FirstName
LastName
Age

I am going to concatenate the First Name and Last Name, then bind that to the grid.

Now that we have our Silverlight application ready, we will add a WCF service to our existing “SilverlightWCFTutorial.Web” project that was automatically created for us.

Image3

Now we are going to setup the interface that was created for us.  The interface automatically creates a method called “DoWork”.  We are going to change the name of this to be a little more specific.  I gave the method the name of “GetNames”.

[ServiceContract]
public interface IDatabaseService
{
   
[OperationContract]
   
List<string> GetNames();
}

Now that the interface is finished, we will move to the service file.  Double-click on the “DatabaseService.svc” file to get to the code.  This code is just going to run some simple ADO to get the data from the database.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Data.SqlClient;
using System.Data;

namespace SilverlightWcfService
{
   
// NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "DatabaseService" in code, svc and config file together.
   
public class DatabaseService : IDatabaseService
   
{
       
string myConnectionString = "someConnectionString";

       
public List<string> GetNames()
       
{
           
List<string> list = new List<string>();

           
using (SqlConnection cn = new SqlConnection(myConnectionString))
           
{
               
using (SqlCommand cmd = cn.CreateCommand())
               
{
                    cmd
.CommandText = "SELECT FirstName + ' ' + LastName FROM Person";
                    cmd
.CommandType = CommandType.Text;

                    cn
.Open();

                   
using (SqlDataReader dr = cmd.ExecuteReader())
                   
{
                       
while (dr.Read())
                       
{
                            list
.Add(dr.GetString(0));
                       
}
                   
}
               
}
           
}

           
return list;
       
}
   
}
}

Next, we will need to fix the “Markup” of the “DatabaseService.svc” file.   Right-click on the file, then choose “View Markup”.  In the markup, you will notice a “Service” attribute.  This should be in the format of “Namespace.ServiceName”.  In our case, the autogenerated value could be incorrect.  Change the code to this..

<%@ ServiceHost Language="C#" Debug="true" Service="SilverlightWCFTutorial.Web.DatabaseService" CodeBehind="DatabaseService.svc.cs" %>

Now that our WCF service is complete, we are going back to the Silverlight app.  We are going to add an event handler for the “Loaded” event of the MainPage.xaml.

public MainPage()
{
   
InitializeComponent();

   
this.Loaded += new RoutedEventHandler(MainPage_Loaded);
}

You will need to rebuild your solution at this point.

We will also need to add a Reference to the Service for our Silverlight project.  Right-click on the “SilverlightWCFTutorial” project, and choose “Add Service Reference…”.  Once the Add Service Reference window comes up, click the “Discover” button.  This will find our service.  Fill in the “Namespace”(called mine “MyDatabaseService”).  Then click OK.

Image4

Now we are ready to do some code.  Remember that the requests in Silverlight are made asynchronously.

In our “MainPage_Loaded’ event handler, we will have this code..

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
   
// The DatabaseServiceClient class was automatically created for us.
   
// The autogeneration takes the name of the service, then appends "Client" to it,
   
//   giving us the "DatabaseServiceClient" class.
   
DatabaseServiceClient client = new DatabaseServiceClient();

   
// Since requests in Silverlight are asynchronous, we have a Completed method
   
//   that will be fired when the request has been completed.
    client
.GetNamesCompleted += delegate(object s, GetNamesCompletedEventArgs es)
   
{
       
// when the request has been completed, we want to bind the data to the grid.
       
// the Result property of the EventArgs contains the returned data.
       
// ObservableCollection is a common collection that is used when databinding to
       
//    a DataGrid.
       
ObservableCollection<string> myList = es.Result;

        dataGridPerson
.DataContext = myList;
   
};

    client
.GetNamesAsync();
}

And that’s it.  We now run the Silverlight app, and we get this…

Image5

Here is the full code of the MainPage.xaml…

using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;
using SilverlightWCFTutorial.MyDatabaseService;

namespace SilverlightWCFTutorial
{
   
public partial class MainPage : UserControl
   
{
       
public MainPage()
       
{
           
InitializeComponent();

           
this.Loaded += new RoutedEventHandler(MainPage_Loaded);
       
}

       
void MainPage_Loaded(object sender, RoutedEventArgs e)
       
{
           
// The DatabaseServiceClient class was automatically created for us.
           
// The autogeneration takes the name of the service, then appends "Client" to it,
           
//   giving us the "DatabaseServiceClient" class.
           
DatabaseServiceClient client = new DatabaseServiceClient();

           
// Since requests in Silverlight are asynchronous, we have a Completed method
           
//   that will be fired when the request has been completed.
            client
.GetNamesCompleted += delegate(object s, GetNamesCompletedEventArgs es)
           
{
               
// when the request has been completed, we want to bind the data to the grid.
               
// the Result property of the EventArgs contains the returned data.
               
// ObservableCollection is a common collection that is used when databinding to
               
//    a DataGrid.
               
ObservableCollection<string> myList = es.Result;

                dataGridPerson
.DataContext = myList;
           
};

            client
.GetNamesAsync();
       
}
   
}
}