Private Sub btnSearchReferences_Click(sender As Object, e As EventArgs) Handles btnSearchReferences.Click
    Dim strSolutionFolder As String = txtSolutionFolder.Text
    If (String.IsNullOrWhiteSpace(strSolutionFolder) OrElse (Not IO.Directory.Exists(strSolutionFolder))) Then
        txtResults.Text = "Solution folder does not exist. Please provide a valid one!"
        Return
    End If

    Dim strBinFolder As String = txtBinFolder.Text
    If (String.IsNullOrWhiteSpace(strSolutionFolder) OrElse (Not IO.Directory.Exists(strSolutionFolder))) Then
        txtResults.Text = "Bin folder is empty. Please provide a valid one!"
        Return
    End If

    Try
        Cursor.Current = Cursors.WaitCursor
        btnSearchReferences.Enabled = False
        txtResults.Text = "Searching for references..."
        Application.DoEvents()
        Dim strResults As String = cConflictingReferences.FindReferences(strSolutionFolder, strBinFolder, chkOnlyConflicting.Checked)
        txtResults.Text = strResults
    Catch ex As Exception
        txtResults.Text = $"An exception occured: {ex}"
    Finally
        btnSearchReferences.Enabled = True
        Cursor.Current = Cursors.Default
    End Try
End Sub

private void btnSearchReferences_Click(object sender, EventArgs e)
{
    string strSolutionFolder = txtSolutionFolder.Text;
    if (string.IsNullOrWhiteSpace(strSolutionFolder) || !System.IO.Directory.Exists(strSolutionFolder))
    {
        txtResults.Text = "Solution folder does not exist. Please provide a valid one!";
        return;
    }

    string strBinFolder = txtBinFolder.Text;
    if (string.IsNullOrWhiteSpace(strSolutionFolder) || !System.IO.Directory.Exists(strSolutionFolder))
    {
        txtResults.Text = "Bin folder is empty. Please provide a valid one!";
        return;
    }
    
    try
    {
        Cursor.Current = Cursors.WaitCursor;
        btnSearchReferences.Enabled = false;
        txtResults.Text = "Searching for references...";
        Application.DoEvents();
        string strResults = cConflictingReferences.FindReferences(strSolutionFolder, strBinFolder, chkOnlyConflicting.Checked);
        txtResults.Text = strResults;
    }
    catch (Exception exception)
    {
        txtResults.Text = $"An exception occured: {exception}";
    }
    finally
    {
        btnSearchReferences.Enabled = true;
        Cursor.Current = Cursors.Default;
    }
}

Public Class cConflictingReferences

    ' Reference https://gist.github.com/brianlow/1553265

    Public Shared Function FindReferences(ByVal pSolutionFolder As String, ByVal pBinFolder As String, ByVal pOnlyConflicting As Boolean) As String
        Dim strResults As New StringBuilder(10000)
        Dim directories As String() = Directory.GetDirectories(pSolutionFolder)
        Dim projectFolders As IEnumerable(Of String) = directories.Where(Function(x) x.Contains(""))

        For Each folder As String In projectFolders
            Dim targetFolder As String = $"{folder}{pBinFolder}"

            If Directory.Exists(targetFolder) Then
                Dim assemblies As IEnumerable(Of Assembly) = GetAllAssemblies(targetFolder)
                Dim references As IEnumerable(Of Reference) = GetReferencesFromAllAssemblies(assemblies)

                Dim groupsOfConflicts = If(pOnlyConflicting, 
                                           FindReferencesWithTheSameShortNameButDifferentFullNames(references), 
                                           FindAllReferences(references))
                Dim sectionHeader As String = $"-----{folder}-----"
                strResults.AppendLine(sectionHeader)

                For Each group As IGrouping(Of String, Reference) In groupsOfConflicts
                    Dim padding As Integer = group.Max(Function(x) x.ToString().Length)
                    strResults.AppendLine($"Assemblies referencing {group.Key}")

                    For Each reference As Reference In group
                        strResults.AppendLine($"     {reference.Assembly.Name.PadRight(padding)} references {reference.ReferencedAssembly.FullName}")
                    Next
                Next

                strResults.AppendLine(String.Concat(Enumerable.Repeat("-", sectionHeader.Length)) & vbLf & vbLf)
            End If
        Next

        Return strResults.ToString()
    End Function

    Private Shared Function FindReferencesWithTheSameShortNameButDifferentFullNames(ByVal pReferences As IEnumerable(Of Reference)) As IEnumerable(Of IGrouping(Of String, Reference))
        Return pReferences.
            GroupBy(Function(r) r.ReferencedAssembly.Name).
            Where(Function(r) r.ToList().Select(Function(s) s.ReferencedAssembly.FullName).Distinct().Count() > 1)
    End Function

    Private Shared Function FindAllReferences(ByVal pReferences As IEnumerable(Of Reference)) As IEnumerable(Of IGrouping(Of String, Reference))
        Return pReferences.
            GroupBy(Function(r) r.ReferencedAssembly.Name)
    End Function

    Private Shared Function GetReferencesFromAllAssemblies(ByVal pAssemblies As IEnumerable(Of Assembly)) As IEnumerable(Of Reference)
        Dim references As New List(Of Reference)()

        For Each assembly In pAssemblies
            For Each referencedAssembly In assembly.GetReferencedAssemblies()
                references.Add(New Reference With {
                    .Assembly = assembly.GetName(),
                    .ReferencedAssembly = referencedAssembly
                })
            Next
        Next

        Return references
    End Function

    Private Shared Function GetAllAssemblies(ByVal pPath As String) As IEnumerable(Of Assembly)
        Dim files As New List(Of FileInfo)()
        Dim directoryToSearch As New DirectoryInfo(pPath)
        files.AddRange(directoryToSearch.GetFiles("*.dll", SearchOption.AllDirectories))
        files.AddRange(directoryToSearch.GetFiles("*.exe", SearchOption.AllDirectories))
        Return files.ConvertAll(Function(file) Assembly.LoadFile(file.FullName))
    End Function

    Private Class Reference
        Public Property Assembly As AssemblyName
        Public Property ReferencedAssembly As AssemblyName
    End Class

End Class

public class cConflictingReferences
{
    
    public static string FindReferences(string pSolutionFolder, string pBinFolder, bool pOnlyConflicting)
    {
        StringBuilder strResults = new StringBuilder(10000);
        string[] directories = Directory.GetDirectories(pSolutionFolder);
        IEnumerable<string> projectFolders = directories.Where(x => x.Contains("")); 
        foreach (string folder in projectFolders)
        {
            string targetFolder = $"{folder}{pBinFolder}"; 
            if (Directory.Exists(targetFolder))
            {
                IEnumerable<Assembly> assemblies = GetAllAssemblies(targetFolder);
                IEnumerable<Reference> references = GetReferencesFromAllAssemblies(assemblies);

                var groupsOfConflicts = pOnlyConflicting ? 
                    FindReferencesWithTheSameShortNameButDifferentFullNames(references) : 
                    FindAllReferences(references);

                string sectionHeader = $"-----{folder}-----";
                strResults.AppendLine(sectionHeader);
                foreach (IGrouping<string, Reference> group in groupsOfConflicts)
                {
                    int padding = group.Max(x => x.ToString().Length);
                    strResults.AppendLine($"Assemblies referencing {group.Key}");
                    foreach (Reference reference in group)
                    {
                        strResults.AppendLine($"\t{reference.Assembly.Name.PadRight(padding)} references {reference.ReferencedAssembly.FullName}");
                    }
                }
                strResults.AppendLine(string.Concat(Enumerable.Repeat("-", sectionHeader.Length)) + "\n\n");
            }
        }

        return strResults.ToString();
    }

    private static IEnumerable<IGrouping<string, Reference>> FindReferencesWithTheSameShortNameButDifferentFullNames(IEnumerable<Reference> pReferences)
    {
        return from reference in pReferences
               group reference by reference.ReferencedAssembly.Name
                   into referenceGroup
               where referenceGroup.ToList().Select(reference => reference.ReferencedAssembly.FullName).Distinct().Count() > 1
               select referenceGroup;
    }

    private static IEnumerable<IGrouping<string, Reference>> FindAllReferences(IEnumerable<Reference> pReferences)
    {
        return from reference in pReferences
            group reference by reference.ReferencedAssembly.Name
            into referenceGroup
            select referenceGroup;
    }

    private static IEnumerable<Reference> GetReferencesFromAllAssemblies(IEnumerable<Assembly> pAssemblies)
    {
        List<Reference> references = new List<Reference>();
        foreach (var assembly in pAssemblies)
        {
            foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
            {
                references.Add(new Reference
                {
                    Assembly = assembly.GetName(),
                    ReferencedAssembly = referencedAssembly
                });
            }
        }
        return references;
    }

    private static IEnumerable<Assembly> GetAllAssemblies(string pPath)
    {
        List<FileInfo> files = new List<FileInfo>();
        DirectoryInfo directoryToSearch = new DirectoryInfo(pPath);
        files.AddRange(directoryToSearch.GetFiles("*.dll", SearchOption.AllDirectories));
        files.AddRange(directoryToSearch.GetFiles("*.exe", SearchOption.AllDirectories));
        return files.ConvertAll(file => Assembly.LoadFile(file.FullName));
    }

    private class Reference
    {
        public AssemblyName Assembly { get; set; }
        public AssemblyName ReferencedAssembly { get; set; }
    }

}