Using C#'s implicit type conversions from other .NET languages

One interesting C# feature is the ability to define a method that implements implicit conversion from one type to another. In this post I'm going to show how to use this feature from IronPython, F#, VB.NET and IronRuby.

Example

In order to illustrate the implicit conversion feature we're going to use the following classes:

namespace Langexplr.Experiments
{
   public class Complex 
   {
       public double Real { get; set; }
       public double Img { get; set; }
       
       public static implicit operator Complex(double real) 
       {
           return new Complex() { Real = real };
       }

       public static implicit operator Polar(Complex complex) 
       {
           return new Polar() { Angle = Math.Atan(complex.Img/complex.Real),
                                Length = Math.Sqrt(complex.Real*complex.Real +
                                                   complex.Img*complex.Img) };
       }
    
       public static implicit operator double(Complex complex) 
       {
           return Math.Sqrt(complex.Real*complex.Real +
                            complex.Img*complex.Img);
       }
       
   }

   public class Polar 
   {
       public double Angle { get; set; }
       public double Length { get; set; }
   }
}

The Complex class is a simple definition of a complex number. The Polar class is defined(conveniently) to represent a complex number in polar form. The Complex class defines three implicit conversions:

1. From double to a complex number


2. From Complex to Polar


3. From Complex to double

The following C# code shows a use of this feature:

using Langexplr.Experiments;
using System;

class main 
{ 
  public static void Main(string[] args) 
  {    
       Complex c = 10.3;
       Polar p = new Complex() {Real = 12.3, Img = 5.2};
       double abs = c;

       Console.WriteLine("abs:{0} Polar: {1},{2}", abs ,p.Angle ,p.Length);
    } 
}

By looking at the definitions generated by the compiler for the Complex class, we can see several definitions for the op_Implicit method with different parameters and return types.

...
.method public hidebysig specialname static 
        class Langexplr.Experiments.Complex 
        op_Implicit(float64 real) cil managed
...
.method public hidebysig specialname static 
        class Langexplr.Experiments.Polar 
        op_Implicit(class Langexplr.Experiments.Complex complex) cil managed
...
.method public hidebysig specialname static 
        float64  op_Implicit(class Langexplr.Experiments.Complex complex) cil managed
...

Now these uses of the Complex class will be presented on different .NET languages.

IronPython

As described in "Dark Corners of IronPython" by Michael Foord the clr.Convert function can be used to convert between types using the op_Implicit if necessary.

For example:

import clr
clr.AddReference("ImplicitTest")

from Langexplr.Experiments import *
from System import Double

c = clr.Convert(10.3, Complex)
nC = Complex()
nC.Real = 12.3
nC.Img = 5.2
p = clr.Convert(nC, Polar)
abs = clr.Convert(c, Double)

print 'abs: %(0)f Polar: %(1)f,%(2)f\n' % \
       { '0': abs, '1' : p.Angle, '2' : p.Length }

IronRuby

IronRuby will use the op_Implicit definition if a conversion required at a particular call. I couldn't find a nice way to do this directly as with IronPython's clr.Convert . However the following function definition seems to do the trick:

def dotnet_convert(value,type)
   f =  System::Func[type,type].new {|x| x}
   f.invoke(value)
end

This conversion function works since IronRuby tries to convert the value to the expected .NET type in the call to 'invoke' .

Using this definition we can write:

require 'ImplicitTest.dll'

c = dotnet_convert(10.3,Langexplr::Experiments::Complex)
nC = Langexplr::Experiments::Complex.new
nC.Real = 12.3
nC.Img = 5.2
p = dotnet_convert(nC,Langexplr::Experiments::Polar)
abs = dotnet_convert(c,System::Double)

print "abs: #{abs} Polar: #{p.Angle},#{p.Length} \n"

F#

In F# we can call the op_Implicit method directly and F# will use type inference to determine the correct overload to use.

For example:

open Langexplr.Experiments

let c : Complex = Complex.op_Implicit 10.3
let p : Polar = Complex.op_Implicit (new Complex(Real=12.3, Img=5.2))
let abs : double = Complex.op_Implicit c

System.Console.WriteLine("1. {0} Polar: {1},{2} ", abs, p.Angle, p.Length )

There's a nice post called "F# – Duck Typing and Structural Typing" by Matthew Podwysocki, which describes a nice way to define a generic function to use the op_Implicit operator.

let inline convert (x:^a) : ^b =  ((^a or ^b) : (static member op_Implicit : ^a -> ^b) x )

This function can be used as follows:

let c2:Complex = convert 10.3
let p2:Polar = convert (new Complex(Real=12.3, Img=5.2))
let abs2:float = convert c

System.Console.WriteLine("2. {0} Polar: {1},{2} ",abs2,p2.Angle,p2.Length)

VB.NET

Finally in Visual Basic .NET the implicit conversion is used automatically as in C#. For example:

Imports System
Imports Langexplr.Experiments
Module Test
   Sub Main
      Dim c As Complex = 10.3
      Dim p As Polar = new Complex() With { _
            .Real = 12.3, _
            .Img = 5.2 _
      }
      Dim abs As Double = c
      Console.WriteLine("abs:{0} Polar: {1},{2}",abs,p.Angle,p.Length)
   End Sub
End Module

Creating Dynamic JSON array finders using the DLR

One of the things that really impressed me while reading about Ruby on Rails was the use of method_missing to implement dynamic finders. The technique is described on the "How dynamic filters work". In this post I'm going to show a little experiment of creating a similar technique for querying JSON arrays using the .NET's Dynamic Language Runtime infrastructure.

Code for this post was created using Visual Studio 2010 Beta 1, IronRuby for .NET 4 beta 1 and IronPython 2.6 beta 4 for .NET 4.

JSON.NET

For this post I'm using the JSON.NET library for loading the JSON data. This library provides several ways of loading JSON data. Here I'll be using a set of predefined classes: JObject for JSON objects, JArray for arrays, JValue for literal values, etc. All these classes inherit from JToken.
Code in this post use the JSON data returned by the Twitter REST API. An example of this data:

[
 {"in_reply_to_screen_name":null,
  "text":"...",
  "user": { "following":null,
            "description":"...",
            "screen_name":"...",
            "utc_offset":0,
            "followers_count":10,
            "time_zone":"...",
            "statuses_count":155,
            "created_at":"...",
            "friends_count":1,
            "url":"...",
            "name":"...",
            "notifications":null,
            "protected":false,
            "verified":false,
            "favourites_count":0,
            "location":"...",
            "id": ...,
            ...
  },
  "truncated":false,
  "created_at":"...",
  "in_reply_to_status_id":null,
  "in_reply_to_user_id":null,
  "favorited":false,
  "id":...,
  "source":"...."
 },
  ...
]

Dynamic queries on JSON data

Finders will be implemented for JSON arrays. As with Rail's dynamic finders the names of the required fields will be encoded in the name of the invoked method.

The following C# 4.0 code shows an example of this wrapper class in conjunction with the dynamic keyword.

JsonTextReader reader = new JsonTextReader(rdr);
JsonSerializer serializer = new JsonSerializer();
JArray o = (JArray)serializer.Deserialize(reader);
dynamic dArray = new FSDynArrayWrapper(o);

string name = "ldfallas";
foreach (var aJObject in dArray.FindAllByFavoritedAlsoByUserWithScreen_Name("false",name))
{
   dynamic tobj = new FSDynJObjectWrapper(aJObject);
   Console.WriteLine("========");
   Console.WriteLine(tobj.user.screen_name);
   Console.Write("\t'{0}'",tobj.text);
}

A small definition of the syntax used for names is the following.

method-name = "FindAllBy" , 
              property-name , ("With", property-name)? ,
             ("AlsoBy" property-name , ("With", property-name)? ) *
property-name = valid json property name

In order to be more flexible the following syntax will also be allowed:

method-name = "find_all_by_" , 
              property-name , ("_with_", property-name)? ,
             ("_also_by" property-name , ("_with_", property-name)? ) *
property-name = valid json property name

A sample name for this query methods look like this:

array.FindAllByFavoritedAlsoByUserWithScreen_Name("true","ldfallas")

This method will accept two parameters and is going to :

Find all the object elements from the array that has a 'Favorited' property equal to 'true' and also has an object with a 'User' property associated with an object which has a 'Screen_Name' property which is equal to the 'ldfallas'

Interoperability

One of the nice things of using the DLR infrastructure to create this feature, is that it can be used by other DLR languages. The following example is an IronRuby snippet:

require 'FsDlrJsonExperiments.dll'
include Langexplr::Experiments

while true do
  print "Another try\n"
  str = System::Net::WebClient.new().download_string("http://twitter.com/statuses/public_timeline.json")
  json = FSDynArrayWrapper.CreateFromReader(System::IO::StringReader.new(str))

  for i in json.find_all_by_user_with_time_zone('Central America') do
     print i.to_string()
  end
  sleep(5)
end

The following IronPython code shows a little example of this wrapper class.

fReader = StreamReader(GetTwitterPublicTimeline())
jReader  = JsonTextReader(fReader)
serializer = JsonSerializer()

json = FSDynArrayWrapper( serializer.Deserialize(jReader) )

for i in json.FindAllByFavoritedAlsoByUserWithScreen_Name("false","ldfallas"):
   print i

Implementation

In order to implement the functionality presented here, the IDynamicMetaObjectProvider interface and the DynamicMetaObject class were used. By using these we can generate the code for the call site as a expression tree. For more information on how to use this interface see
Getting Started with the DLR as a Library Author document (available here) .

The code generated to do the filtering is an expression which uses the Where method from System.Linq.Enumerable
. The generated expression written in source using a pseudo C# looks like this:

{
  object tmp;
  array.Where(c => (((c Is JObject) && 
                     CompareHelper(
                         GetJObjectPropertyCI(((JObject)c), "Favorited"), 
                         "true")) 
                    && 
                    ((((tmp = GetJObjectPropertyCI(((JObject)c), "User")) As JObject) != null) && 
                     CompareHelper(
                         GetJObjectPropertyCI(((JObject)tmp), "Screen_Name"), 
                         "ldfallas"))))

}

Where GetJObjectPropertyCI is a helper method that gets a property from a JObject by case-intensive name . And CompareHelper is a helper method to do the comparison.

The implementation for FSDynArrayWrapper was written in F#. Mainly because it's a nice language to implement this kind of features. However there's no easy way to consume this feature using F# since it doesn't use the DLR.

Here's the definition:

type FSDynArrayWrapper(a:JArray) =   
   member this.array with get() = a
   static member CreateFromReader(stream : System.IO.TextReader) =
     ...
   static member CreateFromFile(fileName:string) =
     ... 
   interface IDynamicMetaObjectProvider with
      member this.GetMetaObject( parameter : Expression) : DynamicMetaObject =
         FSDynArrayWrapperMetaObject(parameter,this)  :> DynamicMetaObject

As you can see, the interesting part is in the implementation of FSDynArrayWrapperMetaObject. The CreateFromReader and CreateFromFile methods are only utility methods to load data from a document.

The implementation of FSDynArrayWrapperMetaObject looks like this:

type FSDynArrayWrapperMetaObject(expression : Expression, value: System.Object) = 
   inherit DynamicMetaObject(expression,BindingRestrictions.Empty,value) 
   
   ...
   
   override this.BindInvokeMember(binder : InvokeMemberBinder, args: DynamicMetaObject array) =
     match QueryInfo.GetQueryElements(binder.Name) with
     | Some( elements ) ->
         (new DynamicMetaObject(
             this.GenerateCodeForBinder(
                 elements, 
                 Array.map 
                   (fun (v:DynamicMetaObject) -> 
                      Expression.Constant(v.Value.ToString()) :> Expression) args),
             binder.FallbackInvokeMember(this,args).Restrictions))
     | None -> base.BindInvokeMember(binder,args)

The BindInvokeMember creates the expression tree for the code that will be executed for a given invocation of a dynamic finder method. Here the QueryInfo.GetQueryElements method is called to extract the elements of the name as described above. The value returned by this method is QueryElement list option where:

type QueryElement =
  | ElementQuery of string
  | SubElementQuery of string * string

ElementQuery specifies the "Favorited" part in FindAllByFavoritedAlsoByUserWithScreen and the SubElementQuery belongs to the "ByUserWithScreen" part in FindAllByFavoritedAlsoByUserWithScreen .

If the name of the invoked method corresponds is a supported name for a finder, the GenerateCodeForBinder is called to generate the expression tree. The last argument of this method is a collection of the arguments provided for this invocation.

member this.GenerateCodeForBinder(elements, arguments : Expression array) =
   let whereParameter = Expression.Parameter(typeof<JToken>, "c") in
   let tmpVar = Expression.Parameter(typeof<JToken>, "tmp") in
   let whereMethodInfo =
         (typeof<System.Linq.Enumerable>).GetMethods() 
                 |> Seq.filter (fun (m:MethodInfo) -> m.Name = "Where" && (m.GetParameters().Length = 2))
                 |> Seq.map (fun (m:MethodInfo) -> m.MakeGenericMethod(typeof<JToken>))
                 |> Seq.hd
   let queryElementsConditions =              
        elements 
           |> Seq.zip arguments
           |> Seq.map 
                  (fun (argument,queryParameter) ->
                       this.GetPropertyExpressionForQueryArgument(queryParameter,argument,whereParameter,tmpVar)) in
   let initialCondition =  Expression.TypeIs(whereParameter,typeof<JObject>)  in
   
   let resultingExpression =
        Expression.Block(
           [tmpVar],
           Expression.Call(
              whereMethodInfo,
              Expression.Property(
                 Expression.Convert(
                    this.Expression,this.LimitType),"array"),
              Expression.Lambda(                     
                  Seq.fold 
                       (fun s c -> Expression.And(s,c) :> Expression) 
                       (initialCondition :> Expression) 
                       queryElementsConditions,
                   whereParameter))) in
   resultingExpression                

The most important parts of this method is the definition of queryElementsConditions and resultingExpression. The resulting expression specifies the invocation to the Where method


The queryElementsConditions take each argument extracted from the name of the method and tries to generate the necessary conditions for the value provided as an argument. In order to do this the GetPropertyExpressionForQueryArgument method is used:

member this.GetPropertyExpressionForQueryArgument(parameter:QueryElement,argument,cParam,tmpVar) : Expression =
    match parameter with
    | ElementQuery(propertyName) -> 
        this.CompareExpression(     
           this.GetJObjectPropertyExpression(cParam,propertyName) ,
           argument) 
    | SubElementQuery(propertyName,subPropertyName) ->
        Expression.And(
          Expression.NotEqual(
              Expression.TypeAs(
                 Expression.Assign(
                     tmpVar,
                     this.GetJObjectPropertyExpression(cParam,propertyName)),
                 typeof<JObject>),  
              Expression.Constant(null)),          
          this.CompareExpression(          
              this.GetJObjectPropertyExpression(
                  tmpVar,
                  subPropertyName),argument)) :> Expression

This method generates a different expression depending on the kind of query element that is requested.

Considerations for IronPython

As a curious note, in IronPython the BindInvokeMember method is not called in the FSDynArrayWrapperMetaObject when a method is invoked. It seems that IronPython calls the BindGetMember method and then tries to apply the result of getting the method.

So to make this object work with IronPython a implementation of the BindGetMember method was created that returns a lambda expression tree with the generated Where invocation.

override this.BindGetMember(binder: GetMemberBinder) =
  match QueryInfo.GetQueryElements(binder.Name) with
  | Some( elements ) ->
      let parameters =
        List.mapi ( fun i _ ->
                         Expression.Parameter(
                                     typeof<string>,
                                     sprintf "p%d" i)) elements
      (new DynamicMetaObject(
          Expression.Lambda(
              this.GenerateCodeForBinder(
                  elements, 
                  parameters 
                  |> List.map (fun p -> p :> Expression)
                  |> List.to_array ),
              parameters),
          binder.FallbackGetMember(this).Restrictions))
  | None -> base.BindGetMember(binder)

Accessing using different names

The QueryInfo.GetQueryElements method is used to allow the "FindAllBy..." and "find_all_by..." method names .

module QueryInfo = begin

    ...

    let GetQueryElements(methodName:string) =
       match methodName with
       | str when str.StartsWith("FindAllBy") ->
              Some(ExtractQueryElements(str.Substring("FindAllBy".Length),"AlsoBy","With")) 
       | str when str.StartsWith("find_all_by_") ->
           Some(ExtractQueryElements(str.Substring("find_all_by_".Length),"_also_by_","_with_") )
       | _ -> None
end

Code

Code for this post can be found here.

Creating an XSD schema from classes using XAML rules with IronRuby

This post presents a little unfinished experiment for creating an XSD Xml Schema definition from classes based on some of the rules to map XAML documents to objects. The program is written in IronRuby and it uses reflection to inspect classes and generate the schema definition.

The goal is to have an XML Schema that could be used in conjunction with an XML editor to create XAML documents (which is useful for those of us who don't have a full Visual Studio version). Although as the XAML Overview document says, there are elements that could not be completely mapped to an schema definition, some of them are mentioned below.

The Silverlight Visual Studio integration already includes a very nice XAML editing capabilities.

I think this experiment is a great way to learn more about IronRuby and how to use it to call .NET Libraries.

The strategy

What the program will do is to navigate all the classes inheriting from System.Windows.DependencyObject and generate and XML element and a complex type definition with all the properties included in the definition. For this experiment only two mappings are implemented: properties and content properties.

Properties

As the XAML Overview document describes two ways for specifying properties:

1. By using XML attributes


2. By using a class.property-name element

This means that:

This

<Button Background="Blue" >
...
</Button>

and

<Button>
   <Button.Background>
       <SolidColorBrush Color="Blue">
   </Button.Background>
   ...
</Button>

are equivalent.

So the alternative is to create both the attribute and the property element definitions in the schema.

Content properties

For elements that contain the ContentPropertyAttribute a special child element will be created with a reference to a sequence of all identified concrete elements that in inherit from the property type. As discussed below, this definition is not complete for content properties that accept basic types such as a string.


The program

Some constant and variable definitions

require 'mscorlib'
require 'System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL'
include System::Xml
include System::Reflection

SILVERLIGHT_FOLDER = "c:\\Program files\\Microsoft Silverlight\\2.0.30523.8\\"
BASE_TYPE_NAME = "System.Windows.DependencyObject"
CONTENT_PROPERTY_ATTRIBUTE = "System.Windows.Markup.ContentPropertyAttribute"

SILVERLIGHT_NAMESPACE = "http://schemas.microsoft.com/client/2007"
EXTRA_ATTRIBUTES_NAMESPACE = "http://schemas.microsoft.com/winfx/2006/xaml"
XSD_NAMESPACE = "http://www.w3.org/2001/XMLSchema"
CONCRETE_ELEMENTS_GROUP_NAME = "UIElementsGroup"

PRESENTATION_FRAMEWORK_COLLECTION_BASE_TYPE =  "PresentationFrameworkCollection`1"

The main program

The main program looks like this:

begin
  
  silveright_system_assembly = Assembly.reflection_only_load_from(SILVERLIGHT_FOLDER + "system.dll")
  silveright_windows_assembly = Assembly.reflection_only_load_from(SILVERLIGHT_FOLDER + "System.Windows.dll")
  silveright_core_assembly = Assembly.reflection_only_load_from(SILVERLIGHT_FOLDER + "System.Core.dll")
  silveright_net_assembly = Assembly.reflection_only_load_from(SILVERLIGHT_FOLDER + "System.Net.dll")
  silveright_xml_assembly = Assembly.reflection_only_load_from(SILVERLIGHT_FOLDER + "System.Xml.dll")
   

  registry = Registry.new(silveright_windows_assembly)
  
  registry.collect_data
  
  registry.generate_xsd_schema
  puts 'Done!'
  
rescue System::Reflection::ReflectionTypeLoadException => tl
  puts tl
  puts tl.LoaderExceptions
rescue System::IO::FileLoadException => e
  puts e
  puts "-----"  
  puts e.FusionLog
end

As presented here, the program first collects data about the classes stored in the System.Windows.dll Silverlight library and then generate the XSD schema definition.

The Registry class

The Registry class stores information on the identified classes and keeps track of element groups to be generated.

The collect_data method of the Registry class looks like this:

class Registry
  
  def initialize(types_assembly)
    @groups = {}
    @types_assembly = types_assembly
    @additional_types = {}
    @classes = {}
  end

  ...
  
  def get_or_create(name,registry)
    if @classes.has_key? name 
      return @classes[name]
    else 
      return (@classes[name] = ClassNode.new(name,nil,registry))
    end
  end



  ...

  def collect_data
    base_type = @types_assembly.GetType(BASE_TYPE_NAME)  
    @classes[base_type.FullName] = RootClassNode.new(BASE_TYPE_NAME,base_type,self)
        
    @types_assembly.get_types.each do |a_type|
      if (base_type.is_assignable_from a_type and base_type.FullName != a_type.FullName  )
        node = get_or_create(a_type.full_name,self)
        node.the_type = a_type
        parent = get_or_create(a_type.BaseType.full_name,self)
        parent.add_child(node)
        
        puts "Adding #{a_type.FullName}"       
      end
    end
  end

end

As shown here the collect_data method iterates all the classes in the assembly, asking for elements that descend from System.Windows.DependencyObject. For each of these classes an instance of the ClassNode class is created.
If you are familiar with the .NET Reflection API you will recognize some of the names presented here such as is_assignable_from which is a call to the IsAssignableFrom method. As described here, IronRuby allows you to call existing .NET method names using Ruby naming convention .

Generating the Schema

The XSD schema is generated in the generate_xsd_schema Registry method which looks like this:

  def generate_xsd_schema
    base_type = @types_assembly.GetType(BASE_TYPE_NAME)  
    swriter = System::IO::StreamWriter.new("silveright.xsd")
    writer_settings = XmlWriterSettings.new()
    writer_settings.Indent = true
    w = XmlWriter.Create(swriter,writer_settings)
    w.write_start_document
    w.write_start_element("schema",XSD_NAMESPACE)
    w.write_attribute_string("targetNamespace",SILVERLIGHT_NAMESPACE)
    w.write_attribute_string("elementFormDefault","qualified")
    w.write_attribute_string("xmlns","sl",nil,SILVERLIGHT_NAMESPACE)
    w.write_attribute_string("xmlns","x",nil,EXTRA_ATTRIBUTES_NAMESPACE)
    
    w.write_start_element("import",XSD_NAMESPACE)
    w.write_attribute_string("namespace",EXTRA_ATTRIBUTES_NAMESPACE)
    w.write_attribute_string("schemaLocation","extraxamldefs.xsd")
    w.write_end_element()
    
    @classes[base_type.FullName].write_schema_definition(w)
    
    
    create_additional_type_definitions(w)
    create_concrete_elements_group(w)
    
    w.write_end_element
    w.write_end_document
    
    w.Close
    swriter.Close
  end

As shown here a .NET XmlWriter class is used to generate the schema.

The write_schema_definition of the RootClassNode and ClassNode classes generates all the appropriate definitions for each class.


For the RootClassNode which represents classes that don't inherit from the DependencyObject the code looks like this:

class RootClassNode 
  attr_accessor :name,:the_type,:children
  
  def initialize(name,the_type,registry)
    @the_type = the_type
    @name = name  
    @children = {}    
    @registry = registry    
  end  
 
  ...

  def write_schema_definition(writer)
    ctype_name = @the_type.Name.to_s+"Type"
    writer.write_start_element("complexType",XSD_NAMESPACE)
    writer.write_attribute_string("name",ctype_name )    
        
    write_inner_elements_definition(writer) unless is_abstract
           
    write_properties_definition(writer)
    if (@the_type.FullName.to_s == BASE_TYPE_NAME)
      writer.write_start_element("attributeGroup",XSD_NAMESPACE)
      writer.write_attribute_string("ref","x:extraAttributes")
      writer.write_end_element
    end
             
    writer.write_end_element
   
    write_element_definition(writer,ctype_name) unless is_abstract
   
    @children.values.each {|c| c.write_schema_definition(writer)}
  end

end

A complex type is generated with the content of the current class. The write_inner_elements_definition method writes all the description of the child nodes for this complexType, for example it writes the property/element definitions and child node references. The write_properties_definition
method writes the attribute definitions for all the properties.

Also for all base types, a reference to an attribute group of "extraAttributes" is generated. This attribute group contains reference to definitions for some of the XAML attributes such as x:Name. More information about these attributes can be found in XAML Namespace (x:) Language Features.

Finally an element definition is created if the class is not abstract.

For classes inheriting from DependencyObject, a ClassNode instance is created.

class ClassNode < RootClassNode
  
  def write_schema_definition(writer)
    
    if @the_type.contains_generic_parameters 
      ctype_name = @the_type.Name.to_s.gsub(/`/,'')+"Type"
    else
      ctype_name = @the_type.Name.to_s + "Type"
    end
   
    writer.write_start_element("complexType",XSD_NAMESPACE)
    writer.write_attribute_string("name",ctype_name )    
    
    writer.write_start_element("complexContent",XSD_NAMESPACE)
    writer.write_start_element("extension",XSD_NAMESPACE)
    writer.write_attribute_string("base","sl:#{@the_type.BaseType.Name}Type")
    write_inner_elements_definition(writer) unless is_abstract
    write_properties_definition(writer)         
    writer.write_end_element
    writer.write_end_element
    writer.write_end_element
    
    
    write_element_definition(writer,ctype_name) unless is_abstract        
    
    @children.values.each {|c| c.write_schema_definition(writer)}
  end
end

The main difference with BaseClassNode is that a complex type extension to the base type is generated. This will reduce the number of attribute definitions of each complex type.

Writing child node references

In order to allow sequences of heterogeneous elements as child nodes of XAML elements, a group definition is created with a choice that references every concrete type.

For example for elements that have a content property of type UIElement the following group is generated:

<group name="UIElementGroup">
  <choice>
    <element ref="sl:Path" />
    <element ref="sl:Ellipse" />
    <element ref="sl:Line" />
    <element ref="sl:Polygon" />
    <element ref="sl:Polyline" />
    <element ref="sl:Rectangle" />
   ...
  </choice>
</group>

Combining Enum values

The only way, that I could find, for combining .NET Enum values was to use a combination of Convert.ToInt32 and Enum.ToObject. The following function was used to do that.

def combine(enum_type,enum_values)
  System::Enum.ToObject(
     enum_type.to_clr_type,
     ((enum_values.map  {|e_value| 
           System::Convert.ToInt32(e_value)}).inject  {|i,j| (j | i)}))
end

A use of this function for combining BindingFlags looks like this:

p = @the_type.get_property(
                    c.to_string, 
                    combine(BindingFlags,
                            [BindingFlags.Instance,
                             BindingFlags.Public,
                             BindingFlags.NonPublic]))

result_type = p.PropertyType

Elements not mapped

As mentioned at the beginning of the document, not all XAML document features can be accurately represented using XSD. Some of the things that I noticed:

• Couldn't find a way to define attached properties. A possible workaround is to generate all possible attached property definitions


• Content properties that allow strings are not represented. This is difficult since it has conflicts with the property/element definitions. Mixed content could be a possible workaround.


• Extensibility: no easy way to represent things outside of System.Windows. This is a very difficult problem, maybe things like substitution groups could help to represent future child nodes.

Using the generated schema

With the schema generated, an XML editor with XSD Schema aware completion can be used. For example here it is used in Eclipse with XML editor tools included in WTP.




I tried to use the schema with the Netbeans 6.1 IDE (which was used as the Ruby editor for this code) however for schema completion it requires you to specify the schemaLocation attribute. Using this attribute or declaring the xsi namespace generates an error when the XAML is loaded at runtime!.


Code and generated schema for this post can be found here.