/// <summary>
        /// Inserts avalidation message at the specified index.
        /// </summary>
        /// <param name="index">The index.</param>
        /// <param name="message">The message.</param>
        public new void Insert(int index, ValidationMessage message)
        {
            index.MustBeBetween(0, this.Count);
            message.CannotBeNull();

            ValidationMessageCollection messages = this[message.ValidationSource, message.PropertyName, message.ValidationContext];

            if (messages != null &&
                messages.Count > 0)
            {
                // insert only if there are no messages with higher validation level for this property
                if (!messages.Any(x => x.ValidationLevel > message.ValidationLevel))
                {
                    // remove messages with lower priority
                    foreach (var lowerPriorityMessage in messages.Where(x => x.ValidationLevel < message.ValidationLevel))
                    {
                        this.Remove(lowerPriorityMessage);
                    }

                    // insert message
                    base.Insert(Math.Min(this.Count, index), message);
                }
            }
            else
            {
                base.Insert(index, message);
            }
        }
        /// <summary>
        /// Merges the specified messages.
        /// </summary>
        /// <param name="list">The validation message list.</param>
        /// <returns>Merged message.</returns>
        private static MergedValidationMessage Merge(ValidationMessageCollection list)
        {
            ValidationLevel  validationLevel;
            int              validationPriortiy = int.MaxValue;
            HashSet <string> messages           = new HashSet <string>();

            if (list == null ||
                list.Count == 0)
            {
                validationLevel = ValidationLevel.None;
            }
            else if (list.Count == 1)
            {
                messages.Add(list[0].Message);
                validationLevel = list[0].ValidationLevel;
            }
            else
            {
                validationLevel = ValidationLevel.None;

                // find max validation level
                foreach (ValidationMessage vm in list)
                {
                    validationLevel = (int)vm.ValidationLevel > (int)validationLevel ? vm.ValidationLevel : validationLevel;
                }

                // find max validation priority
                foreach (ValidationMessage vm in list.Where(x => x.ValidationLevel == validationLevel))
                {
                    validationPriortiy = vm.ValidationPriority < validationPriortiy ? vm.ValidationPriority : validationPriortiy;
                }

                // select only messages for that level
                foreach (ValidationMessage vm in list.Where(x => x.ValidationLevel == validationLevel &&
                                                            x.ValidationPriority == validationPriortiy))
                {
                    if (!messages.Contains(vm.Message))
                    {
                        // prevent duplicates
                        messages.Add(vm.Message);
                    }
                }
            }

            return(new MergedValidationMessage(validationLevel, messages));
        }