Matt W's Windows Workflow Place : xaml

Emitting the mc:Ignorable Instruction In Your WF4 XAML

mwinkle — Thu, 10 Dec 2009 21:33:48 GMT

Frequent forum guest Notre posed this question to the forums the other day noting that the XAML being produced from ActivityXamlServices.CreateBuilderWriter() was slightly different than the XAML being output from WorkflowDesigner.Save(). The reason for this stems from the fact that WorkflowDesigner leverages an additional internal type (which derives from XamlXmlWriter) in order to attach the mc:Ignorable attribute.

Why use mc:Ignorable?

From the source at MSDN:

The mc XML namespace prefix is the recommended prefix convention to use when mapping the XAML compatibility namespace http://schemas.openxmlformats.org/markup-compatibility/2006.

Elements or attributes where the prefix portion of the element name are identified as mc:Ignorable will not raise errors when processed by a XAML processor. If that attribute could not be resolved to an underlying type or programming construct, then that element is ignored. Note however that ignored elements might still generate additional parsing errors for additional element requirements that are side effects of that element not being processed. For instance, a particular element content model might require exactly one child element, but if the specified child element was in an mc:Ignorable prefix, and the specified child element could not be resolved to a type, then the XAML processor might raise an error.

Basically, this lets a XAML reader gracefully ignore any content marked from that namespace if it cannot be resolved. So, imagine a runtime scenario where we don’t want to load System.Activities.Presentation every time we read a WF XAML file that may contain viewstate. As a result, we use mc:Ignorable, which means the reader will skip that content when it does not have that assembly referenced at runtime.

This is what the output from the designer usually contains:

<Sequence 
     mc:Ignorable="sap" 
     mva:VisualBasic.Settings="Assembly references and imported namespaces serialized as XML namespaces"
     xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities" 
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
     xmlns:mva="clr-namespace:Microsoft.VisualBasic.Activities;assembly=System.Activities" 
     xmlns:sap="http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation" 
     xmlns:scg="clr-namespace:System.Collections.Generic;assembly=mscorlib" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <sap:WorkflowViewStateService.ViewState>
    <scg:Dictionary x:TypeArguments="x:String, x:Object">
      <x:Boolean x:Key="IsExpanded">True</x:Boolean>
    </scg:Dictionary>
  </sap:WorkflowViewStateService.ViewState>
  <Persist sap:VirtualizedContainerService.HintSize="211,22" />
  <Persist sap:VirtualizedContainerService.HintSize="211,22" />
  <WriteLine sap:VirtualizedContainerService.HintSize="211,61" />
</Sequence>

mc:Ignorable will cause the ViewState and HintSize to be ignored.

Why do I have to worry about this?

If you use WorkflowDesigner.Save(), you don’t. If you want to be able to serialize the ActivityBuilder and have XAML which is what the designer produces, you need will need to add a XamlXmlWriter into the XamlWriter stack in order to get the right output. You may also worry about this if you are implementing your own storage and plan on writing some additional XAML readers or writers for additional extensibility and flexibility.

How Do I Get the Same Behavior?

The code below describes the same approach you would need to take to implement an XamlXmlWriter that does the same thing our internal type does. While I can’t copy and paste code, this does the same thing. We do two things:

Override WriteNamespace() to collect all of the namespaces being emitted. We do this to specifically check for ones that we should ignore, and to also gather all of the prefixes to make sure we don’t have a collision
Override WriteStartObject() to generate and write out the Ignorable attribute within the start (first) member for any namespaces we should ignore.

What namespaces do we ignore in the designer? Just one: http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation

using System.Collections.Generic;

using System.IO;

using System.Xaml;

using System.Xml;

namespace IgnorableXamlWriter

    class IgnorableXamlXmlWriter : XamlXmlWriter

        HashSet<NamespaceDeclaration> ignorableNamespaces = new HashSet<NamespaceDeclaration>();

        HashSet<NamespaceDeclaration> allNamespaces = new HashSet<NamespaceDeclaration>();

        bool objectWritten;

        bool hasDesignNamespace;

        string designNamespacePrefix;

        public IgnorableXamlXmlWriter(TextWriter tw, XamlSchemaContext context)

            : base(XmlWriter.Create(tw,

                                    new XmlWriterSettings { Indent = true, OmitXmlDeclaration = true }),

                                    context,

                                    new XamlXmlWriterSettings { AssumeValidInput = true })

        public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)

            if (!objectWritten)

                allNamespaces.Add(namespaceDeclaration);

                // if we find one, add that to ignorable namespaces

                // the goal here is to collect all of them that might point to this

                // if you had a broader set of things to ignore, you would collect

                // those here.

                if (namespaceDeclaration.Namespace == "http://schemas.microsoft.com/netfx/2009/xaml/activities/presentation")

                    hasDesignNamespace = true;

                    designNamespacePrefix = namespaceDeclaration.Prefix;

            base.WriteNamespace(namespaceDeclaration);

        public override void WriteStartObject(XamlType type)

            if (!objectWritten)

                // we should check if we should ignore

                if (hasDesignNamespace)

                    // note this is not robust as mc could naturally occur

                    string mcAlias = "mc";

                    this.WriteNamespace(

                        new NamespaceDeclaration(

                            "http://schemas.openxmlformats.org/markup-compatibility/2006",

                            mcAlias)

);

            base.WriteStartObject(type);

            if (!objectWritten)

                if (hasDesignNamespace)

                    XamlDirective ig = new XamlDirective(

                        "http://schemas.openxmlformats.org/markup-compatibility/2006",

                        "Ignorable");

                    WriteStartMember(ig);

                    WriteValue(designNamespacePrefix);

                    WriteEndMember();

                    objectWritten = true;

One note on the code above, it is noted that the generation of the namespace prefix “mc” is not robust. In the product code we will check to see if mc1, mc2, … are available up to mc1000. In that case we would then append a GUID for the ugliest XML namespace known to mankind. The chance of collision up to 1000 would be a highly extreme edge case.

How would I use this? The following code shows feeding this into a CreateBuilderWriter that is passed to XamlServices.Save()

StringBuilder sb = new StringBuilder();
XamlSchemaContext xsc = new XamlSchemaContext();
var bw = ActivityXamlServices.CreateBuilderWriter(
    new IgnorableXamlXmlWriter(new StringWriter(sb), xsc));

XamlServices.Save(bw,
                  wd.Context.Services.GetService<ModelTreeManager>().Root.GetCurrentValue());

Types, Metatypes and Bears, Redux

mwinkle — Fri, 23 Oct 2009 16:16:29 GMT

I made a quick post a few months back where I tried to talk about the way the designer works and lets us design types, as well as simply configure instances of types.

There were a couple of key points that I wanted to make there in that post:

The workflow designer can configure instances of activity graphs, and create entire types as well
Types are designed by editing an instance of a type that represents the type being designed, the metatype
There is some XAML trickery required to serialize and deserialize this
This same type of work is done to enable the DynamicActivity capability

A few folks have noticed (and sent me mail), that things look a little different in Beta2. While we are going to have a more thorough, “here’s everything that changed” doc, I want to go ahead and update at least some of the things that I’ve been talking about here.

What’s New

In reality, very little is new, we’ve primarily moved stuff around now. One thing that you may remember is that the DesignTimeXamlReader was not public in beta1, and if you are looking around, you may not find it. We have made this functionality public however. Thus, see the “what’s changed" bit.

What’s Changed

We took a long look at things and realized we had a bunch of XAML stuff all over the place. We felt it would be a good idea to try to consolidate that into one place in WF, so System.Activities.XamlIntegration.ActivityXamlServices becomes your one stop shop for most things Activity and XAML related. Let’s take a quick look and see what’s in there:

ActivityXamlServices Members

[This documentation is for preview only, and is subject to change in later releases. Blank topics are included as placeholders.]

Creates an instance of an activity tree described in XAML.

The ActivityXamlServices type exposes the following members.

Methods

Name

Description

CreateBuilderReader

Overloaded. Maps an x:Class activity tree to an ActivityBuilder or ActivityBuilder<(Of <(TResult>)>).

CreateBuilderWriter

Maps an ActivityBuilder or ActivityBuilder<(Of <(TResult>)>) from the specified writer to an x:Class activity tree.

CreateReader

Overloaded. Maps an x:Class activity tree to an DynamicActivity or DynamicActivity<(Of <(TResult>)>).

Load

Overloaded. Creates an instance of a declarative workflow.

Top

Load is used to generally take some XAML and return an Activity which you can then use to execute. If Load encounters a XAML stream for <Activity x:Class, it will subsequently generate a DynamicActivity. This functions basically the same way WorkflowXamlServices.Load() did in beta1.

You also see CreateBuilderReader, and CreateBuilderWriter, which are used to surface the DesignTimeXaml capabilities that we used in beta1. These will return an instance of a XamlReader/Writer that handles the transformation between the metatype and the <Activity x:Class XAML. The metatype has changed names from ActivitySchemaType to ActivityBuilder.

The table below should help summarize the uses and changes between beta1 and beta2. In this area, I don’t expect any changes between what you see now, and what you will see in RTM.

Task	Beta1	Beta2
metatype (type to build types)	ActivitySchemaType	ActivityBuilder
Mechanism to load DynamicActivity	WorkflowXamlServices.Load()	ActivityXamlServices.Load()
Mechanism to load ActivityBuilder	use WorkflowDesigner.Load() to get an ActivitySchemaType	Use the reader from CreateBuilderReader() to pass into XamlServices.Load()
Mechanism to save ActivityBuilder to XAML	Create a new DesignTimeXamlWriter, pass that to XamlServices.Save()	Use the writer returned from CreateBuilderWriter() to pass into XamlServices.Save()

To explore this, use CreateBuilderReader() and XamlServices.Load() on a workflow that you’ve built in the designer and poke around a bit to see what’s going on.

Here is some sample code that walks through this:

   1:  ActivityBuilder ab1 = new ActivityBuilder();

   2:  ab1.Name = "helloWorld.Foo";

   3:  ab1.Properties.Add(new DynamicActivityProperty { Name = "input1", Type = typeof(InArgument<string>) });

   4:  ab1.Properties.Add(new DynamicActivityProperty { Name = "input2", Type = typeof(InArgument<string>) });

   5:  ab1.Properties.Add(new DynamicActivityProperty { Name = "output", Type = typeof(OutArgument<string>) });

   6:  ab1.Implementation = new Sequence

   7:  {

   8:      Activities =

   9:      {

  10:          new WriteLine { Text = "Getting Started " },

  11:          new Delay { Duration = TimeSpan.FromSeconds(4) },

  12:          new WriteLine { Text = new VisualBasicValue<string> { ExpressionText= "input1 + input2" }},

  13:          new Assign<string> { To = new VisualBasicReference<string> { ExpressionText = "output" },

  14:                       Value = new VisualBasicValue<string> {ExpressionText= "input1 + input2 + \"that's it folks\"" } }

  15:      }

16:

  17:  };

  18:  StringBuilder sb = new StringBuilder();

  19:  StringWriter tw = new StringWriter(sb);

  20:  XamlWriter xw = ActivityXamlServices.CreateBuilderWriter(

  21:      new XamlXmlWriter(tw, new XamlSchemaContext()));

  22:  XamlServices.Save(xw , ab1);

  23:  string serializedAB = sb.ToString();

24:

  25:  DynamicActivity da2 = ActivityXamlServices.Load(new StringReader(serializedAB)) as DynamicActivity;

  26:  var result = WorkflowInvoker.Invoke(da2, new Dictionary<string,object> { {"input1","hello"}, {"input2", "world" }});

  27:  Console.WriteLine("result text is {0}", result["output"]);

28:

29:

  30:  ActivityBuilder ab = XamlServices.Load(

  31:      ActivityXamlServices.CreateBuilderReader(

  32:          new XamlXmlReader(new StringReader(serializedAB)))) as ActivityBuilder;

33:

  34:  Console.WriteLine("there are {0} arguments in the activity builder", ab.Properties.Count);

  35:  Console.WriteLine("Press enter to exit");

  36:  Console.ReadLine();

Good luck, and happy metatyping!

Types, Metatypes and Bears, Oh my!

mwinkle — Tue, 09 Jun 2009 23:23:00 GMT

* UPDATE: Please see this post for how these features and functionality work in Beta2 *

image courtesy of flickr user chodhound

This post comes about after a little conversation on the forums where I was talking about using the xaml stack save and load objects.

Here’s what I said:

Bob (it's a little late in Seattle, so I don't have a code editor handy, so there may be some minor errors below),
If you want to serialize any object graph to xaml, simply look at the XamlServices.Save() api that's in System.Xaml. I'm sure there are a few SDK samples around that as well. It takes in a file name to output to, a text writer or a stream, so you get to pick your poison for destination. Similarly, if you want to get an object graph deserialized from Xaml, you can just use XamlServices.Load() again, with overloads for files, streams, text, xml, and xaml readers.
To see this API, just do something like
Sequence s = new Sequence { Activities = { new Persist(), new Persist() } };
XamlServices.Save(fileNameVar, s);
If you want to read, basically do the reverse.
Save and Load are convinient helper functions to operate on the whole of the doc, there Xaml stack surfaces much more programmability and has a nice node stream style API that lets you plug in while nodes are being read and written.
Now, if you want to deserialize a Xaml file that contains an x:Class directive, you are going to need to do a bit more work (and it depends what you want to serialize to or from). I'll try to blog about that in the next week or so.

Now, I want to take a little bit of time to explain the last part.

A convenient way to think about XAML is a way to write down objects, really, instances of objects. That said I am not limited to writing down just instances, I can actually write down type definitions as well. I do this using the x:Class attribute.

Consider the following XAML snippet

<Activity x:Class="foo" ...

This is roughly equivalent to the following C#

public class foo : Activity
{
...

Now, “normally” what happens with XAML like this in .xaml files is that it is used in a VS project and it is set up so that there is a build task who has the job of generating a type from that XAML so that you can use that type subsequently in your application. This works basically the same way for WPF as well as WF.

However, if you think about trying simply deserialize this, it’s a little confusing what this will actually deserialize to. This is a type definition, so if you simply try to pass it to XamlServices.Load(), you will encounter an exception:

Error System.Xaml.XamlObjectWriterException: No matching constructor found on type System.Activities.Activity. You can use the Arguments or FactoryMethod direct ives to construct this type. ---> System.MissingMethodException: No default constructor found for type System.Activities.Activity. You can use the Arguments or FactoryMethod directives to construct this type.
   at System.Xaml.Runtime.ClrObjectRuntime.DefaultCtorXamlActivator.EnsureConstructorDelegate(XamlType xamlType)
   at System.Xaml.Runtime.ClrObjectRuntime.DefaultCtorXamlActivator.CreateInstance(XamlType xamlType)
   at System.Xaml.Runtime.ClrObjectRuntime.CreateInstanceWithCtor(XamlType xamlType, Object[] args)
   at System.Xaml.Runtime.ClrObjectRuntime.CreateInstance(XamlType xamlType, Object[] args)
   --- End of inner exception stack trace ---

So, if we want to deserialize that, we need to ask the question first: “Why do we want to deserialize it?”

Deserialize to Execute

If we want to simply use the activity we’ve created and have it execute, we have a special type, DynamicActivity. DynamicActivity lets you execute the activity, and rather than creating a type for it, will allow you to pass in the arguments in the typical Dictionary<string,object> way that we are used to.

Imagine a xaml file, just sitting on disk somewhere that looks like this (a workflow that concats two strings):

<p:Activity mc:Ignorable=""
    x:Class="WorkflowConsoleApplication1.Sequence1" 
     xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities/design"
     xmlns:__Sequence1="clr-namespace:WorkflowConsoleApplication1;" 
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
     xmlns:p="http://schemas.microsoft.com/netfx/2009/xaml/activities" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <x:Members>
    <x:Property Name="argument1" Type="p:InArgument(x:String)" />
    <x:Property Name="argument2" Type="p:InArgument(x:String)" />
  </x:Members>
  <p:Sequence>
    <p:WriteLine>[argument1 + " " + argument2]</p:WriteLine>
  </p:Sequence>
</p:Activity>

The code for this is the following:

object o = WorkflowXamlServices.Load(File.OpenRead("Sequence1.xaml"));
Console.WriteLine("Success {0}", o.GetType());
DynamicActivity da = o as DynamicActivity;da.Properties.ToList().ForEach(ap => Console.WriteLine("argument: {0}", ap.Name));
WorkflowInvoker.Invoke(da, new Dictionary<string, object> { { "argument1", "foo" }, { "argument2", "bar" } });

Deserialize to “Design”

At design time, we have an even more interesting problem. Our designer is an instance editor, and, as such, it must always edit an instance of “something”. In our case, we actually do some work in our design time xaml reader and writer to deserialize into a metatype, an instance of a type whose sole purpose in life is to describe the activity. In Beta1, this is called ActivitySchemaType. ActivitySchemaType simply models the type structure of an activity, complete with properties, etc If you want to construct an instance of an ActivitySchemaType in code, you can, and then you could use the DesignTimeXamlWriter in order to properly serialize out to an Activity x:class xaml file. The following code works on an ActivitySchemaType in memory and then serializes it:

XamlSchemaContext xsc = new XamlSchemaContext();
ActivitySchemaType ast = new ActivitySchemaType()
{
    Name = "foo",
    Members = 
     {
        new Property { Name="argument1", Type = xsc.GetXamlType(typeof(InArgument<string>)) }

     },
    Body = new Sequence { Activities = { new Persist(), new Persist() } }
};
StringBuilder sb = new StringBuilder();

DesignTimeXamlWriter dtxw = new DesignTimeXamlWriter(
    new StringWriter(sb),
    xsc, "foo", "bar.rock");

XamlServices.Save(dtxw, ast);
Console.WriteLine("you wrote:");
ConsoleColor old = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.WriteLine(sb.ToString());
Console.ForegroundColor = old;

This is what the output looks like:

<p:Activity mc:Ignorable=""
     x:Class="foo" 
     xmlns="http://schemas.microsoft.com/netfx/2009/xaml/activities/design" 
     xmlns:__foo="clr-namespace:bar.rock;" 
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
     xmlns:p="http://schemas.microsoft.com/netfx/2009/xaml/activities" 
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <x:Members>
    <x:Property Name="argument1" Type="p:InArgument(x:String)" />
  </x:Members>
  <p:Sequence>
    <p:Persist />
    <p:Persist />
  </p:Sequence>
</p:Activity>

If you want to read in from this, you have to do a little bit of trickery with the designer as DesignTimeXamlReader is not a public type in beta1.

WorkflowDesigner wd = new WorkflowDesigner();
wd.Load("Sequence1.xaml");
object obj = wd.Context.Services.GetService<ModelService>().Root.GetCurrentValue();
Console.WriteLine("object read type: {0}", obj.GetType());
ActivitySchemaType schemaType = obj as ActivitySchemaType;
Console.WriteLine("schema type name: {0}", schemaType.Name);
schemaType.Members.ToList().ForEach(p => Console.WriteLine("argument: {0}, type: {1}", p.Name, p.Type));

That wraps up our tour of the ways to read (and write) <Activity x:Class xaml

Here’s the full text of the little program I put together to execute this, also make sure to drop a sequence1.xaml into your execution directory if you want this to not throw :-)

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xaml;

using System.Activities.Statements;

using System.Activities;

using System.IO;

using System.Activities.Design.Xaml;

using System.Windows.Markup;

using System.Xml;

using System.Activities.Design;

using System.Activities.Design.Services;

namespace ConsoleApplication2

    class Program

        [STAThread()]

        static void Main(string[] args)

            bool doStuff = true;

            Guid g = Guid.NewGuid();

            while (doStuff)

                Console.WriteLine();

                Console.WriteLine("What do you want to do?");

                Console.WriteLine("    read [x]:class xaml with XamlServices");

                Console.WriteLine("    read x:class xaml with W[o]rkflowXamlServices");

                Console.WriteLine("    [w]rite an ActivitySchemaType");

                Console.WriteLine("    r[e]ad an ActivitySchemaType");

                Console.WriteLine("    [q]uit");

                Console.WriteLine();

                char c = Console.ReadKey(true).KeyChar;

                switch (c)

                    case 'w':

                        XamlSchemaContext xsc = new XamlSchemaContext();

                        ActivitySchemaType ast = new ActivitySchemaType()

                            Name = "foo",

                            Members =

                                new Property { Name="argument1", Type = xsc.GetXamlType(typeof(InArgument<string>)) }

},

                            Body = new Sequence { Activities = { new Persist(), new Persist() } }

};

                        StringBuilder sb = new StringBuilder();

                        DesignTimeXamlWriter dtxw = new DesignTimeXamlWriter(

                            new StringWriter(sb),

                            xsc, "foo", "bar.rock");

                        XamlServices.Save(dtxw, ast);

                        Console.WriteLine("you wrote:");

                        ConsoleColor old = Console.ForegroundColor;

                        Console.ForegroundColor = ConsoleColor.DarkGray;

                        Console.WriteLine(sb.ToString());

                        Console.ForegroundColor = old;

                        break;

                    case 'x':

try

                            object o = XamlServices.Load(File.OpenRead("Sequence1.xaml"));

                            Console.WriteLine("Success{0}", o.GetType());

                        catch (Exception ex)

                            Console.WriteLine("Error {0}", ex);

                        break;

                    case 'o':

try

                            object o = WorkflowXamlServices.Load(File.OpenRead("Sequence1.xaml"));

                            Console.WriteLine("Success {0}", o.GetType());

                            DynamicActivity da = o as DynamicActivity;

                            da.Properties.ToList().ForEach(ap => Console.WriteLine("argument: {0}", ap.Name));

                            WorkflowInvoker.Invoke(da, new Dictionary<string, object> { { "argument1", "foo" }, { "argument2", "bar" } });

                        catch (Exception ex)

                            Console.WriteLine("Error {0}", ex);

                        break;

                    case 'e':

                        WorkflowDesigner wd = new WorkflowDesigner();

                        wd.Load("Sequence1.xaml");

                        object obj = wd.Context.Services.GetService<ModelService>().Root.GetCurrentValue();

                        Console.WriteLine("object read type: {0}", obj.GetType());

                        ActivitySchemaType schemaType = obj as ActivitySchemaType;

                        Console.WriteLine("schema type name: {0}", schemaType.Name);

                        schemaType.Members.ToList().ForEach(p => Console.WriteLine("argument: {0}, type: {1}", p.Name, p.Type));

                        break;

                    case 'q':

                        doStuff = false;

                        break;

                    default:

                        break;

            Console.WriteLine("All done");

            Console.ReadLine();

        private static object CreateWfObject()

            return new Sequence { Activities = { new Persist(), new Persist() } };

	Name	Description
	CreateBuilderReader	Overloaded. Maps an x:Class activity tree to an ActivityBuilder or ActivityBuilder<(Of <(TResult>)>).
	CreateBuilderWriter	Maps an ActivityBuilder or ActivityBuilder<(Of <(TResult>)>) from the specified writer to an x:Class activity tree.
	CreateReader	Overloaded. Maps an x:Class activity tree to an DynamicActivity or DynamicActivity<(Of <(TResult>)>).
	Load	Overloaded. Creates an instance of a declarative workflow.