C# Class.getComponentType方法代码示例

 /// <summary>
 /// This is used to match a <c>Transform</c> based on the
 /// array component type of an object to be transformed. This will
 /// attempt to match the transform using the fully qualified class
 /// name of the array component type. If a transform can not be
 /// found then this method will throw an exception.
 /// </summary>
 /// <param name="type">
 /// this is the array to find the transform for
 /// </param>
 public Transform Match(Class type) {
    Class entry = type.getComponentType();
    if(entry == char.class) {
       return new CharacterArrayTransform(entry);
    }
    if(entry == Character.class) {
       return new CharacterArrayTransform(entry);
    }
    if(entry == String.class) {
       return new StringArrayTransform();
    }
    return MatchArray(entry);
 }

 /// <summary>
 /// This is used to determine whether the provided base class can be
 /// assigned from the issued type. For an override to be compatible
 /// with the field type an instance of the override type must be
 /// assignable to the field value.
 /// </summary>
 /// <param name="expect">
 /// this is the field value present the the object
 /// </param>
 /// <param name="type">
 /// this is the specialized type that will be assigned
 /// </param>
 /// <returns>
 /// true if the field type can be assigned the type value
 /// </returns>
 public bool IsCompatible(Class expect, Class type) {
    if(expect.isArray()) {
       expect = expect.getComponentType();
    }
    return expect.isAssignableFrom(type);
 }

 /// <summary>
 /// This is used to add a length attribute to the element due to
 /// the fact that the serialized value is an array. The length
 /// of the array is acquired and inserted in to the attributes.
 /// </summary>
 /// <param name="field">
 /// this is the field type for the array to set
 /// </param>
 /// <param name="value">
 /// this is the actual value for the array to set
 /// </param>
 /// <param name="node">
 /// this is the map of attributes for the element
 /// </param>
 /// <returns>
 /// returns the array component type that is set
 /// </returns>
 public Class WriteArray(Class field, Object value, NodeMap node) {
    int size = Array.getLength(value);
    if(length != null) {
       node.put(length, String.valueOf(size));
    }
    return field.getComponentType();
 }

 /// <summary>
 /// This returns the name of the class specified. If there is a root
 /// annotation on the type, then this is ignored in favor of the
 /// actual class name. This is typically used when the type is a
 /// primitive or if there is no <c>Root</c> annotation present.
 /// </summary>
 /// <param name="type">
 /// this is the type to acquire the root name for
 /// </param>
 /// <returns>
 /// this returns the name of the type from the root
 /// </returns>
 public String GetClassName(Class type) {
    if(type.isArray()) {
       type = type.getComponentType();
    }
    String name = type.getSimpleName();
    if(type.IsPrimitive()) {
       return name;
    }
    return Reflector.GetName(name);
 }