WPF Interview Questions And Answers

<Grid Name="StackPanel1" Background="LightGray">  
    <Button Name="Button1" Background="LightBlue" Height="45" Content="Click Me!" Margin="23,12,159,0" VerticalAlignment="Top" FontSize="16" FontWeight="Bold" VerticalContentAlignment="Bottom" HorizontalContentAlignment="Right" />  
    <TextBox Height="50" Margin="26,72,74,0" Name="textBox1" VerticalAlignment="Top" Text="I am a TextBox" FontSize="16" VerticalContentAlignment="Bottom" HorizontalContentAlignment="Right" />   
</Grid>

<Grid.Resources>  
   <SolidColorBrush x:Key="lblbgcolor" Color="Blue"/>  
</Grid.Resources>  
<Label Name="lbl" Margin="71,44,77,0" Background="{StaticResourcelblbgcolor}" Height="49" /> 

<Window.Resources>  
   <SolidColorBrush x:Key="brush" Color="Red" />  
</Window.Resources>  
<Button x:Name="btn" Content="Click Me" Click="Button_Click" Background="{DynamicResource brush}" Height="100" Width="100" />

private void Button_Click(object sender, RoutedEventArgs e)  
{  
   this.btn.SetResourceReference(BackgroundProperty, "brush");  
}

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
using System.Threading.Tasks;  
using System.Windows.Data;  
namespace ValueConverters  
{  
    public class ValueConverter: IValueConverter  
    {  
        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
        {  
            bool isenable = true;  
            if (string.IsNullOrEmpty(value.ToString()))  
            {  
                isenable = false;  
            }  
            return isenable;  
        }  
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)  
        {  
            throw new NotImplementedException();  
        }  
    }  
}

private void Rectangle_MouseMove_1(object sender, MouseEventArgs e)   
{   
   this.rctback.Fill = Brushes.Red;   
}   
private void Rectangle_MouseLeave(object sender, MouseEventArgs e)   
{   
   this.rctback.Fill = Brushes.Green;   
} 

<Grid>   
   <Grid.Resources>   
      <ControlTemplate x:Key="RoundButtonTemplate" />   
   </Grid.Resources>   
</Grid>

<Grid.Resources>  
    <ControlTemplate x:Key="RoundButtonTemplate">  
        <Grid>  
            <Ellipse Width="100" Height="100" Name="ButtonBorder" Fill="OrangeRed" />  
            <Ellipse Width="80" Height="80" Fill="Orange" /> </Grid>  
    </ControlTemplate>  
</Grid.Resources>

<Grid>  
    <Grid.Resources>  
        <Style TargetType="{x:Type Button}">  
<Setter Property="Width" Value="200"/> <Setter Property="Height" Value="30"/> <Setter Property="Foreground" Value="White"/> <Setter Property="Background" Value="DarkGreen"/> <Setter Property="BorderBrush" Value="Black"/> <EventSetter Event="Click" Handler="Button1_Click"/>  
        </Style>  
    </Grid.Resources>  
    <Button>Click me</Button>  
</Grid>

<Window x:Class="CanvasPanelSample.Window1"   
   xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"   
   xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"   
   Title="Window1" Height="300" Width="300"   
   Name="RootWindow">   
   <Grid Name="GridPanel" Background="Blue"   
      Width="250" Height="200"   
      VerticalAlignment="Top"   
      HorizontalAlignment="Left"   
      FlowDirection="LeftToRight"   
   />   
</Window>

public static bool GetAllowOnlyString(DependencyObject obj)  
{  
    return (bool) obj.GetValue(AllowOnlyStringProperty);  
}  
public static void SetAllowOnlyString(DependencyObject obj, bool value)  
{  
    obj.SetValue(AllowOnlyStringProperty, value);  
}  
// Using a DependencyProperty as the backing store for AllowOnlyString. This enables animation, styling, binding, etc...   
public static readonly DependencyProperty AllowOnlyStringProperty = DependencyProperty.RegisterAttached("AllowOnlyString", typeof (bool), typeof (TextblockExtension), new PropertyMetadata(false, AllowOnlyString));  
private static void AllowOnlyString(DependencyObject d, DependencyPropertyChangedEventArgs e)  
{  
    if (d is TextBox)  
    {  
        TextBox txtObj = (TextBox) d;  
        txtObj.TextChanged += (s, arg) =>  
        {  
            TextBox txt = s as TextBox;  
            if (!Regex.IsMatch(txt.Text, "^[a-zA-Z]*$"))  
            {  
                txtObj.BorderBrush = Brushes.Red;  
                MessageBox.Show("Only letter allowed!");  
            }  
        };  
    }  
}

<TextBox Width="200" Height="50" local:TextblockExtension.AllowOnlyString="True"></TextBox>

<Grid.Resources>  
   <SolidColorBrush x:Key="lblbgcolor" Color="Blue"/>  
</Grid.Resources>  
<Label Name="lbl" Margin="71,44,77,0" Background="{StaticResourcelblbgcolor}" Height="49" /> 

<Window.Resources>  
   <SolidColorBrush x:Key="brush" Color="Red" />  
</Window.Resources>  
<Button x:Name="btn" Content="Click Me" Click="Button_Click" Background="{DynamicResource brush}" Height="100" Width="100" />  

private void Button_Click(object sender, RoutedEventArgs e)  
{  
   this.btn.SetResourceReference(BackgroundProperty, "brush");  
} 

<Window.Resources>  
    <SolidColorBrush x:Key="brush" Color="Green" />  
    <Style TargetType="Border" x:Key="PageBackground">  
<Setter Property="Background" Value="Gold"/>  
    </Style>  
</Window.Resources>  
<Grid>  
    <Border Style="{DynamicResource PageBackground}">  
        <Button x:Name="btn" Content="Rajkumar Test" Click="Button_Click" Background="{DynamicResource brush}" Height="30" Margin="53,130,85,130" /> </Border>  
</Grid>

private void Button_Click(object sender, RoutedEventArgs e)  
{  
   this.btn.SetResourceReference(BackgroundProperty, "brush");  
} 

public class CarDependencyProperty: DependencyObject  
{  
    //Register Dependency Property  
    public static readonly DependencyProperty CarDependency = DependencyProperty.Register("MyProperty", typeof (string), typeof (DependencyPropertySample));  
    public string MyCar  
    {  
        get  
        {  
            return (string) GetValue(CarDependency);  
        }  
        set  
        {  
            SetValue(CarDependency, value);  
        }  
    }  
}  
public partial class CarDependencyPropertyDemo: Window  
{  
    public CarDependencyPropertyDemo()  
    {  
        InitializeComponent();  
    }  
    private void MyButton_Click(object sender, RoutedEventArgs e)  
    {  
        CarDependency dpSample = TryFindResource("CarDependency ") as CarDependency;  
        MessageBox.Show(dpSample.MyCar);  
    }  
}

public static bool GetAllowOnlyString(DependencyObject obj)  
{  
    return (bool) obj.GetValue(AllowOnlyStringProperty);  
}  
public static void SetAllowOnlyString(DependencyObject obj, bool value)  
{  
    obj.SetValue(AllowOnlyStringProperty, value);  
}  
// Using a DependencyProperty as the backing store for AllowOnlyString. This enables animation, styling, binding, etc...   
public static readonly DependencyProperty AllowOnlyStringProperty = DependencyProperty.RegisterAttached("AllowOnlyString", typeof (bool), typeof (TextblockExtension), new PropertyMetadata(false, AllowOnlyString));  
private static void AllowOnlyString(DependencyObject d, DependencyPropertyChangedEventArgs e)  
{  
    if (d is TextBox)  
    {  
        TextBox txtObj = (TextBox) d;  
        txtObj.TextChanged += (s, arg) =>  
        {  
            TextBox txt = s as TextBox;  
            if (!Regex.IsMatch(txt.Text, "^[a-zA-Z]*$"))  
            {  
                txtObj.BorderBrush = Brushes.Red;  
                MessageBox.Show("Only letter allowed!");  
            }  
        };  
    }  
}

<TextBox Width="200" Height="50" local:TextblockExtension.AllowOnlyString="True"></TextBox> 

Bubbling Events: Bubbling Events are those Events which are first raised by the control than raised by the other controls in the control hierarchy. It allows Bubble up to the tree till the Root Element. First Tunneling events are raised then bubbling events raised.

Direct Event: Direct Event is generally raised by the control itself. The behavior of this event is same as the .NET general event.

See for more details:

• Routed Event in WPF using F#

Question 22: What is Rotate transform in WPF?

Answer: RotateTransform rotates an element clockwise by a specified angle about the point. The RotateTransform object in WPF represents RotateTransform. The Angle property represents the angle in degrees to rotate clockwise. The CenterX and CenterY properties represent the X and Y coordinates of the center point. By default, a ScaleTransform is centered at the point (0,0), which corresponds to the upper-left corner of the rectangle.

Creates two rectangles with same position and sizes accept the second rectangle is rotated at 45 degrees.

<Grid>  
    <!-- Original Rectangle -->  
    <Rectangle Width="200" Height="50" Fill="Yellow" />  
    <!-- Rectangle with 45 degrees rotation -->  
    <Rectangle Width="200" Height="50" Fill="Blue" Opacity="0.5">  
        <Rectangle.RenderTransform>  
            <RotateTransform CenterX="0" CenterY="0" Angle="45" /> </Rectangle.RenderTransform>  
    </Rectangle>  
</Grid>

The following code snippet changes the values of CenterX and CenterY.

<Rectangle Width="200" Height="50" Fill="Blue" Opacity="0.5" Margin="61,27,117,184">  
   <Rectangle.RenderTransform>  
      <RotateTransform CenterX="-50" CenterY="50" Angle="45" />  
   </Rectangle.RenderTransform>  
</Rectangle>

See for more details:

• RotateTransform in WPF

Question 23: What is the Control Template in WPF?

Answer: The ControlTemplate contains the tree of elements that define the desired look. After you define a ControlTemplate you can attach it to any Control or Page by setting it's TemplateProperty.

<Grid>  
    <Grid.Resources>  
        <ControlTemplate x:Key="buttonTemplate">  
            <Grid>  
                <Ellipse Width="160" Height="160" x:Name="outerCircle">  
                    <Ellipse.Fill>  
                        <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">  
                            <GradientStop Offset="0" Color="Green"></GradientStop>  
                            <GradientStop Offset="1" Color="Purple"></GradientStop>  
                        </LinearGradientBrush>  
                    </Ellipse.Fill>  
                </Ellipse>  
                <Ellipse Width="120" Height="120">  
                    <Ellipse.Fill>  
                        <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">  
                            <GradientStop Offset="0" Color="Gray"> </GradientStop>  
                            <GradientStop Offset="1" Color="Blue"> </GradientStop>  
                        </LinearGradientBrush>  
                    </Ellipse.Fill>  
                </Ellipse>  
            </Grid>  
            <ControlTemplate.Triggers>  
                <Trigger Property="Button.IsMouseOver" Value="True">  
                    <Setter TargetName="outerCircle" Property="Fill" Value="Black"> </Setter>  
                </Trigger>  
                <Trigger Property="Button.IsPressed" Value="True">  
                    <Setter Property="RenderTransform">  
                        <Setter.Value>  
                            <ScaleTransform ScaleX=".8" ScaleY=".8"> </ScaleTransform>  
                        </Setter.Value>  
                    </Setter>  
                    <Setter Property="RenderTransformOrigin" Value=".6,.6"> </Setter>  
                </Trigger>  
            </ControlTemplate.Triggers>  
        </ControlTemplate>  
    </Grid.Resources>  
    <Button Template="{StaticResource buttonTemplate}">Click Me</Button>  
</Grid>

After MouseOver:

See for more details:

• ControlTemplate in WPF

Question 24: How can we create Borderless Window in WPF?

Answer: We can create a borderless window in two ways.

Firstly, by writing a WindowStyle property = None, SingleBorderWindow, ThreeDBorderWindow or ToolWindow in the <Window> element.

<Window x:Class="WpfApp1.MainWindow" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525" WindowStyle="None">  
    <Grid> </Grid>  
</Window>

The second way is to open the Property Window, select the window style property to either None, SingleBorderWindow, ThreeDBorderWindow or ToolWindow.

See for more details:

• Various Methods to Close a WPF Application

Question 25: What is XAML in WPF and also explain the types of XAML?

Answer: Extensible Application Markup Language and pronounced "zammel" is a markup language used to instantiate .NET objects. Although XAML is a technology that can be applied to many different problem domains, its primary role in life is to construct WPF user interfaces.

Important task XAML performs as as follows,

• Wiring up an event handler: Attaching event handler in the most cases, for example Click on Button is easy to do in Visual Studio. However once we understand how events are wired up in XAML,we'll be able create more sophisticated connections.
  
• Defining resources: Resources are the object which once we define in XAML can be re-used in the various places inside markup. Resources allow us to centralize and standardize formatting, and create nonvisual objects such as templates and animations.
  
• Defining control template: WPF controls are designed to be lookless, which means we can substitute our custom visuals in place of the standard appearance. To do so, we must create our own control template, which is nothing more than a block of XAML markup.

Type of XAML

• WPF XAML: Encompasses the elements that describe WPF content, such as vector graphics, controls, and documents.
  
• XPS XAML: It is the part of WPF XAML that defines an XML representation for formatted electronic documents.
  
• Silverlight XAML: A subset of WPF XAML that's intended for Silverlight applications. Silverlight is a cross-platform browser plug-in that allows us to create rich web content.
  
• WF XAML: Encompasses the elements that describe Windows Workflow Foundation.

See for more details:

• Understanding In and Out of XAML in WPF

Question 26: How to set content of a NavigationWindow?

Answer:The Navigation Window class is derived from the Window class, so it inherits all the properties of Windows such as methods, properties and events. The navigation window provides backward and forward buttons for navigating to pages that we have visited before or have yet to visit.

Creating Navigation Paged Application: To create Navigation Window based applications, use a Navigation Window container instead of a Window container as shown in the following picture and the source is the property of the Navigation window and write the name of the page that you want to set as the home page as shown in the following picture:

See for more details:

• Navigation Window Based Application in WPF

Question 27: What is a WPF Child Window?

Answer: A ChildWindow control is a light weight window that can be used as a child window or a popup control. The parent window is automatically disabled when a child window is active and modal. You can think of a ChildWindow as a custom modal or modeless dialog where you can place any child controls you want. However, the ChildWindow has several common Window properties.

Creating a ChildWindow:

The ChildWindow element represents a WPF ChildWindow control in XAML. The ChildWindow control is defined in the System.Windows.Controls namespace.

creates a simple ChildWindow control with its Width, Height, Name, IsModal and Caption property.

<wpfx:ChildWindow Name="PopupChildWindow" Caption="Child Window" Width="300" Height="200"IsModal="True" />

We need to call the Show() method to make a Child Window visible.

1. PopupChildWindow.Show();

See for more details:

• WPF Child Window

Question 28: What are the WPF Content Controls?

Answer:Content Controls are mainly parent containers to hold the content. It displays information to the user to be viewed but that generally won't be modified.

With content controls, the following aspects:

1. Property: A Property specifies the object's appearance or behavior. For example, the IsEnabled property specifies whether the user can interact with a control or not.
   
2. Method: A Method is a routine that a control executes to perform something. For example Coa unt Method counts the number of items available for the object or control.
   
3. Event: An event is related when a control raises one to let your application know that something has happened. For example TextBox raises a TextChanged event whenever its text changes.

Code Snippet

<Button Name="btnAdd" Content="Add" Click="btnAdd_Click" />

See for more details:

• WPF Content Controls

Question 29: What is the Tab Control in WPF?

Answer: The Tab control is a common UI element that has been around for some time. It makes a convenient way to organize your window when there is more than could realistically fit and still be comprehensible. Tab Control is easier in Windows Presentation Foundation.

Two elements play main roles in building a tab control:

• TabControl and
• TabItem

TabControl is the container of one or more TabItem elements like as follows.

<TabControl>  
   <TabItem Header="Tab 1">xyz</TabItem>  
   <TabItem Header="Tab 2">abc</TabItem>  
</TabControl>

In WPF, Tabs are very easy to implement. Create a new WPF Window, remove the default Grid tags, and add the following XAML:

<TabControl>  
   <TabItem Header="Tab 1">xyz</TabItem>  
   <TabItem Header="Tab 2">abc</TabItem>  
</TabControl>

See for more details:

• Tab Control in WPF

Question 30: How can I clip or crop an image?

Answer: Clipping a region is a process of displaying partial area of a region by setting the outline of a region. In WPF, the clipping has been extended to all elements that are inherited from UIElement that includes controls, images, panels, Windows, and Pages.

<Window.Clip>  
   <EllipseGeometry Center="150,160" RadiusX="120" RadiusY="120" />  
</Window.Clip>

The following code snippet clips or crops an image to an ellipse.

<Image Source="Garden.jpg">  
    <Image.Clip>  
        <EllipseGeometry Center="150,160" RadiusX="120" RadiusY="120" />   
    </Image.Clip>  
</Image>

private void ClipImage()  
{  
    // Create a BitmapImage  
    BitmapImage bmpImage = new BitmapImage();  
    bmpImage.BeginInit();  
    bmpImage.UriSource = new Uri(@ "C:\Images\Garden.jpg", UriKind.RelativeOrAbsolute);  
    bmpImage.EndInit();  
    // Clipped Image  
    Image clippedImage = new Image();  
    clippedImage.Source = bmpImage;  
    EllipseGeometry clipGeometry = new EllipseGeometry(new Point(150, 160), 120, 120);  
    clippedImage.Clip = clipGeometry;  
    LayoutRoot.Children.Add(clippedImage);  
}

See for more details:

• Clipping or Cropping Images in WPF

Question 31: What are Converters in WPF?

Answer: Converters provide substantial supremacy since they allow insertion of an object between a source and a target object. At a high level, converters are a chunk of custom code hooked up using the binding and the data will flow via that converter. So, whenever data is flown from a source to a target, one can change the value or can change the type of object that needs to be set on the target property.

So, whenever data travels from source to target, it can be transformed in two ways:

1. Data value: Here the transformation will be done with just the value by keeping the data type intact. For example, for number fields, you can transform a value from a floating point number to an integer by keeping the actual value as a float.
   
2. Data type: One can also transform the data type. For example, setting a style based on some Boolean flag.

Defining a converter

Defining any converter requires implementation of an IValueConverter interface in a class. This interface has the following two methods:

1. Convert: Is called when data is flowing from a source to a target.
   
2. ConvertBack: Is called when data is flowing from a target to a source. It is basically useful in two-way binding scenarios.

How to use

Once your class is part of a ResourceDictionary, you can point to the instance of the converter using the Converter property of Binding, along with a StaticResource markup extension.

Where to place converters

To implement an IValueConverter one must create a class and then put the instance of that class in a ResourceDictionary within your UI.

See for more details:

• Converters in WPF

Question 32: How does “UpdateSourceTrigger” affect bindings?

Answer: This is a property on a binding that controls the data flow from a target to a source and used for two-way data binding. The default mode is when the focus changes but there are many other options available.

Properties available with UpdateSourceTrigger

• Default: This is the default value and it means a lost focus for most of the controls.
• LostFocus: Value update will be on hold until the focus moves out of the control.
• PropertyChanged: Value update will happen whenever a target property changes. It usually happen on every keystoke.
• Explicit: Used to defer source updates until the user does it forcibly by the click of a button or so.

Default vs LostFocus

Default and LostFocus means the same thing for most of the controls with the exception of DataGrid. For DataGrid:

• Lost Focus: Cell lost focus
• Default: Row lost focus

Code

<grid>  
    <Grid.ColumnDefinitions>  
        <ColumnDefinition Width="50*" />  
        <ColumnDefinition Width="50*" />   
     </Grid.ColumnDefinitions>  
    <TextBlock Text="Source:" Width="auto" />  
    <TextBox Name="SourceText" Width="160" Height="30" Margin="48,0,44,82" />  
    <TextBlock Text="Target:" Grid.Column="1" Width="auto" />  
    <TextBox Name="TargetText" Width="160" Height="30" Text="{Binding ElementName=SourceText, Path=Text,UpdateSourceTrigger=Default}" Grid.Column="1" Margin="44,0,47,82" />   
</grid>

Output

When the user types into the source TextBox:

See for more details:

• Overview of UpdateSourceTrigger and Its Properties in WPF

Question 33: What are various ways of doing alignment in WPF?

Answer:The FrameworkElement has two alignment properties: HorizontalAlignment and Vertical Alignment. The Horizontal Alignment property is a type of HorizontalAlignment enumeration and represents how a child element is positioned within a parent element horizontally.

The HorizontalAlignment enumeration has the four properties Left, Center, Right and Stretch. The Left, Center and Right properties sets a child element to left, center and right of the parent element. The Stretch property stretches a child element to fill the parent element's allocated layout space.

Example

<StackPanel Background="LightGray">  
    <Button Name="Rect1" Background="LightBlue" Width="150" Height="50" HorizontalAlignment="Left" Content="Left Aligned" />  
    <Button Name="Rect2" Background="LightGreen" Width="150" Height="50" HorizontalAlignment="Center" Content="Center Aligned" />  
    <Button Name="Rect3" Background="LightCyan" Width="150" Height="50" HorizontalAlignment="Right" Content="Right Aligned" />  
    <Button Name="Rect4" Background="LightPink" Height="50" HorizontalAlignment="Stretch" Content="Stretch Aligned" />   
</StackPanel>  

The VerticalAlignment property is a type of HorizontalAlignment enumeration and represents how a child element is positioned within a parent element vertically.

The VerticalAlignment enumeration has the four properties Top, Center, Bottom and Stretch. The Top, Center and Bottom properties set a child element to top, center or bottom of the parent element. The Stretch property stretches a child element to fill the parent element's allocated layout space vertically.

Example

<Grid>  
    <Grid.ColumnDefinitions>  
        <ColumnDefinition Width="100" />  
        <ColumnDefinition Width="100" />  
        <ColumnDefinition Width="100" />  
        <ColumnDefinition Width="100" />   
     </Grid.ColumnDefinitions>  
    <Button Name="Button1" Background="LightBlue" Height="30" Width="100" VerticalAlignment="Top" Content="Left Aligned" />  
    <Button Name="Button2" Background="LightGreen" Height="30" Width="100" Grid.Column="1" VerticalAlignment="Center" Content="Center Aligned" />  
    <Button Name="Button3" Background="LightCyan" VerticalAlignment="Bottom" Height="30" Width="100" Grid.Column="2" HorizontalAlignment="Left" Content="Right Aligned" />  
    <Button Name="Button4" Background="LightPink" Content="Stretch ligned" Width="100" Grid.Column="3" HorizontalAlignment="Stretch" />   
</Grid>

See for more details:

• WPF Layout: Horizontal and Vertical Alignment

Question 34: What is ToolTip and how we use it in WPF?

Answer: A ToolTip control shows some information or a hint about a control in a floating box when the mouse hovers over that control and it disappears when the mouse is moved away from that control.

Tool tips are used to help the users to learn the purpose of Controls in many Windows-based programs. Tooltips are nothing but small rectangles that appear when the user hovers the mouse pointer over the Control. The rectangle contains a short piece of text describing the control. Once displayed, the tips disappear when the user moves the mouse pointer away from the linked control or clicks a mouse button, or after a short delay.

ToolTip Example: Drag a Button control from the toolbox and drop it. Add a ToolTip property to the button with a message you want to show on mouse hover of the button. We can add a ToolTip in two ways. First the button shows the simplest way to display a ToolTip. The second method is preferred for creating a customized ToolTip.

<Button Content="Click Here" Margin="30" FontSize="16" ToolTip="Click Here"></Button>  
<Button Content="Click Here" Margin="30" FontSize="16">  
    <Button.ToolTip>  
        <ToolTip> Click Here </ToolTip>  
    </Button.ToolTip>  
</Button>

See for more details:

• ToolTip in WPF

Question 35: How can ListBox be made to scroll smoothly?

Answer: A ListBox control is an items control that works as a ListBox control but only one item from the collection is visible at a time and clicking on the ListBox makes the collection visible and allows users to pick an item from the collection. Unlike a ListBox control, a ListBox does not have multiple item selection.

The ListBox element represents a ListBox control in XAML.

<ListBox></ListBox>

The Width and Height properties represent the width and the height of a ListBox. The x:Name property represents the name of the control, which is a unique identifier of a control. The Margin property sets the location of a ListBox on the parent control. The HorizontalAlignment and VerticalAlignment properties are used to set horizontal and vertical alignments.

The code sets the vertical and horizontal alignment of the ListBox and sets the margin.

<ListBox x:Name="ListBox1" Width="200" Height="200"  
   VerticalAlignment="Top" HorizontalAlignment="Left"   
   Margin="10,10,0,0">  
</ListBox>

See for more details:

• ListBox in WPF

Question 36: What is a Popup window and how to open and close the popup window?

Answer: A popup window is a window that floats over a page or window providing functionality for some quick action. For example, a login control on a page or window or an animated popup tip of a control.

The Popup element of XAML represents a WPF Popup control.

<Popup></Popup>

The Width and the Height properties represent the width and the height of a Popup. The Name property represents the name of the control that is a unique identifier of a control. The Margin property is used to set the location of a Popup on the parent control. The HorizontalAlignment and VerticalAlignment properties are used to set horizontal and vertical alignments.

The following code snippet sets the name, height, and width of a Popup control. The code also sets horizontal alignment to left and vertical alignment to top.

<Popup Margin="10,10,0,13" Name="Popup1" HorizontalAlignment="Left"  
VerticalAlignment="Top" Width="194" Height="200" />

Open a Popup: The Popup Control displays its contents when IsOpen set true.

private void Popup_Ok_Click(object sender, RoutedEventArgs e)  
{  
   Popup1.IsOpen = true;  
}

Where popup1 is the name of the popup control.

Closing a Popup: The Popup Control displays its contents when IsOpen is set to false.

private void Popup_Ok_Click(object sender, RoutedEventArgs e)  
{  
   Popup1.IsOpen = false;  
}

See for more details:

• WPF Popup

Question 37: What is a Decorators class in WCF?

Answer: Decorator class that is a simple base class of WPF layout controls. Decorators have a single child control to which they apply a single child control.

Add a click event to the button. Replace the Button's XAML with the following:

<Border Name="MyBorder" BorderBrush="Black" BorderThickness="4" CornerRadius="10">  
   <Button Click="Button_Click">Hello, world!</Button>  
</Border> 

When the program is executed the window that appears similar to the image below:

See for more details:

• Decorator Class in WPF

Question 38: What are the advantages and disadvantages of WPF?

Advantages

• Tight multimedia integration: To use 3-D graphics, video, speech, and rich document viewing in Windows 32 or Windows Forms applications, you would need to learn several independent technologies and blend them together without much built-in support. WPF applications allow you to use all these features with a consistent programming model.
  
• Resolution independence: WPF lets you shrink or enlarge elements on the screen, independent of the screen's resolution. It uses vector graphics to make your applications resolution-independent.
  
• Hardware acceleration: WPF is built on top of Direct3D, which offloads work to graphics processing units (GPUs) instead of central processor units (CPUs). This provides WPF applications with the benefit of hardware acceleration, permitting smoother graphics and enhanced performance.
  
• Declarative programming: WPF uses Extensible Application Markup Language (XAML) declarative programming to define the layout of application objects and to represent 3-D models, among other things. This allows graphic designers to directly contribute to the look and feel of WPF applications.
  
• Rich composition and customization: WPF controls are easily customizable. You need not write any code to customize controls in very unique ways. WPF also lets you create skins for applications that have radically different looks.
  
• Easy deployment: WPF provides options for deploying traditional Windows applications (using Windows Installer or Click Once). This feature is not unique to WPF, but is still an important component of the technology.
  
• Culturally aware controls: Static text in controls and the return data for the String function are modified according to the culture and language specified by the end user's operating system.

Disadvantages

• WPF's in-box control suite is far more limited than that of WinForms.
  
• There's greater support in the 3rd-party control space for WinForms. (That's changing, but for now by advantage of time, WinForms has greater support in the community).
  
• Most developers already know WinForms; WPF provides a new learning curve.
  
• WPF will not run on Windows 2000 or lower.
  
• No MDI child mode.

See for more details:

• WPF: An Introduction (Part 2)

Question 39: What are the WPF assemblies and Namespace?

WPF Assembly	Meaning in Life
WindowsBase.dll	Defines the base infrastructure of WPF, including dependency properties support. While this assembly contains types used within the WPF framework, the majority of these types can be used within other .NET applications.
PresentationCore.dll	This assembly defines numerous types that constitute the foundation of the WPF GUI layer.
PresentationFoundation.dll	This assembly—the ‘meatiest’ of the three—defines the WPF controls types, animation and multimedia support, data binding support, and other WPF services. For all practical purposes, this is the assembly you will spend most of your time working with directly.

Although these assemblies provide hundreds of types within numerous namespaces, consider this partial list of WPF namespaces:

• You will encounter other namespaces during the remainder of this class.
• Again, consult the .NET Framework SDK documentation for full details.

WPF Namespace	Meaning in Life
System.Windows	Here you will find core types such as Application and Window that are required by any WPF desktop project.
System.Windows.Controls	Here you will find all of the expected WPF widgets, including types to build menu systems, tool tips, and numerous layout managers.
System.Windows.Markup	This namespace defines a number of types that allow XAML markup and the equivalent binary format, BAML, to be parsed.
System.Windows.Media	Within these namespaces you will find types to work with animations, 3D rendering, text rendering, and other multimedia primitives.
System.Windows.Navigation	This namespace provides types to account for the navigation logic employed by XAML browser applications / desktop navigation apps.
System.Windows.Shapes	This namespace defines basic geometric shapes (Rectangle, Polygon, etc.) used by various aspects of the WPF framework.

See for more details:

• WPF: An Introduction (Part 2)

Question 40: What is the difference between WPF and Silverlight?

Answer:Silverlight and Windows Presentation Foundation (WPF) are 2 different products from Microsoft, but have lot of overlap. Silverlight is a subset of WPF in terms of features and functionality. Silverlight was of course known as WPF/E where E means everywhere. Both use XAML, a form of XML to define controls but WPF is purely for windows while Silverlight runs in the browser on Windows and Macs. So, here are the differences between WPF and Silverlight:

1. Silverlight is meant to be used online, while WPF is for local use.
2. Silverlight lacks access to local resources, while WPF can utilize local resources.
3. Silverlight only has perspective 3D support, while WPF is capable of full 3D images.
4. Silverlight does not support some of the more advanced concepts of WPF such as controls and templating.
5. Silverlight integrates right into an HTML page whereas WPF XAML files have to be loaded via a frame if they want to mix with HTML content.

See for more details:

• WPF: An Introduction (Part 2)

Question 41: What is WPF accesstext Control?

Answer: The AccessText control in WPF converts a character preceded by an underscore to an Access Key. The Access Key is registered and therefore raises an event when pressed.

Creating an AccessText

The AccessText element represents an AccessText control in XAML.

<AccessText>_Click Me</AccessText>

The following code snippet adds an AccessText to a Button control. The button control click event will be raised when you select the ALT+C keys on the keyboard.

<Button Name="Button1" Width="120" Height="50" Margin="33,70,59,124" FontSize="16" Click="Button1_Click">  
    <AccessText>_Click Me</AccessText>  
</Button>

If there are multiple underscore characters, only the first one is converted into an AccessKey; the other underscores appear as normal text. If the underscore that you want converted to the access key is not the first underscore, use two consecutive underscores for any underscores that precede the one that you want to convert.

See for more details:

• WPF AccessText

Question 42: What are the different types of brushes that WPF offers?

Answer: Brushes and pens are objects used to draw and fill graphics objects. WPF and XAML work together and there is an WPF class corresponding to each XAML control. For example, <SolidColorBrush> tag in XAML and SolidColorBrush class in WPF, both represent the solid color brush. You can create and use brushes in both ways seperately or mix them.

In XAML and WPF model provides the following brush objects:

1. SolidColorBrush
2. LinearGradientBrush
3. RadialGradientBrush
4. DrawingBrush
5. Visual Brush
6. ImageBrush

See for more details:

• Brushes in WPF

Question 43: How many types of Bitmap Effects in WPF?

Answer: Bitmap effects are simple pixel processing operations. A bitmap effect takes a BitmapSource as an input and produces a new BitmapSource after applying the effect.

Bitmap effects enable designers and developers to apply visual effects to rendered Microsoft Windows Presentation Foundation (WPF) content. For example, bitmap effects allow you to easily apply a DropShadowBitmapEffect effect or a blur effect to an image or a button. The unmanaged APIs provide an extensible framework for independent hardware vendors (IHVs) to develop custom effects to use in WPF applications.

The following are the available Bitmap Effects in WPF:

1. BlurBitmapEffect
2. OuterGlowBitmapEffect
3. DropShadowBitmapEffect
4. BevelBitmapEffect
5. EmbossBitmapEffect

Each bitmap effect has properties that can control the filtering properties, such as Radius of BlurBitmapEffect.

See for more details:

• Bitmap Effects In WPF - Part I

Question 44: What is tree view in WPF?How we can delete a tree view in WPF?

Answer: A TreeView represents data in a hierarchical view in a parent child relationship where a parent node can be expanded or collapse. The left side bar of Windows Explorer is an example of a TreeView.

The TreeView tag represents a WPF TreeView control in XAML.

<TreeView></TreeView>

Adding TreeView Items

A TreeView control hosts a collection of TreeViewItem. The Header property is the text of the item that is displayed on the view. The following code snippet adds a parent item and six child items to a TreeView control.

<TreeView Margin="10,10,0,13" Name="TreeView1" HorizontalAlignment="Left" VerticalAlignment="Top" Width="194" Height="200">  
    <TreeViewItem Header="Cold Drinks">  
        <TreeViewItem Header="Coke"></TreeViewItem>  
        <TreeViewItem Header="Pepsi"></TreeViewItem>  
        <TreeViewItem Header="Orange Juice"></TreeViewItem>  
        <TreeViewItem Header="Milk"></TreeViewItem>  
        <TreeViewItem Header="Iced Tea"></TreeViewItem>  
        <TreeViewItem Header="Mango Shake"></TreeViewItem>  
    </TreeViewItem>  
</TreeView>

Deleting TreeView Items

We can use TreeView.Items.Remove or TreeView.Items.RemoveAt method to delete an item from the collection of items in the TreeView. The RemoveAt method takes the index of the item in the collection.

<Button Height="23" Margin="226,14,124,0" Name="DeleteButton"  
VerticalAlignment="Top" Click="DeleteButton_Click">  
Delete Item</Button>  

private void DeleteButton_Click(object sender, RoutedEventArgs e)  
{  
   TreeView1.Items.RemoveAt  
   (TreeView1.Items.IndexOf(TreeView1.SelectedItem));   
}

The above code removes root items from the TreeView, not the subitems. To remove sub items, first we need to find the selected item and then we need to call TreeViewItem.Items.RemoveAt method.

See for more details:

• Working with WPF TreeView

Question 45: What are the Commands in WPF?

Answer:Commands have several purposes. The first purpose is to separate the semantics and the object that invokes a command from the logic that executes the command. This allows for multiple and disparate sources to invoke the same command logic, and it allows the command logic to be customized for different targets. For example, the editing operations Copy, Cut, and Paste, which are found in many applications, can be invoked by using different user actions if they are implemented by using commands. An application might allow a user to cut selected objects or text by either clicking a button, choosing an item in a menu, or using a key combination, such as CTRL+X. By using commands, you can bind each type of user action to the same logic.

Commands are used to share grouped actions within an application in different ways. Sometimes we need to perform the same activity, WPF provides us a feature called Command to make our work easier and faster.

There are basically four type of Commands:

• Application Commands
• Edit Commands
• Component Commands
• Media Commands

XAML

<StackPanel>  
    <Menu>  
        <MenuItem Command="ApplicationCommands.Paste" /> </Menu>  
    <TextBox />   
</StackPanel> 

C#

// Creating the UI objects  
StackPanel mainStackPanel = new StackPanel();  
TextBox pasteTextBox = new TextBox();  
Menu stackPanelMenu = new Menu();  
MenuItem pasteMenuItem = new MenuItem();  
  
// Adding objects to the panel and the menu  
stackPanelMenu.Items.Add(pasteMenuItem);  
mainStackPanel.Children.Add(stackPanelMenu);  
mainStackPanel.Children.Add(pasteTextBox);  
  
// Setting the command to the Paste command  
pasteMenuItem.Command = ApplicationCommands.Paste;  
  
// Setting the command target to the TextBox  
pasteMenuItem.CommandTarget = pasteTextBox;  

See for more details:

• Commands in WPF

Question 46: What are the properties of canvas panel in WPF?

Answer: The Canvas is the most basic layout panel in WPF. It's child elements are positioned by explicit coordinates. The coordinates can be specified relative to any side of the panel usind the Canvas.Left, Canvas.Top, Canvas.Bottom andCanvas.Right attached properties.

The panel is typically used to group 2D graphic elements together and not to layout user interface elements. This is important because specifing absolute coordinates brings you in trouble when you begin to resize, scale or localize your application. People coming from WinForms are familiar with this kind of layout - but it's not a good practice in WPF.

In WPF, a Canvas Panel has a very simple layout. We can position any object using its two properties:

• Canvas.Left
• Canvas.Top

Note: A Canvas panel does not resize automatically when our normal application resizes in the browser.

Here is an example of a Canvas panel:

<Canvas Background="Pink" Width="250" Height="100">  
</Canvas>  

See for more details:

• Canvas Panel in WPF

Question 47: What is WPF TextBlock?

Answer: The TextBlock control is one of the most fundamental controls in WPF, yet it's very useful. It allows you to put text on the screen, much like a Label control does, but in a simpler and less resource demanding way. A common understanding is that a Label is for short, one-line texts (but may include e.g. an image), while the TextBlock works very well for multiline strings as well, but can only contain text (strings). Both the Label and the TextBlock offers their own unique advantages, so what you should use very much depends on the situation.

Creating a TextBlock

The TextBlock element represents a WPF TextBlock control in XAML.

<TextBlock/>

The Width and Height attributes of the TextBlock element represent the width and the height of a TextBlock. The Text property of the TextBlock element represents the content of a TextBlock. The Name attribute represents the name of the control, which is a unique identifier of a control. The Foreground property sets the foreground color of contents. This control does not have a Background property.

<TextBlock Name="TextBlock1" Height="30" Width="200"  
   Text="Hello! I am a TextBlock." Foreground="Red">  
</TextBlock>

The output looks like the following,

See for more details:

• WPF TextBlock

Question 48: What is XAML TabControl in WPF?

Answer: A Tab Control has tab items and each tab item represents a container that is used to host other controls.

The WPF TabControl allows you to split your interface up into different areas, each accessible by clicking on the tab header, usually positioned at the top of the control. Tab controls are commonly used in Windows applications and even within Windows' own interfaces, like the properties dialog for files/folders etc.

Just like with most other WPF controls, the TabControl is very easy to get started with. Here's a very basic example:

<Window x:Class="WpfTutorialSamples.Misc_controls.TabControlSample" <Window x:Class="WpfTutorialSamples.Misc_controls.TabControlSample" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" Title="TabControlSample" Height="200" Width="250">  
    <Grid>  
        <TabControl>  
            <TabItem Header="General">  
                <Label Content="Content goes here..." /> </TabItem>  
            <TabItem Header="Security" />  
            <TabItem Header="Details" /> </TabControl>  
    </Grid>  
</Window>

See for more details:

• Using XAML TabControl in WPF

Question 49: What is Virtualization in WPF?

Answer: Virtualization technique in WPF improves the rendering performance of UI elements. By applying virtualization, the layout system ensures that only the visible items of a container are rendered on the screen. For example, a list control may have thousands of items but virtualization will reduce the rendering to the visible items only.

VirtualizingStackPanel: The VirtualizingStackPanel control in WPF is used to implement virtualization.The IsVirtualizing property of the VirtualizingStackPanel activates the virtualization. By default, the IsVirtualizing property is set to true. When IsVirtualizing is set to false, a VirtualizingStackPanel behaves the same as an ordinary StackPanel.

<VirtualizingStackPanel Width="300" Height="200" />

The VirtualizingStackPanel.VirtualizationMode property has two values, Standard and Recycling. The default value of VirtualizationMode is Standard and means that the VirtualizingStackPanel creates an item container for each visible item and discards it when it is no longer needed (such as when the item is scrolled out of view). When an ItemsControl contains many items, the process of creating and discarding item containers can degrade performance. In that case, using the Recycling reuses item containers instead of creating a new one each time.

See for more details:

• Virtualization in WPF Using VirtualizingStackPanel

Question 50: What is DockPanel Control in WPF?

Answer: A DockPanel is a panel where each child element docks to one of the four edges. DockPanel enables docking of child elements to an entire side of the panel streching it to fill the entire height or width.

The DockPanel makes it easy to dock content in all four directions (top, bottom, left and right). This makes it a great choice in many situations, where you want to divide the window into specific areas, especially because by default, the last element inside the DockPanel, unless this feature is specifically disabled, will automatically fill the rest of the space (center).

<Window x:Class="DockPanelExample1.MainWindow" xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml" Title="DockPanel Example" Height="350" Width="525">  
    <DockPanel>  
        <Button Content="Button1"></Button>  
        <Button Content="Button2"></Button>  
        <Button Content="Button3"></Button>  
        <Button Content="Button4"></Button>  
        <Button Content="Button5"></Button>  
        <Button Content="Button6"></Button>  
    </DockPanel>  
</Window> 

Preview

See for more details:

• DockPanel in WPF

Question 51: What is XAML StatusBar?

Answer: XAML StatusBar represents a status bar. A StatusBar is a horizontal window that usually sits at the bottom of a window to display various kinds of status information of an application.

The StatusBar element in XAML represents a WPF StatusBar control.

<StatusBar></StatusBar>

The Width and Height properties represent the width and the height of a StatusBar. The Name property represents the name of the control that is a unique identifier of a control.

The following code snippet creates a StatusBar control and set its content to some text.

<StatusBar Name="McSBar" Height="30" VerticalAlignment="Bottom"   
   Background="LightBlue" >   
   This is a status bar   
</StatusBar>

The output looks as in the following figure:

See for more details:

• Using XAML StatusBar in WPF

Question 52: Describe Polyline in WPF?

Answer: A polyline is an object in AutoCAD that consists of one or more line (or arc) segments. A rectangle is an example of a polyline that you are already familiar with. As you've seen, it is one object that can be modified and worked with easier than four separate lines.

In other words, A polyline is a collection of connected straight lines. The Polyline object represents a polyline shape and draws a polyline with the given points. The Points property represents the points in a polyline. The Stroke property sets the color and StrokeThickness represents the width of the line of a polyline.

Creating a Polyline: The Polyline element in XAML creates a polyline shape. The following code snippet creates a polyline by setting its Points property. The code also sets the black stroke of width 4.

<Polyline  
   Points="10,100 100,200 200,30 250,200 200,150"  
   Stroke="Black"  
StrokeThickness="4" />

The Polyline element in XAML creates a polyline shape. The following code snippet creates a polyline by setting its Points property. The code also sets the black stroke of width 4.

<Polyline  
   Points="10,100 100,200 200,30 250,200 200,150"  
   Stroke="Black"  
StrokeThickness="4" /> 

See for more details:

• Polyline in WPF

You can enhance your knowledge more, by reading the following articles.

More Interview Questions

• Azure Interview Questions
• ASP.NET MVC Interview Questions
• C# interview questions
• ASP.NET interview questions
• Bootstrap interview questions
• Html 5 interview questions
• WCF interview questions and answers
• WPF interview questions and answers
• CSS interview questions and answers
• Angularjs interview questions
• SQL Server interview questions
• ADO.NET interview questions and answers
• Interview question on.NET framework or clr
• Javascript interview questions
• Interview questions for 2 year experience in SQL and C#
• Important.NET interview questions and answers
• Software Testing Interview Questions/
• Dot.NET interview questions for experienced and fresher
• SQL interview questions
• C# interview questions and answers
• jQuery interview question and answer with practices part 2
• Python interview questions