Are you mapping those dlls?

One of the issues with writing cross platform applications is that if you do P/Invoke into a native library, the name of that library changes depending on the OS. Mono has built in support for selecting the right file at runtime. The problem is that it's hard to ensure that you've correctly mapped all the methods you P/Invoke.

So I wrote a little tool to do that for you. It was inspired by an attempt by Aaron Bockover which parsed the raw cs files. I figured it'd be much better to just parse the compiled assembly ;)

using System;
using System.Collections.Generic;
using System.Xml;
using Mono.Cecil;
using System.IO;

namespace DllImportVerifier
{
    class MainClass
    {
        static void Main (string [] args)
        {
            args = new string [] { Environment.CurrentDirectory };
            if (args.Length != 1) {
                Console.WriteLine ("You must pass the path to the assemblies to be processed as the argument");
                return;
            }

            List<string> assemblies = new List<string> ();

            if (Directory.Exists (args[0])) {
                assemblies.AddRange (Directory.GetFiles (args [0], "*.dll"));
                assemblies.AddRange (Directory.GetFiles (args [0], "*.exe"));
            }
            else if (File.Exists (args [0])) {
                assemblies.Add (args [0]);
            }
            else {
                Console.WriteLine ("{0} is not a valid file or directory", args [0]);
                return;
            }

            foreach (string assembly in assemblies)
                ProcessConfig (assembly);
        }

        static void ProcessConfig (string assemblyName)
        {
            AssemblyDefinition assembly = null;
            try {
                assembly = AssemblyFactory.GetAssembly (assemblyName);
            } catch {
                Console.WriteLine ("{0} is not a valid .NET assembly", Path.GetFileName (assemblyName));
                return;
            }

            List<string> dlls = new List<string> ();
            try {
                XmlTextReader doc = new XmlTextReader (assemblyName + ".config");
                while (doc.Read ()) {
                    if (doc.Name != "dllmap")
                        continue;

                    string dll = doc.GetAttribute ("dll");
                    if (!dlls.Contains (dll))
                        dlls.Add (dll);
                }
            } catch {
                // Ignore malformed or invalid config files. If the config is malformed,
                // drop any successfully parsed dll maps
                dlls.Clear();
            }

            List<string> unreferenced = VerifyReferences (assembly, dlls);
            foreach (string dll in unreferenced)
                Console.WriteLine("Assembly: '{0}' references '{1}' without mapping it", Path.GetFileName (assemblyName), dll);
        }

        static List<string> VerifyReferences (AssemblyDefinition assembly, List<string> dlls)
        {
            List<string> unreferenced = new List<string> ();
            foreach (TypeDefinition type in assembly.MainModule.Types) {
                foreach (MethodDefinition method in type.Methods)  {
                    if (!method.IsPInvokeImpl)
                        continue;
                    
                    string dll = method.PInvokeInfo.Module.Name;
                    if (!dlls.Contains (dll) && !unreferenced.Contains (dll))
                        unreferenced.Add (dll);
                }
            }

            return unreferenced;
        }
    }
}