vectorlayer图层为什么转kmllayer，data属性写入失败?

            //创建点实体图层--向量图层，并且可以进行编辑。
            protected function button3_clickHandler(event:MouseEvent):void
            {
                // TODO Auto-generated method stub
                //创建feature图层
                var markers:VectorLayer = new VectorLayer("markers_demo");
                
                markers.projection= new  ProjProjection("EPSG:4326");
                markers.generateResolutions(19);
                markers.style = Style.getDefaultPointStyle();
                markers.style.name="DefaultPointStyle";  //!!否则导出kml属性报错
                //生成feature对象并加入图层
                //add the first marker
                var marker:PointFeature = PointFeature.createPointFeature(new Location(4.85680,45.75336));
                marker.name="pt101";
                marker.style=Style.getDefaultPointStyle();
                marker.style.name="DefaultPointStyle";  //!!否则导出kml属性报错
                markers.addFeature(marker);
                
                //add a second marker
                marker = PointFeature.createPointFeature(new Location(4.65780,45.55336));
                marker.name="pt102";
                marker.style=Style.getDefaultPointStyle();
                marker.style.name="DefaultPointStyle";  //!!否则导出kml属性报错
                //markers.addEventListener(FeatureEvent.FEATURE_OVER,dd);
                markers.addFeature(marker);
                
                var lblfeature:LabelFeature = LabelFeature.createLabelFeature(new Location(4.65880,45.35336));
                lblfeature.name="pt104";
                lblfeature.text="你好123";
                lblfeature.style=Style.getDefaultLabelStyle();
                lblfeature.style.name="DefaultLabelStyle";  //!!否则导出kml属性报错                
                //markers.addEventListener(FeatureEvent.FEATURE_OVER,dd);
                markers.addFeature(lblfeature);

                markers.editable=true;  //图层是否可编辑，决定在图层管理中该层是否显示添加点、线、面等画图按钮。
                markers.selected=true;
                markers.available=true;
                

                map1.map.addLayer(markers);

}

            //写入矢量图层的data属性，vectorlayer默认为空，不同于kml图层。
            protected function button9_clickHandler(event:MouseEvent):void
            {
                if(list_layer.selectedIndex<0) return;
                if(_map!=null)
                {
                    var selvalue:String=list_layer.dataProvider[list_layer.selectedIndex].value;                    
                    var _veclayer:VectorLayer=_map.getLayerByIdentifier(selvalue) as VectorLayer;
                    
                    Alert.show(_veclayer.features.length.toString());

                    var _kmlformat:KMLFormat=new KMLFormat();

                    _veclayer.displayedName="ajbjl";
                    var odata:Object=_kmlformat.write(_veclayer.features);  //!!!要求图层内所有实体必须设置style,style.name属性。否则报错
                    _veclayer.data=odata as XML;
                }
            }

另附抠取代码：

           
            private function write(features:Object):Object
            {
                //todo write multigeometries
                var i:uint;
                var kmlns:Namespace = new Namespace("kml","http://www.opengis.net/kml/2.2");
                var kmlFile:XML = new XML("<kml></kml>");
                kmlFile.addNamespace(kmlns);
                
                var doc:XML = new XML("<Document></Document>");
                kmlFile.appendChild(doc);
                
                var listOfFeatures:Vector.<Feature> = features as Vector.<Feature>;
                var numberOfFeat:uint = listOfFeatures.length;
                if (numberOfFeat > 0 && listOfFeatures[0].layer)
                {
                    var name:XML = new XML("<name>"+listOfFeatures[0].layer.displayedName+"</name>");
                    doc.appendChild(name);
                }
                // gather Style list
                var styleHashMap:HashMap = new HashMap();
                for(i = 0; i < numberOfFeat; ++i)
                {
                    if(listOfFeatures[i].style)
                    {
                        styleHashMap.put("#"+(listOfFeatures[i] as Feature).style.name, (listOfFeatures[i] as Feature).style);
                    }
                }
                
                //build the style nodes first
                var keysArray:Array = styleHashMap.getKeys();
                var keyLength:Number = keysArray.length;
                for(i = 0; i < keyLength; ++i)
                {
                    var style:XML = this.buildStyleNode(styleHashMap.getValue(keysArray[i]));
                    if (style)
                        doc.appendChild(style);
                }
                
                //build the placemarks
                for (i = 0; i < numberOfFeat; i++)
                {
                    doc.appendChild(this.buildPlacemarkNode(listOfFeatures[i],i));
                }
                return kmlFile;
            }
            private function buildStyleNode(style:Style):XML
            {
                var color:uint;
                var opacity:Number;
                var width:Number;
                
                var stroke:Stroke;
                var rules:Vector.<Rule> = style.rules;
                var symbolizers:Vector.<Symbolizer>;
                if(rules.length > 0)
                {
                    symbolizers = rules[0].symbolizers;
                }
                
                //global style; can contain multiple Style types (Poly, Line, Icon)
                var placemarkStyle:XML = new XML("<Style></Style>");
                
                //Save the style id
                placemarkStyle.@id = style.name;
                
                if(!symbolizers)
                    return null;
                
                var styleNode:XML = null;
                var extensionNode:XML=null;
                var symbLength:Number =symbolizers.length;
                
                // Boolean that track if a stroke style has been exported
                //(to avoid stoke style duplication between polygon et line style)
                var strokeExported:Boolean = false;
                for (var i:int = 0; i < symbLength; ++i)
                {
                    
                    var symb:Symbolizer = symbolizers[i];
                    if (symb is TextSymbolizer) {
                        styleNode = new XML("<LabelStyle></LabelStyle>");
                        var ts:TextSymbolizer = symb as TextSymbolizer;
                        extensionNode = new XML("<LabelStyleSimpleExtensionGroup></LabelStyleSimpleExtensionGroup>");
                        var addExtension:Boolean = false;
                        if(ts.propertyName) {
                            addExtension = true;
                            extensionNode.@propertyName = ts.propertyName;
                        }
                        if(ts.font) {
                            addExtension = true;
                            styleNode.appendChild(this.buildColorNode(ts.font.color,ts.font.opacity));
                            styleNode.colorMode = "normal";
                            styleNode.scale = ts.font.size/10;
                            if(ts.font.family) {
                                extensionNode.@fontFamily = ts.font.family;
                            
                            }
                            if(ts.font.weight == FontStyle.BOLD) {
                                extensionNode.@bold = FontStyle.BOLD;
                            }
                            if(ts.font.style == FontStyle.ITALIC) {
                                extensionNode.@italic = FontStyle.ITALIC;
                            }
                        }
                        if (ts.halo)
                        {
                            addExtension = true;
                            extensionNode.@haloColor = ts.halo.color;
                            extensionNode.@haloRadius = ts.halo.radius;
                            extensionNode.@haloOpacity = ts.halo.opacity;
                        }
                        if(addExtension)
                            styleNode.appendChild(extensionNode);
                        placemarkStyle.appendChild(styleNode);
                    }
                    else if (symb is LineSymbolizer)
                    {
                        if (!strokeExported)
                        {
                            styleNode = new XML("<LineStyle></LineStyle>");
                            var lSym:LineSymbolizer = symb as LineSymbolizer;
                            stroke = lSym.stroke;
                            color = stroke.color;
                            opacity = stroke.opacity;
                            width = stroke.width;
                            styleNode.appendChild(this.buildColorNode(color,opacity));
                            styleNode.colorMode = "normal";
                            styleNode.width = width;
                            placemarkStyle.appendChild(styleNode);
                            strokeExported = true;
                            
                            if (symb is ArrowSymbolizer)
                            {
                                extensionNode = new XML("<ListStyleSimpleExtensionGroup></ListStyleSimpleExtensionGroup>");
                                if ((symb as ArrowSymbolizer).leftMarker)
                                {
                                    
                                    extensionNode.@leftArrow = ((symb as ArrowSymbolizer).leftMarker as ArrowMarker).arrowMarker;
                                }else{
                                    extensionNode.@leftArrow = "none"
                                }
                                if ((symb as ArrowSymbolizer).rightMarker)
                                {
                                    extensionNode.@rightArrow = ((symb as ArrowSymbolizer).rightMarker as ArrowMarker).arrowMarker;
                                }else{
                                    extensionNode.@rightArrow = "none"
                                }
                                styleNode.appendChild(extensionNode);
                            }
                        }
                    }else if (symb is PolygonSymbolizer)
                    {
                        styleNode = new XML("<PolyStyle></PolyStyle>");
                        var polySym:PolygonSymbolizer = symb as PolygonSymbolizer;
                        styleNode.outline = "0";
                        if (polySym.stroke)
                        {
                            styleNode.outline = "1";
                            if (!strokeExported)
                            {
                                var styleNode2:XML = new XML("<LineStyle></LineStyle>");
                                var stroke2:Stroke = polySym.stroke;
                                color = stroke2.color;
                                opacity = stroke2.opacity;
                                width = stroke2.width;
                                styleNode2.appendChild(this.buildColorNode(color,opacity));
                                styleNode2.colorMode = "normal";
                                styleNode2.width = width;
                                placemarkStyle.appendChild(styleNode2);    
                                strokeExported = true;
                            }
                        }
                        
                        var fill:Fill = polySym.fill;
                        if(fill is SolidFill)
                        {
                            styleNode.fill = "1";
                            opacity = (fill as SolidFill).opacity;    
                            color = (fill as SolidFill).color as uint;
                        }
                            
                        else
                        {
                            styleNode.fill = "0";
                            opacity = 0;
                        }
                        styleNode.appendChild(this.buildColorNode(color,opacity));
                        styleNode.colorMode = "normal";    
                        placemarkStyle.appendChild(styleNode);    
                    }else if (symb is PointSymbolizer)
                    {
                        styleNode = new XML("<IconStyle></IconStyle>");
                        var pointSym:PointSymbolizer = symb as PointSymbolizer;
                        var graphic:Marker = pointSym.graphic;
                        
                        // Switch between marker types
                        if(graphic is WellKnownMarker)
                        {
                            var wkm:WellKnownMarker = graphic as WellKnownMarker;
                            var solidFill:SolidFill = wkm.fill;
                            styleNode.appendChild(this.buildColorNode(solidFill.color as uint, solidFill.opacity));
                            styleNode.colorMode = "normal";
                        }else if (graphic is CustomMarker)
                        {
                            var iconNode:XML = new XML("<Icon></Icon>");
                            
                            var cm:CustomMarker = graphic as CustomMarker;
                        
                            var href:String ="";// cm.url;
                            iconNode.href = href;
                            
                            var hotSpotNode:XML = new XML("<hotSpot/>");
                            hotSpotNode.@x = cm.xOffset;
                            hotSpotNode.@xunits =0;// cm.xUnit;
                            hotSpotNode.@y = cm.yOffset;
                            hotSpotNode.@yunits =0;// cm.yUnit;
                            
                            styleNode.appendChild(iconNode);
                            styleNode.appendChild(hotSpotNode);
                        }else
                        {
                            //Not supported Marker
                        }
                        placemarkStyle.appendChild(styleNode);    
                    }else
                    {
                        //Not supported symbolizer
                    }
                }
                return placemarkStyle;
            }
            private function buildColorNode(color:uint,opacity:Number):XML
            {
                var i:uint;
                var spareStringColor:String = "";
                var colorNode:XML = new XML("<color></color>");    
                var stringColor:String = color.toString(16);
                
                for (i = 0; i < (6 - stringColor.length); i++)
                {
                    spareStringColor += "0";                
                }
                
                spareStringColor += stringColor;
                
                if(stringColor.length < 6)
                    stringColor = spareStringColor;
                
                //in OpenScales, the feature opacity is between 0 and 1 (1 means 255 in KML)
                var KMLcolor:String = (opacity*255).toString(16) + stringColor.substr(4,2)
                    + stringColor.substr(2,2)+stringColor.substr(0,2);
                colorNode.appendChild(KMLcolor);
                return colorNode;
            }
            private var _excludeFromExtendedData:Array = new Array("id", "name", "description", "popupContentHTML", "label");
            private function buildPlacemarkNode(feature:Feature,i:uint):XML
            {
                var lineNode:XML;
                var pointNode:XML;
                var extendedData:XML;
                
                var placemark:XML = new XML("<Placemark></Placemark>");
                var att:Object = feature.attributes;
                //
                Alert.show("开始添加id...");
                placemark.appendChild(new XML("<id>" + feature.name + "</id>"));
                if (att.hasOwnProperty("name") && att["name"] != "")
                {
                    placemark.appendChild(new XML("<name>" + att["name"] + "</name>"));
                }
                else
                {
                    //since we build the styles first, the feature will have an id for sure
                    placemark.appendChild(new XML("<name>" + feature.name + "</name>"));
                }
                //
                Alert.show("开始添加样式url...");
                placemark.appendChild(new XML("<styleUrl>#" + feature.style.name + "</styleUrl>"));
                //
                Alert.show("开始添加description...");
                if(att.hasOwnProperty("description"))
                    placemark.appendChild(new XML("<description>" + att["description"] + "</description>"));
                //
                Alert.show("开始添加 feat coordinates...");
                var coords:String;
                if(feature is LineStringFeature)
                {
                    lineNode = new XML("<LineString></LineString>");
                    var line:LineString = (feature as LineStringFeature).lineString;
                    coords = this.buildCoordsAsString(line.getcomponentsClone());
                    if(coords.length != 0)
                        lineNode.appendChild(new XML("<coordinates>" + coords + "</coordinates>"));
                    placemark.appendChild(lineNode);
                }
                else if(feature is PolygonFeature)
                {
                    var poly:Polygon = (feature as PolygonFeature).polygon;
                    placemark.appendChild(this.buildPolygonNode(poly));
                }
                else if(feature is PointFeature)
                {
                    pointNode = new XML("<Point></Point>");
                    var point:org.openscales.geometry.Point = (feature as PointFeature).point as org.openscales.geometry.Point;
                    pointNode.appendChild(new XML("<coordinates>" + point.x + "," + point.y + "</coordinates>"));
                    placemark.appendChild(pointNode);
                }
                else if(feature is MultiPointFeature || feature is MultiLineStringFeature || feature is MultiPolygonFeature)
                {
                    var multiGNode:XML = new XML("<MultiGeometry></MultiGeometry>");
                    if(feature is MultiPointFeature)
                    {
                        var points:Vector.<org.openscales.geometry.Point> = (feature as MultiPointFeature).points.toVertices();
                        var numberOfPoints:uint = points.length;
                        for(i = 0; i < numberOfPoints; i++)
                        {
                            pointNode =    new XML("<Point></Point>");
                            pointNode.appendChild(new XML("<coordinates>" + point.x + "," + point.y + "</coordinates>"));
                            multiGNode.appendChild(pointNode);
                        
                        }
                    }
                    else if (feature is MultiLineStringFeature)
                    {
                         var lines:Vector.<Geometry> = (feature as MultiLineStringFeature).lineStrings.getcomponentsClone();
                         var numberOfLines:uint = lines.length;
                         for(i = 0; i < numberOfLines; i++)
                         {
                             var Line:LineString = lines[i] as LineString;
                             coords = this.buildCoordsAsString(Line.getcomponentsClone());
                             lineNode =    new XML("<LineString></LineString>");
                             lineNode.appendChild(new XML("<coordinates>" + coords + "</coordinates>"));
                             multiGNode.appendChild(lineNode);
                         }    
                    }
                    else//multiPolygon
                    {
                    
                    }
                    placemark.appendChild(multiGNode);
                }
                                        
                Alert.show("开始添加ExtendedData...");
                //Donnees attributaires
                var data:XML;
                var displayName:XML;
                var value:XML;
                if(feature.layer || feature is LabelFeature)
                {
                    extendedData =    new XML("<ExtendedData></ExtendedData>");
                    if(feature is LabelFeature)
                    {
                        var l:org.openscales.geometry.Point = (feature as LabelFeature).geometry as org.openscales.geometry.Point;
                        data = new XML("<Data name=\"label\"></Data>");
                        value = new XML("<value>" + (feature as LabelFeature).text + "</value>");
                        data.appendChild(value);
                        extendedData.appendChild(data);
                    }
                    if(feature.layer)
                    {
                        var j:uint = feature.layer.attributesId.length;
                        if(j>0 || feature is LabelFeature)
                        {                                        
                            for(var i:uint = 0 ;i<j;++i)
                            {
                                var key:String = feature.layer.attributesId[i];
                                //everything except name and description
                                if(_excludeFromExtendedData.indexOf(key) <0 )
                                {
                                    data = new XML("<Data name=\"attribute" + i + "\"></Data>");
                                    displayName = new XML("<displayName>" + key + "</displayName>");
                                    value = new XML("<value>" + att[key] + "</value>");
                                    data.appendChild(displayName);
                                    data.appendChild(value);
                                    extendedData.appendChild(data);
                                }
                            }
                        }
                    }
                    placemark.appendChild(extendedData);
                }
                return placemark;
            }    
            public function buildCoordsAsString(coords:Vector.<Number>):String
            {
                var i:uint;
                var stringCoords:String = "";
                var numberOfPoints:uint = coords.length;
                for(i = 0; i < numberOfPoints; i += 2){
                    stringCoords += String(coords[i])+",";
                    stringCoords += String(coords[i+1]);
                    if( i != (numberOfPoints -2))
                        stringCoords += " ";
                }
                return stringCoords;
            }
            public function buildPolygonNode(poly:Polygon):XML
            {
                var coords:String;
                var polyNode:XML = new XML("<Polygon></Polygon>");
                var outerBoundary:XML = new XML("<outerBoundaryIs></outerBoundaryIs>");
                var extRingNode:XML = new XML("<LinearRing></LinearRing>");
                outerBoundary.appendChild(extRingNode);
                polyNode.appendChild(outerBoundary);
                
                var ringList:Vector.<Geometry> = poly.getcomponentsClone();
                var extRing:LinearRing = ringList[0] as LinearRing;
                coords = this.buildCoordsAsString(extRing.getcomponentsClone());
                if(coords.length != 0)
                    extRingNode.appendChild(new XML("<coordinates>" + coords + "</coordinates>"));
                
                if(ringList.length > 1)
                {
                    var l:uint = ringList.length;
                    var i:uint;
                    for(i = 1; i < l; i++)
                    {
                        var intRing:LinearRing = ringList[i] as LinearRing;
                        var innerBoundary:XML = new XML("<innerBoundaryIs></innerBoundaryIs>");
                        var intRingNode:XML = new XML("<LinearRing></LinearRing>");
                        innerBoundary.appendChild(intRingNode);
                        polyNode.appendChild(innerBoundary);
                        
                        coords = this.buildCoordsAsString(intRing.getcomponentsClone());
                        if(coords.length != 0)
                            intRingNode.appendChild(new XML("<coordinates>" + coords + "</coordinates>"));
                    }
                }
                
                return polyNode;
            }