internal static TypeErrors Merge(this TypeErrors first, TypeErrors other) { if (first == null) { return other; } if (other == null) { return first; } if (first == other) { return first; } if (first.Type == other.Type) { if (first.Errors.Count == 0) { return other; } if (other.Errors.Count == 0) { return first; } var errors = new MergedErrors(first.Errors, other.Errors); return new TypeErrors(first.Type, errors); } return new TypeErrors(null, new[] { first, other }); }
internal static TypeErrors Merge(this TypeErrors first, TypeErrors other) { if (first == null) { return(other); } if (other == null) { return(first); } if (first == other) { return(first); } if (first.Type == other.Type) { if (first.Errors.Count == 0) { return(other); } if (other.Errors.Count == 0) { return(first); } var errors = new MergedErrors(first.Errors, other.Errors); return(new TypeErrors(first.Type, errors)); } return(new TypeErrors(null, new[] { first, other })); }
internal static StringBuilder AppendSuggestImmutable(this StringBuilder errorBuilder, TypeErrors errors) { var fixableTypes = errors.AllErrors.OfType<TypeErrors>() .Where(x => x.Type != errors.Type) .Select(x => x.Type) .Distinct() .ToArray(); if (!fixableTypes.Any()) { return errorBuilder; } foreach (var type in fixableTypes) { var line = type.Assembly == typeof(int).Assembly ? $"* Use an immutable type instead of {type.PrettyName()}." : $"* Make {type.PrettyName()} immutable or use an immutable type."; errorBuilder.AppendLine(line); } errorBuilder.AppendLine(" - For immutable types the following must hold:") .AppendLine(" - Must be a sealed class or a struct.") .AppendLine(" - All fields and properties must be readonly.") .AppendLine(" - All field and property types must be immutable.") .AppendLine(" - All indexers must be readonly.") .AppendLine(" - Event fields are ignored."); return errorBuilder; }
private static void ThrowIfHasErrors(this TypeErrors errors, MemberSettings settings, string className, string methodName) { if (errors == null) { return; } if (errors.Errors.Count == 1 && ReferenceEquals(errors.Errors[0], RequiresReferenceHandling.ComplexType)) { return; } var errorBuilder = new StringBuilder(); errorBuilder.AppendFailed(className, methodName) .AppendNotSupported(errors) .AppendSolveTheProblemBy() .AppendSuggestEquatable(errors) .AppendLine($"* Use {settings.GetType().Name} and specify how comparing is performed:") .AppendSuggestReferenceHandling(errors, settings) .AppendSuggestExclude(errors); var message = errorBuilder.ToString(); throw new NotSupportedException(message); }
// ReSharper disable once UnusedParameter.Local internal static void IfHasErrors(TypeErrors errors, MemberSettings settings, string className, string methodName) { if (errors.HasErrors()) { var message = GetErrorText(errors, settings, className, methodName); throw new NotSupportedException(message); } }
public static IReadOnlyList <Error> MergeAll(TypeErrors typeErrors, IReadOnlyCollection <Error> errors) { var allErrors = new List <Error> { typeErrors }; Add(errors, allErrors); return(allErrors); }
internal static void CanTrackValue(object value, PropertiesSettings settings) { var errors = GetOrCreateErrors(value.GetType(), settings); if (errors != null) { var typeErrors = new TypeErrors(null, errors); Throw.IfHasErrors(typeErrors, settings, typeof(Track).Name, nameof(Track.Changes)); } }
// ReSharper disable once UnusedParameter.Local internal static Exception CannotCopyFixesSizeCollections( IEnumerable source, IEnumerable target, MemberSettings settings) { var error = new CannotCopyFixedSizeCollectionsError(source, target); var typeErrors = new TypeErrors(target.GetType(), error); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); return(new InvalidOperationException(message)); }
private static bool TryEquals(TypeErrors x, TypeErrors y, out bool result) { if (x == null || y == null) { result = false; return(false); } result = x.Type == y.Type; return(true); }
// ReSharper disable once UnusedParameter.Local internal static void ReadonlyMemberDiffers( SourceAndTargetValue sourceAndTargetValue, MemberInfo member, MemberSettings settings) { var error = new ReadonlyMemberDiffersError(sourceAndTargetValue, member); var typeErrors = new TypeErrors(sourceAndTargetValue.Source?.GetType(), error); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); throw new InvalidOperationException(message); }
internal static StringBuilder AppendSuggestNotify(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var error in errors.AllErrors.OfType<TypeErrors>().Where(te => te.HasError<IFixWithNotify>()).Distinct()) { var fixable = error.Errors.OfType<IFixWithNotify>() .First(); fixable.AppendSuggestFixWithNotify(errorBuilder, error.Type); } return errorBuilder; }
internal static InvalidOperationException CreateCannotCreateInstanceException( object sourceValue, MemberSettings settings, Exception exception) { var cannotCopyError = new CannotCreateInstanceError(sourceValue); var typeErrors = new TypeErrors(sourceValue.GetType(), new Error[] { cannotCopyError }); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); return(new InvalidOperationException(message, exception)); }
// ReSharper disable once UnusedParameter.Local internal static void ReadonlyMemberDiffers( SourceAndTargetValue sourceAndTargetValue, MemberInfo member, MemberSettings settings) { var error = new ReadonlyMemberDiffersError(sourceAndTargetValue, member); var typeErrors = new TypeErrors(sourceAndTargetValue.Source?.GetType(), error); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); throw new InvalidOperationException(message); }
private static bool HasErrors(this TypeErrors errors) { if (errors == null) { return(false); } if (errors.Errors.Count == 1 && ReferenceEquals(errors.Errors[0], RequiresReferenceHandling.ComplexType)) { return(false); } return(true); }
// ReSharper disable once UnusedParameter.Local private static void ThrowIfHasErrors(this TypeErrors errors, MemberSettings settings, string className, string methodName) { if (errors == null) { return; } if (errors.Errors.Count == 1 && ReferenceEquals(errors.Errors[0], RequiresReferenceHandling.ComplexType)) { return; } var message = errors.GetErrorText(settings, className, methodName); throw new NotSupportedException(message); }
internal static StringBuilder AppendSuggestEquatable(this StringBuilder errorBuilder, TypeErrors errors) { const string Format = "IEquatable<{0}>"; var types = errors.AllErrors.OfType<TypeErrors>() .Select(x => x.Type) .Distinct(); foreach (var type in types) { var iEquatable = string.Format(Format, type.PrettyName()); var line = type.Assembly == typeof(int).Assembly ? $"* Use a type that implements IEquatable<> instead of {type.PrettyName()}." : $"* Implement {iEquatable} for {type.PrettyName()} or use a type that does."; errorBuilder.AppendLine(line); } return errorBuilder; }
private bool TryMerge(TypeErrors error) { if (error == null) { return(false); } var match = this.errors.OfType <TypeErrors>().SingleOrDefault(e => e.Type == error.Type); if (match != null) { this.errors.Remove(match); var merged = match.Merge(error); this.errors.Add(merged); return(true); } this.errors.Add(error); return(true); }
// ReSharper disable once UnusedParameter.Local private static string GetErrorText(this TypeErrors errors, MemberSettings settings, string className, string methodName) { var errorBuilder = new StringBuilder(); errorBuilder.AppendCopyFailed(className, methodName) .AppendNotSupported(errors) .AppendSolveTheProblemBy() .AppendSuggestImmutable(errors) .AppendSuggestResizableCollection(errors) .AppendSuggestDefaultCtor(errors) .AppendLine($"* Use {settings.GetType().Name} and specify how copying is performed:") .AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.Structural)} means that a the entire graph is traversed and immutable property values are copied.") .AppendLine($" - For structural Activator.CreateInstance is used to create instances so a parameterless constructor may be needed, can be private.") .AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.References)} means that references are copied.") .AppendSuggestExclude(errors); var message = errorBuilder.ToString(); return(message); }
// ReSharper disable once UnusedParameter.Local private static string GetErrorText(TypeErrors errors, MemberSettings settings, string className, string methodName) { var errorBuilder = new StringBuilder(); errorBuilder.AppendLine($"{className}.{methodName}(x, y) failed.") .AppendNotSupported(errors) .AppendSolveTheProblemBy() .AppendSuggestNotify(errors) .AppendSuggestImmutable(errors) .AppendSuggestResizableCollection(errors) .AppendSuggestDefaultCtor(errors) .AppendLine($"* Use {settings?.GetType().Name} and specify how change tracking is performed:") .AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.Structural)} means that a the entire graph is tracked.") .AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.References)} means that only the root level changes are tracked.") .AppendSuggestExclude(errors); var message = errorBuilder.ToString(); return(message); }
private static StringBuilder AppendSuggestReferenceHandling( this StringBuilder errorBuilder, TypeErrors errors, MemberSettings settings) { var references = $" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.References)} means that reference equality is used."; if (settings.ReferenceHandling == ReferenceHandling.Throw) { if (errors.AllErrors.OfType<RequiresReferenceHandling>().Any()) { return errorBuilder.AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.Structural)} means that a deep equals is performed.") .AppendLine(references); } } if (errors.AllErrors.OfType<ReferenceLoop>().Any()) { return errorBuilder.AppendLine(references); } return errorBuilder; }
internal static StringBuilder AppendNotSupported(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var error in errors.AllErrors.OfType<INotSupported>().Distinct()) { error.AppendNotSupported(errorBuilder); } foreach (var member in errors.AllErrors.OfType<MemberErrors>().Select(x => x.Member).Distinct()) { errorBuilder.AppendNotSupportedMember(member); } if (errors.AllErrors.OfType<UnsupportedIndexer>().Any()) { errorBuilder.AppendLine("Indexers are not supported."); foreach (var indexer in errors.AllErrors.OfType<UnsupportedIndexer>().Select(x => x.Indexer).Distinct()) { errorBuilder.AppendNotSupportedMember(indexer); } } return errorBuilder; }
private static StringBuilder AppendSuggestReferenceHandling( this StringBuilder errorBuilder, TypeErrors errors, MemberSettings settings) { var references = $" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.References)} means that reference equality is used."; if (settings.ReferenceHandling == ReferenceHandling.Throw) { if (errors.AllErrors.OfType <RequiresReferenceHandling>().Any()) { return(errorBuilder.AppendLine($" - {typeof(ReferenceHandling).Name}.{nameof(ReferenceHandling.Structural)} means that a deep equals is performed.") .AppendLine(references)); } } if (errors.AllErrors.OfType <ReferenceLoop>().Any()) { return(errorBuilder.AppendLine(references)); } return(errorBuilder); }
internal static StringBuilder AppendNotSupported(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var error in errors.AllErrors.OfType <INotSupported>().Distinct()) { error.AppendNotSupported(errorBuilder); } foreach (var member in errors.AllErrors.OfType <MemberErrors>().Select(x => x.Member).Distinct()) { errorBuilder.AppendNotSupportedMember(member); } if (errors.AllErrors.OfType <UnsupportedIndexer>().Any()) { errorBuilder.AppendLine("Indexers are not supported."); foreach (var indexer in errors.AllErrors.OfType <UnsupportedIndexer>().Select(x => x.Indexer).Distinct()) { errorBuilder.AppendNotSupportedMember(indexer); } } return(errorBuilder); }
internal static StringBuilder AppendSuggestDefaultCtor(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var type in errors.AllErrors.OfType<CannotCreateInstanceError>().Select(x => x.Type).Distinct()) { errorBuilder.AppendLine($"* Add a parameterless constructor to {type.PrettyName()}, can be private."); } return errorBuilder; }
internal static StringBuilder AppendSuggestResizableCollection(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var type in errors.AllErrors.OfType<CannotCopyFixedSizeCollectionsError>().Select(x => x.Type).Distinct()) { errorBuilder.AppendLine($"* Use a resizable collection like List<{type.GetItemType().PrettyName()}> instead of {type.PrettyName()}.") .AppendLine("* Check that the collections are the same size before calling."); } return errorBuilder; }
public MemberErrors(MemberPath path, TypeErrors errors) { this.Path = path; this.Error = errors; this.Errors = errors == null ? EmptyErrors : new[] { errors }; }
// ReSharper disable once UnusedParameter.Local internal static Exception CannotCopyFixesSizeCollections( IEnumerable source, IEnumerable target, MemberSettings settings) { var error = new CannotCopyFixedSizeCollectionsError(source, target); var typeErrors = new TypeErrors(target.GetType(), error); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); return new InvalidOperationException(message); }
internal static InvalidOperationException CreateCannotCreateInstanceException( object sourceValue, MemberSettings settings, Exception exception) { var cannotCopyError = new CannotCreateInstanceError(sourceValue); var typeErrors = new TypeErrors(sourceValue.GetType(), new Error[] { cannotCopyError }); var message = typeErrors.GetErrorText(settings, typeof(Copy).Name, settings.CopyMethodName()); return new InvalidOperationException(message, exception); }
internal static StringBuilder AppendSuggestResizableCollection(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var type in errors.AllErrors.OfType <CannotCopyFixedSizeCollectionsError>().Select(x => x.Type).Distinct()) { errorBuilder.AppendLine($"* Use a resizable collection like List<{type.GetItemType().PrettyName()}> instead of {type.PrettyName()}.") .AppendLine("* Check that the collections are the same size before calling."); } return(errorBuilder); }
internal static StringBuilder AppendSuggestDefaultCtor(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var type in errors.AllErrors.OfType <CannotCreateInstanceError>().Select(x => x.Type).Distinct()) { errorBuilder.AppendLine($"* Add a parameterless constructor to {type.PrettyName()}, can be private."); } return(errorBuilder); }
internal static StringBuilder AppendSuggestEquatable(this StringBuilder errorBuilder, TypeErrors errors) { const string Format = "IEquatable<{0}>"; var types = errors.AllErrors.OfType <TypeErrors>() .Select(x => x.Type) .Distinct(); foreach (var type in types) { var iEquatable = string.Format(Format, type.PrettyName()); var line = type.Assembly == typeof(int).Assembly ? $"* Use a type that implements IEquatable<> instead of {type.PrettyName()}." : $"* Implement {iEquatable} for {type.PrettyName()} or use a type that does."; errorBuilder.AppendLine(line); } return(errorBuilder); }
internal static StringBuilder AppendSuggestImmutable(this StringBuilder errorBuilder, TypeErrors errors) { var fixableTypes = errors.AllErrors.OfType <TypeErrors>() .Where(x => x.Type != errors.Type) .Select(x => x.Type) .Distinct() .ToArray(); if (!fixableTypes.Any()) { return(errorBuilder); } foreach (var type in fixableTypes) { var line = type.Assembly == typeof(int).Assembly ? $"* Use an immutable type instead of {type.PrettyName()}." : $"* Make {type.PrettyName()} immutable or use an immutable type."; errorBuilder.AppendLine(line); } errorBuilder.AppendLine(" - For immutable types the following must hold:") .AppendLine(" - Must be a sealed class or a struct.") .AppendLine(" - All fields and properties must be readonly.") .AppendLine(" - All field and property types must be immutable.") .AppendLine(" - All indexers must be readonly.") .AppendLine(" - Event fields are ignored."); return(errorBuilder); }
public CollectionErrors(MemberPath memberPath, TypeErrors typeErrors) { this.Path = memberPath; this.Errors = new[] { typeErrors }; }
public CollectionErrors(MemberPath memberPath, TypeErrors typeErrors) { this.Path = memberPath; this.Errors = new[] { typeErrors }; }
internal static StringBuilder AppendSuggestNotify(this StringBuilder errorBuilder, TypeErrors errors) { foreach (var error in errors.AllErrors.OfType <TypeErrors>().Where(te => te.HasError <IFixWithNotify>()).Distinct()) { var fixable = error.Errors.OfType <IFixWithNotify>() .First(); fixable.AppendSuggestFixWithNotify(errorBuilder, error.Type); } return(errorBuilder); }
internal static StringBuilder AppendSuggestExclude(this StringBuilder errorBuilder, TypeErrors errors) { var types = errors.AllErrors.OfType <TypeErrors>() .Where(e => e.Type != errors.Type) .Select(x => x.Type) .Distinct() .ToArray(); if (types.Any() || errors.AllErrors.OfType <IExcludableMember>().Any()) { errorBuilder.AppendLine(" - Exclude a combination of the following:"); foreach (var member in errors.AllErrors.OfType <IExcludableMember>().Select(x => x.Member).Distinct()) { errorBuilder.AppendSuggestExcludeMember(member); } foreach (var type in types) { if (type == errors.Type) { continue; } errorBuilder.AppendLine($" - The type {type.PrettyName()}."); } } return(errorBuilder); }
internal static StringBuilder AppendSuggestExclude(this StringBuilder errorBuilder, TypeErrors errors) { var types = errors.AllErrors.OfType<TypeErrors>() .Where(e => e.Type != errors.Type) .Select(x => x.Type) .Distinct() .ToArray(); if (types.Any() || errors.AllErrors.OfType<IExcludableMember>().Any()) { errorBuilder.AppendLine(" - Exclude a combination of the following:"); foreach (var member in errors.AllErrors.OfType<IExcludableMember>().Select(x => x.Member).Distinct()) { errorBuilder.AppendSuggestExcludeMember(member); } foreach (var type in types) { if (type == errors.Type) { continue; } errorBuilder.AppendLine($" - The type {type.PrettyName()}."); } } return errorBuilder; }
public MemberErrors(MemberPath path, TypeErrors errors) { this.Path = path; this.Error = errors; this.Errors = errors == null ? EmptyErrors : new[] { errors }; }