private ReflectionWrapper FindMember(ReflectionWrapper other)
{
var fields = this.GetSubExtendedMemberInfosFields();
foreach (var info in fields)
{
if (other.NameInSource == info.NameInSource)
{
return(info);
}
}
return(null);
}
private void MapFields(
ReflectionWrapper expected,
ICollection <object> scanned,
int depth, Func <ReflectionWrapper, ReflectionWrapper, int, bool> mapFunction)
{
if (!mapFunction(this, expected, depth))
{
// no need to recurse
return;
}
if (this.Value != null)
{
// logic recursion prevention, only for (non null) reference type
if (scanned.Contains(this.Value))
{
return;
}
scanned.Add(this.Value);
}
// we recurse
var nextDepth = depth - 1;
foreach (var member in this.GetSubExtendedMemberInfosFields())
{
member.MapFields(expected.FindMember(member), scanned, nextDepth, mapFunction);
}
// we deal with missing fields (unless asked to ignore them)
if (this.Criteria.IgnoreExtra)
{
return;
}
foreach (var expectedField in expected.GetSubExtendedMemberInfosFields())
{
if (this.FindMember(expectedField) == null)
{
mapFunction(null, expectedField, nextDepth);
}
}
}
private static AggregatedDifference AnonymousTypeDifference <TA, TE>(TA actual, TE expected, Type type,
AggregatedDifference result)
{
var criteria = new ClassMemberCriteria(BindingFlags.Instance);
criteria.SetPublic();
criteria.CaptureProperties();
criteria.CaptureFields();
// use field based comparison
var wrapper = ReflectionWrapper.BuildFromInstance(type, expected, criteria);
var actualWrapped = ReflectionWrapper.BuildFromInstance(actual.GetType(), actual, criteria);
foreach (var match in actualWrapped.MemberMatches(wrapper).Where(match => !match.DoValuesMatches))
{
result.Add(DifferenceDetails.FromMatch(match));
}
return(result);
}
private void MapFields(
ReflectionWrapper actual,
ICollection <object> scanned,
int depth, Func <ReflectionWrapper, ReflectionWrapper, int, bool> mapFunction)
{
if (this.ValueType.IsClass() && this.Value != null)
{
// logic recursion prevention, only for (non null) reference type
if (scanned.Contains(this.Value))
{
return;
}
scanned.Add(this.Value);
}
if (!mapFunction(this, actual, depth))
{
// no need to recurse
return;
}
// we recurse
foreach (var member in this.GetSubExtendedMemberInfosFields())
{
member.MapFields(actual.FindMember(member), scanned, depth - 1, mapFunction);
}
// we deal with missing fields
if (this.Criteria.IgnoreExtra)
{
return;
}
foreach (var actualFields in actual.GetSubExtendedMemberInfosFields())
{
if (this.FindMember(actualFields) == null)
{
mapFunction(null, actualFields, depth - 1);
}
}
}
internal List <MemberMatch> MemberMatches <TU>(TU expectedValue)
{
var expectedWrapped =
ReflectionWrapper.BuildFromInstance(expectedValue?.GetType() ?? typeof(TU), expectedValue, this.Criteria);
var result = new List <MemberMatch>();
expectedWrapped.MapFields(this, 1, (expected, actual, depth) =>
{
if (actual?.Value == null || expected?.Value == null)
{
result.Add(new MemberMatch(expected, actual));
return(false);
}
if (depth <= 0 && expected.ValueType.ImplementsEquals())
{
result.Add(new MemberMatch(expected, actual));
return(false);
}
if (!expected.IsArray)
{
return(true);
}
if (actual.IsArray && ((Array)expected.Value).Length == ((Array)actual.Value).Length)
{
return(true);
}
result.Add(new MemberMatch(expected, actual));
return(false);
});
return(result);
}
private ReflectionWrapper FindMember(ReflectionWrapper other)
{
var fields = this.GetSubExtendedMemberInfosFields();
return(fields.FirstOrDefault(info => other.NameInSource == info.NameInSource));
}
internal void MapFields(ReflectionWrapper other,
int depth, Func <ReflectionWrapper, ReflectionWrapper, int, bool> mapFunction)
{
this.MapFields(other, new List <object>(), depth, mapFunction);
}
public MemberMatch(ReflectionWrapper expected, ReflectionWrapper actual)
{
this.Actual = actual;
this.Expected = expected;
}