3

考虑以下

class ServiceA : IServiceA
    {
        public void SayHelloFromA()
        {
            Console.WriteLine("Hello Service A");
            Console.ReadKey();
        }
    }    
    class ServiceB : IServiceB{ } 
    class ServiceC : IServiceC{ }
    interface IServiceA 
    { 
        void SayHelloFromA(); 
    }
    interface IServiceB{ }
    interface IServiceC{ }

如果我想使用服务定位器模式，此处提供的示例可以完美运行。

现在说另一个类实现了 IServiceA 接口，如下所示。

class ServiceA1 : IServiceA
{
    public void SayHelloFromA()
    {
        Console.WriteLine("Hello Service A1");
        Console.ReadKey();
    }
}

相应地，我需要将服务添加到字典中，如下所示

internal ServiceLocator()    
        {        
            services = new Dictionary<object, object>();         

            this.services.Add(typeof(IServiceA), new ServiceA());
            this.services.Add(typeof(IServiceA), new ServiceA1());     
            this.services.Add(typeof(IServiceB), new ServiceB());        
            this.services.Add(typeof(IServiceC), new ServiceC());    
        }

这是错误的，因为字典中不能存在重复的键。

那么我该如何解决这个问题呢？应该如何更改数据结构，以便服务定位器可以同时容纳两者。

注意~我正在尝试在我的工厂方法中实现服务定位器模式

public class CustomerFactory : ICustomerBaseFactory

{

          public IBaseCustomer  GetCustomer(string  CustomerType)

          { 
                   switch(CustomerType)

                   { 
                             case "1": return  new Grade1Customer(); break;

                             case "2": return new Grade2Customer(); break;

                             default:return null; 
                   } 
          } 
}

具体工厂来自IBaseCustomer

谢谢

4

2 回答 2

0

在 Java 中，有一个MultiMap类，它支持每个键的多个值。我相信您也可以为 C# 找到类似的数据结构。

于 2013-03-26T11:05:51.450 回答
0

您是否考虑过由嵌套在顶级字典中的具体类型键入的每个抽象类型的字典？

Dictionary<T, Dictionary<T, U>>

这样，您可以按类型查询顶级字典，然后在子字典中查询实现该类型的所有服务。

例如

var services = new Dictionary<Type, Dictionary<Type, Object>>();

现在您可以向服务字典询问类型：

services.TryGetValue(typeof(IServiceA), componentDictionary);

如果返回 true，那么您知道 componentDictionary 将包含实现该服务的组件：

foreach (c in componentDictionary.Values) {... }

通过巧妙地使用抽象基类型和泛型，您可以创建比这更强类型的解决方案。然而，这应该工作得相当好，尽管有铸造。

于 2013-03-25T09:23:21.340 回答