C# PropertyDescriptor.Clone方法代码示例

 private static ArrayList UnsortedMerge(PropertyDescriptor[] baseEntries, ArrayList sortedMergedEntries)
 {
     ArrayList list = new ArrayList();
     PropertyDescriptor[] destinationArray = new PropertyDescriptor[((PropertyDescriptor[]) sortedMergedEntries[0]).Length + 1];
     for (int i = 0; i < baseEntries.Length; i++)
     {
         PropertyDescriptor descriptor = baseEntries[i];
         PropertyDescriptor[] sourceArray = null;
         string strA = descriptor.Name + " " + descriptor.PropertyType.FullName;
         int count = sortedMergedEntries.Count;
         int num3 = count / 2;
         int num4 = 0;
         while (count > 0)
         {
             PropertyDescriptor[] descriptorArray3 = (PropertyDescriptor[]) sortedMergedEntries[num4 + num3];
             PropertyDescriptor descriptor2 = descriptorArray3[0];
             string strB = descriptor2.Name + " " + descriptor2.PropertyType.FullName;
             int num5 = string.Compare(strA, strB, false, CultureInfo.InvariantCulture);
             if (num5 == 0)
             {
                 sourceArray = descriptorArray3;
                 break;
             }
             if (num5 < 0)
             {
                 count = num3;
             }
             else
             {
                 int num6 = num3 + 1;
                 num4 += num6;
                 count -= num6;
             }
             num3 = count / 2;
         }
         if (sourceArray != null)
         {
             destinationArray[0] = descriptor;
             Array.Copy(sourceArray, 0, destinationArray, 1, sourceArray.Length);
             list.Add(destinationArray.Clone());
         }
     }
     return list;
 }

         /// <include file='doc\MultiSelectRootGridEntry.uex' path='docs/doc[@for="MultiSelectRootGridEntry.UnsortedMerge"]/*' />
         /// <devdoc>
         /// merges an unsorted array of grid entries with a sorted array of grid entries that
         /// have already been merged.  The resulting array is the intersection of entries between the two,
         /// but in the order of baseEntries.
         /// </devdoc>
         private static ArrayList UnsortedMerge(PropertyDescriptor[] baseEntries, ArrayList sortedMergedEntries) {
             
             ArrayList mergedEntries = new ArrayList();
             PropertyDescriptor[] mergeArray = new PropertyDescriptor[((PropertyDescriptor[])sortedMergedEntries[0]).Length + 1];
             
             for (int i = 0; i < baseEntries.Length; i++) {
 
                 PropertyDescriptor basePd = baseEntries[i];
 
                 // first, do a binary search for a matching item
                 PropertyDescriptor[] mergedEntryList = null;
                 string entryName = basePd.Name + " " + basePd.PropertyType.FullName;
 
                 int len = sortedMergedEntries.Count;
                 // perform a binary search
                 int offset = len / 2;
                 int start = 0;
                 
                 while (len > 0) {
                     PropertyDescriptor[] pdList = (PropertyDescriptor[])sortedMergedEntries[start + offset];
                     PropertyDescriptor pd = pdList[0];
                     string sortString = pd.Name + " " + pd.PropertyType.FullName;
                     int result = String.Compare(entryName, sortString, false, CultureInfo.InvariantCulture);
                     if (result == 0) {
                         mergedEntryList = pdList;
                         break;
                     }
                     else if (result < 0) {
                         len = offset;
                     }
                     else {
                         int delta = offset + 1;
                         start += delta;
                         len -= delta;
                     }
                     offset = len / 2;
                 }
                 
                 if (mergedEntryList != null) {
                     mergeArray[0] = basePd;
                     Array.Copy(mergedEntryList, 0, mergeArray, 1,  mergedEntryList.Length);
                     mergedEntries.Add(mergeArray.Clone());
                 }
             }
             return mergedEntries;
         }

 private static ArrayList GetCommonProperties(object[] objs, bool presort, PropertyTab tab, GridEntry parentEntry)
 {
     PropertyDescriptorCollection[] descriptorsArray = new PropertyDescriptorCollection[objs.Length];
     Attribute[] array = new Attribute[parentEntry.BrowsableAttributes.Count];
     parentEntry.BrowsableAttributes.CopyTo(array, 0);
     for (int i = 0; i < objs.Length; i++)
     {
         PropertyDescriptorCollection descriptors = tab.GetProperties(parentEntry, objs[i], array);
         if (presort)
         {
             descriptors = descriptors.Sort(MultiSelectRootGridEntry.PropertyComparer);
         }
         descriptorsArray[i] = descriptors;
     }
     ArrayList list = new ArrayList();
     PropertyDescriptor[] descriptorArray = new PropertyDescriptor[objs.Length];
     int[] numArray = new int[descriptorsArray.Length];
     for (int j = 0; j < descriptorsArray[0].Count; j++)
     {
         PropertyDescriptor descriptor = descriptorsArray[0][j];
         bool flag = descriptor.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute();
         for (int k = 1; flag && (k < descriptorsArray.Length); k++)
         {
             if (numArray[k] >= descriptorsArray[k].Count)
             {
                 flag = false;
                 break;
             }
             PropertyDescriptor descriptor2 = descriptorsArray[k][numArray[k]];
             if (descriptor.Equals(descriptor2))
             {
                 numArray[k]++;
                 if (!descriptor2.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute())
                 {
                     flag = false;
                     break;
                 }
                 descriptorArray[k] = descriptor2;
                 continue;
             }
             int num4 = numArray[k];
             descriptor2 = descriptorsArray[k][num4];
             flag = false;
             while (MultiSelectRootGridEntry.PropertyComparer.Compare(descriptor2, descriptor) <= 0)
             {
                 if (descriptor.Equals(descriptor2))
                 {
                     if (!descriptor2.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute())
                     {
                         flag = false;
                         num4++;
                     }
                     else
                     {
                         flag = true;
                         descriptorArray[k] = descriptor2;
                         numArray[k] = num4 + 1;
                     }
                     break;
                 }
                 num4++;
                 if (num4 >= descriptorsArray[k].Count)
                 {
                     break;
                 }
                 descriptor2 = descriptorsArray[k][num4];
             }
             if (!flag)
             {
                 numArray[k] = num4;
                 break;
             }
         }
         if (flag)
         {
             descriptorArray[0] = descriptor;
             list.Add(descriptorArray.Clone());
         }
     }
     return list;
 }

         // this returns an array list of the propertydescriptor arrays, one for each
         // component
         //
         private static ArrayList GetCommonProperties(object[] objs, bool presort, PropertyTab tab, GridEntry parentEntry) {
             PropertyDescriptorCollection[] propCollections = new PropertyDescriptorCollection[objs.Length];
 
             Attribute[] attrs = new Attribute[parentEntry.BrowsableAttributes.Count];
             parentEntry.BrowsableAttributes.CopyTo(attrs, 0);
             
             for (int i = 0; i < objs.Length; i++) {
                 PropertyDescriptorCollection pdc = tab.GetProperties(parentEntry, objs[i], attrs);
                 if (presort) {
                     pdc = pdc.Sort(PropertyComparer);
                 }
                 propCollections[i] = pdc;
             }
             
             ArrayList mergedList = new ArrayList();
             PropertyDescriptor[] matchArray = new PropertyDescriptor[objs.Length];
 
            // 
            // Merge the property descriptors
            //
            int[] posArray = new int[propCollections.Length];
            for (int i = 0; i < propCollections[0].Count; i++) {
                PropertyDescriptor pivotDesc = propCollections[0][i];
                
                bool match = pivotDesc.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute();
                     
                for (int j = 1; match && j < propCollections.Length; j++) {
     
                    if (posArray[j] >= propCollections[j].Count) {
                        match = false;
                        break;
                    }
     
                    // check to see if we're on a match
                    //
                    PropertyDescriptor jProp = propCollections[j][posArray[j]];
                    if (pivotDesc.Equals(jProp)) {
                        posArray[j] += 1;
                        
                        if (!jProp.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute()) {
                             match = false;
                             break;
                        }
                        matchArray[j] = jProp;
                        continue;
                    }
                    
                    int jPos = posArray[j];
                    jProp = propCollections[j][jPos];
 
                    match = false;
     
                    // if we aren't on a match, check all the items until we're past
                    // where the matching item would be
                    while (PropertyComparer.Compare(jProp, pivotDesc) <= 0) {
     
                        // got a match!
                        if (pivotDesc.Equals(jProp)) {
 
                            if (!jProp.Attributes[typeof(MergablePropertyAttribute)].IsDefaultAttribute()) {
                               match = false;
                               jPos++;
                            }
                            else {
                               match = true;
                               matchArray[j] = jProp;
                               posArray[j] = jPos + 1;
                            }
                            break;
                        }
     
                        // try again
                        jPos++;
                        if (jPos < propCollections[j].Count) {
                            jProp = propCollections[j][jPos];
                        }
                        else {
                            break;
                        }
                    }
     
                    // if we got here, there is no match, quit for this guy
                    if (!match) {
                         posArray[j] = jPos;
                         break;
                    }
                }
     
                // do we have a match?
                if (match) {
                    matchArray[0] = pivotDesc;
                    mergedList.Add(matchArray.Clone());
                }
            }
 
            return mergedList;
         }