好的，首先我要描述目标，然后我编码，最后问题。
要拥有一个泛型类来管理多个合同，并且能够发现它是一个在线或离线的情况，在一个操作是正在制作有一个非常简单的方法：每个在线 - 离线对的一个类，它实现合同并检查每个方法是否在线，并进行正确的调用。而这正是我想要避免的。
仅供参考，在幕后，将连接到 WCF服务的在线方案和连接到的离线方案客户本地数据库。
仅供参考2：我试图完成这个以避免拦截和AOP的事情，但我找到了死胡同。您可以看到this post我实现了什么似乎是一个很好的解决方案，但是如果它连接在 contructor 上是否已经连接，但实际情况需要在操作中进行检查级别，而不是构造函数级别。
它已准备好运行＆amp; test：只需复制/粘贴一个新的控制台应用程序。
using System;
using System.Reflection;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.InterceptionExtension;
namespace ConsoleApplication1
{
public class Unity
{
public static IUnityContainer Container;
public static void Initialize()
{
Container = new UnityContainer();
Container.AddNewExtension<Interception>();
Container.RegisterType<ILogger, OnlineLogger>();
Container.Configure<Interception>().SetInterceptorFor<ILogger>(new InterfaceInterceptor());
}
}
class Program
{
static void Main(string[] args)
{
Unity.Initialize();
var r = new Router<ILogger, OnlineLogger, OfflineLogger>();
try
{
r.Logger.Write("Method executed.");
}
catch (CantLogException ex)
{
r.ManageCantLogException(ex);
}
Console.ReadKey();
}
}
public class Router<TContract, TOnline, TOffline>
where TOnline : TContract, new()
where TOffline : TContract, new()
{
public TContract Logger;
public Router()
{
Logger = Unity.Container.Resolve<TContract>();
}
public void ManageCantLogException(CantLogException ex)
{
// Is this an ugly trick? I mean, the type was already registered with online.
Unity.Container.RegisterType<TContract, TOffline>();
Logger = Unity.Container.Resolve<TContract>();
var method = ((MethodBase)ex.MethodBase);
method.Invoke(Logger, ex.ParameterCollection);
}
}
public interface ILogger
{
[Test]
void Write(string message);
}
public class OnlineLogger : ILogger
{
public static bool IsOnline()
{
// A routine that check connectivity
return false;
// Should I perform a "lock" here to make this tread safe?
}
public void Write(string message)
{
Console.WriteLine("Logger: " + message);
}
}
public class OfflineLogger : ILogger
{
public void Write(string message)
{
Console.WriteLine("Logger: " + message);
}
}
[System.Diagnostics.DebuggerStepThroughAttribute()]
public class TestAttribute : HandlerAttribute
{
public override ICallHandler CreateHandler(IUnityContainer container)
{
return new TestHandler();
}
}
public class TestHandler : ICallHandler
{
public int Order { get; set; }
public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
{
Console.WriteLine("It's been intercepted.");
if (!OnlineLogger.IsOnline() && input.Target is OnlineLogger)
{
Console.WriteLine("It's been canceled.");
throw new CantLogException(input.MethodBase, input.Inputs);
}
return getNext()(input, getNext);
}
}
public class CantLogException : Exception
{
public MethodBase MethodBase { get; set; }
public object[] ParameterCollection { get; set; }
public CantLogException(string message)
: base(message)
{
}
public CantLogException(MethodBase methodBase, IParameterCollection parameterCollection)
{
this.MethodBase = methodBase;
var parameters = new object[parameterCollection.Count];
int i = 0;
foreach (var parameter in parameterCollection)
{
parameters[i] = parameter;
i++;
}
this.ParameterCollection = parameters;
}
}
}
我提出的这种设计是线程安全的吗？
这是一种表现上的耻辱吗？处理Online-Offline情况和反射的异常让我感到很沮丧。
我认为这是一个常见的问题，是不是有任何api / fwk /无论做什么在线 - 离线管理？有点像我在这里重新发明了。
这是一个长镜头问题：我真的不希望客户端（此示例中的程序类）知道异常，是否有其他方法取消方法执行但通过拦截器上的异常？任何其他方法也受到欢迎。
我对付费的第三方内容不感兴趣，所以遗憾的是PostSharp这样的内容对我来说不适合。
答案 0 :(得分：2)
关于线程安全 - 特别是你的评论建议锁定的地方：
public static bool IsOnline()
{
// A routine that check connectivity
return false;
// Should I perform a "lock" here to make this tread safe?
}
你不能“锁定自己在线”，虽然你想知道状态是否可以在一个检查语句和返回之间发生变化（参见经典的单例模式），但这里的担心是连接断开，无论你是否检查线程是否安全。
在这种情况下，您只能处理（或选择不）抛出的异常
答案 1 :(得分：1)
好的，最后，我有解决方案。我将分享它，因为我发现这在这种在线离线方案中非常有用。有一点好处可以做到：这样一来，Online总是首先被击中，设置必须首先使用才会很好。但这是发布的，这对于测试版来说还不错。
using System;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.InterceptionExtension;
namespace ConsoleApplication1
{
public enum ConnectionStatus
{
Online,
Offline,
System // System checks connectivity
}
public static class Connectivity
{
private static ConnectionStatus ConnectionStatus = ConnectionStatus.Offline;
public static void ForceConnectionStatus(ConnectionStatus connectionStatus)
{
ConnectionStatus = connectionStatus;
}
public static bool IsConnected()
{
switch (ConnectionStatus)
{
case ConnectionStatus.Online:
return true;
case ConnectionStatus.Offline:
return false;
case ConnectionStatus.System:
return CheckConnection();
}
return false;
}
private static bool CheckConnection()
{
return true;
}
}
public class Unity
{
public static IUnityContainer Container;
public static void Initialize()
{
Container = new UnityContainer();
Container.AddNewExtension<Interception>();
Container.RegisterType<ILogger, OnlineLogger>();
Container.Configure<Interception>().SetInterceptorFor<ILogger>(new InterfaceInterceptor());
}
}
class Program
{
static void Main(string[] args)
{
Unity.Initialize();
var r = new Router<ILogger, OnlineLogger, OnlineLogger>();
Connectivity.ForceConnectionStatus(ConnectionStatus.Offline);
Console.WriteLine("Calling Online, will attend offline: ");
r.Logger.Write("Used offline.");
Connectivity.ForceConnectionStatus(ConnectionStatus.Online);
Console.WriteLine("Calling Online, will attend online: ");
r.Logger.Write("Used Online. Clap Clap Clap.");
Console.ReadKey();
}
}
public class Router<TContract, TOnline, TOffline>
where TOnline : TContract
where TOffline : TContract
{
public TContract Logger;
public Router()
{
Logger = Unity.Container.Resolve<TContract>();
}
}
public interface IOnline
{
IOffline Offline { get; set; }
}
public interface IOffline
{
}
public interface ILogger
{
[Test()]
void Write(string message);
}
public class OnlineLogger : ILogger, IOnline
{
public IOffline Offline { get; set; }
public OnlineLogger()
{
this.Offline = new OfflineLogger();
}
public void Write(string message)
{
Console.WriteLine("Online Logger: " + message);
}
}
public class OfflineLogger : ILogger, IOffline
{
public IOnline Online { get; set; }
public void Write(string message)
{
Console.WriteLine("Offline Logger: " + message);
}
}
[System.Diagnostics.DebuggerStepThroughAttribute()]
public class TestAttribute : HandlerAttribute
{
public override ICallHandler CreateHandler(IUnityContainer container)
{
return new TestHandler();
}
}
public class TestHandler : ICallHandler
{
public int Order { get; set; }
public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)
{
Console.WriteLine("It's been intercepted.");
if (!Connectivity.IsConnected() && input.Target is IOnline)
{
Console.WriteLine("It's been canceled.");
var offline = ((input.Target as IOnline).Offline);
if (offline == null)
throw new Exception("Online class did not initialized Offline Dispatcher.");
var offlineResult = input.MethodBase.Invoke(offline, this.GetObjects(input.Inputs));
return input.CreateMethodReturn(offlineResult, this.GetObjects(input.Inputs));
}
return getNext()(input, getNext);
}
private object[] GetObjects(IParameterCollection parameterCollection)
{
var parameters = new object[parameterCollection.Count];
int i = 0;
foreach (var parameter in parameterCollection)
{
parameters[i] = parameter;
i++;
}
return parameters;
}
}
}
答案 2 :(得分：0)
我想建议另一种可行的方法。它与您的计划有很大的不同，但可能会更好。
基本思路是将您的应用分为两部分。第一部分是您所描述的 - UI。但是，它假设您处于脱机状态。它将所有内容存储到本地数据库/文件/内存存储中。
然后你有另一部分程序，可能在另一个负责同步的线程（或可能在另一个进程中）。它查看数据存储，等待更改，如果在线，则将它们写入服务器。当从服务器发出更新时，数据存储将需要引发事件以告诉主程序发生了什么变化，但无论如何它都必须这样做。如果您处于脱机状态，同步器不会执行任何操作，但所有数据更改都会被自动安全地移除，直到您以后重新联机。
这种方法的好处是你永远不必担心除了专门处理同步的部分代码之外的任何地方的在线/离线切换。假设您已离线，您已经设置了默认案例。你可以完全摆脱所有拦截/ AOP的东西。