.Net 2.0 的 XDocument？

Posted 2023-02-16

【中文标题】.Net 2.0 的 XDocument？

【英文标题】：XDocument for .Net 2.0?

【发布时间】：2011-05-05 22:27:24

【问题描述】：

我有一些使用 XDocument 类的 .Net 3.5 代码。

您能否建议一种快速而肮脏的方法来让此代码在 .Net 2.0 中运行？

    public static HaarClassifierCascade Parse(XDocument xDoc)
    
        HaarClassifierCascade cascade = null;
        XElement stages_fn;
        XElement seq_fn = null; /* sequence */
        XElement fn;
        int n;
        int i = 0, j = 0, k = 0, l = 0;
        int parent, next;

        stages_fn = xDoc.Descendants(stageId).First();

        n = stages_fn.Elements().Count();
        cascade = new HaarClassifierCascade(n);

        seq_fn = xDoc.Descendants(sizeId).First();
        string[] size = seq_fn.Value.Split(' ');
        int.TryParse(size[0], out cascade.OriginalWindowSize.Width);
        int.TryParse(size[1], out cascade.OriginalWindowSize.Height);

        XElement stage_fn = (XElement)stages_fn.FirstNode;
        while (null != stage_fn)
        
            XElement trees_fn = stage_fn.Element(treeId);

            n = trees_fn.Elements().Count();
            cascade.StageClassifiers[i].Classifiers = new List<HaarClassifier>(n);
            for (j = 0; j < n; j++)
            
                cascade.StageClassifiers[i].Classifiers.Add(new HaarClassifier());
                cascade.StageClassifiers[i].Classifiers[j].HaarFeatures = null;
            

            cascade.StageClassifiers[i].Count = n;

            j = 0;
            XElement tree_fn = (XElement)trees_fn.FirstNode;
            while (null != tree_fn)
            
                HaarClassifier classifier;
                int lastIndex;

                classifier = cascade.StageClassifiers[i].Classifiers[j];
                classifier.Count = tree_fn.Elements().Count();

                classifier.HaarFeatures = new List<HaarFeature>(classifier.Count);
                for (k = 0; k < classifier.Count; k++)
                
                    classifier.HaarFeatures.Add(new HaarFeature());
                    classifier.Left.Add(0);
                    classifier.Right.Add(0);
                    classifier.Threshold.Add(0);
                    classifier.Alpha.Add(0);
                
                classifier.Alpha.Add(0);

                lastIndex = 0;
                k = 0;
                XNode node_fn = tree_fn.FirstNode;
                while (null != node_fn)
                
                    if (!(node_fn is XElement))
                        goto next_node_fn;

                    XElement feature_fn;
                    XElement rects_fn;

                    feature_fn = ((XElement)node_fn).Element(featureId);
                    rects_fn = feature_fn.Element(rectsId);

                    l = 0;
                    XNode rect_fn = rects_fn.FirstNode;
                    while (null != rect_fn)
                    
                        if (!(rect_fn is XElement))
                            goto next_rect_fn;

                        
                            string[] rectangleParams = ((XElement)rect_fn).Value.Split(' ');
                            Rectangle rectangle = new Rectangle();
                            rectangle.X = int.Parse(rectangleParams[0]);
                            rectangle.Y = int.Parse(rectangleParams[1]);
                            rectangle.Width = int.Parse(rectangleParams[2]);
                            rectangle.Height = int.Parse(rectangleParams[3]);

                            classifier.HaarFeatures[k].Rectangles[l] = new HaarRectangle();
                            classifier.HaarFeatures[k].Rectangles[l].Weight = float.Parse(rectangleParams[4]);
                            classifier.HaarFeatures[k].Rectangles[l].Rectangle = rectangle;
                        

                        l++;
                    next_rect_fn:
                        rect_fn = (XElement)rect_fn.NextNode;
                    

                    for (; l < 3; ++l)
                        classifier.HaarFeatures[k].Rectangles[l] = new HaarRectangle();

                    fn = feature_fn.Element(tiltedId);
                    int.TryParse(fn.Value, out classifier.HaarFeatures[k].Tilted);

                    fn = ((XElement)node_fn).Element(thresholdId);
                    classifier.Threshold[k] = float.Parse(fn.Value);

                    fn = ((XElement)node_fn).Element(left_nodeId);
                    if (null != fn) /* left node */
                        classifier.Left[k] = int.Parse(fn.Value);
                    else
                    
                        fn = ((XElement)node_fn).Element(left_valId);

                        classifier.Left[k] = -lastIndex;
                        classifier.Alpha[lastIndex++] = float.Parse(fn.Value);
                    

                    fn = ((XElement)node_fn).Element(right_nodeId);
                    if (null != fn) /* right node */
                        classifier.Right[k] = int.Parse(fn.Value);
                    else
                    
                        fn = ((XElement)node_fn).Element(right_valId);

                        classifier.Right[k] = -lastIndex;
                        classifier.Alpha[lastIndex++] = float.Parse(fn.Value);
                    

                    k++;
                next_node_fn:
                    node_fn = (XElement)node_fn.NextNode;
                

                j++;
                tree_fn = (XElement)tree_fn.NextNode;
            

            fn = stage_fn.Element(stageThresholdId);
            cascade.StageClassifiers[i].Threshold = float.Parse(fn.Value);

            parent = i - 1;
            next = -1;

            fn = stage_fn.Element(parentId);
            parent = int.Parse(fn.Value);

            fn = stage_fn.Element(nextId);
            next = int.Parse(fn.Value);

            cascade.StageClassifiers[i].Parent = parent;
            cascade.StageClassifiers[i].Next = next;
            cascade.StageClassifiers[i].Child = -1;

            if (parent != -1 && cascade.StageClassifiers[parent].Child == -1)
                cascade.StageClassifiers[parent].Child = i;

            i++;
            stage_fn = (XElement)stage_fn.NextNode;
        

        return cascade;
    

【问题讨论】：

你为什么受限于 .Net 2？

升级到现有系统，由于与供应商应用程序的潜在冲突，用户无法安装更高的 .net 版本，服务台不想推出任何潜在的修补程序，名单还在继续。跨度>

@Bill，我知道您对此可能无能为力，但我认为您应该尝试一下。 .Net 库是有意进行版本控制的，因此您可以在任何给定时间拥有多个版本，而不会出现任何问题。

@Bill，同样，回复：“帮助台不想推出任何潜在的修补程序”。诶？他们现在似乎没有安装修补程序，因此它们可能非常不安全。安装 .Net 3.5 不会降低它们的安全性。如果他们不想安装任何新的、未经测试的技术，我会理解的。但 .Net 3.5 于 2007 年推出！

@svick 政治优先于设计，让它发挥作用是我的工作。

【参考方案1】：

您可以尝试在您的 .Net 2.0 项目中编译单声道源代码：https://github.com/mono

这里是 Mono 实现 System.Xml.Linq 的源代码：

https://github.com/mono/mono/tree/c7c906d69ac9e360ce3e7d517258b8eea2b962b2/mcs/class/System.Xml.Linq

这在理论上应该是可行的，因为 .Net 3 与 .Net 2 共享相同的运行时。但是我怀疑这会很快......

【讨论】：

工作就像一个魅力。我必须导入所有 System.Linq、System.Xml.Linq 和其他一些，但它可以工作！

【参考方案2】：

XDocument 和 XElement 在 LINQ（语言集成查询）之上运行。因此，代码本身不能在 .NET 2.0 上下文中运行。

不过，您可以尝试使用 Xml Serialization 或 XmlReader。

【讨论】：

这不太准确。 XDocument 和 XElement 都支持 LINQ，它们不会“在它之上运行”。请注意，OP 发布的代码不使用 LINQ 查询理解或任何 LINQ 扩展方法。