public static void MergeRelatedClasses(List <HashSet <string> > classesRelatedToEachOther, SortedDictionary <Tuple <string, string>, HashSet <string> > data)
        {
            Dictionary <string, Tuple <string, string> > classNameAlreadyVisitedToKey = new Dictionary <string, Tuple <string, string> >();
            List <Tuple <string, string> > entriesToRemoveFromDictionary = new List <Tuple <string, string> >();                                            // This is here because we cannot remove the keys while iterating in the dictionary, so we do it afterwards.
            Dictionary <Tuple <string, string>, HashSet <string> > entriesToAddToDictionary = new Dictionary <Tuple <string, string>, HashSet <string> >(); // This is here because we cannot add entries while iterating in the dictionary, so we do it afterwards.

            foreach (KeyValuePair <Tuple <string, string>, HashSet <string> > pair in data)
            {
                string           theFullMethodName = pair.Key.Item1;
                string           theAssemblyName   = pair.Key.Item2;
                HashSet <string> whereItIsUsed     = pair.Value;

                // Get the class name:
                string className = theFullMethodName;
                if (className.IndexOf('.') >= 0)
                {
                    className = className.Substring(0, className.IndexOf('.'));
                }
                if (className.IndexOf(' ') >= 0)
                {
                    className = className.Substring(0, className.IndexOf(' '));
                }

                // Check if the class has related classes:
                HashSet <string> groupOfClassesRelatedToEachOther = null;
                string           classAlreadyVisitedToMerge       = null;
                foreach (HashSet <string> item in classesRelatedToEachOther)
                {
                    if (item.Contains(className))
                    {
                        groupOfClassesRelatedToEachOther = item;
                        break;
                    }
                }
                if (groupOfClassesRelatedToEachOther != null)
                {
                    // Check if we already visited one of those classes:
                    foreach (string className2 in groupOfClassesRelatedToEachOther)
                    {
                        if (classNameAlreadyVisitedToKey.ContainsKey(className2))
                        {
                            classAlreadyVisitedToMerge = className2;
                            break;
                        }
                    }
                }
                if (classAlreadyVisitedToMerge != null)
                {
                    // Get the first item to merge:
                    Tuple <string, string> keyOfFirstItem = classNameAlreadyVisitedToKey[classAlreadyVisitedToMerge];
                    HashSet <string>       valueOfFirstItem;
                    if (data.ContainsKey(keyOfFirstItem))
                    {
                        valueOfFirstItem = data[keyOfFirstItem];
                    }
                    else if (entriesToAddToDictionary.ContainsKey(keyOfFirstItem))
                    {
                        valueOfFirstItem = entriesToAddToDictionary[keyOfFirstItem];
                    }
                    else
                    {
                        throw new KeyNotFoundException("Cannot find item with key: " + keyOfFirstItem);
                    }

                    // Get the second item to merge:
                    Tuple <string, string> keyOfSecondItem   = pair.Key;
                    HashSet <string>       valueOfSecondItem = pair.Value;

                    // Merge the two classes (only if they are in the same assembly):
                    if (keyOfFirstItem.Item2 == keyOfSecondItem.Item2) // Note: "item2" is the assembly name.
                    {
                        entriesToRemoveFromDictionary.Add(keyOfFirstItem);
                        entriesToRemoveFromDictionary.Add(keyOfSecondItem);
                        string assemblyName = keyOfFirstItem.Item2;
                        HashSetHelpers.AddItemsFromOneHashSetToAnother(valueOfFirstItem, valueOfSecondItem);
                        Tuple <string, string> newKey = new Tuple <string, string>(keyOfFirstItem.Item1 + ", " + keyOfSecondItem.Item1, assemblyName);
                        entriesToAddToDictionary.Add(newKey, valueOfSecondItem);
                        classNameAlreadyVisitedToKey[classAlreadyVisitedToMerge] = newKey;
                    }
                }
                else
                {
                    classNameAlreadyVisitedToKey[className] = pair.Key;
                }
            }

            // Perform the actual addition and removal (note: this cannot be done before because it is not possible to remove or add an item from a collection while iterating it with "foreach");
            foreach (var entry in entriesToAddToDictionary)
            {
                data.Add(entry.Key, entry.Value);
            }
            foreach (var key in entriesToRemoveFromDictionary)
            {
                data.Remove(key);
            }
        }
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            string coreAssemblyPath      = CoreAssemblyPathTextBox.Text;
            string supportedElementsPath = SupportedElementsPathTextBox.Text;
            string mscorlibFolderPath    = MscorlibFolderPathTextBox.Text;
            string sdkFolderPath         = SDKFolderPathTextBox.Text;
            string otherFoldersPath      = OtherFoldersPathTextBox.Text;

            HashSet <string> xamlFilesToIgnore = null;

            try
            {
                xamlFilesToIgnore = new HashSet <string>(XamlFilesToIgnoreTextBox.Text.Split(',').Select(s => s.Trim().ToLower()));
            }
            catch (Exception ex)
            {
                MessageBox.Show("Invalid list of XAML files to exclude." + Environment.NewLine + Environment.NewLine + ex.ToString());
                return;
            }

            if (string.IsNullOrEmpty(coreAssemblyPath) ||
                string.IsNullOrEmpty(supportedElementsPath) ||
                string.IsNullOrEmpty(mscorlibFolderPath))
            {
                MessageBox.Show("Please fill all the fields before continuing.");
                return;
            }

            if (!File.Exists(supportedElementsPath))
            {
                MessageBox.Show("File not found: " + supportedElementsPath);
                return;
            }

            var featuresAndEstimationsFileProcessor = new FeaturesAndEstimationsFileProcessor(FeaturesAndEstimationsPathTextBox.Text);

            // Save the content of the text boxes for reuse when relaunching the application:
            SaveContentOfTextBoxes();

#if ASK_USER_TO_CHOOSE_ASSEMBLIES_TO_ANALYZE
            // Create OpenFileDialog
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

            // Set filter for file extension and default file extension
            dlg.DefaultExt  = ".dll";
            dlg.Filter      = "Assemblies and executables (*.dll,*.exe)|*.dll;*.exe";
            dlg.Multiselect = true;

            // Display OpenFileDialog by calling ShowDialog method
            Nullable <bool> result = dlg.ShowDialog();

            if (result == true)
            {
                string[] fileNames = dlg.FileNames;
#else
            string[] fileNames = Configuration.AssembliesToAnalyze;

            if (true)
            {
#endif

                if (_coreSupportedMethods == null)
                {
                    _coreSupportedMethods = new CoreSupportedMethodsContainer(coreAssemblyPath);
                }

                var logger = new LoggerThatAggregatesAllErrors();
                var watch  = Stopwatch.StartNew();
                var listOfUnsupportedMethods = new List <UnsupportedMethodInfo>();

                // Get the path of the folder where the first assembly is located, and add that path to the list of places where to look in for resolving referenced assemblies:
                string firstFileToAnalyze = fileNames.FirstOrDefault();
                string additionalFolderWhereToResolveAssemblies = null;
                if (firstFileToAnalyze != null)
                {
                    additionalFolderWhereToResolveAssemblies = System.IO.Path.GetDirectoryName(firstFileToAnalyze);
                }

                // Do the analysis:
                try
                {
                    foreach (var filename in fileNames)
                    {
                        CompatibilityAnalyzer.Analyze(
                            filename,
                            logger,
                            listOfUnsupportedMethods,
                            _coreSupportedMethods,
                            fileNames,
                            Configuration.UrlNamespacesThatBelongToUserCode,
                            Configuration.AttributesToIgnoreInXamlBecauseTheyAreFromBaseClasses,
                            xamlFilesToIgnore,
                            supportedElementsPath,
                            mscorlibFolderPath,
                            sdkFolderPath,
                            otherFoldersPath,
                            skipTypesWhereNoMethodIsActuallyCalled: true,
                            additionalFolderWhereToResolveAssemblies: additionalFolderWhereToResolveAssemblies);;
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                }

                // Replace all telerik assembly names with "http://schemas.telerik.com/2008/xaml/presentation" so as to avoid differences between namespaces from .xaml files and namespaces from .cs files:
                foreach (UnsupportedMethodInfo unsupportedMethodInfo in listOfUnsupportedMethods)
                {
                    if (unsupportedMethodInfo.MethodAssemblyName.StartsWith("Telerik."))
                    {
                        unsupportedMethodInfo.MethodAssemblyName = "http://schemas.telerik.com/2008/xaml/presentation";
                    }
                }

                // Replace all Expression Blend-related namespaces with "http://schemas.microsoft.com/expression/2010/..." so as to avoid differences between namespaces from .xaml files and namespaces from .cs files:
                foreach (UnsupportedMethodInfo unsupportedMethodInfo in listOfUnsupportedMethods)
                {
                    if (unsupportedMethodInfo.MethodAssemblyName.StartsWith("Microsoft.Expression.") ||
                        unsupportedMethodInfo.MethodAssemblyName.StartsWith("System.Windows.Interactivity") ||
                        unsupportedMethodInfo.MethodAssemblyName == "http://schemas.microsoft.com/expression/2010/drawing" ||
                        unsupportedMethodInfo.MethodAssemblyName == "http://schemas.microsoft.com/expression/2010/interactivity" ||
                        unsupportedMethodInfo.MethodAssemblyName == "http://schemas.microsoft.com/expression/2010/interactions"
                        )
                    {
                        unsupportedMethodInfo.MethodAssemblyName = "http://schemas.microsoft.com/expression/2010/...";
                    }
                }

                // Aggregate all MEF-related namespaces:
                foreach (UnsupportedMethodInfo unsupportedMethodInfo in listOfUnsupportedMethods)
                {
                    if (unsupportedMethodInfo.MethodAssemblyName.StartsWith("System.ComponentModel.Composition."))
                    {
                        unsupportedMethodInfo.MethodAssemblyName = "System.ComponentModel.Composition";
                    }
                }

                // Aggregate all DomainServices-related namespaces:
                foreach (UnsupportedMethodInfo unsupportedMethodInfo in listOfUnsupportedMethods)
                {
                    if (unsupportedMethodInfo.MethodAssemblyName.StartsWith("System.ServiceModel.DomainServices.Client."))
                    {
                        unsupportedMethodInfo.MethodAssemblyName = "System.ServiceModel.DomainServices.Client";
                    }
                }

                // Replace all the native MS UI-related assembly names with "http://schemas.microsoft.com/winfx/2006/xaml/presentation" so as to avoid differences between namespaces from .xaml files and namespaces from .cs files:
                foreach (UnsupportedMethodInfo unsupportedMethodInfo in listOfUnsupportedMethods)
                {
                    if (unsupportedMethodInfo.MethodAssemblyName == "System.Windows" ||
                        unsupportedMethodInfo.MethodAssemblyName == "System.Windows.Controls" ||
                        unsupportedMethodInfo.MethodAssemblyName == "System.Windows.Controls.Data" ||
                        unsupportedMethodInfo.MethodAssemblyName == "System.Windows.Browser" ||
                        unsupportedMethodInfo.MethodAssemblyName == "System.Windows.Controls.Navigation" ||
                        unsupportedMethodInfo.MethodAssemblyName == "System.Windows.Controls.Toolkit")
                    {
                        unsupportedMethodInfo.MethodAssemblyName = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
                    }
                }

                // Process the list of unsupported methods:
                SortedDictionary <Tuple <string, string>, HashSet <string> > unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed;
                ProcessUnsupportedMethods(listOfUnsupportedMethods, out unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed, rectifyMethodName: true);

                // Remove some stuff:
                foreach (Tuple <string, string> additionalEntryToRemove in Configuration.AdditionalEntriesToRemoveBeforeAggregation)
                {
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed.Remove(additionalEntryToRemove);
                }

                // For classes that are not defined at all (ie. missing constructor), aggregate all the methods into the same line:
                List <Tuple <string, string> > entriesToRemoveFromDictionary = new List <Tuple <string, string> >();                                                                // This is here because we cannot remove the keys while iterating in the dictionary, so we do it afterwards.
                List <KeyValuePair <Tuple <string, string>, HashSet <string> > > entriesToAddToDictionary = new List <KeyValuePair <Tuple <string, string>, HashSet <string> > >(); // This is here because we cannot add entries while iterating in the dictionary, so we do it afterwards.
                HashSet <Tuple <string, string> > classesForWhichTheMethodsHaveAlreadyBeenAggregated      = new HashSet <Tuple <string, string> >();
                foreach (KeyValuePair <Tuple <string, string>, HashSet <string> > pair in unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed)
                {
                    string           theFullMethodName = pair.Key.Item1;
                    string           theAssemblyName   = pair.Key.Item2;
                    HashSet <string> whereItIsUsed     = pair.Value;

                    if (!Configuration.EntriesToNotAggregateWithOtherEntries.Contains(theFullMethodName))
                    {
#if ALWAYS_AGGREGATE_METHODS
                        if (theFullMethodName.Contains("."))
#else
                        if (theFullMethodName.Contains("..ctor"))
#endif
                        {
#if ALWAYS_AGGREGATE_METHODS
                            string className = theFullMethodName.Substring(0, theFullMethodName.IndexOf("."));
#else
                            string className = theFullMethodName.Substring(0, theFullMethodName.IndexOf("..ctor"));
#endif
                            if (!classesForWhichTheMethodsHaveAlreadyBeenAggregated.Contains(new Tuple <string, string>(className, theAssemblyName)))
                            {
                                classesForWhichTheMethodsHaveAlreadyBeenAggregated.Add(new Tuple <string, string>(className, theAssemblyName));
                                List <string> methodNames = new List <string>();

                                // Find all other methods that concern the same class:
                                foreach (KeyValuePair <Tuple <string, string>, HashSet <string> > pair2 in unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed)
                                {
                                    //todo-perf: optimize performance by creating a dictionary beforehand instead of nesting two iterations!

                                    string           theFullMethodName2 = pair2.Key.Item1;
                                    string           theAssemblyName2   = pair2.Key.Item2;
                                    HashSet <string> whereItIsUsed2     = pair.Value;
                                    if (!Configuration.EntriesToNotAggregateWithOtherEntries.Contains(theFullMethodName2))
                                    {
                                        if (theFullMethodName2.Contains('.') &&
                                            !theFullMethodName2.Contains("..ctor")
                                            )
                                        {
                                            string className2 = theFullMethodName2.Substring(0, theFullMethodName2.IndexOf('.'));
                                            if (className2 == className && theAssemblyName2 == theAssemblyName)
                                            {
                                                string methodName2 = theFullMethodName2.Substring(theFullMethodName2.IndexOf('.') + 1);
                                                methodNames.Add(methodName2);
                                                HashSetHelpers.AddItemsFromOneHashSetToAnother(whereItIsUsed2, whereItIsUsed);
                                                entriesToRemoveFromDictionary.Add(pair2.Key);
                                            }
                                        }
                                    }
                                }

                                // Aggregate them:
                                string newMethodName;
                                if (methodNames.Count > 0)
                                {
                                    if (theFullMethodName.Contains("..ctor"))
                                    {
                                        newMethodName = className + " (members used: " + string.Join(", ", methodNames) + ")";
                                    }
                                    else
                                    {
                                        newMethodName = className + "." + string.Join(", .", methodNames);
                                    }
                                }
                                else
                                {
                                    newMethodName = className;
                                }

                                entriesToRemoveFromDictionary.Add(pair.Key);
                                entriesToAddToDictionary.Add(new KeyValuePair <Tuple <string, string>, HashSet <string> >(
                                                                 new Tuple <string, string>(newMethodName, theAssemblyName),
                                                                 whereItIsUsed));
                            }
                        }
                    }
                }
                // Perform the actual removal and addition (note: this cannot be done before because it is not possible to remove or add an item from a collection while iterating it with "foreach");
                foreach (var key in entriesToRemoveFromDictionary)
                {
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed.Remove(key);
                }
                foreach (var entry in entriesToAddToDictionary)
                {
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed.Add(entry.Key, entry.Value);
                }

                //-------------------------------------
                // Merge classes that are related to each other:
                //-------------------------------------
                MergingRelatedClasses.MergeRelatedClasses(Configuration.ClassesRelatedToEachOther, unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed);

                //-------------------------------------
                // Remove elements with an empty assembly name because they are due to "clr-namespace:..." without any assembly being specified, which means that the assembly is the user assembly itself, so we should remove the entry:
                //-------------------------------------
                entriesToRemoveFromDictionary = new List <Tuple <string, string> >();
                foreach (var entry in unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed)
                {
                    if (entry.Key.Item2 == "")
                    {
                        entriesToRemoveFromDictionary.Add(entry.Key);
                    }
                }
                foreach (var key in entriesToRemoveFromDictionary)
                {
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed.Remove(key);
                }

                //-------------------------------------
                // Remove some additional stuff:
                //-------------------------------------

                foreach (Tuple <string, string> additionalEntryToRemove in Configuration.AdditionalEntriesToRemoveAfterAggregation)
                {
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed.Remove(additionalEntryToRemove);
                }

                //-------------------------------------
                // Save the result:
                //-------------------------------------

                // Save as Excel document:
                ExcelGenerator.Generate(
                    OutputExcelFilePathTextBox.Text,
                    featuresAndEstimationsFileProcessor,
                    unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed,
                    fileNames.Select(fileName => System.IO.Path.GetFileName(fileName)));

#if SAVE_CSV_DOCUMENT
                // Save as CSV document:
                CsvGenerator.Generate(OutputCsvFilePathTextBox.Text, unsupportedMethodsAndTheirAssemblyToLocationsWhereTheyAreUsed);
#endif

                var elapsedMs = watch.ElapsedMilliseconds;
                MessageBox.Show(string.Format("Operation completed in {0} seconds.", Math.Floor(elapsedMs / 1000d).ToString()));

                //-------------------------------------
                // Open the result:
                //-------------------------------------

                Process.Start(OutputExcelFilePathTextBox.Text);

                //-------------------------------------
                // Close this app:
                //-------------------------------------

                System.Windows.Application.Current.Shutdown();
            }
        }