好的，代码结构问题：
假设我有一个名为FruitManager的类，它周期性地从某个数据源接收Fruit对象。我还有一些其他的类需要在接收到这些Fruit对象时得到通知。但是，每个类只对特定类型的水果感兴趣，而且每种水果都有不同的处理逻辑。例如，CitrusLogic类具有方法OnFruitReceived(Orange o)和OnFruitReceived(Lemon l)，在接收到相应的子类型水果时应调用这些方法，但不需要通知其他水果。
在C#中是否有一种优雅的方式来处理这个问题（可能使用事件或委托）？显然，我可以添加通用的OnFruitReceived(Fruit f)事件处理程序，并使用if语句来过滤不需要的子类，但这似乎不够优雅。有没有更好的想法？谢谢！
编辑：我刚刚发现通用委托，它们似乎是一个好的解决方案。这听起来是个好主意吗？
首先，Unity支持一部分.NET 3.5，具体取决于您的构建参数。
接下来回答您的问题，C#中通用的事件模式是使用委托和event关键字。由于您希望仅在传入的水果与其方法定义兼容时调用处理程序，因此可以使用字典来完成查找。诀窍是存储委托的类型。您可以使用一些类型魔法使其正常工作，并将所有内容存储为
Dictionary<Type, Action<Fruit>> handlers = new Dictionary<Type, Action<Fruit>>();
这并不理想，因为现在所有的处理程序似乎都接受 Fruit 而不是更具体的类型。但这只是内部表示，公开地人们仍会通过特定的方式添加处理程序。
public void RegisterHandler<T>(Action<T> handler) where T : Fruit
这样可以保持公共API的简洁和类型明确。在内部，委托需要从Action<T>更改为Action<Fruit>。要做到这一点，请创建一个新的委托，它接收一个Fruit并将其转换为T。
Action<Fruit> wrapper = fruit => handler(fruit as T);
当然，这并不是一种安全的类型转换。如果传递给它的不是 T（或从 T 继承的类），它将会崩溃。这就是为什么它只能在类内部存储并且不能暴露在类外部的原因。将此函数存储在处理程序字典中的 Type 键 typeof(T) 下。
接下来调用事件需要一个自定义函数。该函数需要调用所有类型的事件处理程序，一直到最通用的 Fruit 处理程序。这允许在任何子类型参数上触发函数，而不仅仅是特定类型的参数。对我来说，这似乎是直观的行为，但如果需要可以省略。
最后，可以公开普通事件以允许添加常规的 Fruit 处理程序。
以下是完整示例。请注意，示例相当简洁，并排除了一些典型的安全检查，如空检查。如果从 child 到 parent 没有继承链，则还存在潜在的无限循环。实际实现应根据需要进行扩展。它也可以使用一些优化。特别是在高使用场景中，缓存继承链可能很重要。
public class Fruit { }
class FruitHandlers
{
private Dictionary<Type, Action<Fruit>> handlers = new Dictionary<Type, Action<Fruit>>();
public event Action<Fruit> FruitAdded
{
add
{
handlers[typeof(Fruit)] += value;
}
remove
{
handlers[typeof(Fruit)] -= value;
}
}
public FruitHandlers()
{
handlers = new Dictionary<Type, Action<Fruit>>();
handlers.Add(typeof(Fruit), null);
}
static IEnumerable<Type> GetInheritanceChain(Type child, Type parent)
{
for (Type type = child; type != parent; type = type.BaseType)
{
yield return type;
}
yield return parent;
}
public void RegisterHandler<T>(Action<T> handler) where T : Fruit
{
Type type = typeof(T);
Action<Fruit> wrapper = fruit => handler(fruit as T);
if (handlers.ContainsKey(type))
{
handlers[type] += wrapper;
}
else
{
handlers.Add(type, wrapper);
}
}
private void InvokeFruitAdded(Fruit fruit)
{
foreach (var type in GetInheritanceChain(fruit.GetType(), typeof(Fruit)))
{
if (handlers.ContainsKey(type) && handlers[type] != null)
{
handlers[type].Invoke(fruit);
}
}
}
}
System.Reactive.Linq，我们还可以访问Observable类，其中包含一系列用于观察者的Linq方法，包括.OfType<>。fruitSource.OfType<CitrusFruit>.Subscribe(new CitrusLogic());
fruitSource.OfType<LemonFruit>.Subscribe(new LemonLogic());
...
public class Ciruslogic : IObersver<CitrusFruit>
{ ... }
AFruitLogic<TFruit>的所有实现，你需要使用反射扫描程序集或研究各种IoC方法，如MEF。namespace Eventing
{
public class EventAggregator : IEventAggregator
{
private readonly Dictionary<Type, List<WeakReference>> eventSubscriberLists =
new Dictionary<Type, List<WeakReference>>();
private readonly object padLock = new object();
public void Subscribe(object subscriber)
{
Type type = subscriber.GetType();
var subscriberTypes = GetSubscriberInterfaces(type)
.ToArray();
if (!subscriberTypes.Any())
{
throw new ArgumentException("subscriber doesn't implement ISubscriber<>");
}
lock (padLock)
{
var weakReference = new WeakReference(subscriber);
foreach (var subscriberType in subscriberTypes)
{
var subscribers = GetSubscribers(subscriberType);
subscribers.Add(weakReference);
}
}
}
public void Unsubscribe(object subscriber)
{
Type type = subscriber.GetType();
var subscriberTypes = GetSubscriberInterfaces(type);
lock (padLock)
{
foreach (var subscriberType in subscriberTypes)
{
var subscribers = GetSubscribers(subscriberType);
subscribers.RemoveAll(x => x.IsAlive && object.ReferenceEquals(x.Target, subscriber));
}
}
}
public void Publish<TEvent>(TEvent eventToPublish)
{
var subscriberType = typeof(ISubscriber<>).MakeGenericType(typeof(TEvent));
var subscribers = GetSubscribers(subscriberType);
List<WeakReference> subscribersToRemove = new List<WeakReference>();
WeakReference[] subscribersArray;
lock (padLock)
{
subscribersArray = subscribers.ToArray();
}
foreach (var weakSubscriber in subscribersArray)
{
ISubscriber<TEvent> subscriber = (ISubscriber<TEvent>)weakSubscriber.Target;
if (subscriber != null)
{
subscriber.OnEvent(eventToPublish);
}
else
{
subscribersToRemove.Add(weakSubscriber);
}
}
if (subscribersToRemove.Any())
{
lock (padLock)
{
foreach (var remove in subscribersToRemove)
subscribers.Remove(remove);
}
}
}
private List<WeakReference> GetSubscribers(Type subscriberType)
{
List<WeakReference> subscribers;
lock (padLock)
{
var found = eventSubscriberLists.TryGetValue(subscriberType, out subscribers);
if (!found)
{
subscribers = new List<WeakReference>();
eventSubscriberLists.Add(subscriberType, subscribers);
}
}
return subscribers;
}
private IEnumerable<Type> GetSubscriberInterfaces(Type subscriberType)
{
return subscriberType
.GetInterfaces()
.Where(i => i.IsGenericType &&
i.GetGenericTypeDefinition() == typeof(ISubscriber<>));
}
}
public interface IEventAggregator
{
void Subscribe(object subscriber);
void Unsubscribe(object subscriber);
void Publish<TEvent>(TEvent eventToPublish);
}
public interface ISubscriber<in T>
{
void OnEvent(T e);
}
}
您的模型或者您想发布的任何内容
public class Fruit
{
}
class Orange : Fruit
{
}
class Apple : Fruit
{
}
class Lemon : Fruit
{
}
//Class which handles citrus events
class CitrusLogic : ISubscriber<Orange>, ISubscriber<Lemon>
{
void ISubscriber<Orange>.OnEvent(Orange e)
{
Console.WriteLine(string.Format("Orange event fired: From {0}", this.GetType().Name));
}
void ISubscriber<Lemon>.OnEvent(Lemon e)
{
Console.WriteLine(string.Format("Lemon event fired: From {0}", this.GetType().Name));
}
}
//Class which handles Apple events
class AppleLogic : ISubscriber<Apple>
{
void ISubscriber<Apple>.OnEvent(Apple e)
{
Console.WriteLine(string.Format("Apple event fired: From {0}", this.GetType().Name));
}
}
void Main()
{
EventAggregator aggregator = new EventAggregator();
CitrusLogic cl =new CitrusLogic();
AppleLogic al =new AppleLogic();
aggregator.Subscribe(cl);
aggregator.Subscribe(al);
//...
aggregator.Publish(new Apple());
aggregator.Publish(new Lemon());
aggregator.Publish(new Orange());
}
这将输出
Apple event fired: From AppleLogic
Lemon event fired: From CitrusLogic
Orange event fired: From CitrusLogic
IFruitHandlers fruitHandlers;
fruitHandlers.Register(new CitrusLogic()) // Or some good DI way of doing this
// later
fruitHandlers.Handle(fruit);
然后在内部，您可以处理不同的实现以查看哪个有效。例如，给定类似于逻辑处理程序定义：
public class FruitLogic<T> where T:Fruit {}
Dictionary<Type, List<IFruitLogic>> fruitHandlers;
List<FruitLogic> handlers;
并让每个处理程序负责自己的过滤。
重要的是建立一个API，使得灵活地处理实现细节，以便为您的领域找到最佳解决方案。在真实环境中测量不同解决方案的性能是找到最佳解决方案的唯一方法。
请注意，代码示例不一定可编译，仅供参考。
Fruit<T>- Daniel A. White