public static void PreLoad(Type type)
{
// Register soap actions for the methods in the type.
foreach (MethodInfo method in type.GetMethods())
{
RegisterSoapActionForMethodBase(method);
}
// Register XML tags for the type, if specified.
SoapTypeAttribute tattr = (SoapTypeAttribute)
InternalRemotingServices.GetCachedSoapAttribute(type);
if (tattr.xmlElementWasSet)
{
RegisterInteropXmlElement
(tattr.XmlElementName, tattr.XmlNamespace, type);
}
if (tattr.xmlTypeWasSet)
{
RegisterInteropXmlType
(tattr.XmlTypeName, tattr.XmlTypeNamespace, type);
}
// Load and register the field mapping information.
lock (typeof(SoapServices))
{
if (fields == null)
{
fields = new Hashtable();
}
TypeFieldInfo typeInfo = new TypeFieldInfo();
foreach (FieldInfo field in type.GetFields())
{
SoapFieldAttribute fattr = (SoapFieldAttribute)
InternalRemotingServices.GetCachedSoapAttribute
(field);
if (fattr.IsInteropXmlElement())
{
if (fattr.UseAttribute)
{
typeInfo.StoreAttribute
(XmlKey(fattr.XmlElementName,
fattr.XmlNamespace),
field.Name, field.FieldType);
}
else
{
typeInfo.StoreElement
(XmlKey(fattr.XmlElementName,
fattr.XmlNamespace),
field.Name, field.FieldType);
}
}
}
if (typeInfo.IsPopulated)
{
fields[type] = typeInfo;
}
}
}
} // ProcessTypeAttribute
internal static void ProcessMemberInfoAttribute(MemberInfo memberInfo, SoapAttributeInfo attributeInfo)
{
SoapAttribute attr = (SoapAttribute)
InternalRemotingServices.GetCachedSoapAttribute(memberInfo);
if (attr.Embedded)
{
attributeInfo.m_attributeType |= SoapAttributeType.Embedded;
}
// check for attribute and other junk
if (attr is SoapFieldAttribute)
{
SoapFieldAttribute fieldAttr = (SoapFieldAttribute)attr;
if (fieldAttr.UseAttribute)
{
attributeInfo.m_attributeType |= SoapAttributeType.XmlAttribute;
attributeInfo.m_elementName = fieldAttr.XmlElementName;
attributeInfo.m_nameSpace = fieldAttr.XmlNamespace;
}
else
{
if (fieldAttr.IsInteropXmlElement())
{
attributeInfo.m_attributeType |= SoapAttributeType.XmlElement;
attributeInfo.m_elementName = fieldAttr.XmlElementName;
attributeInfo.m_nameSpace = fieldAttr.XmlNamespace;
}
}
}
} // ProcessMemberInfoAttribute
internal static void ProcessMemberInfoAttribute(MemberInfo memberInfo, SoapAttributeInfo attributeInfo)
{
SoapAttribute cachedSoapAttribute = InternalRemotingServices.GetCachedSoapAttribute(memberInfo);
if (cachedSoapAttribute.Embedded)
{
attributeInfo.m_attributeType |= SoapAttributeType.Embedded;
}
if (cachedSoapAttribute is SoapFieldAttribute)
{
SoapFieldAttribute attribute2 = (SoapFieldAttribute)cachedSoapAttribute;
if (attribute2.UseAttribute)
{
attributeInfo.m_attributeType |= SoapAttributeType.XmlAttribute;
attributeInfo.m_elementName = attribute2.XmlElementName;
attributeInfo.m_nameSpace = attribute2.XmlNamespace;
}
else if (attribute2.IsInteropXmlElement())
{
attributeInfo.m_attributeType |= SoapAttributeType.XmlElement;
attributeInfo.m_elementName = attribute2.XmlElementName;
attributeInfo.m_nameSpace = attribute2.XmlNamespace;
}
}
}
void WriteClassSchema(XmlTextWriter tw, Type type)
{
tw.WriteStartElement("element", MetaData.SchemaNamespace);
tw.WriteAttributeString("name", type.Name);
tw.WriteAttributeString("type", GetQualifiedXmlType(tw, type, null));
tw.WriteEndElement();
tw.WriteStartElement("complexType", MetaData.SchemaNamespace);
tw.WriteAttributeString("name", GetXmlType(type));
if (type.BaseType != null && type.BaseType != typeof(object) && type.BaseType != typeof(ValueType))
{
tw.WriteAttributeString("base", GetQualifiedXmlType(tw, type.BaseType, null));
}
FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
// Element fields
bool elemsStart = false;
foreach (FieldInfo fi in fields)
{
SoapFieldAttribute att = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(fi);
if (att.UseAttribute)
{
continue;
}
if (!elemsStart)
{
tw.WriteStartElement("all", MetaData.SchemaNamespace);
elemsStart = true;
}
tw.WriteStartElement("element", MetaData.SchemaNamespace);
tw.WriteAttributeString("name", att.XmlElementName);
tw.WriteAttributeString("type", GetQualifiedXmlType(tw, fi.FieldType, type));
tw.WriteEndElement();
}
if (elemsStart)
{
tw.WriteEndElement(); // all
}
// Attribute fields
foreach (FieldInfo fi in fields)
{
SoapFieldAttribute att = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(fi);
if (!att.UseAttribute)
{
continue;
}
tw.WriteStartElement("attribute", MetaData.SchemaNamespace);
tw.WriteAttributeString("name", att.XmlElementName);
tw.WriteAttributeString("type", GetQualifiedXmlType(tw, fi.FieldType, type));
tw.WriteEndElement();
}
tw.WriteEndElement(); // complexType
}
} // RegisterInteropXmlType
/// <include file='doc\Soap.uex' path='docs/doc[@for="SoapServices.PreLoad"]/*' />
public static void PreLoad(Type type)
{
// register soap action values
MethodInfo[] methods = type.GetMethods();
foreach (MethodInfo mi in methods)
{
// This will only add an entry to the table if SoapAction was explicitly set
// on the SoapMethodAttribute.
RegisterSoapActionForMethodBase(mi);
}
// register interop xml elements and types if specified
SoapTypeAttribute attr = (SoapTypeAttribute)
InternalRemotingServices.GetCachedSoapAttribute(type);
if (attr.IsInteropXmlElement())
{
RegisterInteropXmlElement(attr.XmlElementName, attr.XmlNamespace, type);
}
if (attr.IsInteropXmlType())
{
RegisterInteropXmlType(attr.XmlTypeName, attr.XmlTypeNamespace, type);
}
// construct field maps for mapping xml elements and attributes back to
// the correct type
int mapCount = 0;
XmlToFieldTypeMap map = new XmlToFieldTypeMap();
foreach (FieldInfo field in type.GetFields())
{
SoapFieldAttribute fieldAttr = (SoapFieldAttribute)
InternalRemotingServices.GetCachedSoapAttribute(field);
if (fieldAttr.IsInteropXmlElement())
{
String xmlName = fieldAttr.XmlElementName;
String xmlNamespace = fieldAttr.XmlNamespace;
if (fieldAttr.UseAttribute)
{
map.AddXmlAttribute(field.FieldType, field.Name, xmlName, xmlNamespace);
}
else
{
map.AddXmlElement(field.FieldType, field.Name, xmlName, xmlNamespace);
}
mapCount++;
}
} // foreach field
// add field map if there is more than one entry
if (mapCount > 0)
{
_xmlToFieldTypeMap[type] = map;
}
} // PreLoad
public static void PreLoad(Type type)
{
string name, namspace;
TypeInfo tf = _typeInfos [type] as TypeInfo;
if (tf != null)
{
return;
}
if (GetXmlTypeForInteropType(type, out name, out namspace))
{
RegisterInteropXmlType(name, namspace, type);
}
if (GetXmlElementForInteropType(type, out name, out namspace))
{
RegisterInteropXmlElement(name, namspace, type);
}
lock (_typeInfos.SyncRoot)
{
tf = new TypeInfo();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo field in fields)
{
SoapFieldAttribute att = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(field);
if (!att.IsInteropXmlElement())
{
continue;
}
string key = GetNameKey(att.XmlElementName, att.XmlNamespace);
if (att.UseAttribute)
{
if (tf.Attributes == null)
{
tf.Attributes = new Hashtable();
}
tf.Attributes [key] = field;
}
else
{
if (tf.Elements == null)
{
tf.Elements = new Hashtable();
}
tf.Elements [key] = field;
}
}
_typeInfos [type] = tf;
}
}
public static void PreLoad(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
}
MethodInfo[] methods = type.GetMethods();
foreach (MethodInfo mb in methods)
{
SoapServices.RegisterSoapActionForMethodBase(mb);
}
SoapTypeAttribute soapTypeAttribute = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
if (soapTypeAttribute.IsInteropXmlElement())
{
SoapServices.RegisterInteropXmlElement(soapTypeAttribute.XmlElementName, soapTypeAttribute.XmlNamespace, type);
}
if (soapTypeAttribute.IsInteropXmlType())
{
SoapServices.RegisterInteropXmlType(soapTypeAttribute.XmlTypeName, soapTypeAttribute.XmlTypeNamespace, type);
}
int num = 0;
SoapServices.XmlToFieldTypeMap xmlToFieldTypeMap = new SoapServices.XmlToFieldTypeMap();
foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
SoapFieldAttribute soapFieldAttribute = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(fieldInfo);
if (soapFieldAttribute.IsInteropXmlElement())
{
string xmlElementName = soapFieldAttribute.XmlElementName;
string xmlNamespace = soapFieldAttribute.XmlNamespace;
if (soapFieldAttribute.UseAttribute)
{
xmlToFieldTypeMap.AddXmlAttribute(fieldInfo.FieldType, fieldInfo.Name, xmlElementName, xmlNamespace);
}
else
{
xmlToFieldTypeMap.AddXmlElement(fieldInfo.FieldType, fieldInfo.Name, xmlElementName, xmlNamespace);
}
num++;
}
}
if (num > 0)
{
SoapServices._xmlToFieldTypeMap[type] = xmlToFieldTypeMap;
}
}
/// <summary>Preloads the given <see cref="T:System.Type" /> based on values set in a <see cref="T:System.Runtime.Remoting.Metadata.SoapTypeAttribute" /> on the type.</summary>
/// <param name="type">The <see cref="T:System.Type" /> to preload. </param>
/// <exception cref="T:System.Security.SecurityException">The immediate caller does not have infrastructure permission. </exception>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" />
/// </PermissionSet>
public static void PreLoad(Type type)
{
SoapServices.TypeInfo typeInfo = SoapServices._typeInfos[type] as SoapServices.TypeInfo;
if (typeInfo != null)
{
return;
}
string text;
string text2;
if (SoapServices.GetXmlTypeForInteropType(type, out text, out text2))
{
SoapServices.RegisterInteropXmlType(text, text2, type);
}
if (SoapServices.GetXmlElementForInteropType(type, out text, out text2))
{
SoapServices.RegisterInteropXmlElement(text, text2, type);
}
object syncRoot = SoapServices._typeInfos.SyncRoot;
lock (syncRoot)
{
typeInfo = new SoapServices.TypeInfo();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo fieldInfo in fields)
{
SoapFieldAttribute soapFieldAttribute = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(fieldInfo);
if (soapFieldAttribute.IsInteropXmlElement())
{
string nameKey = SoapServices.GetNameKey(soapFieldAttribute.XmlElementName, soapFieldAttribute.XmlNamespace);
if (soapFieldAttribute.UseAttribute)
{
if (typeInfo.Attributes == null)
{
typeInfo.Attributes = new Hashtable();
}
typeInfo.Attributes[nameKey] = fieldInfo;
}
else
{
if (typeInfo.Elements == null)
{
typeInfo.Elements = new Hashtable();
}
typeInfo.Elements[nameKey] = fieldInfo;
}
}
}
SoapServices._typeInfos[type] = typeInfo;
}
}
private void SerializeSimpleObject(
object currentObject,
long currentObjectId)
{
Type currentType = currentObject.GetType();
// Value type have to be serialized "on the fly" so
// SerializeComponent calls SerializeObject when
// a field of another object is a struct. A node with the field
// name has already be written so WriteStartElement must not be called
// again. Fields that are structs are passed to SerializeObject
// with a id = 0
if (currentObjectId > 0)
{
Element element = _mapper.GetXmlElement(currentType);
_xmlWriter.WriteStartElement(element.Prefix, element.LocalName, element.NamespaceURI);
Id(currentObjectId);
}
if (currentType == typeof(TimeSpan))
{
_xmlWriter.WriteString(SoapTypeMapper.GetXsdValue(currentObject));
}
else if (currentType == typeof(string))
{
_xmlWriter.WriteString(currentObject.ToString());
}
else
{
MemberInfo[] memberInfos = FormatterServices.GetSerializableMembers(currentType, _context);
object[] objectData = FormatterServices.GetObjectData(currentObject, memberInfos);
#if FIXED
for (int i = 0; i < memberInfos.Length; i++)
{
FieldInfo fieldInfo = (FieldInfo)memberInfos[i];
SoapFieldAttribute at = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(fieldInfo);
_xmlWriter.WriteStartElement(XmlConvert.EncodeLocalName(at.XmlElementName));
SerializeComponent(
objectData[i],
IsEncodingNeeded(objectData[i], fieldInfo.FieldType));
_xmlWriter.WriteEndElement();
}
#endif
}
if (currentObjectId > 0)
{
_xmlWriter.WriteFullEndElement();
}
}
public static void PreLoad(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
}
foreach (MethodInfo info in type.GetMethods())
{
RegisterSoapActionForMethodBase(info);
}
SoapTypeAttribute cachedSoapAttribute = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
if (cachedSoapAttribute.IsInteropXmlElement())
{
RegisterInteropXmlElement(cachedSoapAttribute.XmlElementName, cachedSoapAttribute.XmlNamespace, type);
}
if (cachedSoapAttribute.IsInteropXmlType())
{
RegisterInteropXmlType(cachedSoapAttribute.XmlTypeName, cachedSoapAttribute.XmlTypeNamespace, type);
}
int num = 0;
XmlToFieldTypeMap map = new XmlToFieldTypeMap();
foreach (FieldInfo info2 in type.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
SoapFieldAttribute attribute2 = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(info2);
if (attribute2.IsInteropXmlElement())
{
string xmlElementName = attribute2.XmlElementName;
string xmlNamespace = attribute2.XmlNamespace;
if (attribute2.UseAttribute)
{
map.AddXmlAttribute(info2.FieldType, info2.Name, xmlElementName, xmlNamespace);
}
else
{
map.AddXmlElement(info2.FieldType, info2.Name, xmlElementName, xmlNamespace);
}
num++;
}
}
if (num > 0)
{
_xmlToFieldTypeMap[type] = map;
}
}
public static void PreLoad(Type type)
{
foreach (MethodBase method in type.GetMethods())
{
SoapServices.RegisterSoapActionForMethodBase(method);
}
SoapTypeAttribute cachedSoapAttribute1 = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute((object)type);
if (cachedSoapAttribute1.IsInteropXmlElement())
{
SoapServices.RegisterInteropXmlElement(cachedSoapAttribute1.XmlElementName, cachedSoapAttribute1.XmlNamespace, type);
}
if (cachedSoapAttribute1.IsInteropXmlType())
{
SoapServices.RegisterInteropXmlType(cachedSoapAttribute1.XmlTypeName, cachedSoapAttribute1.XmlTypeNamespace, type);
}
int num = 0;
SoapServices.XmlToFieldTypeMap xmlToFieldTypeMap = new SoapServices.XmlToFieldTypeMap();
foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
SoapFieldAttribute cachedSoapAttribute2 = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute((object)field);
if (cachedSoapAttribute2.IsInteropXmlElement())
{
string xmlElementName = cachedSoapAttribute2.XmlElementName;
string xmlNamespace = cachedSoapAttribute2.XmlNamespace;
if (cachedSoapAttribute2.UseAttribute)
{
xmlToFieldTypeMap.AddXmlAttribute(field.FieldType, field.Name, xmlElementName, xmlNamespace);
}
else
{
xmlToFieldTypeMap.AddXmlElement(field.FieldType, field.Name, xmlElementName, xmlNamespace);
}
++num;
}
}
if (num <= 0)
{
return;
}
SoapServices._xmlToFieldTypeMap[(object)type] = (object)xmlToFieldTypeMap;
}
/// <summary>Gets an appropriate SOAP-related attribute for the specified class member or method parameter. </summary>
/// <param name="reflectionObject">A class member or method parameter.</param>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="Infrastructure" />
/// </PermissionSet>
public static SoapAttribute GetCachedSoapAttribute(object reflectionObject)
{
object syncRoot = InternalRemotingServices._soapAttributes.SyncRoot;
SoapAttribute result;
lock (syncRoot)
{
SoapAttribute soapAttribute = InternalRemotingServices._soapAttributes[reflectionObject] as SoapAttribute;
if (soapAttribute != null)
{
result = soapAttribute;
}
else
{
ICustomAttributeProvider customAttributeProvider = (ICustomAttributeProvider)reflectionObject;
object[] customAttributes = customAttributeProvider.GetCustomAttributes(typeof(SoapAttribute), true);
if (customAttributes.Length > 0)
{
soapAttribute = (SoapAttribute)customAttributes[0];
}
else if (reflectionObject is Type)
{
soapAttribute = new SoapTypeAttribute();
}
else if (reflectionObject is FieldInfo)
{
soapAttribute = new SoapFieldAttribute();
}
else if (reflectionObject is MethodBase)
{
soapAttribute = new SoapMethodAttribute();
}
else if (reflectionObject is ParameterInfo)
{
soapAttribute = new SoapParameterAttribute();
}
soapAttribute.SetReflectionObject(reflectionObject);
InternalRemotingServices._soapAttributes[reflectionObject] = soapAttribute;
result = soapAttribute;
}
}
return(result);
}
public static SoapAttribute GetCachedSoapAttribute(object reflectionObject)
{
lock (_soapAttributes.SyncRoot)
{
SoapAttribute att = _soapAttributes [reflectionObject] as SoapAttribute;
if (att != null)
{
return(att);
}
ICustomAttributeProvider ap = (ICustomAttributeProvider)reflectionObject;
object[] atts = ap.GetCustomAttributes(typeof(SoapAttribute), true);
if (atts.Length > 0)
{
att = (SoapAttribute)atts[0];
}
else
{
if (reflectionObject is Type)
{
att = new SoapTypeAttribute();
}
else if (reflectionObject is FieldInfo)
{
att = new SoapFieldAttribute();
}
else if (reflectionObject is MethodBase)
{
att = new SoapMethodAttribute();
}
else if (reflectionObject is ParameterInfo)
{
att = new SoapParameterAttribute();
}
}
att.SetReflectionObject(reflectionObject);
_soapAttributes [reflectionObject] = att;
return(att);
}
}
TypeMetadata GetTypeMetadata(Type type)
{
TypeMetadata tm = _fieldIndices[type] as TypeMetadata;
if (tm != null)
{
return(tm);
}
tm = new TypeMetadata();
tm.MemberInfos = FormatterServices.GetSerializableMembers(type, _context);
tm.Indices = new Hashtable();
for (int i = 0; i < tm.MemberInfos.Length; i++)
{
SoapFieldAttribute at = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(tm.MemberInfos[i]);
tm.Indices [XmlConvert.EncodeLocalName(at.XmlElementName)] = i;
}
_fieldIndices[type] = tm;
return(tm);
}
// Get the cached SOAP attribute data for an object.
public static SoapAttribute GetCachedSoapAttribute(Object reflectionObject)
{
// Validate the paramter to ensure that it is a
// legitimate reflection object.
if (reflectionObject == null)
{
return(null);
}
else if (!(reflectionObject is MemberInfo) &&
!(reflectionObject is ParameterInfo))
{
return(null);
}
lock (typeof(InternalRemotingServices))
{
Object attr;
Object[] attrs;
// Look for a cached value from last time.
if (attributeHash == null)
{
attributeHash = new Hashtable();
}
else if ((attr = attributeHash[reflectionObject]) != null)
{
return(attr as SoapAttribute);
}
// Get the attribute information from the type.
if (reflectionObject is Type)
{
attrs = ((Type)reflectionObject).GetCustomAttributes
(typeof(SoapTypeAttribute), true);
if (attrs == null || attrs.Length < 1)
{
attr = new SoapTypeAttribute();
}
else
{
attr = attrs[0];
}
}
else if (reflectionObject is MethodBase)
{
attrs = ((MethodBase)reflectionObject)
.GetCustomAttributes
(typeof(SoapMethodAttribute), true);
if (attrs == null || attrs.Length < 1)
{
attr = new SoapMethodAttribute();
}
else
{
attr = attrs[0];
}
}
else if (reflectionObject is FieldInfo)
{
attrs = ((FieldInfo)reflectionObject)
.GetCustomAttributes
(typeof(SoapFieldAttribute), true);
if (attrs == null || attrs.Length < 1)
{
attr = new SoapFieldAttribute();
}
else
{
attr = attrs[0];
}
}
else if (reflectionObject is ParameterInfo)
{
attrs = ((ParameterInfo)reflectionObject)
.GetCustomAttributes
(typeof(SoapParameterAttribute), true);
if (attrs == null || attrs.Length < 1)
{
attr = new SoapParameterAttribute();
}
else
{
attr = attrs[0];
}
}
else
{
attrs = ((MemberInfo)reflectionObject)
.GetCustomAttributes(typeof(SoapAttribute), true);
if (attrs == null || attrs.Length < 1)
{
attr = new SoapAttribute();
}
else
{
attr = attrs[0];
}
}
((SoapAttribute)attr).SetReflectInfo(reflectionObject);
return((SoapAttribute)attr);
}
}
[System.Security.SecurityCritical] // auto-generated
public static void PreLoad(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
Contract.EndContractBlock();
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
}
// register soap action values
MethodInfo[] methods = type.GetMethods();
foreach (MethodInfo mi in methods)
{
// This will only add an entry to the table if SoapAction was explicitly set
// on the SoapMethodAttribute.
RegisterSoapActionForMethodBase(mi);
}
// register interop xml elements and types if specified
SoapTypeAttribute attr = (SoapTypeAttribute)
InternalRemotingServices.GetCachedSoapAttribute(type);
if (attr.IsInteropXmlElement())
{
RegisterInteropXmlElement(attr.XmlElementName, attr.XmlNamespace, type);
}
if (attr.IsInteropXmlType())
{
RegisterInteropXmlType(attr.XmlTypeName, attr.XmlTypeNamespace, type);
}
// construct field maps for mapping xml elements and attributes back to
// the correct type
int mapCount = 0;
XmlToFieldTypeMap map = new XmlToFieldTypeMap();
foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
SoapFieldAttribute fieldAttr = (SoapFieldAttribute)
InternalRemotingServices.GetCachedSoapAttribute(field);
if (fieldAttr.IsInteropXmlElement())
{
String xmlName = fieldAttr.XmlElementName;
String xmlNamespace = fieldAttr.XmlNamespace;
if (fieldAttr.UseAttribute)
{
map.AddXmlAttribute(field.FieldType, field.Name, xmlName, xmlNamespace);
}
else
{
map.AddXmlElement(field.FieldType, field.Name, xmlName, xmlNamespace);
}
mapCount++;
}
} // foreach field
// add field map if there is more than one entry
if (mapCount > 0)
{
_xmlToFieldTypeMap[type] = map;
}
} // PreLoad
