从循环引用谈依赖倒置原则(二)
ProductName = product.ProductName,
ProductId = product.ProductId };
return result;
}
///
/// 根据OrderID获取Product
///
///
///
private Product GetProduct(int orderId)
{
Product product = new Product()
{
ProductId = 1,
OrderId = orderId,
ProductName = "test product"
};
return product;
}
}
在实现的接口方法内部，我们可以调用其它的方法，只需要将返回结果Product转换为接口中定义的返回类型ProductModel即可，因为有些时候，我们可能不需要对外提供那么多的信息。只需要提供指定了的信息即可。然后在Product 类库中我们提供一个产生ProductService实体的类ProductSharedService，中间只有一个Create方法，该方法返回ProductService实体。
public static class ProductSharedService
{
public static ProductService Create()
{
return new ProductService();
}
}
我们还需要在Shared类库中提供动态加载程序集，反射调用ProductSharedService的Create方法的通用方法。于是新建类SharedInterfaceProxy，通过构造函数传入程序集名称，以及创建实体类的类名称。
public class SharedInterfaceProxy
{
private string _assemblyName;
private string _className;
private const string _methodName = "Create";
private MethodInfo _proxcy;
///
/// 构造函数
///
/// 程序集名称
/// 程序集中产生实体类的类名称，该类必须存在一个名为Create的方法，这里是约定
public SharedInterfaceProxy(string assemblyName, string className)
{
this._assemblyName = assemblyName;
this._className = className;
Init();
}
private void Init()
{
Type type;
try
{
type = GetAssemblyType();
if (type != null)
{
_proxcy = type.GetMethod(_methodName);
}
}
catch (Exception)
{
throw;
}
}
private Type GetAssemblyType()
{
Type result;
Assembly assem;
result = null;
try
{
assem = AppDomain.CurrentDomain.Load(_assemblyName);
if (assem != null)
{
result = assem.GetType(_className);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return result;
}
public object GetInstance()
{
object result;
if (_proxcy == null)
{
return null;
}
result = null;
try
{
result = _proxcy.Invoke(null, null);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return result;
}
}
方法中我们约定了传进去的className这个类必须存在一个Create方法，使用反射调用该方法就可以产生创建一个服务实体。
现在，假设我们需要在Order类库中调用Product的GetProductsByOrderId 方法，现在我们可以通过 实例化SharedInterfaceProxy类，然后通过接口实现调用。
public static ProductModel GetProductByOrderId(int orderId)
{
ProductModel result;
result = null;
SharedInterfaceProxy shareProxy = new SharedInterfaceProxy("Product", "Product.ProductSharedService");
object product=shareProxy.GetInstance();
if (product != null)
{
IProduct pro = product as IProduct;
if (pro != null)
{
result = pro.GetProductsByOrderId(orderId);
}
}
return result;
}
以上就是通过使用反射和接口实现了循环引用工程的解耦和，其基本原理就是设计模式中的依赖倒置原理，即高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。这里在本文之前Product依赖Order高层模块，Order也依赖Product高层模块，改造之后，两者都依赖于Sh