public void CreateInstance()
{
//不会重复创建打上并发访问安全类型特性的对象
AssertPro.NotThrowsException <TypeUnsafeAccessException>(() =>
{
var obj0 = SafeAccessAttribute.CreateSingleton <SafeInternalClass>();
var obj1 = SafeAccessAttribute.CreateSingleton <SafeInternalClass>();
Assert.AreEqual(obj0.Id, obj1.Id);
});
//不能以单例形式创建没有打上并发访问安全类型特性的对象
Assert.ThrowsException <TypeUnsafeAccessException>(() =>
{
SafeAccessAttribute.CreateSingleton <UnsafeInternalClass>();
});
//自动创建实例，也不会重复创建打上并发访问安全类型特性的对象
{
var obj0 = SafeAccessAttribute.CreateInstance <SafeInternalClass>();
var obj1 = SafeAccessAttribute.CreateInstance <SafeInternalClass>();
Assert.AreEqual(obj0.Id, obj1.Id);
}
//自动创建实例，会重复创建没有打上并发访问安全类型的对象
{
var obj0 = SafeAccessAttribute.CreateInstance <UnsafeInternalClass>();
var obj1 = SafeAccessAttribute.CreateInstance <UnsafeInternalClass>();
Assert.AreNotEqual(obj0.Id, obj1.Id);
}
}
/// <summary>
/// 获取类型定义
/// </summary>
/// <typeparam name="RT"></typeparam>
/// <returns></returns>
public static TypeDefine GetDefine <RT>()
where RT : TypeDefine
{
var define = SafeAccessAttribute.CreateSingleton <RT>();
return(GetDefine(define.TypeName)); //为了防止重定向了类型定义，所以要再获取一遍
}
public void IsSafe()
{
//InternalSafeClass是并发访问安全的
Assert.IsTrue(SafeAccessAttribute.IsDefined(typeof(SafeInternalClass)));
//InternalUnsafeClass不是并发访问安全的
Assert.IsFalse(SafeAccessAttribute.IsDefined(typeof(UnsafeInternalClass)));
}
/// <summary>
/// 获取目标类型的类型转换器
/// </summary>
/// <param name="targetType"></param>
/// <returns></returns>
public static TypeConverter CreateConverter(Type targetType)
{
var attr = targetType.GetCustomAttribute <TypeConverterAttribute>(true);
if (attr == null)
{
return(null);
}
return(SafeAccessAttribute.CreateInstance <TypeConverter>(attr.ConverterType));
}
public static IRepository Create(Type repositoryInterfaceType)
{
object repository = _cache.GetOrCreate(repositoryInterfaceType, (t) =>
{
var repositoryType = GetRepositoryType(repositoryInterfaceType);
return(SafeAccessAttribute.CreateSingleton(repositoryType));
});
return((IRepository)repository);
}
/// <summary>
/// 订阅事件
/// </summary>
public void Subscribe(IDomainEventHandler handler)
{
lock (_handlers)
{
SafeAccessAttribute.CheckUp(handler);
if (!_handlers.Contains(handler))
{
_handlers.Add(handler);
}
}
}
public void AddHandler(IEventHandler handler)
{
lock (_handlers)
{
SafeAccessAttribute.CheckUp(handler);
if (!_handlers.Contains(handler))
{
_handlers.Add(handler);
}
}
}
private static TypeConverter GetConverter(PropertyInfo propertyInfo)
{
//先查找属性是否定义了类型转换器，如果没有定义，那么从属性所属的类型上查找是否定义了类型转换器
var attr = propertyInfo.GetCustomAttribute <TypeConverterAttribute>(true) ?? propertyInfo.PropertyType.GetCustomAttribute <TypeConverterAttribute>(true);
if (attr == null)
{
return(PrimitiveTypeConverter.Instance); //如果没有定义，那么使用默认的转换器
}
return(SafeAccessAttribute.CreateInstance <TypeConverter>(attr.ConverterType));
}
public T GetInstance <T>() where T : class
{
var instanceType = typeof(T);
var isSafe = SafeAccessAttribute.IsDefined(instanceType);
var obj = isSafe ? GetInstanceBySingleton() : CreateInstance();
var instance = obj as T;
if (instance == null)
{
throw new TypeMismatchException(obj.GetType(), instanceType);
}
return(instance);
}
public static IRepository Create(Type repositoryInterfaceType)
{
object repository = _cache.GetOrCreate(repositoryInterfaceType, (t) =>
{
var repositoryType = GetRepositoryType(repositoryInterfaceType);
if (repositoryType == null)
{
throw new DomainDrivenException(string.Format(Strings.NotFoundRepository, repositoryInterfaceType.FullName));
}
return(SafeAccessAttribute.CreateSingleton(repositoryType));
});
return((IRepository)repository);
}
public void CheckUp()
{
//检查InternalSafeClass,不会引起非并发访问安全的异常
AssertPro.NotThrowsException <TypeUnsafeAccessException>(() =>
{
SafeAccessAttribute.CheckUp(typeof(SafeInternalClass));
});
//检查InternalUnsafeClass，会引起非并发访问安全的异常
Assert.ThrowsException <TypeUnsafeAccessException>(() =>
{
SafeAccessAttribute.CheckUp(typeof(UnsafeInternalClass));
});
}
public object CreateComponent(string componentName)
{
var type = ComponentTypeLocator.Locate(componentName) ?? HtmlElement.Type;
if (type == null)
{
throw new XamlException("没有找到" + componentName + "的定义");
}
if (DataUtil.IsPrimitiveType(type))
{
return(type); //如果是基础类型，那么直接返回类型本身
}
return(SafeAccessAttribute.CreateInstance(type));
}
/// <summary>
/// 从仓储的定义中得到mapper
/// </summary>
/// <param name="objectType"></param>
/// <returns></returns>
private static IDataMapper GetByRepository(Type objectType)
{
var repository = Repository.CreateWithNoCheckUp(objectType);
if (repository == null)
{
return(null);
}
var dataMapperType = DataMapperAttribute.GetDataMapperType(repository);
if (dataMapperType == null)
{
return(null);
}
return(SafeAccessAttribute.CreateSingleton <IDataMapper>(dataMapperType));
}
/// <summary>
/// 获取服务，该方法不会缓存结果
/// </summary>
/// <param name="serviceName"></param>
/// <returns></returns>
public static IServiceProvider GetServiceImpl(string serviceName)
{
RuntimeTypeHandle serviceHandle = default(RuntimeTypeHandle);
if (_handlers.TryGetValue(serviceName, out serviceHandle))
{
var type = Type.GetTypeFromHandle(serviceHandle);
SafeAccessAttribute.CheckUp(type);
var service = Activator.CreateInstance(type) as IServiceProvider;
if (service == null)
{
throw new TypeMismatchException(type, typeof(IServiceProvider));
}
return(service);
}
return(null);
}
/// <summary>
/// ×¢²áµ¥Àý²Ö´¢£¬ÇëÈ·±£<paramref name="repository"/>Êǵ¥ÀýµÄ
/// </summary>
/// <typeparam name="TRepository"></typeparam>
/// <param name="repository"></param>
public static void RegisterHandler <Q, S>(string handlerKey, IModuleHandler <Q, S> handler)
where Q : class
where S : class
{
if (_singletons.ContainsKey(handlerKey))
{
throw new ModuleException("Öظ´×¢²áÄ£¿é´¦ÀíÆ÷" + handlerKey);
}
lock (_syncObject)
{
if (_singletons.ContainsKey(handlerKey))
{
throw new ModuleException("Öظ´×¢²áÄ£¿é´¦ÀíÆ÷" + handlerKey);
}
SafeAccessAttribute.CheckUp(handler.GetType());
_singletons.Add(handlerKey, handler);
}
}
internal static IContractEvent CreateCE(DTObject dto)
{
var typeName = dto.GetValue <string>("type", string.Empty);
if (string.IsNullOrEmpty(typeName))
{
throw new ServiceException("没有定义IContractEvent的类型，无法实例化ContractEvent");
}
var factoryType = _getFactoryType(typeName);
if (factoryType == null)
{
throw new ServiceException("没有找到" + typeName + "的类型创建工厂，无法实例化ContractEvent");
}
var factory = SafeAccessAttribute.CreateInstance <IContractEventFactory>(factoryType);
return(factory.Create(dto));
}
/// <summary>
/// ×¢²áµ¥Àý²Ö´¢£¬ÇëÈ·±£<paramref name="repository"/>Êǵ¥ÀýµÄ
/// </summary>
/// <typeparam name="TRepository"></typeparam>
/// <param name="repository"></param>
public static void Register <TRepository>(object repository)
{
var interfaceType = typeof(TRepository);
if (_singletons.ContainsKey(interfaceType))
{
throw new DomainDrivenException("Öظ´×¢²á²Ö´¢" + interfaceType.FullName);
}
lock (_syncObject)
{
if (_singletons.ContainsKey(interfaceType))
{
throw new DomainDrivenException("Öظ´×¢²á²Ö´¢" + interfaceType.FullName);
}
if (!(repository is TRepository))
{
throw new TypeMismatchException(repository.GetType(), interfaceType);
}
SafeAccessAttribute.CheckUp(repository);
_singletons.Add(interfaceType, repository);
}
}
/// <summary>
/// 语言提供其，请保证<paramref name="prodiver"/>是单例的
/// </summary>
/// <param name="prodiver"></param>
public static void Register(ILanguageProvider prodiver)
{
SafeAccessAttribute.CheckUp(prodiver.GetType());
_instance = prodiver;
}
public WebGuard(Type guardType)
{
SafeAccessAttribute.CheckUp(guardType);
_guard = _getGuard(guardType);
}
/// <summary>
/// 页面路由器，请保证<paramref name="router"/>是单例的
/// </summary>
/// <param name="router"></param>
public static void RegisterRouter(IWebPageRouter router)
{
SafeAccessAttribute.CheckUp(router.GetType());
_instance = router;
}
/// <summary>
/// 创建类型定义的实例，该方法主要用于程序初始化时主动初始化类型
/// </summary>
/// <param name="define"></param>
internal static void Initialize(Type typeDefineType)
{
SafeAccessAttribute.CreateSingleton(typeDefineType);
}
/// <summary>
/// 创建类型定义的实例，该方法主要用于程序初始化时主动初始化类型
/// </summary>
/// <param name="define"></param>
internal static object Initialize(Type typeDefineType)
{
return(SafeAccessAttribute.CreateSingleton(typeDefineType));
}
/// <summary>
/// 页面路由器，请保证<paramref name="router"/>是单例的
/// </summary>
/// <param name="router"></param>
public static void RegisterRoute(IModuleHandlerRouter router)
{
SafeAccessAttribute.CheckUp(router.GetType());
_instance = router;
}
/// <summary>
/// 注册结果发送者
/// </summary>
/// <param name="router"></param>
public static void RegisterSender(IResultSender sender)
{
SafeAccessAttribute.CheckUp(sender.GetType());
_sender = sender;
}
public IEventHandler CreateHandler()
{
return(SafeAccessAttribute.CreateSingleton <IEventHandler>(this.HandlerType));
}
/// <summary>
/// 注册参数提取者
/// </summary>
/// <param name="router"></param>
public static void RegisterExtractor(IParameterExtractor extractor)
{
SafeAccessAttribute.CheckUp(extractor.GetType());
_extractor = extractor;
}
private IObjectValidator CreateValidator(Type validatorType)
{
return(SafeAccessAttribute.CreateSingleton <IObjectValidator>(validatorType));
}
/// <summary>
/// 移动端检测器，请保证<paramref name="detector"/>是单例的
/// </summary>
/// <param name="detector"></param>
public static void RegisterDetector(IDeviceDetector detector)
{
SafeAccessAttribute.CheckUp(detector.GetType());
_instance = detector;
}
/// <summary>
/// 注册服务提供者工厂，请保证<paramref name="factory"/>是线程安全的
/// </summary>
/// <param name="factory"></param>
public static void Register(IServiceProviderFactory factory)
{
SafeAccessAttribute.CheckUp(factory);
_factoryByRegister = factory;
}
/// <summary>
/// 获取类型定义
/// </summary>
/// <typeparam name="RT"></typeparam>
/// <returns></returns>
public static RT GetDefine <RT>()
where RT : TypeDefine
{
return(SafeAccessAttribute.CreateSingleton <RT>());
}
