public static bool TryParse (string typeName, IXamlNamespaceResolver namespaceResolver, out XamlTypeName result)
{
if (typeName == null)
throw new ArgumentNullException ("typeName");
if (namespaceResolver == null)
throw new ArgumentNullException ("namespaceResolver");
result = null;
IList<XamlTypeName> args = null;
int nArray = 0;
int idx;
if (typeName.Length > 2 && typeName [typeName.Length - 1] == ']') {
idx = typeName.LastIndexOf ('[');
if (idx < 0)
return false; // mismatch brace
nArray = 1;
for (int i = idx + 1; i < typeName.Length - 1; i++) {
if (typeName [i] != ',')
return false; // only ',' is expected
nArray++;
}
if (!TryParse (typeName.Substring (0, idx), namespaceResolver, out result))
return false;
// Weird result, but Name ends with '[]'
result = new XamlTypeName (result.Namespace, result.Name + '[' + new string (',', nArray - 1) + ']', result.TypeArguments);
return true;
}
idx = typeName.IndexOf ('(');
if (idx >= 0) {
if (typeName [typeName.Length - 1] != ')')
return false;
if (!TryParseList (typeName.Substring (idx + 1, typeName.Length - idx - 2), namespaceResolver, out args))
return false;
typeName = typeName.Substring (0, idx);
}
idx = typeName.IndexOf (':');
string prefix, local;
if (idx < 0) {
prefix = String.Empty;
local = typeName;
} else {
prefix = typeName.Substring (0, idx);
local = typeName.Substring (idx + 1);
if (!XamlLanguage.IsValidXamlName (prefix))
return false;
}
if (!XamlLanguage.IsValidXamlName (local))
return false;
string ns = namespaceResolver.GetNamespace (prefix);
if (ns == null)
return false;
result = new XamlTypeName (ns, local, args);
return true;
}
protected override XamlType GetXamlType(string xamlNamespace, string name, params XamlType[] typeArguments)
{
EnsureXmlnsAssembliesLoaded(xamlNamespace);
XamlTypeName fullTypeName = new XamlTypeName { Namespace = xamlNamespace, Name = name };
if (typeArguments != null)
{
foreach (XamlType typeArg in typeArguments)
{
fullTypeName.TypeArguments.Add(new XamlTypeName(typeArg));
}
}
return _parentSchemaContext.GetXamlType(fullTypeName);
}
Type TypeFromXamlType(SysXamlTypeName xty)
{
if (xty.TypeArguments.Count > 0)
{
var nxty = new SysXamlTypeName(xty.Namespace, xty.Name);
var tyary = new Type[xty.TypeArguments.Count];
for (int i = 0; i < tyary.Length; i++)
{
tyary[i] = TypeFromXamlType(xty.TypeArguments[i]);
}
return(SchCtxt.GetXamlType(nxty).UnderlyingType.MakeGenericType(tyary));
}
return(SchCtxt.GetXamlType(xty).UnderlyingType);
}
public static Type TypeFromXamlType(SysXamlTypeName xty, XamlSchemaContext sch)
{
if (xty.TypeArguments.Count > 0)
{
var nxty = new SysXamlTypeName(xty.Namespace, xty.Name);
var tyary = new Type[xty.TypeArguments.Count];
for (int i = 0; i < tyary.Length; i++)
{
tyary[i] = TypeFromXamlType(xty.TypeArguments[i], sch);
}
return(sch.GetXamlType(nxty).UnderlyingType.MakeGenericType(tyary));
}
return(sch.GetXamlType(xty).UnderlyingType);
}
public XamlMember GetDottedProperty(XamlType tagType, string tagNamespace, XamlPropertyName propName, bool tagIsRoot)
{
if (tagType == null)
{
throw new XamlInternalException(System.Xaml.SR.Get("ParentlessPropertyElement", new object[] { propName.ScopedName }));
}
XamlMember xamlAttachableProperty = null;
XamlType xamlType = null;
string propNs = this.ResolveXamlNameNS(propName);
if (propNs == null)
{
throw new XamlParseException(System.Xaml.SR.Get("PrefixNotFound", new object[] { propName.Prefix }));
}
XamlType rootTagType = tagIsRoot ? tagType : null;
bool flag = false;
if (tagType.IsGeneric)
{
flag = this.PropertyTypeMatchesGenericTagType(tagType, tagNamespace, propNs, propName.OwnerName);
if (flag)
{
xamlAttachableProperty = this.GetInstanceOrAttachableProperty(tagType, propName.Name, rootTagType);
if (xamlAttachableProperty != null)
{
return xamlAttachableProperty;
}
}
}
XamlTypeName typeName = new XamlTypeName(propNs, propName.Owner.Name);
xamlType = this.GetXamlType(typeName, true);
bool flag2 = tagType.CanAssignTo(xamlType);
if (flag2)
{
xamlAttachableProperty = this.GetInstanceOrAttachableProperty(xamlType, propName.Name, rootTagType);
}
else
{
xamlAttachableProperty = this.GetXamlAttachableProperty(xamlType, propName.Name);
}
if (xamlAttachableProperty != null)
{
return xamlAttachableProperty;
}
XamlType declaringType = flag ? tagType : xamlType;
if (flag || flag2)
{
return this.CreateUnknownMember(declaringType, propName.Name);
}
return this.CreateUnknownAttachableMember(declaringType, propName.Name);
}
SysXamlTypeName BuildSysXamlTypeName(XamlTypeName xty)
{
string name = xty.Name;
if (_Delimeter != (TypeExtensionDelimeter)'`')
{
name = xty.Name.Replace((char)_Delimeter, '`');
}
if (xty.TypeArguments.Count > 0)
{
var args = new SysXamlTypeName[xty.TypeArguments.Count];
for (int i = 0; i < args.Length; i++)
{
args[i] = BuildSysXamlTypeName(xty.TypeArguments[i]);
}
return(new SysXamlTypeName(xty.Namespace, name, args));
}
return(new SysXamlTypeName(xty.Namespace, name));
}
public static bool TryParse (string typeName, IXamlNamespaceResolver namespaceResolver, out XamlTypeName result)
{
if (typeName == null)
throw new ArgumentNullException ("typeName");
if (namespaceResolver == null)
throw new ArgumentNullException ("namespaceResolver");
result = null;
IList<XamlTypeName> args = null;
int idx = typeName.IndexOf ('(');
if (idx >= 0) {
if (typeName [typeName.Length - 1] != ')')
return false;
if (!TryParseList (typeName.Substring (idx + 1, typeName.Length - idx - 2), namespaceResolver, out args))
return false;
typeName = typeName.Substring (0, idx);
}
idx = typeName.IndexOf (':');
string prefix, local;
if (idx < 0) {
prefix = String.Empty;
local = typeName;
} else {
prefix = typeName.Substring (0, idx);
local = typeName.Substring (idx + 1);
if (!XamlLanguage.IsValidXamlName (prefix))
return false;
}
if (!XamlLanguage.IsValidXamlName (local))
return false;
string ns = namespaceResolver.GetNamespace (prefix);
if (ns == null)
return false;
result = new XamlTypeName (ns, local, args);
return true;
}
public void ToStringNamespaceNull ()
{
// allowed.
var n = new XamlTypeName (null, "FooBar");
n.ToString ();
}
internal XamlType GetXamlType(XamlTypeName typeName)
{
return this.GetXamlType(typeName, false, false);
}
public static bool TryParse(string typeName, IXamlNamespaceResolver namespaceResolver, out XamlTypeName result)
{
string str;
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
if (namespaceResolver == null)
{
throw new ArgumentNullException("namespaceResolver");
}
result = ParseInternal(typeName, new Func<string, string>(namespaceResolver.GetNamespace), out str);
return (result != null);
}
private static XamlType GetXamlTypeOrUnknown(XamlSchemaContext schemaContext, XamlTypeName typeName)
{
XamlType result = schemaContext.GetXamlType(typeName);
if (result != null)
{
return(result);
}
XamlType[] typeArgs = null;
if (typeName.HasTypeArgs)
{
typeArgs = new XamlType[typeName.TypeArguments.Count];
for (int i = 0; i < typeName.TypeArguments.Count; i++)
{
typeArgs[i] = GetXamlTypeOrUnknown(schemaContext, typeName.TypeArguments[i]);
}
}
result = new XamlType(typeName.Namespace, typeName.Name, typeArgs, schemaContext);
return(result);
}
private bool ProcessCurrentNode()
{
bool flag = false;
this.namespaceTable.ManageNamespace(this.innerReader);
switch (this.innerReader.NodeType)
{
case XamlNodeType.StartObject:
this.EnterObject();
if (this.depth != 1)
{
goto Label_049A;
}
if (!(this.innerReader.Type.UnderlyingType == typeof(Activity)))
{
if ((this.innerReader.Type.IsGeneric && (this.innerReader.Type.UnderlyingType != null)) && (this.innerReader.Type.UnderlyingType.GetGenericTypeDefinition() == typeof(Activity<>)))
{
System.Type type2;
this.activityXamlType = this.innerReader.Type;
System.Type underlyingType = this.innerReader.Type.TypeArguments[0].UnderlyingType;
if (this.isBuilder)
{
type2 = typeof(ActivityBuilder<>).MakeGenericType(new System.Type[] { underlyingType });
}
else
{
type2 = typeof(DynamicActivity<>).MakeGenericType(new System.Type[] { underlyingType });
}
this.activityReplacementXamlType = this.SchemaContext.GetXamlType(type2);
}
else
{
this.DisableRewrite();
return false;
}
break;
}
this.activityXamlType = this.innerReader.Type;
if (!this.isBuilder)
{
this.activityReplacementXamlType = this.SchemaContext.GetXamlType(typeof(DynamicActivity));
break;
}
this.activityReplacementXamlType = this.SchemaContext.GetXamlType(typeof(ActivityBuilder));
break;
case XamlNodeType.GetObject:
this.EnterObject();
goto Label_049A;
case XamlNodeType.EndObject:
case XamlNodeType.EndMember:
this.ExitObject();
goto Label_049A;
case XamlNodeType.StartMember:
{
XamlMember member = this.innerReader.Member;
if (!this.IsXClassName(member.DeclaringType))
{
if (this.frontLoadedDirectives && (member == XamlLanguage.FactoryMethod))
{
this.DisableRewrite();
return false;
}
this.depth++;
if (this.depth != 2)
{
if (this.bufferMembers)
{
this.currentBuilderMember = new BuilderMemberNode(this, this.depth);
this.innerReader.Read();
return true;
}
}
else if ((member.DeclaringType != this.activityXamlType) && (member.DeclaringType != this.baseActivityXamlType))
{
if (member != XamlLanguage.Class)
{
if (member == XamlLanguage.Members)
{
if (this.bufferedProperties == null)
{
this.bufferedProperties = new BufferedPropertyList(this);
}
this.bufferedProperties.BufferDefinitions(this);
this.depth--;
return true;
}
if (member == XamlLanguage.ClassAttributes)
{
this.nodeQueue.Writer.WriteStartMember(this.activityReplacementXamlType.GetMember("Attributes"), this.innerReaderLineInfo);
this.WriteWrappedMember(false);
flag = true;
return true;
}
}
else
{
this.inXClassDepth = this.depth;
this.nodeQueue.Writer.WriteStartMember(this.activityReplacementXamlType.GetMember("Name"), this.innerReaderLineInfo);
flag = true;
}
}
else
{
XamlMember xamlMember = this.activityReplacementXamlType.GetMember(member.Name);
if (xamlMember == null)
{
throw FxTrace.Exception.AsError(CreateXamlException(System.Activities.SR.MemberNotSupportedByActivityXamlServices(member.Name), this.innerReaderLineInfo));
}
this.nodeQueue.Writer.WriteStartMember(xamlMember, this.innerReaderLineInfo);
if (xamlMember.Name == "Constraints")
{
this.WriteWrappedMember(true);
flag = true;
return true;
}
flag = true;
if (this.isBuilder && (xamlMember.Name == "Implementation"))
{
this.bufferMembers = true;
}
}
goto Label_049A;
}
if (this.bufferedProperties == null)
{
this.bufferedProperties = new BufferedPropertyList(this);
}
this.bufferedProperties.BufferDefaultValue(member.Name, this.activityPropertyValue, this.innerReader, this.innerReaderLineInfo);
return true;
}
case XamlNodeType.Value:
if ((this.inXClassDepth >= this.depth) && (this.xClassName == null))
{
string str = (string) this.innerReader.Value;
string xamlNamespace = "";
string name = str;
int length = str.LastIndexOf('.');
if (length > 0)
{
xamlNamespace = str.Substring(0, length);
name = str.Substring(length + 1);
}
this.xClassName = new XamlTypeName(xamlNamespace, name);
}
goto Label_049A;
default:
goto Label_049A;
}
this.nodeQueue.Writer.WriteStartObject(this.activityReplacementXamlType, this.innerReaderLineInfo);
flag = true;
Label_049A:
if (!flag)
{
if ((this.currentBuilderMember != null) && (this.depth >= this.currentBuilderMember.Depth))
{
bool flag2 = this.currentBuilderMember.ProcessNode(this.innerReader, this.nodeQueue.Writer, this.depth, this.innerReaderLineInfo);
if (!flag2)
{
bool exitObject = this.currentBuilderMember.ExitObject;
this.currentBuilderMember = null;
if (exitObject)
{
this.ExitObject();
this.ExitObject();
}
}
return flag2;
}
this.nodeQueue.Writer.WriteNode(this.innerReader, this.innerReaderLineInfo);
}
return false;
}
void ReadStartMember ()
{
var xt = types.Peek ();
var name = r.LocalName;
int idx = name.IndexOf ('.');
if (idx >= 0) {
string tname = name.Substring (0, idx);
var xtn = new XamlTypeName (r.NamespaceURI, tname, null);
xt = SchemaContext.GetXamlType (xtn) ?? new XamlType (xtn.Namespace, xtn.Name, null, SchemaContext);
name = name.Substring (idx + 1);
}
var xm = (XamlMember) FindStandardDirective (name, AllowedMemberLocations.MemberElement) ?? xt.GetAttachableMember (name) ?? xt.GetMember (name);
if (xm == null)
// create unknown member.
xm = new XamlMember (name, xt, false); // FIXME: not sure if isAttachable is always false.
current = current_member = xm;
members.Push (xm);
node_type = XamlNodeType.StartMember;
inside_object_not_member = false;
r.Read ();
}
public void ToStringNamespaceLookupInsufficient ()
{
var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
var lookup = new MyNamespaceLookup ();
lookup.Add ("a", "urn:foo");
lookup.Add ("c", "urn:baz");
// it fails because there is missing mapping for urn:bar.
Assert.AreEqual ("a:Foo({urn:bar}Bar, c:Baz)", n.ToString (lookup), "#1");
}
private XamlType GetXamlTypeOrUnknown(XamlTypeName typeName)
{
return this.GetXamlType(typeName, true);
}
public void ToStringEmptyNamespace ()
{
var n = new XamlTypeName (string.Empty, "Foo");
Assert.AreEqual ("{}Foo", n.ToString (), "#1");
}
public void ToStringXamlTypePredefined ()
{
var n = new XamlTypeName (XamlLanguage.Int32);
Assert.AreEqual ("{http://schemas.microsoft.com/winfx/2006/xaml}Int32", n.ToString (), "#1");
}
public void ToStringTypeArguments2 ()
{
var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
Assert.AreEqual ("{urn:foo}Foo({urn:bar}Bar, {urn:baz}Baz)", n.ToString (), "#1");
}
public void ToStringTypeArgumentsNullEntry ()
{
var n = new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [] {null, new XamlTypeName ("urn:bar", "FooBarBaz")});
Assert.AreEqual ("{urn:foo}FooBar()", n.ToString (), "#1");
}
public void ToStringTypeArgumentsNull ()
{
var n = new XamlTypeName ("urn:foo", "FooBar", (XamlTypeName []) null);
Assert.AreEqual ("{urn:foo}FooBar", n.ToString (), "#1");
}
internal XamlType GetXamlType(XamlTypeName typeName, bool returnUnknownTypesOnFailure)
{
return this.GetXamlType(typeName, returnUnknownTypesOnFailure, false);
}
public void ToStringNullLookup ()
{
var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
Assert.AreEqual ("{urn:foo}Foo({urn:bar}Bar, {urn:baz}Baz)", n.ToString (null), "#1");
}
internal XamlType GetXamlType(XamlTypeName typeName, bool returnUnknownTypesOnFailure, bool skipVisibilityCheck)
{
XamlType xamlType = this._schemaContext.GetXamlType(typeName);
if (((xamlType != null) && !skipVisibilityCheck) && !xamlType.IsVisibleTo(this.LocalAssembly))
{
xamlType = null;
}
if ((xamlType != null) || !returnUnknownTypesOnFailure)
{
return xamlType;
}
XamlType[] typeArguments = null;
if (typeName.HasTypeArgs)
{
typeArguments = ArrayHelper.ConvertArrayType<XamlTypeName, XamlType>(typeName.TypeArguments, new Func<XamlTypeName, XamlType>(this.GetXamlTypeOrUnknown));
}
return new XamlType(typeName.Namespace, typeName.Name, typeArguments, this.SchemaContext);
}
public void ToStringNamespaceLookup ()
{
var n = new XamlTypeName ("urn:foo", "Foo", new XamlTypeName [] {new XamlTypeName ("urn:bar", "Bar"), new XamlTypeName ("urn:baz", "Baz")});
var lookup = new MyNamespaceLookup ();
lookup.Add ("a", "urn:foo");
lookup.Add ("b", "urn:bar");
lookup.Add ("c", "urn:baz");
Assert.AreEqual ("a:Foo(b:Bar, c:Baz)", n.ToString (lookup), "#1");
Assert.AreEqual ("b:Bar, c:Baz", XamlTypeName.ToString (n.TypeArguments, lookup), "#2");
}
public void ToStringDefault ()
{
var n = new XamlTypeName ();
n.ToString ();
}
public static bool TryParseList (string typeNameList, IXamlNamespaceResolver namespaceResolver, out IList<XamlTypeName> list)
{
if (typeNameList == null)
throw new ArgumentNullException ("typeNameList");
if (namespaceResolver == null)
throw new ArgumentNullException ("namespaceResolver");
list = null;
var split = typeNameList.Split (commas);
if (split.Length == 0)
return false;
var arr = new XamlTypeName [split.Length];
for (int i = 0; i < split.Length; i++) {
var s = split [i].Trim ();
XamlTypeName tn;
if (!TryParse (s, namespaceResolver, out tn))
return false;
arr [i] = tn;
}
list = arr;
return true;
}
void ReadStartTypeOrContentGetObject ()
{
string name = r.LocalName;
string ns = r.NamespaceURI;
string typeArgNames = null;
var members = new List<Pair> ();
var atts = ProcessAttributes (members);
// check TypeArguments to resolve Type, and remove them from the list. They don't appear as a node.
var l = new List<Pair> ();
foreach (var p in members) {
if (p.Key == XamlLanguage.TypeArguments) {
typeArgNames = p.Value;
l.Add (p);
break;
}
}
foreach (var p in l)
members.Remove (p);
XamlType xt;
IList<XamlTypeName> typeArgs = typeArgNames == null ? null : XamlTypeName.ParseList (typeArgNames, xaml_namespace_resolver);
var xtn = new XamlTypeName (ns, name, typeArgs);
xt = sctx.GetXamlType (xtn);
if (xt == null) {
// creates name-only XamlType. Also, it does not seem that it does not store this XamlType to XamlSchemaContext (Try GetXamlType(xtn) after reading such xaml node, it will return null).
xt = new XamlType (ns, name, typeArgs == null ? null : typeArgs.Select<XamlTypeName,XamlType> (xxtn => sctx.GetXamlType (xxtn)).ToArray (), sctx);
}
if (current_member != null && !xt.CanAssignTo (current_member.Type)) {
var pxt = types.Count > 0 ? types.Peek () : null;
if (pxt != null && pxt.ContentProperty == current_member) {
SetGetObject ();
return;
}
// It could still be GetObject if current_member
// is not a directive and current type is not
// a markup extension.
// (I'm not very sure about the condition;
// it could be more complex.)
// seealso: bug #682131
if (!get_flags.Peek () &&
!(current_member is XamlDirective) &&
!xt.IsMarkupExtension) {
SetGetObject ();
return;
}
}
types.Push (xt);
get_flags.Push (false);
current = xt;
if (!r.IsEmptyElement) {
r.Read ();
do {
r.MoveToContent ();
switch (r.NodeType) {
case XmlNodeType.Element:
// FIXME: parse type arguments etc.
case XmlNodeType.EndElement:
break;
default:
// this value is for Initialization, or Content property value
if (xt.ContentProperty != null)
members.Add (new Pair (xt.ContentProperty, r.Value));
else
members.Add (new Pair (XamlLanguage.Initialization, r.Value));
r.Read ();
continue;
}
break;
} while (true);
}
else
is_empty_object = true;
foreach (var p in atts) {
int idx = p.Key.IndexOf (':');
string prefix = idx > 0 ? p.Key.Substring (0, idx) : String.Empty;
string aname = idx > 0 ? p.Key.Substring (idx + 1) : p.Key;
idx = aname.IndexOf ('.');
if (idx > 0) {
string apns = prefix.Length > 0 ? r.LookupNamespace (prefix) : r.NamespaceURI;
var apname = aname.Substring (0, idx);
var axtn = new XamlTypeName (apns, apname, null);
var at = sctx.GetXamlType (axtn);
var am = at.GetAttachableMember (aname.Substring (idx + 1));
if (am != null)
members.Add (new Pair (am, p.Value));
// ignore unknown attribute
}
var xm = xt.GetMember (aname);
if (xm != null)
members.Add (new Pair (xm, p.Value));
// ignore unknown attribute
}
node_type = XamlNodeType.StartObject;
inside_object_not_member = true;
// The next Read() results are likely directives.
stored_member_enumerator = members.GetEnumerator ();
}
public static bool TryParse(string typeName, IXamlNamespaceResolver namespaceResolver, out XamlTypeName result)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
if (namespaceResolver == null)
{
throw new ArgumentNullException("namespaceResolver");
}
result = null;
IList <XamlTypeName> args = null;
int nArray = 0;
int idx;
if (typeName.Length > 2 && typeName [typeName.Length - 1] == ']')
{
idx = typeName.LastIndexOf('[');
if (idx < 0)
{
return(false); // mismatch brace
}
nArray = 1;
for (int i = idx + 1; i < typeName.Length - 1; i++)
{
if (typeName [i] != ',')
{
return(false); // only ',' is expected
}
nArray++;
}
if (!TryParse(typeName.Substring(0, idx), namespaceResolver, out result))
{
return(false);
}
// Weird result, but Name ends with '[]'
result = new XamlTypeName(result.Namespace, result.Name + '[' + new string (',', nArray - 1) + ']', result.TypeArguments);
return(true);
}
idx = typeName.IndexOf('(');
if (idx >= 0)
{
if (typeName [typeName.Length - 1] != ')')
{
return(false);
}
if (!TryParseList(typeName.Substring(idx + 1, typeName.Length - idx - 2), namespaceResolver, out args))
{
return(false);
}
typeName = typeName.Substring(0, idx);
}
idx = typeName.IndexOf(':');
string prefix, local;
if (idx < 0)
{
prefix = String.Empty;
local = typeName;
}
else
{
prefix = typeName.Substring(0, idx);
local = typeName.Substring(idx + 1);
if (!XamlLanguage.IsValidXamlName(prefix))
{
return(false);
}
}
if (!XamlLanguage.IsValidXamlName(local))
{
return(false);
}
string ns = namespaceResolver.GetNamespace(prefix);
if (ns == null)
{
return(false);
}
result = new XamlTypeName(ns, local, args);
return(true);
}
void ReadStartType ()
{
string name = r.LocalName;
string ns = r.NamespaceURI;
string typeArgNames = null;
var members = new List<Pair> ();
var atts = ProcessAttributes (members);
// check TypeArguments to resolve Type, and remove them from the list. They don't appear as a node.
var l = new List<Pair> ();
foreach (var p in members) {
if (p.Key == XamlLanguage.TypeArguments) {
typeArgNames = p.Value;
l.Add (p);
break;
}
}
foreach (var p in l)
members.Remove (p);
XamlType xt;
IList<XamlTypeName> typeArgs = typeArgNames == null ? null : XamlTypeName.ParseList (typeArgNames, xaml_namespace_resolver);
var xtn = new XamlTypeName (ns, name, typeArgs);
//Type rtype = sctx.ResolveXamlTypeName (ns, name, typeArgs, xaml_namespace_resolver);
//if (rtype != null)
// xt = sctx.GetXamlType (rtype);
//else
xt = sctx.GetXamlType (xtn);
if (xt == null)
// creates name-only XamlType. Also, it does not seem that it does not store this XamlType to XamlSchemaContext (Try GetXamlType(xtn) after reading such xaml node, it will return null).
xt = new XamlType (ns, name, typeArgs == null ? null : typeArgs.Select<XamlTypeName,XamlType> (xxtn => sctx.GetXamlType (xxtn)).ToArray (), sctx);
types.Push (xt);
current = xt;
if (!r.IsEmptyElement) {
r.Read ();
do {
r.MoveToContent ();
switch (r.NodeType) {
case XmlNodeType.Element:
// FIXME: parse type arguments etc.
case XmlNodeType.EndElement:
break;
default:
// this value is for Initialization, or Content property value
if (xt.ContentProperty != null)
members.Add (new Pair (xt.ContentProperty, r.Value));
else
members.Add (new Pair (XamlLanguage.Initialization, r.Value));
r.Read ();
continue;
}
break;
} while (true);
}
else
is_empty_object = true;
foreach (var p in atts) {
var xm = xt.GetMember (p.Key);
if (xm != null)
members.Add (new Pair (xm, p.Value));
// ignore unknown attribute
}
node_type = XamlNodeType.StartObject;
inside_object_not_member = true;
// The next Read() results are likely directives.
stored_member_enumerator = members.GetEnumerator ();
}
public void ConstructorNamespaceNull ()
{
// allowed.
var xtn = new XamlTypeName (null, "FooBar");
Assert.IsNotNull (xtn.TypeArguments, "#1");
}
public void GetTypeFromXamlTypeNameWithClrName ()
{
// ensure that this does *not* resolve clr type name.
var xn = new XamlTypeName ("clr-namespace:System;assembly=mscorlib", "DateTime");
var ctx = NewStandardContext ();
var xt = ctx.GetXamlType (xn);
Assert.IsNull (xt, "#1");
ctx = new XamlSchemaContext ();
xt = ctx.GetXamlType (xn);
Assert.IsNotNull (xt, "#2");
}
public void ConstructorTypeArgumentsEmpty ()
{
var n = new XamlTypeName ("urn:foo", "FooBar", new XamlTypeName [0]);
Assert.IsNotNull (n.TypeArguments, "#1");
Assert.AreEqual (0, n.TypeArguments.Count, "#2");
}
public void ConstructorDefault ()
{
var xtn = new XamlTypeName ();
Assert.IsNotNull (xtn.TypeArguments, "#1");
}
public void ToStringNameNull ()
{
var n = new XamlTypeName ("urn:foo", null);
n.ToString ();
}
public void ConstructorNameNull ()
{
// allowed.
var xtn = new XamlTypeName ("urn:foo", null);
Assert.IsNotNull (xtn.TypeArguments, "#1");
}
public static bool TryParse(string typeName, IXamlNamespaceResolver namespaceResolver, out XamlTypeName result)
{
string str;
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
if (namespaceResolver == null)
{
throw new ArgumentNullException("namespaceResolver");
}
result = ParseInternal(typeName, new Func <string, string>(namespaceResolver.GetNamespace), out str);
return(result != null);
}
