C# MirrorData.GetElements方法代码示例

        internal WatchViewModel ProcessThing(MirrorData data, string tag, bool showRawData)
        {
            if (data.IsCollection)
            {
                var list = data.GetElements();

                var node = new WatchViewModel(visualizationManager, list.Count == 0 ? "Empty List" : "List", tag, true);
                foreach (var e in list.Select((element, idx) => new { element, idx }))
                {
                    node.Children.Add(ProcessThing(e.element, tag + ":" + e.idx, showRawData));
                }

                return node;
            }
            
            // MAGN-3494: If "data.Data" is null, then return a "null" string 
            // representation instead of casting it as dynamic (that leads to 
            // a crash).
            if (data.IsNull || data.Data == null)
                return new WatchViewModel(visualizationManager, NULL_STRING, tag);

            //If the input data is an instance of a class, create a watch node
            //with the class name and let WatchHandler process the underlying CLR data
            var classMirror = data.Class;
            if (null != classMirror)
            {
                if (data.Data == null && !data.IsNull) //Must be a DS Class instance.
                    return ProcessThing(classMirror.ClassName, tag, showRawData); //just show the class name.
                return Process(data.Data, tag, showRawData);
            }

            //Finally for all else get the string representation of data as watch content.
            return Process(data.Data, tag, showRawData);
        }

 /// <summary>
 /// Validates the watch content with given mirror data.
 /// </summary>
 /// <param name="watch">WatchViewModel of the watch node</param>
 /// <param name="mirrorData">MirrorData to be shown in watch</param>
 private void AssertWatchContent(WatchViewModel watch, MirrorData mirrorData)
 {
     Assert.IsNotNull(mirrorData);
     if (mirrorData.IsCollection)
         AssertWatchTreeBranchContent(watch.Children, mirrorData.GetElements());
     else if (mirrorData.IsNull)
         Assert.AreEqual("null", watch.NodeLabel);
     else
     {
         string nodeLabel = string.Format("{0}", mirrorData.Data);
         Assert.AreEqual(nodeLabel, watch.NodeLabel);
     }
 }

        /// <summary>
        /// Counts the number of all collection items of node output and if specified 
        /// it generates appropriate view model for compact preview bubble
        /// </summary>
        /// <param name="mirrorData">Data which represents the value of node output</param>
        /// <param name="generateViewModel">Flag to not create unused view models</param>
        /// <returns><cref name="CompactBubbleViewModel"/> instance 
        /// if <paramref name="generateViewModel"/> is specified. Otherwise, null</returns>
        private static CompactBubbleViewModel ProcessThing(MirrorData mirrorData, bool generateViewModel)
        {
            if (mirrorData == null)
            {
                return generateViewModel ? new CompactBubbleViewModel(Resources.NullString, 0) : null;
            }

            if (mirrorData.IsCollection)
            {
                var list = mirrorData.GetElements();

                foreach (var item in list)
                {
                    ProcessThing(item, false);
                }

                return generateViewModel
                    ? new CompactBubbleViewModel(true)
                    {
                        NodeLabel = list.Any() ? "List" : "Empty List"
                    }
                    : null;
            }

            items++;

            if (!generateViewModel) return null;

            var viewModel = new CompactBubbleViewModel(false);
            if (mirrorData.Data == null && !mirrorData.IsNull && mirrorData.Class != null)
            {
                viewModel.NodeLabel = mirrorData.Class.ClassName;
            }
            else if (mirrorData.Data is Enum)
            {
                viewModel.NodeLabel = ((Enum)mirrorData.Data).GetDescription();
            }
            else
            {
                // Cut StringData so that only the type name remains
                // for example, "Point (Z = 0.000, Y = 0.000, Z = 0.000)" -> "Point"
                viewModel.NodeLabel = string.IsNullOrEmpty(mirrorData.StringData)
                    ? string.Empty
                    : mirrorData.StringData.Split('(')[0];
            }

            return viewModel;
        }

 private void AssertCollection(MirrorData data, IEnumerable collection)
 {
     Assert.IsTrue(data.IsCollection);
     List<MirrorData> elements = data.GetElements();
     int i = 0;
     foreach (var item in collection)
     {
         AssertValue(elements[i++], item);
     }
 }

 private void AssertMirrorData(MirrorData data1, MirrorData data2)
 {
     if (data1.IsNull)
         Assert.True(data2.IsNull);
     else if (data1.IsCollection)
     {
         Assert.True(data2.IsCollection);
         List<MirrorData> elems1 = data1.GetElements();
         List<MirrorData> elems2 = data2.GetElements();
         Assert.AreEqual(elems1.Count, elems2.Count);
         int i = 0;
         foreach (var item in elems1)
         {
             AssertMirrorData(item, elems2[i++]);
         }
     }
     else
         Assert.AreEqual(data1.Data, data2.Data);
 }

        private void SelectivelyAssertValues(MirrorData data, Dictionary<int, object> selectedValues)
        {
            Assert.IsTrue(data.IsCollection);

            if (data.IsCollection)
            {
                List<MirrorData> elements = data.GetElements();
                foreach (var pair in selectedValues)
                {
                    AssertValue(elements[pair.Key], pair.Value);
                }
            }
        }

 private void AddToSizeMap(MirrorData data, ICollection<double> map)
 {
     if (data.IsCollection)
     {
         var list = data.GetElements();
         foreach (MirrorData t in list)
         {
             AddToSizeMap(t, map);
         }
     }
     else if (data.Data is IEnumerable)
     {
         var list = data.Data as IEnumerable;
         AddToSizeMap(list, map);
     }
     else
     {
         map.Add(ComputeBBoxDiagonalSize(data.Data));
     }
 }

 /// <summary>
 /// Add labels for each of a mirror data object's inner
 /// data object to a label map.
 /// </summary>
 /// <param name="data"></param>
 /// <param name="map"></param>
 /// <param name="tag"></param>
 private void AddToLabelMap(MirrorData data, List<string> map, string tag)
 {
     if (data.IsCollection)
     {
         var list = data.GetElements();
         for (int i = 0; i < list.Count; i++)
         {
             AddToLabelMap(list[i], map, string.Format("{0}:{1}", tag, i));
         }
     }
     else if (data.Data is IEnumerable)
     {
         var list = data.Data as IEnumerable;
         AddToLabelMap(list, map, tag);
     }
     else
     {
         map.Add(tag);
     }
 }

        private static object MarshalMirrorDataForWatch(MirrorData mirrorData)
        {
            if (mirrorData == null || mirrorData.IsNull)
                return null;

            if (mirrorData.IsCollection)
                return mirrorData.GetElements().Select(MarshalMirrorDataForWatch).ToList();

            return mirrorData.Data;
        }

        /// <summary>
        /// Convert mirror data objects for nodes to Revit types.
        /// </summary>
        /// <param name="data"></param>
        /// <param name="geoms"></param>
        private void RevitGeometryFromMirrorData(MirrorData data, ref List<GeometryObject> geoms)
        {
            if (data.IsCollection)
            {
                foreach (var md in data.GetElements())
                {
                    try
                    {
                        RevitGeometryFromMirrorData(md, ref geoms);
                    }
                    catch (Exception ex)
                    {
                        this.dynamoModel.Logger.Log(ex.Message);
                    }
                }
            }
            else
            {
                try
                {
                    var geom = data.Data as PolyCurve;
                    if (geom != null)
                    {
                        // We extract the curves explicitly rather than using PolyCurve's ToRevitType
                        // extension method.  There is a potential issue with CurveLoop which causes
                        // this method to introduce corrupt GNodes.  
                        foreach (var c in geom.Curves())
                        {
                            // Tesselate the curve.  This greatly improves performance when
                            // we're dealing with NurbsCurve's with high knot count, commonly
                            // results of surf-surf intersections.
                            Tesselate(c, ref geoms);
                        }
                        
                        return;
                    }

                    var point = data.Data as Point;
                    if (point != null)
                    {
                        geoms.Add(DocumentManager.Instance.CurrentUIApplication.Application.Create.NewPoint(point.ToXyz()));
                        return;
                    }

                    var curve = data.Data as Curve;
                    if (curve != null)
                    {
                        // Tesselate the curve.  This greatly improves performance when
                        // we're dealing with NurbsCurve's with high knot count, commonly
                        // results of surf-surf intersections.
                        Tesselate(curve, ref geoms);
                        return;
                    }
                }
                catch (Exception ex)
                {
                    this.dynamoModel.Logger.Log(ex.Message);
                }
            }
        }

 // Add labels for each of a mirror data object's inner data object to a label map.
 private static void AddToLabelMap(MirrorData data, List<string> map, string tag)
 {
     if (data.IsCollection)
     {
         var index = 0;
         var elements = data.GetElements();
         foreach (var element in elements)
         {
             var newTag = string.Format("{0}:{1}", tag, index++);
             AddToLabelMap(element, map, newTag);
         }
     }
     else if (data.Data is IEnumerable)
     {
         AddToLabelMap(data.Data as IEnumerable, map, tag);
     }
     else
     {
         map.Add(tag);
     }
 }

        private static void GetGraphicItemsFromMirrorData(MirrorData mirrorData, List<IGraphicItem> graphicItems)
        {
            if (mirrorData == null) return;

            if (mirrorData.IsCollection)
            {
                foreach (var el in mirrorData.GetElements())
                {
                    GetGraphicItemsFromMirrorData(el, graphicItems);
                }
            }
            else
            {
                var graphicItem = mirrorData.Data as IGraphicItem;
                if (graphicItem == null) return;

                graphicItems.Add(graphicItem);
            }
        }

        private void GetRenderPackagesFromMirrorData(MirrorData mirrorData, bool displayLabels, bool isNodeSelected, ref List<string> labelMap, ref int count)
        {
            if (mirrorData.IsNull)
            {
                return;
            }

            if (mirrorData.IsCollection)
            {
                foreach (var el in mirrorData.GetElements())
                {
                    GetRenderPackagesFromMirrorData(el, displayLabels, isNodeSelected, ref labelMap, ref count);
                }
            }
            else
            {
                var graphicItem = mirrorData.Data as IGraphicItem;
                if (graphicItem == null)
                {
                    return;
                }

                var package = factory.CreateRenderPackage();
                package.Description = labelMap.Count > count ? labelMap[count] : "?";

                try
                {
                    graphicItem.Tessellate(package, factory.TessellationParameters);

                    if (factory.TessellationParameters.ShowEdges)
                    {
                        var surf = graphicItem as Surface;
                        if (surf != null)
                        {
                            foreach (var curve in surf.PerimeterCurves())
                            {
                                curve.Tessellate(package, factory.TessellationParameters);
                                curve.Dispose();
                            }
                        }

                        var solid = graphicItem as Solid;
                        if (solid != null)
                        {
                            var edges = solid.Edges;
                            foreach (var geom in edges.Select(edge => edge.CurveGeometry))
                            {
                                geom.Tessellate(package, factory.TessellationParameters);
                                geom.Dispose();
                            }
                            edges.ForEach(x => x.Dispose());
                        }
                    }
                    
                    var plane = graphicItem as Plane;
                    if (plane != null)
                    {
                        package.RequiresPerVertexColoration = true;

                        var s = 2.5;

                        var cs = CoordinateSystem.ByPlane(plane);
                        var a = Point.ByCartesianCoordinates(cs, s, s, 0);
                        var b = Point.ByCartesianCoordinates(cs, -s, s, 0);
                        var c = Point.ByCartesianCoordinates(cs, -s, -s, 0);
                        var d = Point.ByCartesianCoordinates(cs, s, -s, 0);

                        // Get rid of the original plane geometry.
                        package.Clear();

                        package.AddTriangleVertex(a.X, a.Y, a.Z);
                        package.AddTriangleVertex(b.X, b.Y, b.Z);
                        package.AddTriangleVertex(c.X, c.Y, c.Z);

                        package.AddTriangleVertex(c.X, c.Y, c.Z);
                        package.AddTriangleVertex(d.X, d.Y, d.Z);
                        package.AddTriangleVertex(a.X, a.Y, a.Z);

                        package.AddTriangleVertexUV(0, 0);
                        package.AddTriangleVertexUV(0, 0);
                        package.AddTriangleVertexUV(0, 0);
                        package.AddTriangleVertexUV(0, 0);
                        package.AddTriangleVertexUV(0, 0);
                        package.AddTriangleVertexUV(0, 0);

                        // Draw plane edges
                        package.AddLineStripVertex(a.X, a.Y, a.Z);
                        package.AddLineStripVertex(b.X, b.Y, b.Z);
                        package.AddLineStripVertex(b.X, b.Y, b.Z);
                        package.AddLineStripVertex(c.X, c.Y, c.Z);
                        package.AddLineStripVertex(c.X, c.Y, c.Z);
                        package.AddLineStripVertex(d.X, d.Y, d.Z);
                        package.AddLineStripVertex(d.X, d.Y, d.Z);
                        package.AddLineStripVertex(a.X, a.Y, a.Z);

                        // Draw normal
                        package.AddLineStripVertex(plane.Origin.X, plane.Origin.Y, plane.Origin.Z);
                        var nEnd = plane.Origin.Add(plane.Normal.Scale(2.5));
                        package.AddLineStripVertex(nEnd.X, nEnd.Y, nEnd.Z);

//.........这里部分代码省略.........

        /// <summary>
        /// Update the watch content from the given MirrorData and returns WatchNode.
        /// </summary>
        /// <param name="data">The Mirror data for which watch content is needed.</param>
        /// <param name="prefix">Prefix string used for formatting the content.</param>
        /// <param name="index">Index of input data if it is a part of a collection.</param>
        /// <param name="isListMember">Specifies if this data belongs to a collection.</param>
        /// <returns>WatchNode</returns>
        public static WatchViewModel Process(MirrorData data, string path, bool showRawData = true)
        {
            WatchViewModel node = null;

            if (data == null || data.IsNull)
            {
                node = new WatchViewModel(nullString, path);
            }
            else if (data.IsCollection)
            {
                var list = data.GetElements();

                node = new WatchViewModel(list.Count == 0 ? "Empty List" : "List", path, true);

                foreach (var e in list.Select((x, i) => new { Element = x, Index = i }))
                {
                    node.Children.Add(Process(e.Element, path + ":" + e.Index, showRawData));
                }
            }
            else
            {
                node = dynSettings.Controller.WatchHandler.Process(data as dynamic, path, showRawData);
            }

            return node ?? (new WatchViewModel("null", path));
        }

        /// <summary>
        /// Helper method to get all items from mirror data as flat list recursively.
        /// </summary>
        /// <param name="data">Input data</param>
        /// <returns>List of objects</returns>
        protected static IEnumerable<object> GetElementsFromMirrorData(MirrorData data)
        {
            if (data == null || data.IsNull)
                yield return null;

            if (data.IsCollection)
            {
                var elems = data.GetElements();
                foreach (var item in elems)
                {
                    var objs = GetElementsFromMirrorData(item);
                    foreach (var obj in objs)
                    {
                        yield return obj;
                    }
                }
            }

            yield return data.Data;
        }