.Net 2.0 용 XDocument?

XDocument 클래스를 사용하는 .Net 3.5 코드가 있습니다..Net 2.0 용 XDocument?

.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; 
    }

출처

2011-05-05 Biff MaGriff

왜 .NET 2에 제약이 있습니까? – svick

기존 시스템으로 업그레이드하면 사용자가 더 높은 .net 버전을 설치할 수 없으며 공급 업체 앱과 충돌 할 가능성이 있기 때문에 헬프 데스크에서 잠재적 인 핫픽스를 배포하고 싶지는 않습니다. –

@Bill, 나는 그것에 대해 할 수있는 일이 많지 않을 것이라고 생각하지만 시도해야한다고 생각합니다. .Net 라이브러리는 의도적으로 버전이 지정되어 있으므로 아무 문제없이 주어진 시간에 둘 이상의 버전을 가질 수 있습니다. – svick