|
public Sort ( ) : |
||
| Результат | ||
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection(null);
descriptors.Add(new RuleConditionReferenceNamePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "ConditionName", typeof(string), new Attribute[] { new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes })));
descriptors.Add(new RuleConditionReferencePropertyDescriptor(context, TypeDescriptor.CreateProperty(typeof(RuleConditionReference), "Expression", typeof(CodeExpression), new Attribute[] { new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content), DesignOnlyAttribute.Yes })));
return descriptors.Sort(new string[] { "ConditionName", "Expression" });
}
public Vector2Converter()
{
Type typeFromHandle = typeof(Vector2);
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(new PropertyDescriptor[]
{
new FieldPropertyDescriptor(typeFromHandle.GetField("X")),
new FieldPropertyDescriptor(typeFromHandle.GetField("Y"))
});
this.propertyDescriptions = propertyDescriptorCollection.Sort(new string[]
{
"X",
"Y"
});
}
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
System.ComponentModel.PropertyDescriptorCollection pds
= TypeDescriptor.GetProperties(value.GetType(), attributes);
string[] atts = new string[]
{
"Index",
"Name",
"SomeValue",
"OtherValue",
};
return(pds.Sort(atts));
}
public PropertyDescriptorCollection GetItemProperties(PropertyDescriptor[] listAccessors)
{
System.ComponentModel.PropertyDescriptorCollection pds
= TypeDescriptor.GetProperties(typeof(VirtualItem));
string[] atts = new string[]
{
"Index",
"Name",
"SomeValue",
"OtherValue",
};
return(pds.Sort(atts));
}
public RectangleFConverter()
{
Type typeFromHandle = typeof(RectangleF);
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(new PropertyDescriptor[]
{
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("X")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("Y")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("Width")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("Height"))
});
this.propertyDescriptions = propertyDescriptorCollection.Sort(new string[]
{
"X",
"Y",
"Width",
"Height"
});
}
public ColorConverter()
{
Type typeFromHandle = typeof(Color);
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(new PropertyDescriptor[]
{
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("R")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("G")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("B")),
new PropertyPropertyDescriptor(typeFromHandle.GetProperty("A"))
});
this.propertyDescriptions = propertyDescriptorCollection.Sort(new string[]
{
"R",
"G",
"B",
"A"
});
}
protected PropertyDescriptorCollection SortProperties (PropertyDescriptorCollection props, string[] names)
{
props.Sort (names);
return props;
}
public override PropertyDescriptorCollection GetChildProperties( object instance, Attribute[] filter )
{
PropertyDescriptorCollection pdc = null;
var tc = this.Converter;
if (tc.GetPropertiesSupported(null) == false)
{
pdc = base.GetChildProperties(instance, filter);
}
else
{
}
if (propertyDescriptor != null)
{
tc = propertyDescriptor.Converter;
}
else
{
//pdc = base.GetChildProperties(instance, filter);// this gives us a readonly collection, no good
tc = TypeDescriptor.GetConverter(instance, true);
}
if (pdc == null || pdc.Count == 0)
{
return pdc;
}
if (pdc[0] is CustomPropertyDescriptor)
{
return pdc;
}
// now wrap these properties with our CustomPropertyDescriptor
var pdl = new PropertyDescriptorList( );
foreach (PropertyDescriptor pd in pdc)
{
if (pd is CustomPropertyDescriptor)
{
pdl.Add(pd as CustomPropertyDescriptor);
}
else
{
pdl.Add(new CustomPropertyDescriptor(instance, pd));
}
}
pdl.Sort(new PropertySorter( ));
var pdcReturn = new PropertyDescriptorCollection(pdl.ToArray( ));
pdcReturn.Sort( );
return pdcReturn;
}
/// <summary>
/// Sorts a collection of properties.
/// </summary>
protected PropertyDescriptorCollection SortProperties(PropertyDescriptorCollection props, string[] names)
{
props.Sort(names);
return(props);
}
[Test] // Sort (String [], IComparer)
public void Sort4 ()
{
PropertyDescriptorCollection descriptors;
PropertyDescriptorCollection sorted;
PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
PropertyDescriptor [] props = new PropertyDescriptor [] {
descA, descB, descC, descD, descE, descF };
descriptors = new PropertyDescriptorCollection (props);
Assert.AreSame (descA, descriptors [0], "#A1");
Assert.AreSame (descB, descriptors [1], "#A2");
Assert.AreSame (descC, descriptors [2], "#A3");
Assert.AreSame (descD, descriptors [3], "#A4");
Assert.AreSame (descE, descriptors [4], "#A5");
Assert.AreSame (descF, descriptors [5], "#A6");
sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
new ComparableComparer ());
Assert.AreSame (descA, descriptors [0], "#B1");
Assert.AreSame (descB, descriptors [1], "#B2");
Assert.AreSame (descC, descriptors [2], "#B3");
Assert.AreSame (descD, descriptors [3], "#B4");
Assert.AreSame (descE, descriptors [4], "#B5");
Assert.AreSame (descF, descriptors [5], "#B6");
Assert.AreSame (descA, sorted [0], "#C1");
Assert.AreSame (descE, sorted [1], "#C2");
Assert.AreSame (descC, sorted [2], "#C3");
Assert.AreSame (descB, sorted [3], "#C4");
Assert.AreSame (descD, sorted [4], "#C5");
Assert.AreSame (descF, sorted [5], "#C6");
sorted = descriptors.Sort ((string []) null, new ComparableComparer ());
Assert.AreSame (descA, descriptors [0], "#D1");
Assert.AreSame (descB, descriptors [1], "#D2");
Assert.AreSame (descC, descriptors [2], "#D3");
Assert.AreSame (descD, descriptors [3], "#D4");
Assert.AreSame (descE, descriptors [4], "#D5");
Assert.AreSame (descF, descriptors [5], "#D6");
Assert.AreSame (descC, sorted [0], "#E1");
Assert.AreSame (descA, sorted [1], "#E2");
Assert.AreSame (descB, sorted [2], "#E3");
Assert.AreSame (descE, sorted [3], "#E4");
Assert.AreSame (descD, sorted [4], "#E5");
Assert.AreSame (descF, sorted [5], "#E6");
sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
(Comparer) null);
Assert.AreSame (descA, descriptors [0], "#F1");
Assert.AreSame (descB, descriptors [1], "#F2");
Assert.AreSame (descC, descriptors [2], "#F3");
Assert.AreSame (descD, descriptors [3], "#F4");
Assert.AreSame (descE, descriptors [4], "#F5");
Assert.AreSame (descF, descriptors [5], "#F6");
Assert.AreSame (descA, sorted [0], "#G1");
Assert.AreSame (descE, sorted [1], "#G2");
Assert.AreSame (descB, sorted [2], "#G3");
Assert.AreSame (descD, sorted [3], "#G4");
Assert.AreSame (descC, sorted [4], "#G5");
Assert.AreSame (descF, sorted [5], "#G6");
sorted = descriptors.Sort ((string []) null, (Comparer) null);
Assert.AreSame (descA, descriptors [0], "#H1");
Assert.AreSame (descB, descriptors [1], "#H2");
Assert.AreSame (descC, descriptors [2], "#H3");
Assert.AreSame (descD, descriptors [3], "#H4");
Assert.AreSame (descE, descriptors [4], "#H5");
Assert.AreSame (descF, descriptors [5], "#H6");
Assert.AreSame (descB, sorted [0], "#I1");
Assert.AreSame (descD, sorted [1], "#I2");
Assert.AreSame (descC, sorted [2], "#I3");
Assert.AreSame (descE, sorted [3], "#I4");
Assert.AreSame (descA, sorted [4], "#I5");
Assert.AreSame (descF, sorted [5], "#I6");
}
[Test] // Sort (IComparer)
public void Sort3 ()
{
PropertyDescriptorCollection descriptors;
PropertyDescriptorCollection sorted;
PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
PropertyDescriptor [] props = new PropertyDescriptor [] {
descA, descB, descC, descD, descE, descF };
descriptors = new PropertyDescriptorCollection (props);
Assert.AreSame (descA, descriptors [0], "#A1");
Assert.AreSame (descB, descriptors [1], "#A2");
Assert.AreSame (descC, descriptors [2], "#A3");
Assert.AreSame (descD, descriptors [3], "#A4");
Assert.AreSame (descE, descriptors [4], "#A5");
Assert.AreSame (descF, descriptors [5], "#A6");
sorted = descriptors.Sort (new ComparableComparer ());
Assert.AreSame (descA, descriptors [0], "#B1");
Assert.AreSame (descB, descriptors [1], "#B2");
Assert.AreSame (descC, descriptors [2], "#B3");
Assert.AreSame (descD, descriptors [3], "#B4");
Assert.AreSame (descE, descriptors [4], "#B5");
Assert.AreSame (descF, descriptors [5], "#B6");
Assert.AreSame (descC, sorted [0], "#C1");
Assert.AreSame (descA, sorted [1], "#C2");
Assert.AreSame (descB, sorted [2], "#C3");
Assert.AreSame (descE, sorted [3], "#C4");
Assert.AreSame (descD, sorted [4], "#C5");
Assert.AreSame (descF, sorted [5], "#C6");
sorted = descriptors.Sort ((Comparer) null);
Assert.AreSame (descA, descriptors [0], "#D1");
Assert.AreSame (descB, descriptors [1], "#D2");
Assert.AreSame (descC, descriptors [2], "#D3");
Assert.AreSame (descD, descriptors [3], "#D4");
Assert.AreSame (descE, descriptors [4], "#D5");
Assert.AreSame (descF, descriptors [5], "#D6");
Assert.AreSame (descB, sorted [0], "#E1");
Assert.AreSame (descD, sorted [1], "#E2");
Assert.AreSame (descC, sorted [2], "#E3");
Assert.AreSame (descE, sorted [3], "#E4");
Assert.AreSame (descA, sorted [4], "#E5");
Assert.AreSame (descF, sorted [5], "#E6");
}
/// <summary>Retrieves the set of properties for this type. By default, a type does not return any properties. </summary>
/// <returns>The set of properties that should be exposed for this data type. If no properties should be exposed, this may return null. The default implementation always returns null.</returns>
/// <param name="context">A <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> through which additional context can be provided. </param>
/// <param name="value">The value of the object to get the properties for. </param>
/// <param name="attributes">An array of <see cref="T:System.Attribute" /> objects that describe the properties. </param>
/// <filterpriority>1</filterpriority>
public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
{
Type typeFromHandle = typeof(FloatRectangle);
PropertyDescriptorCollection propertyDescriptorCollection = new PropertyDescriptorCollection(new PropertyDescriptor[]
{
new FieldPropertyDescriptor(typeFromHandle.GetField("X")),
new FieldPropertyDescriptor(typeFromHandle.GetField("Y")),
new FieldPropertyDescriptor(typeFromHandle.GetField("Width")),
new FieldPropertyDescriptor(typeFromHandle.GetField("Height"))
});
propertyDescriptorCollection = propertyDescriptorCollection.Sort(new string[]
{
"X",
"Y",
"Width",
"Height",
});
return propertyDescriptorCollection;
}
private PropertyDescriptorCollection GetEditableProperties(object editableObject)
{
if (editableObject == null)
throw new ArgumentNullException("editableObject");
var webBrowsableFilter = new Attribute[] {WebBrowsableAttribute.Yes};
var properties = TypeDescriptor.GetProperties(editableObject, webBrowsableFilter);
var editableProperties = new PropertyDescriptorCollection(null);
foreach (PropertyDescriptor descriptor in properties)
{
if (CanEditProperty(descriptor))
editableProperties.Add(descriptor);
}
return editableProperties.Sort(new WebCategoryComparer());
}
