C# Label.getConverter方法代码示例

 /// <summary>
 /// This <c>readObject</c> method is used to perform the
 /// deserialization of the XML in to any original value. If there
 /// is no original value then this will do a read and instantiate
 /// a new value to deserialize in to. Reading in to the original
 /// ensures that existing lists or maps can be read in to.
 /// </summary>
 /// <param name="node">
 /// this is the node that contains the contact value
 /// </param>
 /// <param name="source">
 /// the source object to assign the contact value to
 /// </param>
 /// <param name="label">
 /// this is the label used to create the converter
 /// </param>
 /// <returns>
 /// this returns the original value deserialized in to
 /// </returns>
 public Object ReadObject(InputNode node, Object source, Label label) {
    Converter reader = label.getConverter(context);
    String name = label.GetName(context);
    if(label.isCollection()) {
       Variable variable = criteria.Get(name);
       Contact contact = label.getContact();
       if(variable != null) {
          Object value = variable.getValue();
          return reader.Read(node, value);
       } else {
          if(source != null) {
             Object value = contact.Get(source);
             if(value != null) {
                return reader.Read(node, value);
             }
          }
       }
    }
    return reader.Read(node);
 }

 /// <summary>
 /// This <c>validate</c> method is used to perform validation
 /// of the provided node object using a delegate converter. This is
 /// typically another <c>Composite</c> converter, or if the
 /// node is an attribute a <c>Primitive</c> converter. If this
 /// fails validation then an exception is thrown to report the issue.
 /// </summary>
 /// <param name="node">
 /// this is the node that contains the contact value
 /// </param>
 /// <param name="label">
 /// this is the label used to create the converter
 /// </param>
 public void Validate(InputNode node, Label label) {
    Converter reader = label.getConverter(context);
    Position line = node.getPosition();
    Class expect = type.Type;
    bool valid = reader.Validate(node);
    if(valid == false) {
      throw new PersistenceException("Invalid value for %s in %s at %s", label, expect, line);
    }
    criteria.Set(label, null);
 }

 /// <summary>
 /// This write method is used to append the provided object as an
 /// element to the given XML element object. This will recursively
 /// write the contacts from the provided object as elements. This is
 /// done using the <c>Converter</c> acquired from the contact
 /// label. If the type of the contact value is not of the same
 /// type as the XML schema class a "class" attribute is appended.
 /// <p>
 /// If the element being written is inline, then this will not
 /// check to see if there is a "class" attribute specifying the
 /// name of the class. This is because inline elements do not have
 /// an outer class and thus could never have an override.
 /// </summary>
 /// <param name="value">
 /// this is the value to be set as an element
 /// </param>
 /// <param name="node">
 /// this is the XML element to write the element to
 /// </param>
 /// <param name="label">
 /// the label that contains the contact details
 /// </param>
 public void WriteElement(OutputNode node, Object value, Label label) {
    if(value != null) {
       String name = label.GetName(context);
       OutputNode next = node.getChild(name);
       Type contact = label.getContact();
       Class type = contact.Type;
       if(!label.isInline()) {
          WriteNamespaces(next, type, label);
       }
       if(label.isInline() || !IsOverridden(next, value, contact)) {
          Converter convert = label.getConverter(context);
          bool data = label.isData();
          next.setData(data);
          WriteElement(next, value, convert);
       }
    }
 }