Step 1
Create a new project in Visual Studio and select "Silverlight Application".

Step 2
Open MainPage.xaml and add the following code.
    <UserControl x:Class="SilverlightAnalogClock.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/expression/blend/2008"  
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"  
        mc:Ignorable="d"  
        d:DesignHeight="300" d:DesignWidth="400">  
      
        <Grid x:Name="LayoutRoot" Background="White">  
             
        </Grid>  
    </UserControl>  

Step 3
Open MainPage.xaml.cs and add the following code.
    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Net;  
    using System.Windows;  
    using System.Windows.Controls;  
    using System.Windows.Documents;  
    using System.Windows.Input;  
    using System.Windows.Media;  
    using System.Windows.Media.Animation;  
    using System.Windows.Media.Imaging;  
    using System.Windows.Shapes;  
      
    namespace SilverlightAnalogClock  
    {  
        public partial class MainPage : UserControl  
        {  
      
            public Canvas ClockArea = null;  
            public Rectangle secondHand = null;  
            public Rectangle minuteHand = null;  
            public Rectangle hourHand = null;  
      
            public RotateTransform secondHandRotate = null;  
            public RotateTransform minuteHandRotate = null;  
            public RotateTransform hourHandRotate = null;  
      
            public Ellipse outerCircle = null;  
      
            public Point centerPoint;  
            public double HEIGHT  = 0;  
            public double WIDTH  = 0;  
            public double RADIUS = 0;  
      
            public MainPage()  
            {  
                InitializeComponent();  
      
                ClockArea = new Canvas()  
                {  
      
                    Width = 300,  
                    Height = 300,  
                    HorizontalAlignment = HorizontalAlignment.Left,  
                    VerticalAlignment = VerticalAlignment.Top  
      
                };  
      
                ClockArea.SetValue(Grid.RowProperty, 0);  
                ClockArea.SetValue(Grid.ColumnProperty, 0);  
                ClockArea.Margin = new Thickness(0, 0, 0, 0);  
                this.LayoutRoot.Children.Add(ClockArea);  
      
                WIDTH = ClockArea.Width;  
                HEIGHT = ClockArea.Height;  
                centerPoint.X = (WIDTH/2);  
                centerPoint.Y = (HEIGHT/2);  
                       
                RADIUS = 400;  
                DrawClockFace();  
      
                Point TOPPOINT = new Point(0, 0);  
      
                DrawMinuteHand();  
                DrawSecondHand();  
                DrawHourHand();  
                DrawCenterCircle();  
      
      
                //Start the Clock  
                ClockStart();  
                  
      
            }  
      
            public void ClockStart()  
            {  
                // Create and Start the Thread Timer  
                System.Windows.Threading.DispatcherTimer clockTimer = new System.Windows.Threading.DispatcherTimer();  
                clockTimer.Interval = new TimeSpan(0, 0, 0, 0, 1000);  
                clockTimer.Tick += new EventHandler(Clock_Tick);  
                clockTimer.Start();  
            }  
      
            // Get and Set the Angles of Each Hand at every Clock Ticks  
            public void Clock_Tick(object o, EventArgs sender)  
            {  
                double hourRotateValue = Convert.ToDouble(DateTime.Now.Hour.ToString());  
                double minuteRotateValue = Convert.ToDouble(DateTime.Now.Minute.ToString());  
                double secondRotateValue = Convert.ToDouble(DateTime.Now.Second.ToString());  
                hourRotateValue = (hourRotateValue + minuteRotateValue / 60) * 30;  
                minuteRotateValue = (minuteRotateValue + secondRotateValue / 60) * 6;  
                secondRotateValue = Convert.ToDouble(DateTime.Now.Second.ToString()) * 6;  
                minuteHandRotate.Angle = minuteRotateValue;  
                hourHandRotate.Angle = hourRotateValue;  
                secondHandRotate.Angle = secondRotateValue;  
            }  
      
            // Draw Center Circle  
            public void DrawCenterCircle()  
            {              
                Ellipse centerCircle = new Ellipse()  
                {  
      
                    Width = 10,  
                    Height = 10,  
                    Stroke = new SolidColorBrush(Colors.Red),  
                    Fill = new SolidColorBrush(Colors.Red),  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
      
                };  
      
                centerCircle.SetValue(Grid.RowProperty, 0);  
                centerCircle.SetValue(Grid.ColumnProperty, 0);  
                Canvas.SetLeft(centerCircle, (WIDTH / 2) - (centerCircle.Width / 2));  
                Canvas.SetTop(centerCircle, (HEIGHT / 2) - (centerCircle.Height / 2));  
                ClockArea.Children.Add(centerCircle);  
            }  
      
            // Draw Clock Face  
            public void DrawClockFace()  
            {  
                          
                int smallCircle = 5;  
      
                Color c = Colors.Blue;  
                int p = 0;  
      
                // Draw Shadow of Outer Circle  
                Ellipse outerCircleShadow = new Ellipse()  
                {  
                    Width = (WIDTH),  
                    Height = (WIDTH),  
                    Stroke = new SolidColorBrush(Colors.Gray),  
                    StrokeThickness = 5,  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
                      
                };  
                 
                outerCircleShadow.SetValue(Grid.RowProperty, 0);  
                outerCircleShadow.SetValue(Grid.ColumnProperty, 0);  
                Canvas.SetLeft(outerCircleShadow, (WIDTH / 2) - (outerCircleShadow.Width / 2) + 6.5);  
                Canvas.SetTop(outerCircleShadow, (HEIGHT / 2) - (outerCircleShadow.Height / 2) + 6.5);  
                ClockArea.Children.Add(outerCircleShadow);  
                 
                //  Draw Outer Circle  
                outerCircle = new Ellipse()  
                {  
                    Width = (WIDTH ),  
                    Height = (WIDTH),  
                    Stroke = new SolidColorBrush(Colors.Black),  
                    StrokeThickness = 5,  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
                };              
                outerCircle.SetValue(Grid.RowProperty, 0);  
                outerCircle.SetValue(Grid.ColumnProperty, 0);  
                Canvas.SetLeft(outerCircle, (WIDTH / 2) - (outerCircle.Width / 2) + 4.5);  
                Canvas.SetTop(outerCircle, (HEIGHT / 2) - (outerCircle.Height / 2) + 4.5);  
                ClockArea.Children.Add(outerCircle);  
      
      
                outerCircle.Fill = new LinearGradientBrush()  
                    {  
                        EndPoint = new Point(1, 0),  
                        GradientStops = new GradientStopCollection()  
                        {  
                                new GradientStop() { Color = Colors.White, Offset = 0 },  
                                new GradientStop() { Color = Colors.Gray, Offset = 0.5 },  
                                 new GradientStop() { Color = Colors.White, Offset = 1 }  
                        }  
                    };  
      
                int clockDigits = 3;  
                double rad = (WIDTH/2) - 10.0f;  
                // 60 Innner Dots as Small Circle  
                for (double i = 0.0; i < 360.0; i += 6)   
                {   
      
                double angle = i * System.Math.PI / 180;  
      
                int x = (int)(centerPoint.X + rad * System.Math.Cos(angle));  
                int y = (int)(centerPoint.Y + rad * System.Math.Sin(angle));  
      
                if (p % 5 == 0)  
                {  
                    smallCircle = 10;  
                    c = Colors.Orange;                  
                }  
                else  
                {  
                    smallCircle = 5;  
                    c = Colors.Blue;  
                }  
                if (p % 15 == 0)  
                {  
                    TextBlock tb = new TextBlock();  
                    tb.Text = clockDigits.ToString();  
                    tb.FontSize = 24;  
                      
                    tb.SetValue(Grid.RowProperty, 0);  
                    tb.SetValue(Grid.ColumnProperty, 0);  
                    Canvas.SetLeft(tb, x );  
                    Canvas.SetTop(tb, y);  
                    if (clockDigits == 3)  
                    {  
                        Canvas.SetLeft(tb, x - 20);  
                        Canvas.SetTop(tb, y - 10);  
                    }  
                    if (clockDigits == 6)  
                    {  
                        Canvas.SetLeft(tb, x);  
                        Canvas.SetTop(tb, y - 30);  
                    }  
                    if (clockDigits == 9)  
                    {  
                        Canvas.SetLeft(tb, x + 15);  
                        Canvas.SetTop(tb, y - 10);  
                    }  
                    if (clockDigits == 12)  
                    {  
                        Canvas.SetLeft(tb, x - 10);  
                        Canvas.SetTop(tb, y + 5 );  
                    }   
                    
                      
                    ClockArea.Children.Add(tb);  
                    clockDigits = clockDigits + 3;  
                }  
      
                p++;  
                 
                            Ellipse innerPoints = new Ellipse()  
                            {  
                                Width = smallCircle,  
                                Height = smallCircle,  
                                Stroke = new SolidColorBrush(c),  
                                Fill = new SolidColorBrush(c),  
                                HorizontalAlignment = HorizontalAlignment.Center,  
                                VerticalAlignment = VerticalAlignment.Center  
                            };  
                            innerPoints.SetValue(Grid.RowProperty, 0);  
                            innerPoints.SetValue(Grid.ColumnProperty, 0);  
                            Canvas.SetLeft(innerPoints, x);  
                            Canvas.SetTop(innerPoints, y);  
                            ClockArea.Children.Add(innerPoints);  
      
                }  
      
                  
            }  
            // Draw the Second Hand  
            public void DrawSecondHand()  
            {  
      
                double handLength = (HEIGHT / 2) - 20;  
                secondHand = new Rectangle()  
                {  
                    Width = 1,  
                    Height = handLength,  
                    Stroke = new SolidColorBrush(Colors.Red),  
                    Fill = new SolidColorBrush(Colors.Red),  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
                };  
                  
                secondHand.SetValue(Grid.RowProperty, 0);  
                secondHand.SetValue(Grid.ColumnProperty, 0);  
                //Add Rotate Transformation  
                secondHandRotate = new RotateTransform();  
                secondHandRotate.Angle = 0;  
                //Set Center for Rotation  
                secondHandRotate.CenterX = Canvas.GetLeft(secondHand);  
                secondHandRotate.CenterY = secondHand.Height;  
                secondHand.RenderTransform = secondHandRotate;  
                //Set Initial Position of Hand  
                Canvas.SetTop(secondHand, centerPoint.Y - handLength);  
                Canvas.SetLeft(secondHand, WIDTH/2);             
                ClockArea.Children.Add(secondHand);  
                 
            }  
      
            public void DrawMinuteHand()  
            {  
                double handLength = (HEIGHT / 2) - 50;  
                minuteHand = new Rectangle()  
                {  
                    Width = 4,  
                    Height = handLength,  
                    Stroke = new SolidColorBrush(Colors.Black),  
                    Fill = new SolidColorBrush(Colors.Black),  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
                };  
      
                minuteHand.SetValue(Grid.RowProperty, 0);  
                minuteHand.SetValue(Grid.ColumnProperty, 0);  
      
                minuteHandRotate = new RotateTransform();  
                minuteHandRotate.Angle = 0;  
                minuteHandRotate.CenterX = Canvas.GetLeft(minuteHand);  
                minuteHandRotate.CenterY = minuteHand.Height;  
                minuteHand.RenderTransform = minuteHandRotate;  
                Canvas.SetTop(minuteHand, centerPoint.Y - handLength);  
                Canvas.SetLeft(minuteHand, WIDTH / 2);  
                ClockArea.Children.Add(minuteHand);  
      
            }  
            public void DrawHourHand()  
            {  
                double handLength = (HEIGHT / 2) - 80;  
                hourHand = new Rectangle()  
                {  
                    Width = 4,  
                    Height = handLength,  
                    Stroke = new SolidColorBrush(Colors.Black),  
                    Fill = new SolidColorBrush(Colors.Black),  
                    HorizontalAlignment = HorizontalAlignment.Center,  
                    VerticalAlignment = VerticalAlignment.Center  
                };  
      
                hourHand.SetValue(Grid.RowProperty, 0);  
                hourHand.SetValue(Grid.ColumnProperty, 0);  
      
                hourHandRotate = new RotateTransform();  
                hourHandRotate.Angle = 0;  
                hourHandRotate.CenterX = Canvas.GetLeft(hourHand);  
                hourHandRotate.CenterY = hourHand.Height;  
                hourHand.RenderTransform = hourHandRotate;  
                Canvas.SetTop(hourHand, centerPoint.Y - handLength);  
                Canvas.SetLeft(hourHand, WIDTH / 2);     
                ClockArea.Children.Add(hourHand);  
      
            }  
      
        }  
    }  

Output
Now execute and you will get a fully drawn Analog Clock.

Data binding is one of the best features the human race has ever devised. Binding a property of a UI Element to a property in the code behind can accomplish any task. It is magic, in a nutshell. Once the properties are bound, we must continue to notify the UI whenever the property's value is modified in the code. INotifyPropertyChanged is useful in this situation.

Because it is an interface, it must first be implemented. However, the procedure is not arduous. Here is the code for my primary page in my new Silverlight project:

publicpartialclassMainPage : UserControl
{
    privatestring _names;
     publicstring Names
    {
        get
        {
            return _names;
        }
        set
        {
            _names = value;
        }
    }

    public MainPage()
    {
        InitializeComponent();
    }

    privatevoid MainPage_OnLoaded(object sender, RoutedEventArgs e)
    {
        Names = "This is the Text";
    }
}

The property "Name" I have here is bound with the textblock in XAML, here is the code:
<UserControlx:Class="PropertyChangedDescribed.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/expression/blend/2008"
 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
  mc:Ignorable="d"
 Loaded="MainPage_OnLoaded"
 x:Name="TestingPropertyChanged"
 d:DesignHeight="300"d:DesignWidth="400">

 <Gridx:Name="LayoutRoot"Background="White">
  <TextBlockText="{Binding Names, ElementName=TestingPropertyChanged}"/>
  </Grid>

</UserControl>

As you can see, the textblock has it's "text" property bound with our code behind's property "Name". Right now, no matter what you set the value of "Name", it will never be reflected onto the UI. So, what we want is, every time we change the value of our property "Name," the text block has its value changed too. In order to do this, we need to implement the interface INotifyPropertyChanged. Here is the modified main page's code to do so:
publicpartialclassMainPage : UserControl, INotifyPropertyChanged
{
    privatestring _names;
    publicstring Names
    {
        get
        {
            return _names;
        }
        set
        {
            _names = value;
            OnPropertyChanged("Names");
        }
    }
    public MainPage()
    {
        InitializeComponent();

    }

    privatevoid MainPage_OnLoaded(object sender, RoutedEventArgs e)
    {
        Names = "This is the Text";

    }

    publicevent PropertyChangedEventHandler PropertyChanged;
    privatevoid OnPropertyChanged(string propertyName)

    {
        if (this.PropertyChanged != null)
        {
            PropertyChanged(this,new PropertyChangedEventArgs(propertyName));
        }
    }
}

So this is how you can implement INotifyPropertyChanged in Silverlight.

The control that you just like drag or move with the mouse is embedded among a Border control then handle the mouse down, up and move events to create the object move among your layout panel.

See sample .xaml code:
<Canvas x:Name="LayoutRoot" Background="White">
<Border x:Name="border1"
Canvas.Top="100"
Canvas.Left="10"
MouseLeftButtonDown="border1_MouseLeftButtonDown"
MouseLeftButtonUp="border1_MouseLeftButtonUp"
MouseMove="border1_MouseMove"> 
<Image x:Name="MyImage" Source="images/Basket.png" Stretch="Uniform" ></Image>           
</Border>
</Canvas>

In the above code, a Border control is placed within the Canvas. The foremost necessary code to notice is:
MouseLeftButtonDown="border1_MouseLeftButtonDown"
MouseLeftButtonUp="border1_MouseLeftButtonUp"
MouseMove="border1_MouseMove"

The above lines outline 3 events that we tend to like to handle. because the name indicates, we are handling the mouse button down, mouse button up and mouse move events for the left mouse.

In the code behind, once the left button is pressed, we are going to set a global variable to point that user has started moving. within the mouse move event, we are going to get the current location of the mouse pointer and then set the new position for the border control. once the left mouse button is discharged, we are going to reset the global variable in order that we are going to not move the item from now on.
See the code for the code behind class:
public partial class Page : UserControl
{
// Global variable to indicate if user has clicked border
// and started/stopped moving.
private bool moving = false;
private double offSetX;
private double offSetY;
public Page()
{
InitializeComponent();
}

private void border1_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
// Left mouse button clicked within border. start moving.
moving = true;

Point offset = e.GetPosition(border1);
offSetX = offset.X;
offSetY = offset.Y;
}

private void border1_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
// Left mouse button release. Stop moving.
moving = false;
}

private void border1_MouseMove(object sender, MouseEventArgs e)
{
if (moving)
{
    // Get the new mouse pointer position
    Canvas parent = (Canvas)this.border1.Parent;
    Point p = e.GetPosition(parent);
    double x = p.X - offSetX;
    double y = p.Y - offSetY;
    // Set the new position for the border control.
    this.border1.SetValue(Canvas.LeftProperty, x);
    this.border1.SetValue(Canvas.TopProperty, y);
}
}
}

HostForLIFE.eu Silverlight 6 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

Hi, I want to download a pdf file form silverlight application , the pdf file is in a folder in my solution , i want to give the path of the pdf to the method and it should download the pdf to the local system. i am happy to say that i achieved it with the following code:
SaveFileDialog dialog = new SaveFileDialog();
                dialog.Filter = "pdf Files|*.pdf";
                dialog.DefaultFileName = "BeneficiaryDesignation.pdf";
                if (dialog.ShowDialog() ?? false)
                {


                    WebClient webClient = new WebClient();
                    webClient.OpenReadCompleted += (s, e2) =>
                    {
                        try
                        {
                            using (Stream fs = (Stream)dialog.OpenFile())
                            {
                                e2.Result.CopyTo(fs);
                                fs.Flush();
                                fs.Close();
                            }
                           
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(ex.ToString());
                        }
                    };
                    string str = App.Current.Host.Source.AbsoluteUri;
                    string path = App.appConfiguration.GetPDFPath("BeneficiaryDesignation.pdf");
                    str = str.Replace("/ClientBin/ProjectDemo.xap", path);                    
                   
                    webClient.OpenReadAsync(new Uri(str), UriKind.RelativeOrAbsolute);
                }

HostForLIFE.eu Silverlight 6 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

In this post I'll describe the way to handle the exceptions in Silverlight. Whereas running the Silverlight application, if any exception happens it'll attend Silverlight.js and show within the internet explorer as a javascript error. Within the debugging purpose of read typically it's cumbersome to see wherever truly the exception happened.

LogWindow.xaml
This is an easy user control that has an easy textbox:
<TextBox
AcceptsReturn="True"
TextAlignment="Left"
TextWrapping="NoWrap"
VerticalScrollBarVisibility="Visible"
x:Name="logText"
FontFamily="Courier New"
FontSize="12" IsReadOnly="True" HorizontalScrollBarVisibility="Auto" />

Logger.cs
This class are used to print the exception and notice the stacktrace. it's an enum for the exception types viz. DEBUG,INFO,WARN,ERROR and FATAL.This class contains an easy delegate to add text to the log window. The static property _instance is about by the LogWindow.xaml.cs go in the load event as:
Logger._instance = logText;
So that it will print whatever exception happenes in your application. The LogException methodology expects exception object because the parameter and find the exception information using the StackFrame class.

StackFrame frame = new StackFrame(true);
callerSignature =  string.Format("@{0}:{1}:{2}", frame.GetMethod(), frame.GetFileName(), frame.GetFileLineNumber());

To use this method in your catch block you just simply need to call the static method as:
Catch(Exception ex)
{
Logger.LogException(ex);
}

Hope this tutorial works for you!

How we can print the document in a Silverlight application.

Step 1
We have the PrintDocument Class which defines a reusable object that sends output to a printer.
    PrintDocument
    The PrintDocument object encapsulates all the information needed to print a page. They associate with the control which content can be print. They handle the events and operations of printing.
    Namespace - System.Drawing.Printing.PrintDocument

    [C#]

    public class PrintDocument : Component
    
We can create an instance of the PrintDocument class, set the properties that describe how to print, and call the Print method to start the printing process. Handle the PrintPage event where you specify the output to print, by using the Graphics included in the PrintPageEventArgs.
    Associate control to Print document
        private void printDoc_PrintPage(object sender, PrintPageEventArgs e) { 
            // print current page 
            e.PageVisual = printPage; 
        } 

Step 2
Create one user control page name as PrintPage.Xaml and design header and footer in this user control page like as following.
    <Grid x:Name="LayoutRoot" Background="White"> 
        <Grid.RowDefinitions> 
            <RowDefinition Height="Auto" /> 
            <RowDefinition /> 
            <RowDefinition Height="Auto" /> 
        </Grid.RowDefinitions> 
        <!--Header--> 
        <Grid> 
            <TextBlock Text="HEADER" /> 
        </Grid> 
        <!--Body--> 
        <ItemsControl Name="BodyItemsControl" Grid.Row="1" Margin="0,24" /> 
        <ItemsControl Name="TemplateItemsControl"> 
            <ItemsControl.ItemTemplate> 
                <DataTemplate> 
                    <Grid> 
                        <Grid.ColumnDefinitions> 
                            <ColumnDefinition Width="Auto" /> 
                            <ColumnDefinition Width="Auto" /> 
                            <ColumnDefinition Width="*" /> 
                        </Grid.ColumnDefinitions> 
                        <TextBlock Text="{Binding ID}" Margin="2" /> 
                        <TextBlock Text=" - " Grid.Column="1" Margin="2" /> 
                        <TextBlock Text="{Binding Description}" Grid.Column="2" TextWrapping="Wrap" MaxWidth="500" HorizontalAlignment="Left" Margin="2" /> 
                    </Grid> 
                </DataTemplate> 
            </ItemsControl.ItemTemplate> 
        </ItemsControl> 
        <Grid Grid.Row="2"> 
            <TextBlock Text="FOOTER" /> 
        </Grid> 

Step 3
In MainPage.Xaml create an instance of PrintDocument like as following.
    public MainPage() { 
        InitializeComponent(); 
        this.Loaded += new RoutedEventHandler(MainPage_Loaded); 
    } 
    void MainPage_Loaded(object sender, RoutedEventArgs e) { 
        GetItems(); 
        printDoc.PrintPage += newEventHandler < PrintPageEventArgs > (printDoc_PrintPage); 
    } 
    //following items for printing. 
    privatevoid GetItems() { 
        for (int i = 0; i < 100; i++) { 
            items.Add(newItem() { 
                ID = i, 
                    Description = "This is Print Document " + i 
            }); 
        } 
    } 
    //Handling the event when we're printing: 
    private void printDoc_PrintPage(object sender, PrintPageEventArgs e) { 
        PrintPage printPage = new PrintPage(); 
        // print current page 
        e.PageVisual = printPage; 
        e.HasMorePages = true; 
        break; 
    }  

Step 4
Add a button to the MainPage.Xaml and print the document when the button is clicked,
    <Button Content="Button" Grid.Row="1" Height="23" HorizontalAlignment="Left" Margin="42,56,0,0" Name="button1" VerticalAlignment="Top" Width="75" Click="button1_Click" /> 
    private void Button_Click(object sender, RoutedEventArgs e) 
    { 
        printDoc.Print("Printing A Page"); 
    } 

Step 5
Output look like as following,

HostForLIFE.eu Silverlight 6 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

In this post allow us to understand how to use ScrollViewer panel Layout inside a Silverlight application. ScrollViewer is an additional layout container, that we don’t use constantly. It's chiefly useful showing contents in an exceedingly scrollable panel such as ListBox or Editor window. ListBox, TextBox, RichTextBox internally uses ScrollViewer to implement the scrolling functionality. Allow us to discuss the implementation in this post.

As usual, open up visual studio and choose Silverlight project. We will discover there's a Grid layout in your MainPage. xaml. Eliminate the default Grid layout and merely drag and drop the Stack panel Layout into our application. The code for this looks such as:
<StackPanel x:Name="LayoutRoot" > </StackPanel>

Inside the stack panel I am just defining 12 different rectangles.  And this is the code that I used:
<StackPanel x:Name="LayoutRoot" Orientation="Vertical" Width="100">
            <Rectangle Height="50" Width="100" Fill="Red" />
            <Rectangle Height="50" Width="100" Fill="Green" />
            <Rectangle Height="50" Width="100" Fill="Orange" />
            <Rectangle Height="50" Width="100" Fill="Tomato" />
            <Rectangle Height="50" Width="100" Fill="WhiteSmoke" />
            <Rectangle Height="50" Width="100" Fill="Green" />
            <Rectangle Height="50" Width="100" Fill="Blue" />
            <Rectangle Height="50" Width="100" Fill="Yellow" />
            <Rectangle Height="50" Width="100" Fill="Azure" />
            <Rectangle Height="50" Width="100" Fill="Gold" />
            <Rectangle Height="50" Width="100" Fill="Blue" />
            <Rectangle Height="50" Width="100" Fill="Violet" />
        </StackPanel>

In case we compile the above code as it's, we will notice all of the rectangles however no scroll bar result. Thus in an effort to get scroll bar effect we ought to put the above stack panel inside scroll viewer and ought to offer fixid width towards the scroll viewer. And this is the code snippet:
<ScrollViewer Height="200" >
        <StackPanel x:Name="LayoutRoot" Orientation="Vertical" Width="100">
            <Rectangle Height="50" Width="100" Fill="Red" />
            <Rectangle Height="50" Width="100" Fill="Green" />
            <Rectangle Height="50" Width="100" Fill="Orange" />
            <Rectangle Height="50" Width="100" Fill="Tomato" />
            <Rectangle Height="50" Width="100" Fill="WhiteSmoke" />
            <Rectangle Height="50" Width="100" Fill="Green" />
            <Rectangle Height="50" Width="100" Fill="Blue" />
            <Rectangle Height="50" Width="100" Fill="Yellow" />
            <Rectangle Height="50" Width="100" Fill="Azure" />
            <Rectangle Height="50" Width="100" Fill="Gold" />
            <Rectangle Height="50" Width="100" Fill="Blue" />
            <Rectangle Height="50" Width="100" Fill="Violet" />
        </StackPanel>
    </ScrollViewer>

Finally, Run the code and here is the result:

A data grid view is a rectangular control made of columns and rows. I have a DataGrid where I have included some controls in column header. Each column is a Template column. These controls appear just below the column header which are used for entering filter information. Here's the issue on my code on Silverlight 5.

VisualTreeHelper class helps to iterate through the visual tree of the xaml. Using it we can find the child and parent controls of the rendered controls. Lets check the Visual Tree of the rendered control using Silverlight Spy.

The Following Method do a search over the child controls with in a control recursively and returns the control based on Name.

private object GetChildControl(DependencyObject parent, string controlName)
{ 
    Object tempObj = null;
    int count = VisualTreeHelper.GetChildrenCount(parent);
    for (int counter = 0; counter < count; counter++)
    {
        //Get The Child Control based on Index
        tempObj = VisualTreeHelper.GetChild(parent, counter);
        //If Control's name Property matches with the argument control
        //name supplied then Return Control
        if ((tempObj as DependencyObject).GetValue(NameProperty).ToString() == controlName)
            return tempObj;
        else //Else Search Recursively
        {
            tempObj = GetChildControl(tempObj as DependencyObject, controlName);
            if (tempObj != null)
                return tempObj;
        }
    }
    return null;
}

Make sure that the same has to be delegated to UI thread using Dispatcher. As the controls created using UI Thread can not be accessed from other thread.
//Access the Grid Header Controls
Dispatcher.BeginInvoke(delegate
{
    var hyperlinkControl = GetChildControl(dataGrid1, "hlSort");
    var checkControl = GetChildControl(dataGrid1, "chkSelectAll");
});

So I was plugging right along in Silverlight using LINQ to asynchronously pull data from our database into my C# code. Everything was going great until I attempted to pull data from one table and its related tables all in one query. Here is what I found which resolved my data problem.

In my Library class I have the following code that enables my ASP.NET code to query a User by UserID and return a User object along with their UserFavorites and Illustration objects. This gives me everything I need to know about the user and their favorite illustrations.
public IQueryable<MyLibrary.User> GetUserByID(int userID)

{
    return myContext.Users.Include("UserFavorites").Include("UserFavorites.Illustration")
        .Where(u => u.UserID == userID);
}

In Silverlight I had a need to perform the same query using LINQ. After much searching on the web I found the two things that were needed to make this happen.
1. Use "Expand" instead of "Include"
2. Instead of "UserFavorites.Illustration" replace the "." with a "/" to get "UserFavorites/Illustration".

    int userID = 0;
    var qUser = ((DataServiceQuery<User>)(from myUser in service.Users
                  where myUser.UserID.Equals(userID)
                  select myUser))
                .Expand("UserFavorites")
                .Expand("UserFavorites/Illustration");

Now I have all of my data and I am happy once again. Using the Expand on my query is very nice in that I can get all of my data in one asynchronous call.

HostForLIFE.eu Silverlight 6 Hosting
HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes. We have customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.