本文整理汇总了C#中System.Xml.Serialization.ClassMap类的典型用法代码示例。如果您正苦于以下问题:C# ClassMap类的具体用法?C# ClassMap怎么用?C# ClassMap使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
ClassMap类属于System.Xml.Serialization命名空间,在下文中一共展示了ClassMap类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: XmlMembersMapping
internal XmlMembersMapping (string elementName, string ns, bool hasWrapperElement, bool writeAccessors, XmlMemberMapping[] mapping)
: base (elementName, ns)
{
_hasWrapperElement = hasWrapperElement;
_mapping = mapping;
ClassMap map = new ClassMap ();
map.IgnoreMemberNamespace = writeAccessors;
foreach (XmlMemberMapping mm in mapping)
map.AddMember (mm.TypeMapMember);
ObjectMap = map;
}
示例2: ImportParticleComplexContent
void ImportParticleComplexContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaParticle particle, CodeIdentifiers classIds, bool isMixed)
{
ImportParticleContent (typeQName, cmap, particle, classIds, false, ref isMixed);
if (isMixed && cmap.XmlTextCollector == null)
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.Name = classIds.AddUnique ("Text", member);
member.TypeData = TypeTranslator.GetTypeData (typeof(string[]));
member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData.ListItemTypeData));
member.IsXmlTextCollector = true;
member.ListMap = new ListMap ();
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
示例3: ImportSequenceContent
void ImportSequenceContent (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection items, CodeIdentifiers classIds, bool multiValue, ref bool isMixed)
{
foreach (XmlSchemaObject item in items)
{
if (item is XmlSchemaElement)
{
string ns;
XmlSchemaElement elem = (XmlSchemaElement) item;
XmlTypeMapping emap;
TypeData typeData = GetElementTypeData (typeQName, elem, null, out emap);
XmlSchemaElement refElem = GetRefElement (typeQName, elem, out ns);
if (elem.MaxOccurs == 1 && !multiValue)
{
XmlTypeMapMemberElement member = null;
if (typeData.SchemaType != SchemaTypes.Array)
{
member = new XmlTypeMapMemberElement ();
if (refElem.DefaultValue != null) member.DefaultValue = ImportDefaultValue (typeData, refElem.DefaultValue);
}
else if (GetTypeMapping (typeData).IsSimpleType)
{
// It is a simple list (space separated list).
// Since this is not supported, map as a single item value
member = new XmlTypeMapMemberElement ();
#if NET_2_0
// In MS.NET those types are mapped to a string
typeData = TypeTranslator.GetTypeData(typeof(string));
#else
typeData = typeData.ListItemTypeData;
#endif
}
else
member = new XmlTypeMapMemberList ();
if (elem.MinOccurs == 0 && typeData.IsValueType)
member.IsOptionalValueType = true;
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
cmap.AddMember (member);
}
else
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.ListMap = new ListMap ();
member.Name = classIds.AddUnique(CodeIdentifier.MakeValid(refElem.Name), member);
member.Documentation = GetDocumentation (elem);
member.TypeData = typeData.ListTypeData;
member.ElementInfo.Add (CreateElementInfo (ns, member, refElem.Name, typeData, refElem.IsNillable, refElem.Form, emap, items.IndexOf (item)));
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
else if (item is XmlSchemaAny)
{
XmlSchemaAny elem = (XmlSchemaAny) item;
XmlTypeMapMemberAnyElement member = new XmlTypeMapMemberAnyElement ();
member.Name = classIds.AddUnique ("Any", member);
member.Documentation = GetDocumentation (elem);
Type ctype;
if (elem.MaxOccurs != 1 || multiValue)
ctype = isMixed ? typeof(XmlNode[]) : typeof(XmlElement[]);
else
ctype = isMixed ? typeof(XmlNode) : typeof(XmlElement);
member.TypeData = TypeTranslator.GetTypeData (ctype);
XmlTypeMapElementInfo einfo = new XmlTypeMapElementInfo (member, member.TypeData);
einfo.IsUnnamedAnyElement = true;
member.ElementInfo.Add (einfo);
if (isMixed)
{
einfo = CreateTextElementInfo (typeQName.Namespace, member, member.TypeData);
member.ElementInfo.Add (einfo);
member.IsXmlTextCollector = true;
isMixed = false; //Allow only one XmlTextAttribute
}
cmap.AddMember (member);
}
else if (item is XmlSchemaParticle) {
ImportParticleContent (typeQName, cmap, (XmlSchemaParticle)item, classIds, multiValue, ref isMixed);
}
}
}
示例4: AddTextMember
void AddTextMember (XmlQualifiedName typeQName, ClassMap cmap, CodeIdentifiers classIds)
{
if (cmap.XmlTextCollector == null)
{
XmlTypeMapMemberFlatList member = new XmlTypeMapMemberFlatList ();
member.Name = classIds.AddUnique ("Text", member);
member.TypeData = TypeTranslator.GetTypeData (typeof(string[]));
member.ElementInfo.Add (CreateTextElementInfo (typeQName.Namespace, member, member.TypeData.ListItemTypeData));
member.IsXmlTextCollector = true;
member.ListMap = new ListMap ();
member.ListMap.ItemInfo = member.ElementInfo;
cmap.AddMember (member);
}
}
示例5: BuildArrayMap
ListMap BuildArrayMap (XmlQualifiedName typeQName, XmlSchemaComplexType stype, out TypeData arrayTypeData)
{
if (encodedFormat)
{
XmlSchemaComplexContent content = stype.ContentModel as XmlSchemaComplexContent;
XmlSchemaComplexContentRestriction rest = content.Content as XmlSchemaComplexContentRestriction;
XmlSchemaAttribute arrayTypeAt = FindArrayAttribute (rest.Attributes);
if (arrayTypeAt != null)
{
XmlAttribute[] uatts = arrayTypeAt.UnhandledAttributes;
if (uatts == null || uatts.Length == 0) throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
XmlAttribute xat = null;
foreach (XmlAttribute at in uatts)
if (at.LocalName == "arrayType" && at.NamespaceURI == XmlSerializer.WsdlNamespace)
{ xat = at; break; }
if (xat == null)
throw new InvalidOperationException ("arrayType attribute not specified in array declaration: " + typeQName);
string name, ns, dims;
TypeTranslator.ParseArrayType (xat.Value, out name, out ns, out dims);
return BuildEncodedArrayMap (name + dims, ns, out arrayTypeData);
}
else
{
XmlSchemaElement elem = null;
XmlSchemaSequence seq = rest.Particle as XmlSchemaSequence;
if (seq != null && seq.Items.Count == 1)
elem = seq.Items[0] as XmlSchemaElement;
else {
XmlSchemaAll all = rest.Particle as XmlSchemaAll;
if (all != null && all.Items.Count == 1)
elem = all.Items[0] as XmlSchemaElement;
}
if (elem == null)
throw new InvalidOperationException ("Unknown array format");
return BuildEncodedArrayMap (elem.SchemaTypeName.Name + "[]", elem.SchemaTypeName.Namespace, out arrayTypeData);
}
}
else
{
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers();
ImportParticleComplexContent (typeQName, cmap, stype.Particle, classIds, stype.IsMixed);
XmlTypeMapMemberFlatList list = (cmap.AllMembers.Count == 1) ? cmap.AllMembers[0] as XmlTypeMapMemberFlatList : null;
if (list != null && list.ChoiceMember == null)
{
arrayTypeData = list.TypeData;
return list.ListMap;
}
else
{
arrayTypeData = null;
return null;
}
}
}
示例6: ImportAttributes
void ImportAttributes (XmlQualifiedName typeQName, ClassMap cmap, XmlSchemaObjectCollection atts, XmlSchemaAnyAttribute anyat, CodeIdentifiers classIds)
{
atts = CollectAttributeUsesNonOverlap (atts, cmap);
if (anyat != null)
{
XmlTypeMapMemberAnyAttribute member = new XmlTypeMapMemberAnyAttribute ();
member.Name = classIds.AddUnique ("AnyAttribute", member);
member.TypeData = TypeTranslator.GetTypeData (typeof(XmlAttribute[]));
cmap.AddMember (member);
}
foreach (XmlSchemaObject at in atts)
{
if (at is XmlSchemaAttribute)
{
string ns;
XmlSchemaAttribute attr = (XmlSchemaAttribute)at;
XmlSchemaAttribute refAttr = GetRefAttribute (typeQName, attr, out ns);
XmlTypeMapMemberAttribute member = new XmlTypeMapMemberAttribute ();
member.Name = classIds.AddUnique (CodeIdentifier.MakeValid (refAttr.Name), member);
member.Documentation = GetDocumentation (attr);
member.AttributeName = refAttr.Name;
member.Namespace = ns;
member.Form = refAttr.Form;
member.TypeData = GetAttributeTypeData (typeQName, attr);
if (refAttr.DefaultValue != null)
member.DefaultValue = ImportDefaultValue (member.TypeData, refAttr.DefaultValue);
else if (member.TypeData.IsValueType)
member.IsOptionalValueType = (refAttr.ValidatedUse != XmlSchemaUse.Required);
if (member.TypeData.IsComplexType)
member.MappedType = GetTypeMapping (member.TypeData);
cmap.AddMember (member);
}
else if (at is XmlSchemaAttributeGroupRef)
{
XmlSchemaAttributeGroupRef gref = (XmlSchemaAttributeGroupRef)at;
XmlSchemaAttributeGroup grp = FindRefAttributeGroup (gref.RefName);
ImportAttributes (typeQName, cmap, grp.Attributes, grp.AnyAttribute, classIds);
}
}
}
示例7: ImportMembersMappingComposite
XmlMemberMapping[] ImportMembersMappingComposite (XmlSchemaComplexType stype, XmlQualifiedName refer)
{
if (stype.Particle == null)
return new XmlMemberMapping [0];
ClassMap cmap = new ClassMap ();
XmlSchemaSequence seq = stype.Particle as XmlSchemaSequence;
if (seq == null) throw new InvalidOperationException ("Schema element '" + refer + "' cannot be imported as XmlMembersMapping");
CodeIdentifiers classIds = new CodeIdentifiers ();
ImportParticleComplexContent (refer, cmap, seq, classIds, false);
ImportAttributes (refer, cmap, stype.Attributes, stype.AnyAttribute, classIds);
BuildPendingMaps ();
int n = 0;
XmlMemberMapping[] mapping = new XmlMemberMapping [cmap.AllMembers.Count];
foreach (XmlTypeMapMember mapMem in cmap.AllMembers)
mapping[n++] = new XmlMemberMapping (mapMem.Name, refer.Namespace, mapMem, encodedFormat);
return mapping;
}
示例8: ImportAnyType
public XmlMembersMapping ImportAnyType (XmlQualifiedName typeName, string elementName)
{
if (typeName == XmlQualifiedName.Empty)
{
XmlTypeMapMemberAnyElement mapMem = new XmlTypeMapMemberAnyElement ();
mapMem.Name = typeName.Name;
mapMem.TypeData = TypeTranslator.GetTypeData(typeof(XmlNode));
mapMem.ElementInfo.Add (CreateElementInfo (typeName.Namespace, mapMem, typeName.Name, mapMem.TypeData, true, XmlSchemaForm.None, -1));
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
else
{
XmlSchemaComplexType stype = (XmlSchemaComplexType) schemas.Find (typeName, typeof (XmlSchemaComplexType));
if (stype == null)
throw new InvalidOperationException ("Referenced type '" + typeName + "' not found");
if (!CanBeAnyElement (stype))
throw new InvalidOperationException ("The type '" + typeName + "' is not valid for a collection of any elements");
ClassMap cmap = new ClassMap ();
CodeIdentifiers classIds = new CodeIdentifiers ();
bool isMixed = stype.IsMixed;
ImportSequenceContent (typeName, cmap, ((XmlSchemaSequence) stype.Particle).Items, classIds, false, ref isMixed);
XmlTypeMapMemberAnyElement mapMem = (XmlTypeMapMemberAnyElement) cmap.AllMembers[0];
mapMem.Name = typeName.Name;
XmlMemberMapping[] mm = new XmlMemberMapping [1];
mm[0] = new XmlMemberMapping (typeName.Name, typeName.Namespace, mapMem, encodedFormat);
return new XmlMembersMapping (mm);
}
}
示例9: ExportMembersMapSchema
void ExportMembersMapSchema (XmlSchema schema, ClassMap map, XmlTypeMapping baseMap, XmlSchemaObjectCollection outAttributes, out XmlSchemaSequence particle, out XmlSchemaAnyAttribute anyAttribute)
{
particle = null;
XmlSchemaSequence seq = new XmlSchemaSequence ();
ICollection members = map.ElementMembers;
if (members != null && !map.HasSimpleContent)
{
foreach (XmlTypeMapMemberElement member in members)
{
if (baseMap != null && DefinedInBaseMap (baseMap, member)) continue;
Type memType = member.GetType();
if (memType == typeof(XmlTypeMapMemberFlatList))
{
XmlSchemaParticle part = GetSchemaArrayElement (schema, member.ElementInfo);
if (part != null) seq.Items.Add (part);
}
else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
seq.Items.Add (GetSchemaArrayElement (schema, member.ElementInfo));
}
else if (memType == typeof(XmlTypeMapMemberElement))
{
GetSchemaElement (schema, (XmlTypeMapElementInfo) member.ElementInfo [0],
member.DefaultValue, true, new XmlSchemaObjectContainer (seq));
}
else
{
GetSchemaElement (schema, (XmlTypeMapElementInfo) member.ElementInfo[0],
true, new XmlSchemaObjectContainer (seq));
}
}
}
if (seq.Items.Count > 0)
particle = seq;
// Write attributes
ICollection attributes = map.AttributeMembers;
if (attributes != null)
{
foreach (XmlTypeMapMemberAttribute attr in attributes) {
if (baseMap != null && DefinedInBaseMap (baseMap, attr)) continue;
outAttributes.Add (GetSchemaAttribute (schema, attr, true));
}
}
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
if (anyAttrMember != null)
anyAttribute = new XmlSchemaAnyAttribute ();
else
anyAttribute = null;
}
示例10: FixupCallbackInfo
public FixupCallbackInfo (XmlSerializationReaderInterpreter sri, ClassMap map, bool isValueList)
{
_sri = sri;
_map = map;
_isValueList = isValueList;
}
示例11: FixupMembers
internal void FixupMembers (ClassMap map, object obfixup, bool isValueList)
{
Fixup fixup = (Fixup)obfixup;
ICollection members = map.ElementMembers;
string[] ids = fixup.Ids;
foreach (XmlTypeMapMember member in members)
{
if (ids[member.Index] != null)
SetMemberValue (member, fixup.Source, GetTarget(ids[member.Index]), isValueList);
}
}
示例12: SetListMembersDefaults
void SetListMembersDefaults (ClassMap map, object ob, bool isValueList)
{
if (map.ListMembers != null)
{
ArrayList members = map.ListMembers;
for (int n=0; n<members.Count; n++) {
XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
if (IsReadOnly (mem, mem.TypeData, ob, isValueList))
continue;
if (GetMemberValue (mem, ob, isValueList) == null)
SetMemberValue (mem, ob, InitializeList (mem.TypeData), isValueList);
}
}
}
示例13: ReadMembers
void ReadMembers (ClassMap map, object ob, bool isValueList, bool readByOrder)
{
// Reads attributes
ReadAttributeMembers (map, ob, isValueList);
if (!isValueList)
{
Reader.MoveToElement();
if (Reader.IsEmptyElement) {
SetListMembersDefaults (map, ob, isValueList);
return;
}
Reader.ReadStartElement();
}
// Reads elements
bool[] readFlag = new bool[(map.ElementMembers != null) ? map.ElementMembers.Count : 0];
bool hasAnyReturnMember = (isValueList && _format == SerializationFormat.Encoded && map.ReturnMember != null);
Reader.MoveToContent();
int[] indexes = null;
object[] flatLists = null;
object[] flatListsChoices = null;
Fixup fixup = null;
int ind = 0;
int maxInd;
if (readByOrder) {
if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
else maxInd = 0;
}
else
maxInd = int.MaxValue;
if (map.FlatLists != null)
{
indexes = new int[map.FlatLists.Count];
flatLists = new object[map.FlatLists.Count];
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists) {
if (IsReadOnly (mem, mem.TypeData, ob, isValueList))
flatLists [mem.FlatArrayIndex] = mem.GetValue (ob);
else if (mem.TypeData.Type.IsArray) {
flatLists [mem.FlatArrayIndex] = InitializeList (mem.TypeData);
}
else {
object list = mem.GetValue (ob);
if (list == null) {
list = InitializeList (mem.TypeData);
SetMemberValue (mem, ob, list, isValueList);
}
flatLists [mem.FlatArrayIndex] = list;
}
if (mem.ChoiceMember != null) {
if (flatListsChoices == null)
flatListsChoices = new object [map.FlatLists.Count];
flatListsChoices [mem.FlatArrayIndex] = InitializeList (mem.ChoiceTypeData);
}
}
}
if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
{
FixupCallbackInfo info = new FixupCallbackInfo (this, map, isValueList);
fixup = new Fixup(ob, new XmlSerializationFixupCallback(info.FixupMembers), map.ElementMembers.Count);
AddFixup (fixup);
}
while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && (ind < maxInd))
{
if (Reader.NodeType == System.Xml.XmlNodeType.Element)
{
XmlTypeMapElementInfo info;
if (readByOrder) {
info = map.GetElement (ind++);
}
else if (hasAnyReturnMember) {
info = (XmlTypeMapElementInfo) ((XmlTypeMapMemberElement)map.ReturnMember).ElementInfo[0];
hasAnyReturnMember = false;
}
else
info = map.GetElement (Reader.LocalName, Reader.NamespaceURI);
if (info != null && !readFlag[info.Member.Index] )
{
if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
{
if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
{
object list = ReadReferencingElement (out fixup.Ids[info.Member.Index]);
if (fixup.Ids[info.Member.Index] == null) // Already read
{
if (IsReadOnly (info.Member, info.TypeData, ob, isValueList)) throw CreateReadOnlyCollectionException (info.TypeData.FullTypeName);
else SetMemberValue (info.Member, ob, list, isValueList);
}
//.........这里部分代码省略.........
示例14: ReadAttributeMembers
void ReadAttributeMembers (ClassMap map, object ob, bool isValueList)
{
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
int anyAttributeIndex = 0;
object anyAttributeArray = null;
while (Reader.MoveToNextAttribute())
{
XmlTypeMapMemberAttribute member = map.GetAttribute (Reader.LocalName, Reader.NamespaceURI);
if (member != null)
{
SetMemberValue (member, ob, GetValueFromXmlString (Reader.Value, member.TypeData, member.MappedType), isValueList);
}
else if (IsXmlnsAttribute(Reader.Name))
{
// If the map has NamespaceDeclarations,
// then store this xmlns to the given member.
// If the instance doesn't exist, then create.
if (map.NamespaceDeclarations != null) {
XmlSerializerNamespaces nss = this.GetMemberValue (map.NamespaceDeclarations, ob, isValueList) as XmlSerializerNamespaces;
if (nss == null) {
nss = new XmlSerializerNamespaces ();
SetMemberValue (map.NamespaceDeclarations, ob, nss, isValueList);
}
if (Reader.Prefix == "xmlns")
nss.Add (Reader.LocalName, Reader.Value);
else
nss.Add ("", Reader.Value);
}
}
else if (anyAttrMember != null)
{
XmlAttribute attr = (XmlAttribute) Document.ReadNode(Reader);
ParseWsdlArrayType (attr);
AddListValue (anyAttrMember.TypeData, ref anyAttributeArray, anyAttributeIndex++, attr, true);
}
else
ProcessUnknownAttribute(ob);
}
if (anyAttrMember != null)
{
anyAttributeArray = ShrinkArray ((Array)anyAttributeArray, anyAttributeIndex, anyAttrMember.TypeData.Type.GetElementType(), true);
SetMemberValue (anyAttrMember, ob, anyAttributeArray, isValueList);
}
Reader.MoveToElement ();
}
示例15: GenerateSetListMembersDefaults
void GenerateSetListMembersDefaults (XmlTypeMapping typeMap, ClassMap map, string ob, bool isValueList)
{
if (map.ListMembers != null)
{
ArrayList members = map.ListMembers;
for (int n=0; n<members.Count; n++) {
XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
continue;
WriteLineInd ("if (" + GenerateGetMemberValue (mem, ob, isValueList) + " == null) {");
GenerateSetMemberValue (mem, ob, GenerateInitializeList (mem.TypeData), isValueList);
WriteLineUni ("}");
}
}
}