<?xml version="1.0"?>
<doc>
    <assembly>
        <name>KellermanSoftware.Compare-NET-Objects</name>
    </assembly>
    <members>
        <member name="T:KellermanSoftware.CompareNetObjects.Cache">
            <summary>
            Cache for properties, fields, and methods to speed up reflection
            </summary>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.Cache._propertyCache">
            <summary>
            Reflection Cache for property info
            </summary>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.Cache._fieldCache">
            <summary>
            Reflection Cache for field info
            </summary>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.Cache._methodList">
            <summary>
            Reflection Cache for methods
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.#cctor">
            <summary>
            Static constructor
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.ClearCache">
            <summary>
            Clear the cache
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.GetFieldInfo(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Type)">
            <summary>
            Get a list of the fields within a type
            </summary>
            <param name="config"> </param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.GetPropertyValue(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Type,System.Object,System.String)">
            <summary>
            Get the value of a property
            </summary>
            <param name="config"> </param>
            <param name="type"></param>
            <param name="objectValue"></param>
            <param name="propertyName"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.GetPropertyInfo(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Type)">
            <summary>
            Get a list of the properties in a type
            </summary>
            <param name="config"> </param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.GetMethod(System.Type,System.String)">
            <summary>
            Get a method by name
            </summary>
            <param name="type"></param>
            <param name="methodName"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Cache.GetMethods(System.Type)">
            <summary>
            Get the cached methods for a type
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CompareException">
            <summary>
            CompareException with a Result Property
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareException.#ctor(KellermanSoftware.CompareNetObjects.ComparisonResult,System.String)">
            <summary>
            CompareException Constructor
            </summary>
            <param name="result"></param>
            <param name="message"></param>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareException.Result">
            <summary>
            The comparison Result
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CompareExtensions">
            <summary>
            A set of BDD style comparison extensions for use with Testing Frameworks
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareExtensions.Config">
            <summary>
            Alter the configuration for the comparison
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareExtensions.ShouldCompare``1(``0,``0,System.String,KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Throws a CompareException if the classes are not equal
            </summary>
            <typeparam name="T"></typeparam>
            <param name="actual"></param>
            <param name="expected"></param>
            <param name="message"></param>
            <param name="compareConfig"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareExtensions.ShouldNotCompare``1(``0,``0,System.String,KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Throws a CompareException if the classes are equal
            </summary>
            <typeparam name="T"></typeparam>
            <param name="actual"></param>
            <param name="expected"></param>
            <param name="message"></param>
            <param name="compareConfig"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CompareLogic">
             <summary>
             Class that allows comparison of two objects of the same type to each other.  Supports classes, lists, arrays, dictionaries, child comparison and more.
             </summary>
             <example>
             CompareLogic compareLogic = new CompareLogic();
             
             Person person1 = new Person();
             person1.DateCreated = DateTime.Now;
             person1.Name = "Greg";
            
             Person person2 = new Person();
             person2.Name = "John";
             person2.DateCreated = person1.DateCreated;
            
             ComparisonResult result = compareLogic.Compare(person1, person2);
             
             if (!result.AreEqual)
                Console.WriteLine(result.DifferencesString);
             
             </example>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareLogic.Config">
            <summary>
            The default configuration
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.#ctor">
            <summary>
            Set up defaults for the comparison
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.#ctor(KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Pass in the configuration
            </summary>
            <param name="config"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.#ctor(System.Boolean)">
            <summary>
            Set up defaults for the comparison
            </summary>
            <param name="useAppConfigSettings">If true, use settings from the app.config</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.Compare(System.Object,System.Object)">
            <summary>
            Compare two objects of the same type to each other.
            </summary>
            <remarks>
            Check the Differences or DifferencesString Properties for the differences.
            Default MaxDifferences is 1 for performance
            </remarks>
            <param name="expectedObject">The expected object value to compare</param>
            <param name="actualObject">The actual object value to compare</param>
            <returns>True if they are equal</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.ClearCache">
            <summary>
            Reflection properties and fields are cached. By default this cache is cleared automatically after each compare.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.SaveConfiguration(System.IO.Stream)">
            <summary>
            Save the current configuration to the passed stream
            </summary>
            <param name="stream"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.LoadConfiguration(System.IO.Stream)">
            <summary>
            Load the current configuration from a json stream
            </summary>
            <param name="stream"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.LoadConfiguration(System.String)">
            <summary>
            Load the current configuration from a json stream
            </summary>
            <param name="filePath"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareLogic.SaveConfiguration(System.String)">
            <summary>
            Save the current configuration to a json file
            </summary>
            <param name="filePath"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CompareObjects">
            <summary>
            Obsolete Use CompareLogic instead
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareObjects.#ctor">
            <summary>
            Obsolete Use CompareLogic instead
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareObjects.#ctor(System.Boolean)">
            <summary>
            Obsolete Use CompareLogic instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ElapsedMilliseconds">
            <summary>
            Obsolete Use the ComparisonResult.ElapsedMilliseconds returned from CompareLogic.Compare
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ShowBreadcrumb">
            <summary>
            Obsolete Use CompareLogic.Config.ShowBreadcrumb instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ElementsToIgnore">
            <summary>
            Obsolete Use CompareLogic.Config.MembersToIgnore for members or CompareLogic.Config.ClassTypesToIgnore instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ElementsToInclude">
            <summary>
            Obsolete Use CompareLogic.Config.MembersToInclude or CompareLogic.Config.ClassTypesToInclude instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ComparePrivateProperties">
            <summary>
            Obsolete Use CompareLogic.Config.ComparePrivateProperties instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ComparePrivateFields">
            <summary>
            Obsolete Use CompareLogic.Config.ComparePrivateFields instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareStaticProperties">
            <summary>
            Obsolete Use CompareLogic.Config.CompareStaticProperties instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareStaticFields">
            <summary>
            Obsolete Use CompareLogic.Config.CompareStaticFields instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareChildren">
            <summary>
            Obsolete Use CompareLogic.Config.CompareChildren instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareReadOnly">
            <summary>
            Obsolete Use CompareLogic.Config.CompareReadOnly instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareFields">
            <summary>
            Obsolete Use CompareLogic.Config.CompareFields instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.IgnoreCollectionOrder">
            <summary>
            Obsolete Use CompareLogic.Config.IgnoreCollectionOrder instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CompareProperties">
            <summary>
            Obsolete Use CompareLogic.Config.CompareProperties instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.MaxDifferences">
            <summary>
            Obsolete Use CompareLogic.Config.MaxDifferences instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.Differences">
            <summary>
            Obsolete Use the ComparisonResult.Differences returned from CompareLogic.Compare
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.DifferencesString">
            <summary>
            Obsolete Use the ComparisonResult.DifferencesString returned from CompareLogic.Compare
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.AutoClearCache">
            <summary>
            Obsolete Use CompareLogic.Config.AutoClearCache instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.Caching">
            <summary>
            Obsolete Use CompareLogic.Config.Caching instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.AttributesToIgnore">
            <summary>
            Obsolete Use CompareLogic.Config.AttributesToIgnore instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.IgnoreObjectTypes">
            <summary>
            Obsolete Use CompareLogic.Config.IgnoreObjectTypes instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.IsUseCustomTypeComparer">
            <summary>
            Obsolete Use CompareLogic.Config.CustomComparers instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CustomComparer">
            <summary>
            Obsolete Use CompareLogic.Config.CustomComparers instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ExpectedName">
            <summary>
            Obsolete Use CompareLogic.Config.ExpectedName instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.ActualName">
            <summary>
            Obsolete Use CompareLogic.Config.ActualName instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.DifferenceCallback">
            <summary>
            Obsolete Use CompareLogic.Config.DifferenceCallback instead
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareObjects.CollectionMatchingSpec">
            <summary>
            Obsolete Use CompareLogic.Config.CollectionMatchingSpec instead
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareObjects.Compare(System.Object,System.Object)">
            <summary>
            Obsolete Use CompareLogic.Compare instead
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CompareObjects.ClearCache">
            <summary>
            Obsolete Use CompareLogic.ClearCache instead
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CompareParms">
            <summary>
            Compare Parameters
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Config">
            <summary>
            The configuration settings
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Object1Type">
            <summary>
            The type of the first object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Object2Type">
            <summary>
            The type of the second object
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "P:KellermanSoftware.CompareNetObjects.CompareParms.Object1DeclaredType" -->
        <!-- Badly formed XML comment ignored for member "P:KellermanSoftware.CompareNetObjects.CompareParms.Object2DeclaredType" -->
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Result">
            <summary>
            Details about the comparison
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.ParentObject1">
            <summary>
            A reference to the parent object1
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.ParentObject2">
            <summary>
            A reference to the parent object2
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Object1">
            <summary>
            The first object to be compared
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.Object2">
            <summary>
            The second object to be compared
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.BreadCrumb">
            <summary>
            The breadcrumb in the tree
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.CompareParms.CustomPropertyComparer">
            <summary>
            Custom comparer used to assert <para>Object1</para>
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.ComparisonConfig">
            <summary>
            Configuration
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.#ctor">
            <summary>
            Default Constructor
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.UseHashCodeIdentifier">
            <summary>
            By default Compare .NET Objects uses reference equal to identify objects.
            Versions 4.61 and older used the hash code.  Setting this to true will identify objects by hash code instead of reference equals.
            The default is false
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CaseSensitive">
            <summary>
            When comparing strings or StringBuilder types, perform a case sensitive comparison.  The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreObjectDisposedException">
            <summary>
            Ignore exceptions when objects are disposed
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MaxMillisecondsDateDifference">
            <summary>
            Ignore millisecond differences between DateTime values or DateTimeOffset values.  The default is 0 (any time difference will be shown).
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareDateTimeOffsetWithOffsets">
            <summary>
            When comparing DateTimeOffsets, offsets will be compared as well as the UtcDateTimes. The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreDateTimeOffsetTimezones">
            <summary>
            When comparing DateTimeOffsets, timezone difference will be ignored by changing both object to their UTC equivalent value. The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MaxStructDepth">
            <summary>
            When comparing struct, the depth to compare for children.  The default is 2, the max is 5
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreUnknownObjectTypes">
            <summary>
            If true, unknown object types will be ignored instead of throwing an exception.  The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.SkipInvalidIndexers">
            <summary>
            If true, invalid indexers will be skipped.  The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.InterfaceMembers">
            <summary>
            If a class implements an interface then only members of the interface will be compared.  The default is all members are compared. 
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ShowBreadcrumb">
            <summary>
            Show breadcrumb at each stage of the comparision.  The default is false.
            This is useful for debugging deep object graphs.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ClassTypesToIgnore">
            <summary>
            A list of class types to be ignored in the comparison. The default is to compare all class types.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ClassTypesToInclude">
            <summary>
            Only these class types will be compared. The default is to compare all class types.
            </summary>
            <remarks>If you specify a class type here no other class types will be compared unless it is in this list.</remarks>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.TypesToIgnore">
            <summary>
            A list of types to be ignored in the comparison. The default is to compare all types.  A typical thing to not compare are GUIDs
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.TypesToInclude">
            <summary>
            Only these types will be compared. The default is to compare all types.
            </summary>
            <remarks>If you specify a type here no others will be compared unless it is in this list.  You must specify ALL Types that you want to compare.</remarks>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MembersToIgnore">
            <summary>
            Ignore Data Table Names, Data Table Column Names, properties, or fields by name during the comparison. Case sensitive. The default is to compare all members.
            </summary>
            <example>MembersToIgnore.Add("CreditCardNumber");
            MembersToIgnore.Add("Invoice.InvoiceGuid");
            MembersToIgnore.Add("*Id");
            </example>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreProperty``1(System.Linq.Expressions.Expression{System.Func{``0,System.Object}})">
            <summary>
            Ignore property during the comparison.  Property is specific to the generic type.
            </summary>
            <param name="ignoredProperty"></param>
            <typeparam name="TClass"></typeparam>
            <exception cref="T:System.ArgumentException"></exception>
            <example>IgnoreProperty&lt;Person&gt;(x => x.Name)</example>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.CustomPropertyComparer``1(System.Linq.Expressions.Expression{System.Func{``0,System.Object}},KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer)">
            <summary>
            Define a Custom Property Comparer using a lambda expression
            </summary>
            <typeparam name="TClass"></typeparam>
            <param name="customProperty"></param>
            <param name="validator"></param>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MembersToInclude">
            <summary>
            Only compare elements by name for Data Table Names, Data Table Column Names, properties and fields. Case sensitive. The default is to compare all members.
            </summary>
            <example>MembersToInclude.Add("FirstName")</example>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ComparePrivateProperties">
            <summary>
            If true, private properties and fields will be compared. The default is false.  Silverlight and WinRT restricts access to private variables.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ComparePrivateFields">
            <summary>
            If true, private fields will be compared. The default is false.  Silverlight and WinRT restricts access to private variables.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareStaticProperties">
            <summary>
            If true, static properties will be compared.  The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareStaticFields">
            <summary>
            If true, static fields will be compared.  The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareChildren">
            <summary>
            If true, child objects will be compared. The default is true. 
            If false, and a list or array is compared list items will be compared but not their children.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareReadOnly">
            <summary>
            If true, compare read only properties (only the getter is implemented). The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareFields">
            <summary>
            If true, compare fields of a class (see also CompareProperties).  The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreCollectionOrder">
            <summary>
            If true, compare each item within a collection to every item in the other.  The default is false. WARNING: setting this to true significantly impacts performance.  
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CompareProperties">
            <summary>
            If true, compare properties of a class (see also CompareFields).  The default is true.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MaxDifferences">
            <summary>
            The maximum number of differences to detect.  The default is 1 for performance reasons.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.MaxByteArrayDifferences">
            <summary>
            The maximum number of differences to detect when comparing byte arrays.  The default is 1.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.AutoClearCache">
            <summary>
            Reflection properties and fields are cached. By default this cache is cleared after each compare.  Set to false to keep the cache for multiple compares.
            </summary>
            <seealso cref="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.Caching"/>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.Caching">
            <summary>
            By default properties and fields for types are cached for each compare.  By default this cache is cleared after each compare.
            </summary>
            <seealso cref="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.AutoClearCache"/>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.AttributesToIgnore">
            <summary>
            A list of attributes to ignore a class, property or field
            </summary>
            <example>AttributesToIgnore.Add(typeof(XmlIgnoreAttribute));</example>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.RequiredAttributesToCompare">
            <summary>
            If a property or field don't have at least one of the attributes in this list, it will be ignored
            </summary>
            <example>RequiredAttributesToCompare.Add(typeof(XmlIgnoreAttribute));</example>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreObjectTypes">
            <summary>
            If true, objects will be compared ignore their type diferences.  The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ExpectedName">
            <summary>
            In the differences string, this is the name for expected name. The default is: Expected 
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.ActualName">
            <summary>
            In the differences string, this is the name for the actual name. The default is: Actual
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.DifferenceCallback">
            <summary>
            Callback invoked each time the comparer finds a difference. The default is no call back.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CollectionMatchingSpec">
            <summary>
            Sometimes one wants to match items between collections by some key first, and then
            compare the matched objects.  Without this, the comparer basically says there is no 
            match in collection B for any given item in collection A that doesn't Compare with a result of true.  
            The results of this aren't particularly useful for object graphs that are mostly the same, but not quite. 
            Enter CollectionMatchingSpec
            
            The enumerable strings should be property (not field, for now, to keep it simple) names of the
            Type when encountered that will be used for matching
            
            You can use complex type properties, too, as part of the key to match.  To match on all props/fields on 
            such a matching key, Don't set this property (default comparer behavior)
            NOTE: types are looked up as exact.  e.g. if foo is an entry in the dictionary and bar is a 
            sub-class of foo, upon encountering a bar type, the comparer will not find the entry of foo
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CustomComparers">
            <summary>
            A list of custom comparers that take priority over the built in comparers
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.CustomPropertyComparers">
            <summary>
            A list of custom property comparers that take priority over the built in and type comparers 
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.TreatStringEmptyAndNullTheSame">
            <summary>
            If true, string.empty and null will be treated as equal for Strings and String Builder. The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.IgnoreStringLeadingTrailingWhitespace">
            <summary>
            If true, leading and trailing whitespaces will be ignored for Strings and String Builder. The default is false.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.DoublePrecision">
            <summary>
            The precision to compare double values.  The default is 0.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonConfig.DecimalPrecision">
            <summary>
            The precision to compare decimal values.  The default is 0.
            </summary>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.ComparisonConfig._hasWildcardInMembersToIgnore">
            <summary>
            Backing member that supports <see cref="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.HasWildcardMembersToExclude"/>
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.HasWildcardMembersToExclude">
            <summary>
            Computed value of whether or not exclusion list has wildcards.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonConfig.Reset">
            <summary>
            Reset the configuration to the default values
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.ComparisonResult">
            <summary>
            Details about the comparison
            </summary>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.ComparisonResult._referenceParents">
            <summary>
            Keep track of parent objects in the object hierarchy by using reference equals
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonResult.#ctor(KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Set the configuration for the comparison
            </summary>
            <param name="config"></param>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.CurrentStructDepth">
            <summary>
            Keep track of the depth of structs being compared.  Used with ComparisonConfig.MaxStructDepth
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.Config">
            <summary>
            Configuration
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.Watch">
            <summary>
            Used to time how long the comparison took
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.ElapsedMilliseconds">
            <summary>
            The amount of time in milliseconds it took for the comparison
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.Differences">
            <summary>
            The differences found during the compare
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.DifferencesString">
            <summary>
            The differences found in a string suitable for a textbox
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.AreEqual">
            <summary>
            Returns true if the objects are equal
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ComparisonResult.ExceededDifferences">
            <summary>
            Returns true if the number of differences has reached the maximum
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonResult.AddParent(System.Object)">
            <summary>
            Add parent, handle references count
            </summary>
            <param name="objectReference"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonResult.RemoveParent(System.Object)">
            <summary>
            Remove parent, handle references count
            </summary>
            <param name="objectReference"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ComparisonResult.IsParent(System.Object)">
            <summary>
            Returns true if we have encountered this parent before
            </summary>
            <param name="objectReference"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.CustomValidationLogic">
            <summary>
            Get custom validator based on property
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CustomValidationLogic.CustomValidatorForDynamicMember(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String,System.Type)">
            <summary>
            Get validator for a member of an expando object
            </summary>
            <param name="config"></param>
            <param name="name"></param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.CustomValidationLogic.CustomValidatorForMember(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Reflection.MemberInfo,System.Type)">
            <summary>
            Get validator for a member
            </summary>
            <param name="config"></param>
            <param name="info"></param>
            <param name="objectType"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Difference">
            <summary>
            Detailed information about the difference
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ExpectedName">
            <summary>
            Name of Expected Object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ActualName">
            <summary>
            Name of Actual Object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ParentPropertyName">
            <summary>
            Returns the parent property name
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.PropertyName">
            <summary>
            The breadcrumb of the property leading up to the value
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ChildPropertyName">
            <summary>
            The child property name
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object1Value">
            <summary>
            Object1 Value as a string
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object2Value">
            <summary>
            Object2 Value as a string
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object1TypeName">
            <summary>
            The type of the first object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object2TypeName">
            <summary>
            The type of the second object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ParentObject1">
            <summary>
            A reference to the parent of object1
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.ParentObject2">
            <summary>
            A reference to the parent of object2
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object1">
            <summary>
            Object1 as a reference
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.Object2">
            <summary>
            Object2 as a reference
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Difference.MessagePrefix">
            <summary>
            Prefix to put on the beginning of the message
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Difference.GetShortItem">
            <summary>
            Item and property name only
            </summary>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Difference.GetWhatIsCompared">
            <summary>
            The type and index of what is compared
            </summary>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Difference.ToString">
            <summary>
            Nicely formatted string
            </summary>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.EnvironmentHelper">
            <summary>
            Environment helper class
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.EnvironmentHelper.IsWindows">
            <summary>
            Returns true if we are running in Windows
            </summary>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.ExcludeLogic">
            <summary>
            Exclude types depending upon the configuration
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.ShouldExcludeDynamicMember(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String,System.Type)">
            <summary>
            Exclude a member of an expando object
            </summary>
            <param name="config"></param>
            <param name="name"></param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.ShouldExcludeMember(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Reflection.MemberInfo,System.Type)">
            <summary>
            Returns true if the property or field should be excluded
            </summary>
            <param name="config"></param>
            <param name="info"></param>
            <param name="objectType"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.ExcludedByWildcard(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String)">
            <summary>
            Returns true if the property or field should be exluded by wilcard
            </summary>
            <param name="config"></param>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.ShouldExcludeClass(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Type,System.Type)">
            <summary>
            Check if the class should be exluded by Attribute
            </summary>
            <param name="config"></param>
            <param name="t1"></param>
            <param name="t2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.ShouldExcludeType(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Type,System.Type)">
            <summary>
            Check if the class type should be excluded based on the configuration
            </summary>
            <param name="config"></param>
            <param name="t1"></param>
            <param name="t2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.IgnoredByAttribute(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Reflection.MemberInfo)">
            <summary>
            Check if any type has attributes that should be bypassed
            </summary>
            <returns></returns>	
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ExcludeLogic.IgnoredByLackOfAttribute(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.Reflection.MemberInfo)">
            <summary>
            Check if any type lacks attributes that should be required
            </summary>
            <returns></returns>	
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.FileHelper">
            <summary>
            Helper methods for files and directories
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.FileHelper.GetCurrentDirectory">
            <summary>
            Get the current directory of the executing assembly
            </summary>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.FileHelper.PathSlash(System.String)">
            <summary>
            Ensure the passed string ends with a directory separator character unless the string is blank.
            </summary>
            <param name="path">The string to append the backslash to.</param>
            <returns>String with a "/" on the end</returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.HtmlConfig">
            <summary>
            Config object for HtmlReport
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.BreadCrumbColumName">
            <summary>
            The header value of the Bread Crumb column
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.ExpectedColumnName">
            <summary>
            The header value of the Expected column
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.ActualColumnName">
            <summary>
            The header value of the Actual column
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.GenerateFullHtml">
            <summary>
            If true, the output will be complete html, if false, it will just be the table
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.HtmlHeader">
            <summary>
            Setting this will overwrite the default html header (html, head, body tags)
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.HtmlFooter">
            <summary>
            Setting this will overwrite the default html footer (closing body, html tags)
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.HtmlTitle">
            <summary>
            The title of the page - only visible if GenerateFullHtml == true
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.HtmlConfig.Style">
            <summary>
            The CSS Style of the page - only used if the GenerateFullHtml == true
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.HtmlConfig.#ctor">
            <summary>
            Default constructor, sets default values
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.HtmlConfig.IncludeCustomCSS(System.String)">
            <summary>
            Appends to the existing Style value
            </summary>
            <param name="css">Any css to append</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.HtmlConfig.ReplaceCSS(System.String)">
            <summary>
            Replaces the existing Style value
            </summary>
            <param name="css">Any css to use</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.ICompareLogic">
            <summary>
            Interface for mocking
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.ICompareLogic.Config">
            <summary>
            The default configuration
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ICompareLogic.Compare(System.Object,System.Object)">
            <summary>
            Compare two objects of the same type to each other.
            </summary>
            <remarks>
            Check the Differences or DifferencesString Properties for the differences.
            Default MaxDifferences is 1 for performance
            </remarks>
            <param name="expectedObject">The expected object value to compare</param>
            <param name="actualObject">The actual object value to compare</param>
            <returns>True if they are equal</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ICompareLogic.ClearCache">
            <summary>
            Reflection properties and fields are cached. By default this cache is cleared automatically after each compare.
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.IgnoreOrderTypes.IgnoreOrderLogic">
            <summary>
            Logic for comparing lists that are out of order based on a key
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.IgnoreOrderTypes.IgnoreOrderLogic.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Initializes a new instance of the <see cref="T:KellermanSoftware.CompareNetObjects.IgnoreOrderTypes.IgnoreOrderLogic"/> class.
            </summary>
            <param name="rootComparer">The root comparer.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.IgnoreOrderTypes.IgnoreOrderLogic.CompareEnumeratorIgnoreOrder(KellermanSoftware.CompareNetObjects.CompareParms,System.Boolean)">
            <summary>
            Compares the enumerators and ignores the order
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.LogicEqualityComparer">
            <summary>Implements methods to support the comparison of objects for equality, in a customizable fashion.</summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.LogicEqualityComparer`1">
            <summary>Implements methods to support the comparison of objects for equality, in a customizable fashion.</summary>
            <typeparam name="T">The comparison object type.</typeparam>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.LogicEqualityComparer`1.CompareLogic">
            <summary>Defines the configuration and logic by which Equals comparisons will be performed.</summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.LogicEqualityComparer`1.UseObjectHashes">
            <summary>Gets or sets a value indicating whether the base object hashes should be used.</summary>
            <remarks>
            False by default to allow CompareLogic to evaluate equivalence of otherwise instance-sensitive hashing objects.
            NOTE: Any object which doesn't override GetHashCode will behave this way, so this property should generally be left false.
            </remarks>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.LogicEqualityComparer`1.Equals(`0,`0)">
            <summary>Compare two objects of the same type to each other.</summary>
            <returns>True if the objects are considered equivalent, according to the current CompareLogic.</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.LogicEqualityComparer`1.GetHashCode(`0)">
            <summary>Retrieves the hash of the specified object.</summary>
            <param name="obj">The object to retrieve a hash for.</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.ProcessHelper">
            <summary>
            Helper methods for processes
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.ProcessHelper.Shell(System.String,System.String,System.Diagnostics.ProcessWindowStyle,System.Boolean)">
            <summary>
            Execute an external program.
            </summary>
            <param name="executablePath">Path and filename of the executable.</param>
            <param name="arguments">Arguments to pass to the executable.</param>
            <param name="windowStyle">Window style for the process (hidden, minimized, maximized, etc).</param>
            <param name="waitUntilFinished">Wait for the process to finish.</param>
            <returns>Exit Code</returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.PropertyEntity">
            <summary>
            Generic class for holding a Property Info, or Dynamic Info
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.PropertyEntity.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.IsDynamic">
            <summary>
            If true, this is a dynamic property
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.Name">
            <summary>
            Name of the property
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.Value">
            <summary>
            Value of the property
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.ReflectedType">
            <summary>
            Let me reflect on this day
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.DeclaringType">
            <summary>
            The type of the parent
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.PropertyType">
            <summary>
            The type of the property
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.CanRead">
            <summary>
            If the property can be read from
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.CanWrite">
            <summary>
            If the property can be written to
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.Indexers">
            <summary>
            Indexers for the property
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.PropertyEntity.PropertyInfo">
            <summary>
            Reference to the property info
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.BaseDualFileReport">
            <summary>
            Abstract Base Duel File Report that has default Output
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.BaseDualFileReport.OutputFiles(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String,System.String)">
            <summary>
            Create two difference files and compare in WinMerge
            </summary>
            <param name="differences">A list of the differences</param>
            <param name="expectedFilePath">The path to write the expected results</param>
            <param name="actualFilePath">The path to write the actual results</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.BaseDualFileReport.LaunchApplication(System.String,System.String)">
            <summary>
            Launch application to compare two files
            </summary>
            <param name="expectedFilePath">The path for the expected file results</param>
            <param name="actualFilePath">The path for the actual file results</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.BeyondCompareReport">
            <summary>
            Output files and launch Beyond Compare
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.BeyondCompareReport.LaunchApplication(System.String,System.String)">
            <summary>
            Launch Beyond Compare
            </summary>
            <param name="expectedFilePath">The path to write the expected results</param>
            <param name="actualFilePath">The path to write the actual results</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.BeyondCompareReport.FindBeyondCompare">
            <summary>
            Find the path of the Beyond Compare executable
            </summary>
            <returns>The path or null if not found</returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.CsvReport">
            <summary>
            Create a CSV file of the differences and launch the default CSV handler (usually Excel)
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.CsvReport.OutputFile(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String)">
            <summary>
            Output the differences to a file
            </summary>
            <param name="differences">A list of differences</param>
            <param name="filePath">The file path</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.CsvReport.OutputStream(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.IO.Stream)">
            <summary>
            Output the differences to a stream
            </summary>
            <param name="differences">A list of differences</param>
            <param name="stream">An output stream</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.CsvReport.OutputString(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference})">
            <summary>
            Output the differences to a string
            </summary>
            <param name="differences">A list of differences</param>
            <returns>A string</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.CsvReport.LaunchApplication(System.String)">
            <summary>
            Launch the application associated with CSV files
            </summary>
            <param name="filePath">The differences file</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.CsvReport.EscapeString(System.Object)">
            <summary>
            Escape special characters
            </summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.HtmlReport">
            <summary>
            Create an HTML file of the differences and launch the default HTML handler
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.#ctor">
            <summary>
            Default constructor, sets up Config object
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.Config">
            <summary>
            HtmlReport Configuration
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.OutputFile(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String)">
            <summary>
            Output the differences to a file
            </summary>
            <param name="differences">A list of differences</param>
            <param name="filePath">The file path</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.LaunchApplication(System.String)">
            <summary>
            Launch the HTML Report
            </summary>
            <param name="filePath">The differences file</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.OutputStream(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.IO.Stream)">
            <summary>
            Output the differences to a stream
            </summary>
            <param name="differences">A list of differences</param>
            <param name="stream">An output stream</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.OutputString(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference})">
            <summary>
            Output the differences to a string
            </summary>
            <param name="differences">A list of differences</param>
            <returns>A string</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.HtmlReport.EscapeString(System.Object)">
            <summary>
            Escape special characters
            </summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.IDualFileReport">
            <summary>
            Define a dual file report like Beyond Compare, WinMerge etc.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.IDualFileReport.OutputFiles(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String,System.String)">
            <summary>
            Output the differences to two files
            </summary>
            <param name="differences">A list of differences</param>
            <param name="expectedFilePath">The path to write the expected results</param>
            <param name="actualFilePath">The path to write the actual results</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.IDualFileReport.LaunchApplication(System.String,System.String)">
            <summary>
            Launch the comparison application
            </summary>
            <param name="expectedFilePath">The path to write the expected results</param>
            <param name="actualFilePath">The path to write the actual results</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.ISingleFileReport">
            <summary>
            Defines a Single File Report
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.ISingleFileReport.OutputFile(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String)">
            <summary>
            Output the differences to a file
            </summary>
            <param name="differences">A list of differences</param>
            <param name="filePath">The file path</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.ISingleFileReport.OutputStream(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.IO.Stream)">
            <summary>
            Output the differences to a stream
            </summary>
            <param name="differences">A list of differences</param>
            <param name="stream">Where to write to</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.ISingleFileReport.OutputString(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference})">
            <summary>
            Output the differences to a string
            </summary>
            <param name="differences">A list of differences</param>
            <returns>A string</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.ISingleFileReport.LaunchApplication(System.String)">
            <summary>
            Launch the application for showing the file
            </summary>
            <param name="filePath">The file path</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport">
            <summary>
            Report for showing differences to an end user
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport"/> class.
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.ChangedToText">
            <summary>
            The text in between the values.  Defaults to: CHANGED TO ->
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.OutputFile(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.String)">
            <summary>
            Output the differences to a file
            </summary>
            <param name="differences">A list of differences</param>
            <param name="filePath">The file path</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.OutputStream(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference},System.IO.Stream)">
            <summary>
            Output the differences to a stream
            </summary>
            <param name="differences">A list of differences</param>
            <param name="stream">Where to write to</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.OutputString(System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.Difference})">
            <summary>
            Output the differences to a string
            </summary>
            <param name="differences">A list of differences</param>
            <returns>A string</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.UserFriendlyReport.LaunchApplication(System.String)">
            <summary>
            Launch the application for showing the file
            </summary>
            <param name="filePath">The file path</param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.Reports.WinMergeReport">
            <summary>
            Output files and launch WinMerge
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.WinMergeReport.LaunchApplication(System.String,System.String)">
            <summary>
            Launch the WinMerge
            </summary>
            <param name="expectedFilePath">The path to write the expected results</param>
            <param name="actualFilePath">The path to write the actual results</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.Reports.WinMergeReport.FindWinMerge">
            <summary>
            Find the path of the WinMerge executable
            </summary>
            <returns>The path or null if not found</returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.RootComparer">
            <summary>
            The base comparer which contains all the type comparers
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.RootComparer.TypeComparers">
            <summary>
            A list of the type comparers
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.RootComparer.Compare(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two objects
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.RootComparerFactory">
            <summary>
            Factory to create a root comparer
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.RootComparerFactory.GetRootComparer">
            <summary>
            Get the current root comparer
            </summary>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.StringHelper">
            <summary>
            Methods for manipulating strings
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.StringHelper.InsertSpaces(System.String)">
            <summary>
            Insert spaces into a string 
            </summary>
            <example>
            OrderDetails = Order Details
            10Net30 = 10 Net 30
            FTPHost = FTP Host
            </example> 
            <param name="input"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeBackwardsCompatibilityExtensions">
            <summary>
            Extensions for Type to provide backward compatibility between latest and older .net Framework APIs.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeBackwardsCompatibilityExtensions.GetTypeInfo(System.Type)">
            <summary>
            Function to provide compilation compatibility between older code and newer style.
            </summary>
            <param name="type">The type.</param>
            <returns>The type.</returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer">
            <summary>
            Common functionality for all Comparers
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.AddBreadCrumb(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String,System.String)">
            <summary>
            Add a breadcrumb to an existing breadcrumb
            </summary>
            <param name="config">Comparison configuration</param>
            <param name="existing">The existing breadcrumb</param>
            <param name="name">The field or property name</param>
            <returns>The new breadcrumb</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.AddBreadCrumb(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String,System.String,System.String,System.Int32)">
            <summary>
            Add a breadcrumb to an existing breadcrumb
            </summary>
            <param name="config">The comparison configuration</param>
            <param name="existing">The existing breadcrumb</param>
            <param name="name">The property or field name</param>
            <param name="extra">Extra information to output after the name</param>
            <param name="index">The index for an array, list, or row</param>
            <returns>The new breadcrumb</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.AddBreadCrumb(KellermanSoftware.CompareNetObjects.ComparisonConfig,System.String,System.String,System.String,System.String)">
            <summary>
            Add a breadcrumb to an existing breadcrumb
            </summary>
            <remarks>This originally used a string builder which had lower performance</remarks>
            <param name="config">Comparison configuration</param>
            <param name="existing">The existing breadcrumb</param>
            <param name="name">The field or property name</param>
            <param name="extra">Extra information to append after the name</param>
            <param name="index">The index if it is an array, list, row etc.</param>
            <returns>The new breadcrumb</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.AddDifference(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Add a difference for the current parameters
            </summary>
            <param name="parameters"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.AddDifference(KellermanSoftware.CompareNetObjects.ComparisonResult,KellermanSoftware.CompareNetObjects.Difference)">
            <summary>
            Add a difference to the result
            </summary>
            <param name="difference">The difference to add to the result</param>
            <param name="result">The comparison result</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseComparer.NiceString(System.Object)">
            <summary>
            Convert an object to a nicely formatted string
            </summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer">
            <summary>
            Common functionality for all Type Comparers
            </summary>
        </member>
        <member name="P:KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer.RootComparer">
            <summary>
            A reference to the root comparer as newed up by the RootComparerFactory
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Protected constructor that references the root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            If true the type comparer will handle the comparison for the type
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.BaseTypeComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare the two objects
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.ByteArrayComparer">
            <summary>
            Compare two byte arrays
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ByteArrayComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Protected constructor that references the root comparer
            </summary>
            <param name="rootComparer">The root comparer.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ByteArrayComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            If true the type comparer will handle the comparison for the type
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns><c>true</c> if it is a byte array; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ByteArrayComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two byte array objects
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.ClassComparer">
            <summary>
            Compare two objects of type class
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ClassComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor for the class comparer
            </summary>
            <param name="rootComparer">The root comparer instantiated by the RootComparerFactory</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ClassComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if the both objects are a class
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ClassComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two classes
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.CollectionComparer">
            <summary>
            Logic to compare two collections of different types.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CollectionComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            The main constructor.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CollectionComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are collections.
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CollectionComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two collections.
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2">
            <summary>
            Compare two generic objects
            </summary>
            <typeparam name="T1">The type of the first object</typeparam>
            <typeparam name="T2">The type of the second object</typeparam>
        </member>
        <member name="F:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.Compare">
            <summary>
            Method to evaluate the results, return true if two objects are equal
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.#ctor">
            <summary>
            Constructor that takes a default root comparer
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.#ctor(System.Func{`0,`1,System.Boolean})">
            <summary>
            Constructor that takes a the predication with a default root comparer
            </summary>
            <param name="compare">A function to determine if two objects are equal</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.#ctor(KellermanSoftware.CompareNetObjects.RootComparer,System.Func{`0,`1,System.Boolean})">
            <summary>
            Constructor that takes a the predication with a root comparer
            </summary>
            <param name="rootComparer">The root comparer</param>
            <param name="compare">Method to determine if two objects are equal</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two objects
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.CustomComparer`2.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects match their types
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DataColumnComparer">
            <summary>
            Compare a data column
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataColumnComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Default constructor
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataColumnComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types compared are a DataColumn
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataColumnComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare a Data Column
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DataRowComparer">
            <summary>
            Compare all columns in a data row
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataRowComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataRowComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if this is a DataRow
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataRowComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two data rows
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DatasetComparer">
            <summary>
            Compare all tables and all rows in all tables
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DatasetComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DatasetComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are data sets
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DatasetComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two data sets
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DataTableComparer">
            <summary>
            Compare all rows in a data table
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataTableComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataTableComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are of type DataTable
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DataTableComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two datatables
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DateComparer">
            <summary>
            Compare dates with the option to ignore based on milliseconds
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are DateTime
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two DateTime variables
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DateTimeOffSetComparer">
            <summary>
            Compare DateTimeOffsets with the ability to ignore millisecond differences
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateTimeOffSetComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateTimeOffSetComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are DateTimeOffset
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DateTimeOffSetComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two DateTimeOffset
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DecimalComparer">
            <summary>
            Compare Decimal values with the ability to specify the precision
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DecimalComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DecimalComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are double
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DecimalComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two decimals
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DictionaryComparer">
            <summary>
            Logic to compare two dictionaries
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DictionaryComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DictionaryComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are dictionaries
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DictionaryComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two dictionaries
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DictionaryComparer.ShouldCompareByKeys(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            This is to handle funky situation of having a complex object as a key
            (In this case a dictionary as a key)
            https://github.com/GregFinzer/Compare-Net-Objects/issues/222
            </summary>
            <param name="parms"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.DoubleComparer">
            <summary>
            Compare Double values with the ability to specify the precision
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DoubleComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DoubleComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are double
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.DoubleComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two doubles
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.EnumComparer">
            <summary>
            Logic to compare to enum values
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor with a default root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are of type enum
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two enums
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.EnumerableComparer">
            <summary>
            Logic to compare two LINQ enumerators
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumerableComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumerableComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if either object is of type LINQ Enumerator
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.EnumerableComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two objects that implement LINQ Enumerator
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.FieldComparer">
            <summary>
            Compare all the fields of a class or struct (Note: inherits from BaseComparer instead of TypeComparer).
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.FieldComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor with a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.FieldComparer.PerformCompareFields(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare the fields of a class
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.FontComparer">
            <summary>
            Class FontDescriptorComparer.
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.FontComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Protected constructor that references the root comparer
            </summary>
            <param name="rootComparer">The root comparer.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.FontComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            If true the type comparer will handle the comparison for the type
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns><c>true</c> if [is type match] [the specified type1]; otherwise, <c>false</c>.</returns>
            <exception cref="T:System.NotImplementedException"></exception>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.FontComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare the two fonts
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.HashSetComparer">
            <summary>
            Logic to compare two hash sets
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.HashSetComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.HashSetComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are hash sets
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.HashSetComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two hash sets
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.ImmutableArrayComparer">
            <summary>
            Compares System.Collections.Immutable.ImmutableArray
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ImmutableArrayComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ImmutableArrayComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both are immutable arrays with same generic argument type
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ImmutableArrayComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compares two immutable arrays
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.IndexerComparer">
            <summary>
            Logic to compare an integer indexer (Note, inherits from BaseComparer, not TypeComparer)
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.IndexerComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.IndexerComparer.CompareIndexer(KellermanSoftware.CompareNetObjects.CompareParms,KellermanSoftware.CompareNetObjects.PropertyEntity,KellermanSoftware.CompareNetObjects.PropertyEntity)">
            <summary>
            Compare an integer indexer
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.IpEndPointComparer">
            <summary>
            Logic to compare two IP End Points
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.IpEndPointComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.IpEndPointComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are an IP End Point
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.IpEndPointComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two IP End Points
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.ListComparer">
            <summary>
            Compare objects that implement IList
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ListComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ListComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects implement IList
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.ListComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two objects that implement IList
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.PointerComparer">
            <summary>
            Logic to compare to pointers
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PointerComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PointerComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are a pointer
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PointerComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two pointers
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.PropertyComparer">
            <summary>
            Compare two properties (Note: inherits from BaseComparer instead of TypeComparer).
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PropertyComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PropertyComparer.PerformCompareProperties(KellermanSoftware.CompareNetObjects.CompareParms,System.Boolean)">
            <summary>
            Compare the properties of a class
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.PropertyComparer.CompareProperty(KellermanSoftware.CompareNetObjects.CompareParms,KellermanSoftware.CompareNetObjects.PropertyEntity,System.Collections.Generic.List{KellermanSoftware.CompareNetObjects.PropertyEntity})">
            <summary>
            Compare a single property of a class
            </summary>
            <param name="parms"></param>
            <param name="info"></param>
            <param name="object2Properties"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.RuntimeTypeComparer">
            <summary>
            Logic to compare two runtime types
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.RuntimeTypeComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.RuntimeTypeComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are of type runtme type
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.RuntimeTypeComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two runtime types
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.SimpleTypeComparer">
            <summary>
            Compare primitive types (long, int, short, byte etc.) and DateTime, decimal, and Guid
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.SimpleTypeComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.SimpleTypeComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if the type is a simple type
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.SimpleTypeComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two simple types
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.StringBuilderComparer">
            <summary>
            Compare two StringBuilders
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringBuilderComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringBuilderComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are a StringBuilder
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringBuilderComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two string builders
            </summary>
            <param name="parms"></param>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.StringComparer">
            <summary>
            Compare two strings
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are a string or if one is a string and one is a a null
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StringComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two strings
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.StructComparer">
            <summary>
            Compare two structs
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StructComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StructComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are of type struct
            </summary>
            <param name="type1"></param>
            <param name="type2"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.StructComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two structs
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.TimespanComparer">
            <summary>
            Logic to compare two timespans
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.TimespanComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.TimespanComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both objects are timespans
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.TimespanComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two timespans
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeComparers.UriComparer">
            <summary>
            Compare two URIs
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.UriComparer.#ctor(KellermanSoftware.CompareNetObjects.RootComparer)">
            <summary>
            Constructor that takes a root comparer
            </summary>
            <param name="rootComparer"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.UriComparer.IsTypeMatch(System.Type,System.Type)">
            <summary>
            Returns true if both types are a URI
            </summary>
            <param name="type1">The type of the first object</param>
            <param name="type2">The type of the second object</param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeComparers.UriComparer.CompareType(KellermanSoftware.CompareNetObjects.CompareParms)">
            <summary>
            Compare two URIs
            </summary>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.TypeHelper">
            <summary>
            Methods for detecting types and converting types
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDynamicObject(System.Type)">
            <summary>
            Returns true if it is a dynamic object
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsExpandoObject(System.Object)">
            <summary>
            Determines whether the specified object is an expando object
            </summary>
            <param name="objectValue">The object value.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsByteArray(System.Type)">
            <summary>
            Returns true if it is a byte array
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.CanHaveChildren(System.Type)">
            <summary>
            Returns true if the type can have children
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsArray(System.Type)">
            <summary>
            True if the type is an array
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsImmutableArray(System.Type)">
            <summary>
            True if the type is an System.Collections.Immutable.ImmutableArray
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsStruct(System.Type)">
            <summary>
            Returns true if it is a struct
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsTimespan(System.Type)">
            <summary>
            Returns true if the type is a timespan
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsClass(System.Type)">
            <summary>
            Return true if the type is a class
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsInterface(System.Type)">
            <summary>
            Return true if the type is an interface
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsUri(System.Type)">
            <summary>
            Return true if the type is a URI
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsPointer(System.Type)">
            <summary>
            Return true if the type is a pointer
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsEnum(System.Type)">
            <summary>
            Return true if the type is an enum
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsIDictionary(System.Type)">
            <summary>
            Return true if the type is a dictionary
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsHashSet(System.Type)">
            <summary>
            Return true if the type is a hashset
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsIList(System.Type)">
            <summary>
            Return true if the type is a List
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsEnumerable(System.Type)">
            <summary>
            Return true if the type is an Enumerable
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDouble(System.Type)">
            <summary>
            Return true if the type is a Double
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDecimal(System.Type)">
            <summary>
            Return true if the type is a Decimal
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDecimal(System.Object)">
            <summary>
            Return true if the type is a Decimal or Nullable Decimal
            </summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDateTime(System.Type)">
            <summary>
            Return true if the type is a DateTime
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDateTimeOffset(System.Type)">
            <summary>
            Return true if the type is a DateTimeOffset
            </summary>
            <param name="type"></param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsStringBuilder(System.Type)">
            <summary>
            Return true if the type is a StringBuilder
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsString(System.Type)">
            <summary>
            Return true if the type is a string
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsSimpleType(System.Type)">
            <summary>
            Return true if the type is a primitive type, date, decimal, string, or GUID
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsRuntimeType(System.Type)">
            <summary>
            Returns true if the Type is a Runtime type
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsGenericType(System.Type)">
            <summary>
            Returns true if the type is a generic type.
            </summary>
            <param name="type">The type.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsIpEndPoint(System.Type)">
            <summary>
            Returns true if the type is an IPEndPoint
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDataset(System.Type)">
            <summary>
            Returns true if the type is a dataset
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDataTable(System.Type)">
            <summary>
            Returns true if the type is a data table
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDataRow(System.Type)">
            <summary>
            Returns true if the type is a data row
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsDataColumn(System.Type)">
            <summary>
            Returns true if the Type is Data Column
            </summary>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.IsFont(System.Type)">
            <summary>
            Returns true if the type is a font
            </summary>
            <param name="type">The type1.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.ListOfTypesSerializer(System.Collections.Generic.List{System.Type})">
            <summary>
            Turn a list of types into a list of string types
            </summary>
            <param name="types"></param>
            <returns></returns>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.TypeHelper.ListOfTypesDeserializer(System.Collections.Generic.List{System.String})">
            <summary>
            Turn a list of string into a list of types
            </summary>
            <param name="stringList"></param>
            <returns></returns>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.VerifyConfig">
            <summary>
            Used internally to verify the config settings before comparing
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.VerifyConfig.Verify(KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Verifies the specified configuration.
            </summary>
            <param name="config">The configuration.</param>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.VerifyConfig.VerifySpec(KellermanSoftware.CompareNetObjects.ComparisonConfig)">
            <summary>
            Verifies the collection matching spec.
            </summary>
            <param name="config">The configuration.</param>
            <exception cref="T:System.Exception">
            </exception>
        </member>
        <member name="T:KellermanSoftware.CompareNetObjects.WebHelper">
            <summary>
            Helper class for web related methods
            </summary>
        </member>
        <member name="M:KellermanSoftware.CompareNetObjects.WebHelper.HtmlEncode(System.String)">
            <summary>
            HTML-encodes a string and returns the encoded string.
            </summary>
            <param name="text">The text string to encode. </param>
            <returns>The HTML-encoded text.</returns>
        </member>
    </members>
</doc>
