MyXaml - Support

Support

About

Frequently Asked Questions

What Is MyXaml?
Umm, What Did That Mean?
Why Use MyXaml?
OK, Why Use Markup For Presentation Layer (PL)?
Can I Use Third Party Controls?
Is It The Same As Longhorn's Markup?
Then Is It Better Than Longhorn's Markup?
What About A Form Designer?
What About Generating Code?
What About Security?
What About Performance?
Why Open Source?
Where Is The Open Source Project Being Hosted?
Never Mind Donating Time; How Do I Donate Money?
Have More Questions?

MyXaml is a general class instantiator capable of initializing properties, wiring up events to event handlers, and drilling down into property collections, customizable with inline or code-behind, language non-specific, JIT assembling at runtime.

Umm, What Did That Mean?

With MyXaml, you can instantiate presentation layer components such as forms and controls through markup rather than code.

You can initialize properties like color, state, captions, and collections.

You can write in-line code that is assembled and instantiated along with the form--handle events, initialize data sets, and so forth. You can write this code in whatever language is supported by .NET.

You can tie in to compile-time code also.

And, nothing says you are limited to doing this with presentation layer components. Want to instantiate a connection to a database specified using markup? No problem.

Why Use MyXaml?

It's open source.

It's extensible. Need to customize the markup tags for your own needs? Go right ahead!

It's lightweight. Basically, MyXaml is just a parser. There isn't any complex, hard to learn Document Object Model (DOM) that's going to change every couple of years, forcing you to learn a new architecture.

OK, Why Use Markup For Presentation Layer (PL)?

The presentation layer is runtime generated. Meaning you can make changes to your presentation layer without bringing down the application. With in-lined code, you can also change how events in the presentation layer are processed.

It cleanly separates the presentation layer from the code.

Example: If you want to move some elements around, change the markup (or use the markup designer) without ever touching code.

Example: If you want to change a ComboBox to a ListBox, change the markup and your done. Use the engine's property getters for obtaining state information, which decouples the instance from the property--no need to change the control type in your code!

It naturally lends itself to organizing your views in logical blocks. This means that it's easy to extend or change a particular view.

Reuse. Need I say more? OK--copy and paste your login screen in about 10 seconds. Got a guest book screen you like? Import the .xaml file!

Style sheets. Want to change the look of your entire application? A few dialogs? MyXaml's style sheets make this a breeze.

Can I Use Third Party Controls?

Absolutely. Map the assembly in your markup, assign a namespace prefix, and you can instantiate any class, initialize properties, and wire up events.

Is It The Same As Longhorn's Markup?

No. There are similarities because both use XML, but they are different.

Then Is It Better Than Longhorn's Markup?

(Would I say anything but *yes*???) Actually, the comparison is not really valid. Longhorn isn't available yet. MyXaml is. Avalon is a completely different architecture from the Windows.Forms namespace, so it's sort of like comparing apples to oranges, and it gets confusing because you have to keep a clear distinction between the markup itself and the namespaces and classes that it manipulates. Because MyXaml doesn't use a DOM, things like "Canvas" and "NavigatableApplication" are really just dumb tags (no pun intended). When Longhorn does come out, MyXaml should be able to work with the MSAvalon namespace as easily as it does with the any other namespace.

However, there are differences in the XML markup style, which I will enumerate here:

MyXaml uses a consistent syntax with regards to tags that represent classes and properties.
MyXaml does not require the compound property syntax
MyXaml does not confuse the meaning of a tag--a tag is always a class, rather than sometimes a class, sometimes a class type, sometimes a method.
MyXaml markup has a 1:1 relationship to the underlying class hierarchy that it instantiates.
MyXaml implements custom parsing as extensions to the core parser rather than embedded in the core parser
Using MyXaml, the serialization of a class can follow straight forward and simple rules regarding properties and collections
MyXaml does not expect, use, nor require the developer to implement an IChild interface that hides the implementing collection for child nodes.
Drew Marsh wrote: ...Personally, I think [Microsoft] XAML has everyone confused as hell right now. Microsoft currently has it packaged as if it belongs solely to Avalon....The core, abstract concepts of XAML are really easy to understand if you take away the more concrete, complex, Avalon specific samples...Personally, I think that XAML needs to be taken out from under the Avalon umbrella and packaged as a generic engine. Then the Avalon side of the story simply becomes one of re-use and specialization of that engine. -- That's what MyXaml is--a generic engine.
MyXaml does not compromise readability for toolability, nor vice versa. It implements an intelligent symbiotic relationship between the two.

What About A Form Designer?

In the works. Including a form designer that generates code stubs and event handlers for your MVC architecture, which is something that MyXaml fits right in to.

What About Generating Code?

This is coming.

What About Security?

This is being addressed.

What About Performance?

If you have concerns about performance, you can generate compile-time code based on the markup.

Why Open Source?

Ultimately, I've put more time into this website than into the parser and some of the utilities (that probably says something about my web design skills). The point is, this wasn't really a major effort. I wanted to share it with the community and hopefully have the community share back. MyXaml is really just a piece of a much bigger solution when it comes to developing applications, whether client, web, distributed, mobile, or other application architectures. And, right or wrong, that's where I feel that the consulting services and some "heavy-weight" products can really be leveraged. As an open source effort, the people who are involved in the effort gain knowledge and have fun. And knowledge is the key--working on this project, you'll become more knowledgeable regarding XAML, MVC architecture, and unit testing (to mention a few key points). This means you'll be more valuable to the rest of the community. And that's a good thing.