public void Visit(ValueNode node, INode parentNode)
{
//TODO support Label text as element
XmlName propertyName;
if (!TryGetPropertyName(node, parentNode, out propertyName))
{
if (!IsCollectionItem(node, parentNode))
return;
string contentProperty;
if (!Context.Variables.ContainsKey((IElementNode)parentNode))
return;
var parentVar = Context.Variables[(IElementNode)parentNode];
if ((contentProperty = GetContentProperty(parentVar.VariableType)) != null)
propertyName = new XmlName(((IElementNode)parentNode).NamespaceURI, contentProperty);
else
return;
}
if (skips.Contains(propertyName))
return;
if (node.SkipPrefix((node.NamespaceResolver ?? parentNode.NamespaceResolver)?.LookupPrefix(propertyName.NamespaceURI)))
return;
if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" &&
propertyName.LocalName == "Ignorable")
{
(parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List<string>())).AddRange(
(node.Value as string).Split(','));
return;
}
SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node);
}
internal static bool IsNullOrEmpty(XmlName xmlName)
{
if (xmlName != null)
{
return xmlName.IsEmpty;
}
return true;
}
public static void SetXsiType(this IXmlNode node, XmlName xsiType)
{
if (xsiType.NamespaceUri != null)
{
var prefix = node.Namespaces.GetAttributePrefix(node, xsiType.NamespaceUri);
xsiType = xsiType.WithNamespaceUri(prefix);
}
node.SetAttribute(Xsi.Type, xsiType.ToString());
}
internal static XmlQualifiedName GetContractName(Type contractType, string name, string ns)
{
XmlName name2 = new XmlName(name ?? TypeName(contractType));
if (ns == null)
{
ns = "http://tempuri.org/";
}
return new XmlQualifiedName(name2.EncodedName, ns);
}
public XmlIncludedType(XmlName xsiType, Type clrType)
{
if (xsiType.LocalName == null)
throw Error.ArgumentNull("xsiType.LocalName");
if (clrType == null)
throw Error.ArgumentNull("clrType");
this.xsiType = xsiType;
this.clrType = clrType;
}
public XmlKnownType(XmlName name, XmlName xsiType, Type clrType)
{
if (name.LocalName == null)
throw Error.ArgumentNull("name.LocalName");
if (clrType == null)
throw Error.ArgumentNull("clrType");
this.name = name;
this.xsiType = xsiType;
this.clrType = clrType;
}
private bool ConsumeNode()
{
var result = true;
var path = Node.Path;
if (path != null)
result = ConsumeFirstStep(path);
else
Name = Node.Name;
Node = Node.Parent;
return result;
}
public MessagePartDescription(string name, string ns)
{
if (name == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
}
this.name = new XmlName(name, true);
if (!string.IsNullOrEmpty(ns))
{
NamingHelper.CheckUriParameter(ns, "ns");
}
this.ns = ns;
}
protected XmlAccessor(Type clrType, IXmlContext context)
{
if (clrType == null)
throw Error.ArgumentNull("clrType");
if (context == null)
throw Error.ArgumentNull("context");
clrType = clrType.NonNullable();
this.clrType = clrType;
this.xsiType = context.GetDefaultXsiType(clrType);
this.serializer = XmlTypeSerializer.For(clrType);
this.context = context;
}
public XmlName GetNameForPrefix( string prefix ) {
prefix = table.NameTable.Add( prefix );
XmlName n = firstName;
for (; n != null; n = n.next) {
if ((object)n.Prefix == (object)prefix)
return n;
}
n = new XmlName( this, prefix );
n.next = firstName;
firstName = n;
return n;
}
// Methods
internal MessagePartDescription(MessagePartDescription other)
{
this.name = other.name;
this.ns = other.ns;
this.index = other.index;
this.type = other.type;
this.serializationPosition = other.serializationPosition;
this.hasProtectionLevel = other.hasProtectionLevel;
this.protectionLevel = other.protectionLevel;
this.memberInfo = other.memberInfo;
this.multiple = other.multiple;
this.additionalAttributesProvider = other.additionalAttributesProvider;
this.baseType = other.baseType;
this.uniquePartName = other.uniquePartName;
}
public void Visit(ValueNode node, INode parentNode)
{
var parentElement = parentNode as IElementNode;
var value = Values[node];
var source = Values[parentNode];
XmlName propertyName;
if (TryGetPropertyName(node, parentNode, out propertyName))
{
if (Skips.Contains(propertyName))
return;
if (parentElement.SkipProperties.Contains(propertyName))
return;
if (parentElement.SkipPrefix(node.NamespaceResolver.LookupPrefix(propertyName.NamespaceURI)))
return;
if (propertyName.NamespaceURI == "http://schemas.openxmlformats.org/markup-compatibility/2006" &&
propertyName.LocalName == "Ignorable")
{
(parentNode.IgnorablePrefixes ?? (parentNode.IgnorablePrefixes = new List<string>())).AddRange(
(value as string).Split(','));
return;
}
SetPropertyValue(source, propertyName, value, Context.RootElement, node, Context, node);
}
else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode)
{
// Collection element, implicit content, or implicit collection element.
var contentProperty = GetContentPropertyName(Context.Types[parentElement].GetTypeInfo());
if (contentProperty != null)
{
var name = new XmlName(((ElementNode)parentNode).NamespaceURI, contentProperty);
if (Skips.Contains(name))
return;
if (parentElement.SkipProperties.Contains(propertyName))
return;
SetPropertyValue(source, name, value, Context.RootElement, node, Context, node);
}
}
}
// Methods
public OperationDescription(string name, ContractDescription declaringContract)
{
this.validateRpcWrapperName = true;
if (name == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("name");
}
if (name.Length == 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("name", SR.GetString("SFxOperationDescriptionNameCannotBeEmpty")));
}
this.name = new XmlName(name, true);
if (declaringContract == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("declaringContract");
}
this.declaringContract = declaringContract;
this.isInitiating = true;
this.isTerminating = false;
this.faults = new FaultDescriptionCollection();
this.messages = new MessageDescriptionCollection();
this.behaviors = new KeyedByTypeCollection<IOperationBehavior>();
this.knownTypes = new Collection<Type>();
}
public static void SetPropertyValue(object xamlelement, XmlName propertyName, object value, object rootElement,
INode node, HydratationContext context, IXmlLineInfo lineInfo)
{
var elementType = xamlelement.GetType();
var localname = propertyName.LocalName;
var serviceProvider = new XamlServiceProvider(node, context);
//If it's an attached BP, update elementType and propertyName
var attached = GetRealNameAndType(ref elementType, propertyName.NamespaceURI, ref localname, context, lineInfo);
//If the target is an event, connect
var eventInfo = elementType.GetRuntimeEvent(localname);
if (eventInfo != null && value is string)
{
var methodInfo = rootElement.GetType().GetRuntimeMethods().FirstOrDefault(mi => mi.Name == (string)value);
if (methodInfo == null) {
var xpe = new XamlParseException (string.Format ("No method {0} found on type {1}", value, rootElement.GetType ()), lineInfo);
if (context.DoNotThrowOnExceptions) {
System.Diagnostics.Debug.WriteLine (xpe.Message);
return;
} else
throw xpe;
}
try
{
eventInfo.AddEventHandler(xamlelement, methodInfo.CreateDelegate(eventInfo.EventHandlerType, rootElement));
}
catch (ArgumentException)
{
var xpe = new XamlParseException (string.Format ("Method {0} does not have the correct signature", value), lineInfo);
if (context.DoNotThrowOnExceptions)
System.Diagnostics.Debug.WriteLine (xpe.Message);
else
throw xpe;
}
return;
}
var property = GetBindableProperty(elementType, localname, lineInfo, false);
//If Value is DynamicResource and it's a BP, SetDynamicResource
if (value is DynamicResource && property != null)
{
if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject)))
throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo);
((BindableObject)xamlelement).SetDynamicResource(property, ((DynamicResource)value).Key);
return;
}
//If value is BindingBase, and target is a BindableProperty, SetBinding
if (value is BindingBase && property != null)
{
if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject)))
throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo);
((BindableObject)xamlelement).SetBinding(property, value as BindingBase);
return;
}
//If it's a BindableProberty, SetValue
if (property != null)
{
if (!(xamlelement.GetType()).GetTypeInfo().IsSubclassOf(typeof (BindableObject)))
throw new XamlParseException(string.Format("{0} is not a BindableObject", xamlelement.GetType().Name), lineInfo);
Func<MemberInfo> minforetriever;
if (attached)
minforetriever = () => elementType.GetRuntimeMethod("Get" + localname, new[] { typeof (BindableObject) });
else
minforetriever = () => elementType.GetRuntimeProperty(localname);
var convertedValue = value.ConvertTo(property.ReturnType, minforetriever, serviceProvider);
//SetValue doesn't throw on mismatching type, so check before to get a chance to try the property setting or the collection adding
var nullable = property.ReturnTypeInfo.IsGenericType &&
property.ReturnTypeInfo.GetGenericTypeDefinition() == typeof (Nullable<>);
if ((convertedValue == null && (!property.ReturnTypeInfo.IsValueType || nullable)) ||
(property.ReturnType.IsInstanceOfType(convertedValue)))
{
((BindableObject)xamlelement).SetValue(property, convertedValue);
return;
}
}
var exception = new XamlParseException(
String.Format("No Property of name {0} found", propertyName.LocalName), lineInfo);
//If we can assign that value to a normal property, let's do it
var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localname);
MethodInfo setter;
if (propertyInfo != null && propertyInfo.CanWrite && (setter = propertyInfo.SetMethod) != null)
{
object convertedValue = value.ConvertTo(propertyInfo.PropertyType, () => propertyInfo, serviceProvider);
if (convertedValue == null || propertyInfo.PropertyType.IsInstanceOfType(convertedValue))
{
try
{
setter.Invoke(xamlelement, new[] { convertedValue });
return;
}
catch (ArgumentException)
{
}
}
else
{
exception = new XamlParseException(
String.Format("Cannot assign property \"{0}\": type mismatch between \"{1}\" and \"{2}\"", propertyName.LocalName,
value.GetType(), propertyInfo.PropertyType), lineInfo);
}
}
//If it's an already initialized property, add to it
MethodInfo getter;
if (propertyInfo != null && propertyInfo.CanRead && (getter = propertyInfo.GetMethod) != null)
{
IEnumerable collection;
MethodInfo addMethod;
if ((collection = getter.Invoke(xamlelement, new object[] { }) as IEnumerable) != null
&&
(addMethod =
collection.GetType().GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1)) !=
null)
{
addMethod.Invoke(collection,
new[] { value.ConvertTo(propertyInfo.PropertyType, (Func<TypeConverter>)null, serviceProvider) });
return;
}
}
if (context.DoNotThrowOnExceptions)
System.Diagnostics.Debug.WriteLine (exception.Message);
else
throw exception;
}
public static void WriteStartAttribute(this XmlWriter writer, XmlName name)
{
writer.WriteStartAttribute(null, name.LocalName, name.NamespaceUri);
}
public static bool TryGetPropertyName(INode node, INode parentNode, out XmlName name)
{
name = default(XmlName);
var parentElement = parentNode as IElementNode;
if (parentElement == null)
return false;
foreach (var kvp in parentElement.Properties)
{
if (kvp.Value != node)
continue;
name = kvp.Key;
return true;
}
return false;
}
internal void SetNameAndElement(XmlName name)
{
this.elementName = this.name = name;
}
MessageDescription CreateParameterMessageDescription(ContractDescription contract,
ParameterInfo[] parameters,
Type returnType,
ICustomAttributeProvider returnCustomAttributes,
XmlName returnValueName,
string methodName,
string ns,
string action,
MessageDirection direction,
bool allowReferences)
{
MessageDescription messageDescription = new MessageDescription(action, direction);
messageDescription.Body.WrapperNamespace = ns;
for (int index = 0; index < parameters.Length; index++)
{
ParameterInfo parameter = parameters[index];
Type parameterType = TypeLoader.GetParameterType(parameter);
if (!ComPlusTypeValidator.IsValidParameter(parameterType, parameter, allowReferences))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(SR.GetString(SR.InvalidWebServiceParameter,
parameter.Name,
parameterType.Name,
methodName,
contract.Name)));
}
MessagePartDescription messagePart = CreateMessagePartDescription(parameterType,
new XmlName(parameter.Name),
ns,
index);
messageDescription.Body.Parts.Add(messagePart);
}
XmlName xmlName = new XmlName(methodName);
if (returnType == null)
{
messageDescription.Body.WrapperName = xmlName.EncodedName;
}
else
{
messageDescription.Body.WrapperName = TypeLoader.GetBodyWrapperResponseName(xmlName).EncodedName;
if (!ComPlusTypeValidator.IsValidParameter(returnType, returnCustomAttributes, allowReferences))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ListenerInitFailed(SR.GetString(SR.InvalidWebServiceReturnValue,
returnType.Name,
methodName,
contract.Name)));
}
MessagePartDescription messagePart = CreateMessagePartDescription(returnType,
returnValueName,
ns,
0);
messageDescription.Body.ReturnValue = messagePart;
}
return(messageDescription);
}
public ElementListItem(XmlName name, bool required, bool choice)
{
this.Name = name;
this.IsRequired = required;
this.IsChoice = choice;
}
internal override string ImportType(MessagePartDescription part, XmlQualifiedName typeName, bool isEncoded)
{
XmlName memberName = new XmlName(part.Name, true /*isEncoded*/);
string memberNs = part.Namespace;
XmlMembersMapping membersMapping;
SoapSchemaMember schemaMember = new SoapSchemaMember();
schemaMember.MemberName = memberName.EncodedName;
schemaMember.MemberType = typeName;
if (isEncoded)
membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
else
membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
return AddPartType(part, membersMapping, isEncoded);
}
private bool Stop()
{
Name = XmlName.Empty;
return(false);
}
public SimpleNameClass(XmlName name)
{
this.name = name;
}
public QuickFixInsert(XmlNode n, XmlName name) : base(n)
{
this.name = name;
}
public QuickFixAppend(XmlNode n, XmlName name) : base(n)
{
this.name = name;
}
public QuickFixChange(XmlNode n, XmlName name) : base(n)
{
this.name = name;
}
public static void WriteStartElement(this XmlWriter writer, XmlName name)
{
writer.WriteStartElement(null, name.LocalName, name.NamespaceUri);
}
public static void WriteAttributeString(this XmlWriter writer, XmlName name, string value)
{
writer.WriteStartAttribute(null, name.LocalName, name.NamespaceUri);
writer.WriteString(value);
writer.WriteEndAttribute();
}
public ElementListItem(XmlName name, bool required) : this(name, required, false)
{
}
internal XmlMembersMapping ImportFaultElement(FaultDescription fault, out XmlQualifiedName elementName)
{
// the number of reflection members is always 1 because there is only one fault detail type
XmlReflectionMember[] members = new XmlReflectionMember[1];
XmlName faultElementName = fault.ElementName;
string faultNamespace = fault.Namespace;
if (faultElementName == null)
{
XmlTypeMapping mapping = _parent._importer.ImportTypeMapping(fault.DetailType);
faultElementName = new XmlName(mapping.ElementName, false /*isEncoded*/);
faultNamespace = mapping.Namespace;
if (faultElementName == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxFaultTypeAnonymous, this.Operation.Name, fault.DetailType.FullName)));
}
elementName = new XmlQualifiedName(faultElementName.DecodedName, faultNamespace);
members[0] = XmlSerializerHelper.GetXmlReflectionMember(null /*memberName*/, faultElementName, faultNamespace, fault.DetailType,
null /*additionalAttributesProvider*/, false /*isMultiple*/, false /*isWrapped*/);
string mappingKey = "fault:" + faultElementName.DecodedName + ":" + faultNamespace;
return ImportMembersMapping(faultElementName.EncodedName, faultNamespace, members, false /*hasWrapperElement*/, this.IsRpc, mappingKey);
}
public void Visit(ElementNode node, INode parentNode)
{
if (node.SkipPrefix(node.NamespaceResolver.LookupPrefix(node.NamespaceURI)))
return;
var value = Values[node];
var parentElement = parentNode as IElementNode;
var markupExtension = value as IMarkupExtension;
var valueProvider = value as IValueProvider;
if (markupExtension != null)
{
var serviceProvider = new XamlServiceProvider(node, Context);
value = markupExtension.ProvideValue(serviceProvider);
}
if (valueProvider != null)
{
var serviceProvider = new XamlServiceProvider(node, Context);
value = valueProvider.ProvideValue(serviceProvider);
}
XmlName propertyName;
if (TryGetPropertyName(node, parentNode, out propertyName))
{
if (Skips.Contains(propertyName))
return;
if (parentElement.SkipProperties.Contains(propertyName))
return;
var source = Values[parentNode];
if (propertyName == XmlName._CreateContent && source is ElementTemplate)
SetTemplate(source as ElementTemplate, node);
else
SetPropertyValue(source, propertyName, value, Context.RootElement, node, Context, node);
}
else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode)
{
// Collection element, implicit content, or implicit collection element.
string contentProperty;
if (typeof (IEnumerable).GetTypeInfo().IsAssignableFrom(Context.Types[parentElement].GetTypeInfo()))
{
var source = Values[parentNode];
if (!(typeof (ResourceDictionary).IsAssignableFrom(Context.Types[parentElement])))
{
var addMethod =
Context.Types[parentElement].GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1);
addMethod.Invoke(source, new[] { value });
}
}
else if ((contentProperty = GetContentPropertyName(Context.Types[parentElement].GetTypeInfo())) != null)
{
var name = new XmlName(node.NamespaceURI, contentProperty);
if (Skips.Contains(name))
return;
if (parentElement.SkipProperties.Contains(propertyName))
return;
var source = Values[parentNode];
SetPropertyValue(source, name, value, Context.RootElement, node, Context, node);
}
}
else if (IsCollectionItem(node, parentNode) && parentNode is ListNode)
{
var parentList = (ListNode)parentNode;
var source = Values[parentNode.Parent];
if (Skips.Contains(parentList.XmlName))
return;
var elementType = source.GetType();
var localname = parentList.XmlName.LocalName;
GetRealNameAndType(ref elementType, parentList.XmlName.NamespaceURI, ref localname, Context, node);
PropertyInfo propertyInfo = null;
try
{
propertyInfo = elementType.GetRuntimeProperty(localname);
}
catch (AmbiguousMatchException)
{
// Get most derived instance of property
foreach (var property in elementType.GetRuntimeProperties().Where(prop => prop.Name == localname))
{
if (propertyInfo == null || propertyInfo.DeclaringType.IsAssignableFrom(property.DeclaringType))
propertyInfo = property;
}
}
if (propertyInfo == null)
throw new XamlParseException(string.Format("Property {0} not found", localname), node);
MethodInfo getter;
if (!propertyInfo.CanRead || (getter = propertyInfo.GetMethod) == null)
throw new XamlParseException(string.Format("Property {0} does not have an accessible getter", localname), node);
IEnumerable collection;
if ((collection = getter.Invoke(source, new object[] { }) as IEnumerable) == null)
throw new XamlParseException(string.Format("Property {0} is null or is not IEnumerable", localname), node);
MethodInfo addMethod;
if (
(addMethod =
collection.GetType().GetRuntimeMethods().First(mi => mi.Name == "Add" && mi.GetParameters().Length == 1)) == null)
throw new XamlParseException(string.Format("Value of {0} does not have a Add() method", localname), node);
addMethod.Invoke(collection, new[] { Values[node] });
}
}
static internal XmlReflectionMember GetXmlReflectionMember(XmlName memberName, XmlName elementName, string ns, Type type, MemberInfo additionalAttributesProvider, bool isMultiple, bool isWrapped)
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = (memberName ?? elementName).DecodedName;
member.MemberType = type;
if (member.MemberType.IsByRef)
member.MemberType = member.MemberType.GetElementType();
if (isMultiple)
member.MemberType = member.MemberType.MakeArrayType();
if (additionalAttributesProvider != null)
{
member.XmlAttributes = XmlAttributesHelper.CreateXmlAttributes(additionalAttributesProvider);
}
if (member.XmlAttributes == null)
member.XmlAttributes = new XmlAttributes();
else
{
Type invalidAttributeType = null;
if (member.XmlAttributes.XmlAttribute != null)
invalidAttributeType = typeof(XmlAttributeAttribute);
else if (member.XmlAttributes.XmlAnyAttribute != null && !isWrapped)
invalidAttributeType = typeof(XmlAnyAttributeAttribute);
else if (member.XmlAttributes.XmlChoiceIdentifier != null)
invalidAttributeType = typeof(XmlChoiceIdentifierAttribute);
else if (member.XmlAttributes.XmlIgnore)
invalidAttributeType = typeof(XmlIgnoreAttribute);
else if (member.XmlAttributes.Xmlns)
invalidAttributeType = typeof(XmlNamespaceDeclarationsAttribute);
else if (member.XmlAttributes.XmlText != null)
invalidAttributeType = typeof(XmlTextAttribute);
else if (member.XmlAttributes.XmlEnum != null)
invalidAttributeType = typeof(XmlEnumAttribute);
if (invalidAttributeType != null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(isWrapped ? SR.SFxInvalidXmlAttributeInWrapped : SR.SFxInvalidXmlAttributeInBare, invalidAttributeType, elementName.DecodedName)));
if (member.XmlAttributes.XmlArray != null && isMultiple)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxXmlArrayNotAllowedForMultiple, elementName.DecodedName, ns)));
}
bool isArray = member.MemberType.IsArray;
if ((isArray && !isMultiple && member.MemberType != typeof(byte[])) ||
(!isArray && typeof(IEnumerable).IsAssignableFrom(member.MemberType) && member.MemberType != typeof(string) && !typeof(XmlNode).IsAssignableFrom(member.MemberType) && !typeof(IXmlSerializable).IsAssignableFrom(member.MemberType)))
{
if (member.XmlAttributes.XmlArray != null)
{
if (member.XmlAttributes.XmlArray.ElementName == String.Empty)
member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName;
if (member.XmlAttributes.XmlArray.Namespace == null)
member.XmlAttributes.XmlArray.Namespace = ns;
}
else if (HasNoXmlParameterAttributes(member.XmlAttributes))
{
member.XmlAttributes.XmlArray = new XmlArrayAttribute();
member.XmlAttributes.XmlArray.ElementName = elementName.DecodedName;
member.XmlAttributes.XmlArray.Namespace = ns;
}
}
else
{
if (member.XmlAttributes.XmlElements == null || member.XmlAttributes.XmlElements.Count == 0)
{
if (HasNoXmlParameterAttributes(member.XmlAttributes))
{
XmlElementAttribute elementAttribute = new XmlElementAttribute();
elementAttribute.ElementName = elementName.DecodedName;
elementAttribute.Namespace = ns;
member.XmlAttributes.XmlElements.Add(elementAttribute);
}
}
else
{
foreach (XmlElementAttribute elementAttribute in member.XmlAttributes.XmlElements)
{
if (elementAttribute.ElementName == String.Empty)
elementAttribute.ElementName = elementName.DecodedName;
if (elementAttribute.Namespace == null)
elementAttribute.Namespace = ns;
}
}
}
return member;
}
internal override CodeTypeReference ImportFaultType(XmlQualifiedName elementName, XmlQualifiedName typeName, bool isEncoded)
{
XmlName memberName = new XmlName(elementName.Name, true /*isEncoded*/);
string memberNs = elementName.Namespace;
XmlMembersMapping membersMapping;
SoapSchemaMember schemaMember = new SoapSchemaMember();
schemaMember.MemberName = memberName.EncodedName;
schemaMember.MemberType = typeName;
if (isEncoded)
{
membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
this.xmlSerializerOperationGenerator.SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
this.xmlSerializerOperationGenerator.XmlExporter.ExportMembersMapping(membersMapping);
}
return new CodeTypeReference(this.xmlSerializerOperationGenerator.GetTypeName(membersMapping[0]));
}
public ElementListItem(XmlName name) : this(name, false, false)
{
}
internal void SetNameOnly(XmlName name)
{
this.name = name;
}
//
// Note - the code below this line a paraphrase of the SM reflection code in TypeLoader.cs
// Ideally we would be re-using their code, but our assumptions are too disjoint
// for that to be realistic at the time of writing (12/2004).
//
OperationDescription CreateOperationDescription(ContractDescription contract, MethodInfo methodInfo, ComContractElement config, bool allowReferences)
{
XmlName operationName = new XmlName(ServiceReflector.GetLogicalName(methodInfo));
XmlName returnValueName = TypeLoader.GetReturnValueName(operationName);
if (ServiceReflector.IsBegin(methodInfo) || ServiceReflector.IsTask(methodInfo))
{
Fx.Assert("No async operations allowed");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.NoAsyncOperationsAllowed());
}
if (contract.Operations.FindAll(operationName.EncodedName).Count != 0)
{
Fx.Assert("Duplicate operation name");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.DuplicateOperation());
}
OperationDescription operationDescription = new OperationDescription(operationName.EncodedName, contract);
operationDescription.SyncMethod = methodInfo;
operationDescription.IsInitiating = true;
operationDescription.IsTerminating = false;
operationDescription.KnownTypes.Add(typeof(Array));
operationDescription.KnownTypes.Add(typeof(DBNull));
operationDescription.KnownTypes.Add(typeof(CurrencyWrapper));
operationDescription.KnownTypes.Add(typeof(ErrorWrapper));
if (allowReferences)
{
operationDescription.KnownTypes.Add(typeof(PersistStreamTypeWrapper));
}
foreach (ComUdtElement udt in config.UserDefinedTypes)
{
Type knownType;
Guid typeLibID = Fx.CreateGuid(udt.TypeLibID);
TypeCacheManager.Provider.FindOrCreateType(typeLibID, udt.TypeLibVersion, Fx.CreateGuid(udt.TypeDefID), out knownType, false);
this.info.AddUdt(knownType, typeLibID);
operationDescription.KnownTypes.Add(knownType);
}
string ns = contract.Namespace;
XmlQualifiedName contractQName = new XmlQualifiedName(contract.Name, ns);
string requestAction = NamingHelper.GetMessageAction(contractQName,
operationName.DecodedName,
null,
false);
string responseAction = NamingHelper.GetMessageAction(contractQName,
operationName.DecodedName,
null,
true);
MessageDescription inMessage = CreateIncomingMessageDescription(contract,
methodInfo,
ns,
requestAction,
allowReferences);
MessageDescription outMessage = CreateOutgoingMessageDescription(contract,
methodInfo,
returnValueName,
ns,
responseAction,
allowReferences);
operationDescription.Messages.Add(inMessage);
operationDescription.Messages.Add(outMessage);
return(operationDescription);
}
private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart)
{
Type bodyObjectType = bodyPart.Type;
MessagePartDescriptionCollection partList = new MessagePartDescriptionCollection();
foreach (MemberInfo member in bodyObjectType.GetMembers(BindingFlags.Instance | BindingFlags.Public))
{
if ((member.MemberType & (MemberTypes.Field | MemberTypes.Property)) == 0)
continue;
if (member.IsDefined(typeof(SoapIgnoreAttribute), false/*inherit*/))
continue;
XmlName xmlName = new XmlName(member.Name);
MessagePartDescription part = new MessagePartDescription(xmlName.EncodedName, string.Empty);
part.AdditionalAttributesProvider = part.MemberInfo = member;
part.Index = part.SerializationPosition = partList.Count;
part.Type = (member.MemberType == MemberTypes.Property) ? ((PropertyInfo)member).PropertyType : ((FieldInfo)member).FieldType;
if (bodyPart.HasProtectionLevel)
part.ProtectionLevel = bodyPart.ProtectionLevel;
partList.Add(part);
}
return partList;
}
public EditNodeName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes)
{
if (node.Node == null) {
throw new ArgumentException(SR.NodeNotCreated);
}
switch (node.NodeType) {
case XmlNodeType.Element:
cmd = new EditElementName(node, newName, autoGenPrefixes);
break;
case XmlNodeType.Attribute:
cmd = new EditAttributeName(node, newName, autoGenPrefixes);
break;
case XmlNodeType.ProcessingInstruction:
cmd = new EditProcessingInstructionName(node, newName.LocalName);
break;
default:
throw new ArgumentException(
string.Format(SR.NodeNameNotEditable, node.NodeType.ToString()));
}
}
public void Visit(ElementNode node, INode parentNode)
{
if (node.SkipPrefix((node.NamespaceResolver ?? parentNode.NamespaceResolver)?.LookupPrefix(node.NamespaceURI)))
{
return;
}
//if this node is an IMarkupExtension, invoke ProvideValue() and replace the variable
var vardef = Context.Variables[node];
var vardefref = new VariableDefinitionReference(vardef);
Context.IL.Append(ProvideValue(vardefref, Context, Module, node));
if (vardef != vardefref.VariableDefinition)
{
vardef = vardefref.VariableDefinition;
Context.Body.Variables.Add(vardef);
Context.Variables[node] = vardef;
}
XmlName propertyName;
if (TryGetPropertyName(node, parentNode, out propertyName))
{
if (skips.Contains(propertyName))
{
return;
}
if (propertyName == XmlName._CreateContent)
{
SetDataTemplate((IElementNode)parentNode, node, Context, node);
}
else
{
SetPropertyValue(Context.Variables[(IElementNode)parentNode], propertyName, node, Context, node);
}
}
else if (IsCollectionItem(node, parentNode) && parentNode is IElementNode)
{
// Collection element, implicit content, or implicit collection element.
string contentProperty;
var parentVar = Context.Variables[(IElementNode)parentNode];
if (parentVar.VariableType.ImplementsInterface(Module.Import(typeof(IEnumerable))))
{
var elementType = parentVar.VariableType;
if (elementType.FullName != "Xamarin.Forms.ResourceDictionary" && elementType.Resolve().BaseType.FullName != "Xamarin.Forms.ResourceDictionary")
{
var adderTuple = elementType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First();
var adderRef = Module.Import(adderTuple.Item1);
adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
Context.IL.Emit(OpCodes.Ldloc, parentVar);
Context.IL.Emit(OpCodes.Ldloc, vardef);
Context.IL.Emit(OpCodes.Callvirt, adderRef);
if (adderRef.ReturnType.FullName != "System.Void")
{
Context.IL.Emit(OpCodes.Pop);
}
}
}
else if ((contentProperty = GetContentProperty(parentVar.VariableType)) != null)
{
var name = new XmlName(node.NamespaceURI, contentProperty);
if (skips.Contains(name))
{
return;
}
SetPropertyValue(Context.Variables[(IElementNode)parentNode], name, node, Context, node);
}
}
else if (IsCollectionItem(node, parentNode) && parentNode is ListNode)
{
// IL_000d: ldloc.2
// IL_000e: callvirt instance class [mscorlib]System.Collections.Generic.IList`1<!0> class [Xamarin.Forms.Core]Xamarin.Forms.Layout`1<class [Xamarin.Forms.Core]Xamarin.Forms.View>::get_Children()
// IL_0013: ldloc.0
// IL_0014: callvirt instance void class [mscorlib]System.Collections.Generic.ICollection`1<class [Xamarin.Forms.Core]Xamarin.Forms.View>::Add(!0)
var parentList = (ListNode)parentNode;
var parent = Context.Variables[((IElementNode)parentNode.Parent)];
if (skips.Contains(parentList.XmlName))
{
return;
}
var elementType = parent.VariableType;
var localname = parentList.XmlName.LocalName;
GetNameAndTypeRef(ref elementType, parentList.XmlName.NamespaceURI, ref localname, Context, node);
TypeReference propertyDeclaringType;
var property = elementType.GetProperty(pd => pd.Name == localname, out propertyDeclaringType);
MethodDefinition propertyGetter;
if (property != null && (propertyGetter = property.GetMethod) != null && propertyGetter.IsPublic)
{
var propertyGetterRef = Module.Import(propertyGetter);
propertyGetterRef = Module.Import(propertyGetterRef.ResolveGenericParameters(propertyDeclaringType, Module));
var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(propertyDeclaringType);
var adderTuple = propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, Module).First();
var adderRef = Module.Import(adderTuple.Item1);
adderRef = Module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, Module));
Context.IL.Emit(OpCodes.Ldloc, parent);
Context.IL.Emit(OpCodes.Callvirt, propertyGetterRef);
Context.IL.Emit(OpCodes.Ldloc, vardef);
Context.IL.Emit(OpCodes.Callvirt, adderRef);
if (adderRef.ReturnType.FullName != "System.Void")
{
Context.IL.Emit(OpCodes.Pop);
}
}
}
}
public bool Contains(XmlName name)
{
return(Contains(name.uri, name.local));
}
internal XmlMembersMapping ImportMembersMapping(XmlName elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool rpc, string mappingKey)
{
XmlMembersMapping mapping;
string mappingName = elementName.DecodedName;
if (XmlMappings.TryGetValue(mappingKey, out mapping))
{
return mapping;
}
mapping = this.XmlImporter.ImportMembersMapping(mappingName, ns, members, hasWrapperElement, rpc);
mapping.SetKey(mappingKey);
XmlMappings.Add(mappingKey, mapping);
return mapping;
}
public static void SetPropertyValue(VariableDefinition parent, XmlName propertyName, INode valueNode,
ILContext context, IXmlLineInfo iXmlLineInfo)
{
var elementType = parent.VariableType;
var localName = propertyName.LocalName;
var module = context.Body.Method.Module;
var br = Instruction.Create(OpCodes.Nop);
TypeReference declaringTypeReference;
var handled = false;
//If it's an attached BP, update elementType and propertyName
GetNameAndTypeRef(ref elementType, propertyName.NamespaceURI, ref localName, context, iXmlLineInfo);
//If the target is an event, connect
// IL_0007: ldloc.0
// IL_0008: ldarg.0
//
// IL_0009: ldftn instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::OnButtonClicked(object, class [mscorlib]System.EventArgs)
//OR, if the handler is virtual
// IL_000x: ldarg.0
// IL_0009: ldvirtftn instance void class Xamarin.Forms.Xaml.XamlcTests.MyPage::OnButtonClicked(object, class [mscorlib]System.EventArgs)
//
// IL_000f: newobj instance void class [mscorlib]System.EventHandler::'.ctor'(object, native int)
// IL_0014: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::add_Clicked(class [mscorlib]System.EventHandler)
var eventinfo = elementType.GetEvent(ed => ed.Name == localName);
if (eventinfo != null)
{
var value = ((ValueNode)valueNode).Value;
context.IL.Emit(OpCodes.Ldloc, parent);
if (context.Root is VariableDefinition)
{
context.IL.Emit(OpCodes.Ldloc, context.Root as VariableDefinition);
}
else if (context.Root is FieldDefinition)
{
context.IL.Emit(OpCodes.Ldarg_0);
context.IL.Emit(OpCodes.Ldfld, context.Root as FieldDefinition);
}
else
{
throw new InvalidProgramException();
}
var declaringType = context.Body.Method.DeclaringType;
if (declaringType.IsNested)
{
declaringType = declaringType.DeclaringType;
}
var handler = declaringType.AllMethods().FirstOrDefault(md => md.Name == value as string);
if (handler == null)
{
throw new XamlParseException(
string.Format("EventHandler \"{0}\" not found in type \"{1}\"", value, context.Body.Method.DeclaringType.FullName),
iXmlLineInfo);
}
if (handler.IsVirtual)
{
context.IL.Emit(OpCodes.Ldarg_0);
context.IL.Emit(OpCodes.Ldvirtftn, handler);
}
else
{
context.IL.Emit(OpCodes.Ldftn, handler);
}
//FIXME: eventually get the right ctor instead fo the First() one, just in case another one could exists (not even sure it's possible).
var ctor = module.Import(eventinfo.EventType.Resolve().GetConstructors().First());
ctor = ctor.ResolveGenericParameters(eventinfo.EventType, module);
context.IL.Emit(OpCodes.Newobj, module.Import(ctor));
context.IL.Emit(OpCodes.Callvirt, module.Import(eventinfo.AddMethod));
return;
}
FieldReference bpRef = elementType.GetField(fd => fd.Name == localName + "Property" && fd.IsStatic && fd.IsPublic,
out declaringTypeReference);
if (bpRef != null)
{
bpRef = module.Import(bpRef.ResolveGenericParameters(declaringTypeReference));
bpRef.FieldType = module.Import(bpRef.FieldType);
}
//If Value is DynamicResource, SetDynamicResource
VariableDefinition varValue;
if (bpRef != null && valueNode is IElementNode &&
context.Variables.TryGetValue(valueNode as IElementNode, out varValue) &&
varValue.VariableType.FullName == typeof(DynamicResource).FullName)
{
var setDynamicResource =
module.Import(typeof(IDynamicResourceHandler)).Resolve().Methods.First(m => m.Name == "SetDynamicResource");
var getKey = typeof(DynamicResource).GetProperty("Key").GetMethod;
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Ldsfld, bpRef);
context.IL.Emit(OpCodes.Ldloc, varValue);
context.IL.Emit(OpCodes.Callvirt, module.Import(getKey));
context.IL.Emit(OpCodes.Callvirt, module.Import(setDynamicResource));
return;
}
//If Value is a BindingBase and target is a BP, SetBinding
if (bpRef != null && valueNode is IElementNode &&
context.Variables.TryGetValue(valueNode as IElementNode, out varValue) &&
varValue.VariableType.InheritsFromOrImplements(module.Import(typeof(BindingBase))))
{
//TODO: check if parent is a BP
var setBinding = typeof(BindableObject).GetMethod("SetBinding",
new[] { typeof(BindableProperty), typeof(BindingBase) });
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Ldsfld, bpRef);
context.IL.Emit(OpCodes.Ldloc, varValue);
context.IL.Emit(OpCodes.Callvirt, module.Import(setBinding));
return;
}
//If it's a BP, SetValue ()
// IL_0007: ldloc.0
// IL_0008: ldsfld class [Xamarin.Forms.Core]Xamarin.Forms.BindableProperty [Xamarin.Forms.Core]Xamarin.Forms.Label::TextProperty
// IL_000d: ldstr "foo"
// IL_0012: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.BindableObject::SetValue(class [Xamarin.Forms.Core]Xamarin.Forms.BindableProperty, object)
if (bpRef != null)
{
//TODO: check if parent is a BP
var setValue = typeof(BindableObject).GetMethod("SetValue", new[] { typeof(BindableProperty), typeof(object) });
if (valueNode is ValueNode)
{
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Ldsfld, bpRef);
context.IL.Append(((ValueNode)valueNode).PushConvertedValue(context, bpRef, valueNode.PushServiceProvider(context),
true, false));
context.IL.Emit(OpCodes.Callvirt, module.Import(setValue));
return;
}
if (valueNode is IElementNode)
{
var getPropertyReturnType = module.Import(typeof(BindableProperty).GetProperty("ReturnType").GetGetMethod());
//FIXME: this should check for inheritance too
var isInstanceOfType = module.Import(typeof(Type).GetMethod("IsInstanceOfType", new[] { typeof(object) }));
var brfalse = Instruction.Create(OpCodes.Nop);
context.IL.Emit(OpCodes.Ldsfld, bpRef);
context.IL.Emit(OpCodes.Call, getPropertyReturnType);
context.IL.Emit(OpCodes.Ldloc, context.Variables[valueNode as IElementNode]);
if (context.Variables[valueNode as IElementNode].VariableType.IsValueType)
{
context.IL.Emit(OpCodes.Box, context.Variables[valueNode as IElementNode].VariableType);
}
context.IL.Emit(OpCodes.Callvirt, isInstanceOfType);
context.IL.Emit(OpCodes.Brfalse, brfalse);
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Ldsfld, bpRef);
context.IL.Emit(OpCodes.Ldloc, context.Variables[(IElementNode)valueNode]);
if (context.Variables[valueNode as IElementNode].VariableType.IsValueType)
{
context.IL.Emit(OpCodes.Box, context.Variables[valueNode as IElementNode].VariableType);
}
context.IL.Emit(OpCodes.Callvirt, module.Import(setValue));
context.IL.Emit(OpCodes.Br, br);
context.IL.Append(brfalse);
handled = true;
}
}
//If it's a property, set it
// IL_0007: ldloc.0
// IL_0008: ldstr "foo"
// IL_000d: callvirt instance void class [Xamarin.Forms.Core]Xamarin.Forms.Label::set_Text(string)
PropertyDefinition property = elementType.GetProperty(pd => pd.Name == localName, out declaringTypeReference);
MethodDefinition propertySetter;
if (property != null && (propertySetter = property.SetMethod) != null && propertySetter.IsPublic)
{
module.Import(elementType.Resolve());
var propertySetterRef =
module.Import(module.Import(propertySetter).ResolveGenericParameters(declaringTypeReference, module));
propertySetterRef.ImportTypes(module);
var propertyType = property.ResolveGenericPropertyType(declaringTypeReference);
ValueNode vnode = null;
if ((vnode = valueNode as ValueNode) != null)
{
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Append(vnode.PushConvertedValue(context,
propertyType,
new ICustomAttributeProvider[] { property, propertyType.Resolve() },
valueNode.PushServiceProvider(context), false, true));
context.IL.Emit(OpCodes.Callvirt, propertySetterRef);
context.IL.Append(br);
return;
}
if (valueNode is IElementNode)
{
var vardef = context.Variables[(ElementNode)valueNode];
var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(propertyType, module);
//TODO replace latest check by a runtime type check
if (implicitOperator != null || vardef.VariableType.InheritsFromOrImplements(propertyType) ||
propertyType.FullName == "System.Object" || vardef.VariableType.FullName == "System.Object")
{
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Ldloc, vardef);
if (implicitOperator != null)
{
// IL_000f: call !0 class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<bool>::op_Implicit(class [Xamarin.Forms.Core]Xamarin.Forms.OnPlatform`1<!0>)
context.IL.Emit(OpCodes.Call, module.Import(implicitOperator));
}
else if (!vardef.VariableType.IsValueType && propertyType.IsValueType)
{
context.IL.Emit(OpCodes.Unbox_Any, module.Import(propertyType));
}
else if (vardef.VariableType.IsValueType && propertyType.FullName == "System.Object")
{
context.IL.Emit(OpCodes.Box, vardef.VariableType);
}
context.IL.Emit(OpCodes.Callvirt, propertySetterRef);
context.IL.Append(br);
return;
}
handled = true;
}
}
//If it's an already initialized property, add to it
MethodDefinition propertyGetter;
//TODO: check if property is assigned
if (property != null && (propertyGetter = property.GetMethod) != null && propertyGetter.IsPublic)
{
var propertyGetterRef = module.Import(propertyGetter);
propertyGetterRef = module.Import(propertyGetterRef.ResolveGenericParameters(declaringTypeReference, module));
var propertyType = propertyGetterRef.ReturnType.ResolveGenericParameters(declaringTypeReference);
var vardef = context.Variables [(ElementNode)valueNode];
//TODO check md.Parameters[0] type
var adderTuple =
propertyType.GetMethods(md => md.Name == "Add" && md.Parameters.Count == 1, module).FirstOrDefault();
if (adderTuple != null)
{
var adderRef = module.Import(adderTuple.Item1);
adderRef = module.Import(adderRef.ResolveGenericParameters(adderTuple.Item2, module));
var childType = GetParameterType(adderRef.Parameters [0]);
var implicitOperator = vardef.VariableType.GetImplicitOperatorTo(childType, module);
if (valueNode is IElementNode)
{
context.IL.Emit(OpCodes.Ldloc, parent);
context.IL.Emit(OpCodes.Callvirt, propertyGetterRef);
context.IL.Emit(OpCodes.Ldloc, vardef);
if (implicitOperator != null)
{
context.IL.Emit(OpCodes.Call, module.Import(implicitOperator));
}
context.IL.Emit(OpCodes.Callvirt, adderRef);
if (adderRef.ReturnType.FullName != "System.Void")
{
context.IL.Emit(OpCodes.Pop);
}
context.IL.Append(br);
return;
}
}
}
if (!handled)
{
throw new XamlParseException(string.Format("No property, bindable property, or event found for '{0}'", localName),
iXmlLineInfo);
}
context.IL.Append(br);
}
private ContentModelCollector(XmlName tagName)
{
this.tagName = tagName;
}
protected virtual void PerformAction(XmlName name)
{
}
public SimpleNameClass( XmlName name )
{
this.name = name;
}
public void AddReference(XmlName xmlName, Type xmlObjectType)
{
throw new NotImplementedException(nameof(AddReference));
}
private bool Stop()
{
Name = XmlName.Empty;
return false;
}
public bool TryGet(XmlName xsiType, out IXmlIncludedType includedType)
{
return((xsiType == Default.XsiType)
? Try.Success(out includedType, Default)
: includedTypes.TryGet(xsiType, out includedType));
}
public bool Contains( XmlName name )
{
return Contains( name.uri, name.local );
}
public EditElementName(XmlTreeNode node, XmlName newName, bool autoGenPrefixes)
{
this.xe = (XmlElement)node.Node; ;
this.node = node;
this.name = newName;
this.autoGenPrefixes = autoGenPrefixes;
}
private bool ConsumeStep()
{
Name = new XmlName
(
Step.LocalName,
Node.LookupNamespaceUri(Step.Prefix)
);
Step = Step.PreviousNode;
return true;
}
public void Reset(XmlName name, XmlNameTable nameTable)
{
LocalName = nameTable.Add(name.LocalName);
NamespaceUri = name.NamespaceUri != null?nameTable.Add(name.NamespaceUri) : null;
}
