查找 GUID 的快速方法

Question

我有很多（+2000）个 GUID（在某些网络类中），我的程序在收到消息时必须找到其中一个并执行与之相关的工作。
积极的一点是我有一个硬代码生成器，但最快的方法是我的目标（而且我不知道如何实现它）。

我的代码应该做这样的事情：

switch(received guid)  
{  
case guid1: do job 1; break;  
case guid2: do job 2; break;  
case guid3: do job 3; break;  
case guid4: do job 4; break;  
....  
}  

Answer 1

您可以创建一个字典，其中 Guid 作为键，委托引用作为值。这将确保快速查找。

Answer 2

创建一个用于执行作业的接口，然后实现 2000 个执行该工作的类，每个类都知道自己的 guid。然后使用其 guid 作为键将类添加到字典中。然后，当您获得 guid 时，您可以在字典中查找该对象并调用接口上的方法。

public interface IJobDoer
{
    void DoJob();
    Guid Guid{get;}
}

public class FirstJobType : IJobDoer
{
    void DoJob()
    {
     /// whatever...
    }
    Guid Guid { get{return "insert-guid-here";}}
}

Answer 3

使用将 Guid 映射到代表任务的委托或类的哈希表，例如 Dictionary 或 Dictionary。

Answer 4

Dictionary 可能比 switch 语句更快。

但你必须进行分析才能确定。

Answer 5

我喜欢展示其他人已经提出的字典方法的变体。在此解决方案的基础上，您可以执行以下操作。

1 定义一个基类：

public abstract class JobDoer
{
    public abstract void DoJob();
}

2 定义一个用于装饰工作执行者的属性。

public sealed class JobDoerAttribute : Attribute
{
    JobDoerAttribute(string jobDoerId)
    {
        this.JobDoerId = new Guid(jobDoerId);
    }

    public Guid JobDoerId { get; private set; }
}

3 定义用该属性修饰的实际作业执行者类。例如：

[JobDoer("063EE2B2-3759-11DF-B738-49BB56D89593")]
public sealed class SpecificJobDoer : JobDoer
{
    public override void DoJob()
    {
        // Do a specific job
    }
}

4 定义一个 JobDoerFactory，允许通过属性中定义的 Id 检索 JobDoer 实例：

public static class JobDoerFactory
{
    static Dictionary<Guid, JobDoer> cache;

    static JobDoerFactory()
    {
        // Building the cache is slow, but it will only run once 
        // during the lifetime of the AppDomain.
        cache = BuildCache();
    }

    public static JobDoer GetInstanceById(Guid jobDoerId)
    {
        // Retrieving a JobDoer is as fast as using a switch statement.
        return cache[jobDoerId];
    }

    private static Dictionary<Guid, JobDoer> BuildCache()
    {
        // See implementation below.
    }
}

在 BuildCache 方法中，您可以可以使用反射来加载 JobDoer 实例。

private static Dictionary<Guid, JobDoer> BuildCache()
{
    // This is a bit naive implementation; we miss some error checking,
    // but you'll get the idea :-)
    var jobDoers =
       (from assembly in AppDomain.CurrentDomain.GetAssemblies()
        from type in assembly.GetTypes()
        where type.IsSubclassOf(typeof(JobDoer))
        let attributes =
            type.GetCustomAttribute(typeof(JobDoerAttribute), true)
        where attributes.Length > 0
        let attribute = attributes[0] as JobDoerAttribute
        select new { attribute.JobDoerId, type }).ToArray();

    var cache = new Dictionary<Guid, JobDoer>(jobDoers.Length);

    foreach (jobDoer in jobDoers)
    {
        // Note that actually a single instance of the job doer is
        // cached by ID. This means that every Job Doer must be 
        // thread-safe and usable multiple times. If this is not 
        // feasable, you can also create store a set of Func<JobDoer> 
        // objects that enable creating a new instance on each call.
        cache[jobDoer.JobDoerId] =
            (JobDoer)Activator.CreateInstance(jobDoer.type);
    }
    return cache;
}

我没有测试这段代码，所以我不知道它是否可以编译，但几年前我在一个项目中使用了这种机制。这样就可以很容易地定义新类，而不需要将其连接到某些字典。它是在运行时自动完成的。

这可能看起来有点大材小用，但如果您有超过 2000 个 JobDoer 类，这会对您有很大帮助。

更新：
请注意，如果您不喜欢 JobDoerAttribute 的想法，您还可以将其实现为抽象 JobDoer 类上的抽象属性。但是，我发现使用属性使代码非常明确且富有表现力。

Answer 6

使用 Guid 和 Action 创建一个字典，然后对其进行搜索。