Extensible Application Markup Language, or XAML (pronounced as ‘zammel’), is an XML-based markup language developed by Microsoft. Although it was originally invented for WPF it can be used to create any kind of object trees. XAML is the language behind the visual presentation of an application that you develop in Microsoft Expression Blend, just as HTML is the language behind the visual presentation of a Web page. Creating an application in Expression Blend means writing XAML code either by hand or visually by working in the Design view of Expression Blend.

Note: You do not need to understand XAML to create applications in Expression Blend if you work in Design view. For more information, see Editing XAML by using Design view in Expression Blend in the topic Editing XAML in this User Guide.

You can export art assets from Microsoft Expression Design 2 as XAML, and then import the XAML into your Expression Blend project. Some other design applications have tools that can convert art assets to XAML. You can search on the Internet for conversion tools that are posted on trusted sites.

Today XAML is used to create user interfaces in WPF, Silverlight, declare workflows in WF and for electronic paper in the XPS standard. All classes in WPF have parameter less constructors and make excessive usage of properties. That is done to make it perfectly fit for XML languages like XAML.

Advantages of XAML:

All you can do in XAML can also be done in code. XAML is just another way to create and initialize objects. You can use WPF without using XAML. It’s on you if you want to declare it in XAML or write it in code.

Declare your UI in XAML has some advantages:

1.       XAML code is short and clear to read

2.       Separation of designer code and logic

3.       Graphical design tools like Expression Blend require XAML as source.

4.       The separation of XAML and UI logic allows it to clearly separate the roles of designer and developer.

XAML VS Code Writing:

XAML is different in some manner with Code writing such as:

1.       Precise code format

2.       Properties as elements

3.       Implicit type conversion

4.       Markup extensions

5.       Namespaces

Let’s have a brief idea about these components which are defined above.

1.     Precise code format:

XAML is used precise code format in comparison to manual code writing. Suppose that we want to draw a stack panel, we could draw it by using XAML

<StackPanel>
    <TextBlock Margin="5">MindStick XAML Section</TextBlock>
    <Button Margin="5" HorizontalAlignment="Left">Ok</Button>
</StackPanel>
 And by using Code we have:
// Create the StackPanel
StackPanel stckPanel = new StackPanel();
this.Content = stckPanel;
// Create the TextBlock
TextBlock txtBlock = new TextBlock();
txtBlock.Margin = new Thickness(10);
txtBlock.Text = "MindStick XAML Section";
stckPanel.Children.Add(txtBlock);
 // Create the Button
Button btnOk = new Button();
btnOk.Margin= new Thickness(20);
btnOk.Content = "OK";
stckPanel.Children.Add(button);
 So from above code it is clear that XAML used precise format of code.

2.     Properties as elements:

Properties are normally written inline as known from XML <Button Content="OK" />. But what if we want to put a more complex object as content like an image that has properties itself or maybe a whole grid panel? To do that we can use the property element syntax, this allows us to extract the property as an own child element.

<Button>
         <Button.Content>
         <Image Source="ImagePath" Width="50" Height="50" />
      </Button.Content>
</Button>

3.     Implicit Type Conversion:

A very powerful construct of WPF are implicit type converters. They do their work silently in the background. When you declare a BorderBrush, the word ‘Yellow’ is only a string. The implicit BrushConverter makes a System.Windows.Media.Brushes.Yellow out of it. The same regards to the border thickness that is being converted implicit into a Thickness object. WPF includes a lot of type converters for built-in classes, but you can also write type converters for your own classes.

<Border BorderBrush="Yellow" BorderThickness="0,10">
</Border>

4.     Markup Extensions:Markup extensions are dynamic placeholders for attribute values in XAML.

They resolve the value of a property at runtime. Markup extensions are surrouded by curly braces (Example: Background="{StaticResource NormalBackgroundBrush}"). WPF has some built-in markup extensions, but you can write your own, by deriving from MarkupExtension. These are the built-in markup extensions:

1.     Binding

 To bind the values of two properties together.

2.   StaticResource

   One time lookup of a resource entry

3.   DynamicResource

    Auto updating lookup of a resource entry

4.   TemplateBinding

To bind a property of a control template to a dependency property of the

control

5.   x:Static

  Resolve the value of a static property.

6.    x:Null

    Return null

5.   Namespaces:

At the beginning of every XAML file you need to include two namespaces.

The first is        

 http://schemas.microsoft.com/winfx/2006/xaml/presentation (It is mapped

to all WPF controls in System.Windows.Controls)

 The second is

http://schemas.microsoft.com/winfx/2006/xaml (it is mapped to

  System.Windows.Markup that defines the XAML keywords)

 The mapping between an XML namespace and a CLR namespace is done

by the XmlnsDefinition  attribute at assembly level. You can also directly

include a CLR namespace in XAML by using the   clr-namespace: prefix.