anchor.diff:          | Some attr when not (empty attr.ItemName) -> attr.ItemName
           | _ -> "item"
   
  -    let defaultDictNames = { Item = "item"; Key = "key"; Value = "value" }
  -
  -    let getDictNames (attribute : XmlElementAttribute option) =
  +    let getDefaultNameInfo name = {
  +        Name = name
  +        Item = "item"
  +        Key = "key"
  +        Value = "value" }
  +
  +    let getNameInfo (property : PropertyInfo) =
  +        let attribute = getAttribute<XmlElementAttribute> property
           let get str fb = if not (empty str) then str else fb
           match attribute with
           | Some attr ->
               let item = get attr.ItemName "item"
               let key = get attr.KeyName "key"
               let value = get attr.ValueName "value"
  -            { Item = item; Key = key; Value = value }
  -        | _ -> defaultDictNames
  +            let name = get attr.Name (property.Name.ToCamelCase())
  +            { Name = name; Item = item; Key = key; Value = value }
  +        | _ -> getDefaultNameInfo (property.Name.ToCamelCase())
   
       /// Build a PropertyWriterInfo object based on the
       /// specified PropertyInfo
       let rec buildPropertyWriterInfo (propInfo : PropertyInfo) =
  -        let cls =
  -            match getAttribute<XmlElementAttribute> propInfo with
  -            | Some attr when not (empty attr.Name) -> attr.Name
  -            | _ -> propInfo.Name.ToCamelCase()
           { Info = propInfo
             OriginalName = propInfo.Name
  -          ClsName = cls
  +          Name = getNameInfo propInfo
             GetFunc = Reflection.getObjGetter propInfo
             WriteFunc = lazy getWriterFunc propInfo.PropertyType
             Default = Reflection.getDefaultValue propInfo.PropertyType }
   
       /// Try to determine a enumerable serialization function
       and getEnumerableWriter attr (t : Type) = fun () ->
  -        let itemName = getItemName attr
           match TypeHelper.getTypeWithGenericType t typedefof<IEnumerable<_>> with
           | Some enumerableType ->
               let elemType = enumerableType.GetGenericArguments().[0]
               let elemWriter = getWriterFunc elemType
  -            Some <| ListSerializer.getGenericEnumerableWriter itemName elemWriter elemType
  +            Some <| ListSerializer.getGenericEnumerableWriter elemWriter elemType
           | _ ->
               if t.HasInterface typeof<IEnumerable> ||
                   t.IsAssignableFrom typeof<IEnumerable> then
  -                Some <| ListSerializer.writeEnumerable itemName getWriterFunc
  +                Some <| ListSerializer.writeEnumerable getWriterFunc
               else None
   
       /// Get the PropertyWriterInfo array for the given type
  
positive.code:             | _ -> writer.Write(c)
          Seq.iter sanitize content
  
      let inline nullableWriter writer value func =
          if value <> null then func writer value
  
      let writeStringObject writer (value : obj) =
          let v : string = unbox value
          writeString writer v
  
      let writeObject (writer : TextWriter) (value : obj) =
          writer.Write(value)
  
      let writeFloat2f (writer : TextWriter) (value : obj) =
          let v = sprintf "%.2f" (unbox value)
          writeString writer v
  
      let writeDateTime writer (value : obj) =
          let v = toShortestXsdFormat (unbox value)
          writeString writer v
  
      let writeNullableDateTime writer (value : obj) =
          nullableWriter writer value writeDateTime
  
      let writeDateTimeOffset writer (value : obj) =
          let v : DateTimeOffset = unbox value
          writeString writer (v.ToString("o"))
  
      let writeNullableDateTimeOffset writer (value : obj) =
          nullableWriter writer value writeDateTimeOffset
  
      let writeGuid writer (value : obj) =
          let v : Guid = unbox value
          writeString writer (v.ToString("N"))
  
      let writeNullableGuid writer (value : obj) =
          nullableWriter writer value writeGuid
  
      let writeChar (writer : TextWriter) (value : obj) =
          let v : char = unbox value
          writer.Write(v)
  
      let writeChars (writer : TextWriter) (value : obj) =
          let v : char[] = unbox value
          writer.Write(v)
  
      let writeByte (writer : TextWriter) (value : obj) =
          let v : byte = unbox value
          writer.Write(v)
  
      let writeSByte (writer : TextWriter) (value : obj) =
          let v : sbyte = unbox value
          writer.Write(v)
  
      let writeBytes (writer : TextWriter) (value : obj) =
          let v = Convert.ToBase64String(unbox value)
          writer.Write(v)
  
      let writeUInt16 (writer : TextWriter) (value : obj) =
          let v : uint16 = unbox value
          writer.Write(v)
  
      let writeInt16 (writer : TextWriter) (value : obj) =
          let v : int16 = unbox value
          writer.Write(v)
  
      let writeInt32 (writer : TextWriter) (value : obj) =
          let v : int = unbox value
          writer.Write(v)
  
      let writeUInt32 (writer : TextWriter) (value : obj) =
          let v : uint32 = unbox value
          writer.Write(v)
  
      let writeInt64 (writer : TextWriter) (value : obj) =
          let v : int64 = unbox value
          writer.Write(v)
  
      let writeUInt64 (writer : TextWriter) (value : obj) =
          let v : uint64 = unbox value
          writer.Write(v)
  
      let writeFloat (writer : TextWriter) (value : obj) =
          let v : float = unbox value
          writer.Write(v.ToString(CultureInfo.InvariantCulture))
  
      let writeFloat32 (writer : TextWriter) (value : obj) =
          let v : float32 = unbox value
          writer.Write(v.ToString(CultureInfo.InvariantCulture))
  
      let writeBool (writer : TextWriter) (value : obj) =
          let v : bool = unbox value
          match v with
          | true -> writer.Write("true")
          | false -> writer.Write("false")
  
      let writeDecimal writer (value : obj) =
          let v : decimal = unbox value
          writeString writer (v.ToString(CultureInfo.InvariantCulture))
  
      let writeEnum writer (value : obj) =
          writeObject writer value
  
      let writeEnumNames (writer : TextWriter) (value : obj) =
          let v : int = unbox value
          writer.Write(v)
  
      let writeType writer (value : obj) =
          let v : Type = unbox value
          writeString writer v.AssemblyQualifiedName
  
      let writeException writer (value : obj) =
          let v : Exception = unbox value
          writeString writer v.Message
  
  
negative.code:             if (!valueWriter).IsNone then valueWriter := Some <| getWriterFunc (dictVal.GetType())
              match !keyWriter, !valueWriter with
              | Some kv, Some vw ->
                  writer.Write(sprintf "<%s>" name.Item)
                  writeTag name.Key name writer kv key
                  writeTag name.Value name writer vw dictVal
                  writer.Write(sprintf "</%s>" name.Item)
              | _ -> ())
  
      and getGenericWriter (t : Type) = fun () ->
  