/// <summary>
/// Advances the enumerator to the next element of the collection.
/// </summary>
/// <returns>
/// true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
/// </returns>
public bool MoveNext()
{
if (!Enumerator.MoveNext())
{
_currentMemberInfo = null;
_currentDumpAttribute = null;
return(false);
}
_currentMemberInfo = Enumerator.Current;
_currentDumpAttribute = PropertyDumpResolver.GetPropertyDumpAttribute(_currentMemberInfo, ClassDumpData.Metadata);
return(true);
}
public int Compare(
MemberInfo x,
MemberInfo y)
{
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
if (y == null)
{
throw new ArgumentNullException(nameof(y));
}
if (!x.DeclaringType.IsAssignableFrom(y.DeclaringType) &&
!y.DeclaringType.IsAssignableFrom(x.DeclaringType))
{
throw new InvalidOperationException("Cannot compare the order weights of properties from unrelated classes.");
}
// get the order of each property:
var orderX = (long)PropertyDumpResolver.GetPropertyDumpAttribute(x, _metadata).Order;
var orderY = (long)PropertyDumpResolver.GetPropertyDumpAttribute(y, _metadata).Order;
// if the properties are from the same type
if (x.DeclaringType == y.DeclaringType)
{
// negative orders should be dumped after the positive orders (and the base class' properties but this is not the case here)
if (orderX < 0)
{
orderX = int.MaxValue + (-orderX);
}
if (orderY < 0)
{
orderY = int.MaxValue + (-orderY);
}
if (orderX < orderY)
{
return(-1);
}
if (orderX > orderY)
{
return(1);
}
var xpi = x as PropertyInfo;
var ypi = y as PropertyInfo;
// if the orders are the same - dump fields before properties in alphabetical order:
if (xpi == null ^ ypi == null)
{
// dump fields before properties
if (x is FieldInfo)
{
return(-1);
}
else
{
return(1);
}
}
else
{
// if both types of the member infos are either PropertyInfo or FieldInfo - dump in alphabetical order
return(string.CompareOrdinal(x.Name, y.Name));
}
}
// dump the properties of the base class after the non-negative properties of the inheriting class
return(y.DeclaringType.IsAssignableFrom(x.DeclaringType)
? (orderX >= 0 ? -1 : 1)
: (orderY >= 0 ? 1 : -1));
}