WPF .NET Core - Creating Objects With XAML
Written by Mike James   
Thursday, 07 May 2020
Article Index
WPF .NET Core - Creating Objects With XAML
Naming Objects
Properties

Banner

Reference Type Properties

A second problem arises if we are trying to initialize a property that takes a reference type.

This is mostly solved by the use of a different property initialization syntax.

For example, instead of using an attribute to set MyProperty we use:

<m:MyClass x:Name="MyObject1">
 <m:MyClass.MyProperty>
  20
 </m:MyClass.MyProperty>
</m:MyClass>

The result is the same but this syntax is more general because we can include a new object between the property tags.

A demonstration of an object property is a little messy but if we add a new class:

public class MyDataClass
{
 private int m_MyProperty2;
 public MyDataClass() { }
 public int MyProperty2
 {
  get { return m_MyProperty2; }
  set { m_MyProperty2 = value; }
 }
}

This class has a single int property but in principle it could be as complicated as required.

Now we can add a new class-valued property to our original class:

private MyDataClass m_MyDataClass;
public MyDataClass MyClassProp
{
 get { return m_MyDataClass; }
 set { m_MyDataClass = value; }
}

This is just a standard get/set property but it takes an object of type MyDataClass.

Clearly this cannot be set to a new value using a string. The way to do it is:

<m:MyClass x:Name="MyObject1">
 <m:MyClass.MyClassProp>
  <m:MyDataClass MyProperty2="35">
  </m:MyDataClass>
 </m:MyClass.MyClassProp>
</m:MyClass>

This creates a new, nameless, instance of the DataClass class and then sets its MyProperty2 to 35. Notice that Attribute setting can be used for MyProperty2 because it is a supported value property however there would be no problem if MyProperty was another reference property – the nesting might get a little deep however!

Implementing a type converter

As an alternative to using nested property syntax to set reference properties, we can opt to handle the conversion from the initializer string to the object properties ourselves.

Surprisingly this isn’t difficult.

For example, suppose we want to allow MyProperty2 to be set by a string. All we have to do is tag the type that the type converter will apply to with:

[TypeConverter(typeof(MyDataClassTypeConverter))]
public class MyDataClass
{

The rest of the class is unaltered. Now we have to implement the MyDataClassTypeConverter and to do this we need to add:

using System.ComponentModel;

The type converter class has to inherit from TypeConverter and it first implements CanConvertFrom which simply returns true or false depending on whether or not the type converter can do the requested conversion: 

public class
MyDataClassTypeConverter:TypeConverter
{
 public override bool
 CanConvertFrom(ITypeDescriptorContext
                           context, Type t)
 {
  if (t == typeof(String)) return true;
  return false;
 }

The second method we need actually does the type conversion:

 public override object ConvertFrom(
              ITypeDescriptorContext context,
              System.Globalization.CultureInfo
              culture,object val)
 {
  MyDataClass temp=new MyDataClass();
  temp.MyProperty2=
              Convert.ToInt32((string)val);
  return temp;
 }
}

Notice that it creates a new instance of the class that it performs type conversion for and then processes the string to initialize the properties of the MyDataClass instance. Notice also that the Type converter creates and then initializes the object to be stored in the property using the information supplied by the initialization string.

Clearly a real example would be more complex and would parse the string to extract multiple items of initialization information.

With the type converter in place we can create an instance of MyClass using:

<m:MyClass x:Name="MyObject"
     MyProperty="23" MyClassProp="35" >
</m:MyClass>

You will also discover that this approach puts both properties into the Property Windows so that they can be changed interactively.

Beyond initialisation

Suppose you want to make use of the objects created by the XAML in your code. The attribute:

x:Class="WpfApplication1.Window1"

defines the partial class that provides the “code behind” support for the XAML. Within this class all of the objects you have created are within the namespace and accessible.

For example you can write, without any other modifications:

private void Window_Loaded(
           object sender,RoutedEventArgs e)
{
 MessageBox.Show(
           MyObject1.MyProperty.ToString());
}

You can similarly write code that manipulates any object or property initialized by XAML.

XAML

Where next?

It is clear that XAML is a very general and extensible object instantiation language. If you follow the example in this article I can promise you lots of difficulties caused by synchronization – the project organization used in this article was adopted to make the example simple and thus falls over in the real world.

The problem is that XAML doesn’t expect the assemblies that contain the classes it is instantiating to change during development. This is easily cured by splitting out the class definitions into another assembly. 

In the final analysis you have to ask yourself if XAML is worth it. Is it really so much better to instantiate objects declarative with all of the type conversion and namespace problems this brings about?

For some situations the declarative approach to object creation makes sense - UIs for example. In other case you need to think carefully and if you decide to create a declarative system using XAML you will almost certainly have to create a custom editor for the objects. 

Knowing how XAML works, for WPF or UWP apps is well worth the effort however. 

 

The Programmer's Guide To
WPF .NET Core

wpfcover

Contents

  1. Getting Started with WPF
  2. Getting To Know WPF 
  3. Creating Objects With XAML
  4. Inside Dependency Properties 
  5. Routed Events ***NEW
  6. Simple WPF data binding
  7. FlexGrid - A Lightweight Data Grid
  8. Using the WPF .NET 4.0 DataGrid
  9. ISupportInitialize and XAML
  10. WPF The Easy 3D Way
  11. BitmapSource: WPF Bitmaps
  12. Loading Bitmaps: DoEvents and the closure pattern
  13. Bitmap Effects
  14. Custom Bitmap Effects - Getting started
  15. Custom Bitmap Effects - HLSL
  16. Custom BitmapSource
  17. Bitmap Coding and Metatdata in WPF
  18. Custom Shape
  19. The bitmap transform classes
  20. Drawing Bitmaps – DrawingImage and DrawingVisual
  21. RenderTargetBitmap - Visual vector to bitmap
  22. WriteableBitmap
  23. BitmapImage and local files

 

To be informed about new articles on I Programmer, sign up for our weekly newsletter, subscribe to the RSS feed and follow us on Twitter, Facebook or Linkedin.

square

 



 

Comments




or email your comment to: comments@i-programmer.info

Banner


FlexGrid - A Lightweight Data Grid

There are more data grids available than the standard one that comes with WPF. In this article we take a look at FlexGrid for WPF and discover how easy it is to use.



Bitmap Effects

WPF bitmap effects are easy to use but subtle. Before moving on to consider custom effects we take a careful look at what is provided as standard.



Custom Bitmap Effects - Getting started

The simplest possible custom effects project is enough for you to see how it all works and to move on to building your own effects that do something useful. This is an introduction to using HLSL in WP [ ... ]



WPF The Easy 3D Way

WPF provides a full 3D graphics experience without the need to master DirectX. It really is the easy 3D approach.



Getting Started with WPF

 

WPF Windows Presentation Foundation is the new way to do forms and all things graphical in .NET. You can still use  Windows Forms but don't expect anything particularly new to be added to [ ... ]


Other Articles

square

 



 

Comments




or email your comment to: comments@i-programmer.info

 

<ASIN:0470041803>

<ASIN:1590599624>

<ASIN:0321374479>



Last Updated ( Saturday, 16 May 2020 )