public InterfaceHash AddInterface(ServiceHash serviceHash, Type iface)
        {
            // Hash all methods
            var methodHashes = iface.GetMethods()
                               .Select(m => new { Method = m, Hash = HashMethod(m) })
                               .ToList();

            // Hash all inherited interfaces
            var interfaceHashes = iface.GetInterfaces()
                                  .Select(i => new { Interface = i, Hash = AddInterface(serviceHash, i) });

            // Hash this interface, based on our methods and interfaces
            var interfaceHash = HashInterface(iface,
                                              methodHashes.Select(m => m.Hash),
                                              interfaceHashes.Select(i => i.Hash)
                                              );

            var descriptor = new RemoteProcedureDescriptor
            {
                ServiceHash   = serviceHash,
                InterfaceHash = interfaceHash
            };

            foreach (var method in methodHashes)
            {
                descriptor.MethodName      = method.Hash.Name;
                descriptor.MethodSignature = method.Hash.Signature;

                // We only need to add it once
                if (!_methods.ContainsKey(descriptor.ToGuid()))
                {
                    _methods.Add(descriptor.ToGuid(), Tuple.Create(iface, method.Method));
                }
            }

            Interfaces.Add(Tuple.Create(interfaceHash, iface));
            return(interfaceHash);
        }
 public Tuple <Type, MethodInfo> FindMethod(RemoteProcedureDescriptor descriptor)
 {
     return(_methods[descriptor.ToGuid()]);
 }