问题描述
|
我一直在阅读一本名为《清洁代码：敏捷软件技巧手册》的书。该书的作者鼓励应避免使用switch语句，如果不能避免，则应使用工厂方法。我有一个连接对象，正在接收各种PDU（协议数据单元）。 PDU有所不同，可以以任何顺序接收它们。因此，如果我有一个方法例如：
public BasePdu ReceiveNext();
解决方法
就我个人而言，我不会对此太担心。如果看起来是进行switch语句的好地方，请使用一个。另一方面，如果每种PDU类型是由类而不是方法处理的，则这似乎也可以使用工厂方法。而且，按照您的书，您可以使用switch语句
,只需创建一个PDUParserFactory即可，它使用PDU类型标识符上的switch语句根据PDU类型创建解析器。这是书说没问题的情况：)
更新：一种可能的方法
class BasePDU
{
string Name { get; set; }
...
}
class PDUType1 : BasePDU
{
...
}
...
class PDUReceiver
{
public event EventHandler<PDUReceivedEventArgs> PDUReceived;
private void ParsePDU(byte[] data)
{
BasePDU pdu;
switch (byte[0]) // PDU type selector
{
.... parse PDU based on type
}
OnPDUReceived(pdu);
}
private void OnPDUReceived(BasePDU pdu)
{
var handler = PDUReceived;
if (handler != null)
{
handler(this,new PDUReceivedEventArgs(pdu));
}
}
}
pduReceiver.PDUReceived += BaseHandler;
pduReceiver.PDUReceived += PDUType1Handler;
...
void PDUType1Handler(object sender,PDUReceivedEventArgs e)
{
// only care about PDUType1
if (e.PDU.GetType() != typeof(PDUType1))
return;
....
}
class PDU
{
public PDUType PDUType { get; }
public byte[] PDUData { get }
}
Dictionary<string,Func<PduBase>>
public BasePdu ReceiveNext();
switch
RecieveNext
Dictionary<Type,Delegate>
public class Receiver
{
Dictionary<Type,MethodMapping> _handlers = new Dictionary<Type,MethodMapping>();
Dictionary<string,Func<PduBase>> _factories = new Dictionary<string,Func<PduBase>>();
// Small container making it easier to invoke each handler
// also needed since different generic types cannot be stored in the same
// dictionary
private class MethodMapping
{
public object Instance { get; set; }
public MethodInfo Method { get; set; }
public void Invoke(PduBase pdu)
{
Method.Invoke(Instance,new[] {pdu});
}
}
// add a method used to create a certain PDU type
public void AddFactory(string name,Func<PduBase> factoryMethod)
{
_factories.Add(name,factoryMethod);
}
// register a class that handles a specific PDU type
// we need to juggle a bit with reflection to be able to invoke it
// hence everything is type safe outside this class,but not internally.
// but that should be a sacrifice we can live with.
public void Register<T>(IPduHandler<T> handler) where T : PduBase
{
var method = handler.GetType().GetMethod(\"Handle\",new Type[] { typeof(T) });
_handlers.Add(typeof(T),new MethodMapping{Instance = handler,Method = method});
}
// fake that we\'ve received a new PDU
public void FakeReceive(string pduName)
{
// create the PDU using the factory method
var pdu = _factories[pduName]();
// and invoke the handler.
_handlers[pdu.GetType()].Invoke(pdu);
}
}
public interface IPduHandler<in T> where T: PduBase
{
void Handle(T pdu);
}
public class TempPdu : PduBase
{}
public class TempPduHandler : IPduHandler<TempPdu>
{
public void Handle(TempPdu pdu)
{
Console.WriteLine(\"Handling pdu\");
}
}
public class PduBase
{ }
private static void Main(string[] args)
{
Receiver r = new Receiver();
r.AddFactory(\"temp\",() => new TempPdu());
r.Register(new TempPduHandler());
// we\'ve recieved a PDU called \"temp\".
r.FakeReceive(\"temp\");
}