private IInterceptor[] SelectMethodInterceptors(IInterceptorSelector selector, IInterceptor[] methodInterceptors, Type targetType) { return methodInterceptors ?? selector.SelectInterceptors(targetType, Method, interceptors) ?? new IInterceptor[0]; }
/// <summary> /// Add the interceptor in the argument as the first interceptor /// and set its next to the interceptor that we have. In the first /// execution it will be the TailInterceptor. /// </summary> /// <param name="interceptor"></param> public virtual void Add(IInterceptor interceptor) { AssertUtil.ArgumentNotNull(interceptor, "interceptor"); interceptor.Next = m_interceptor; m_interceptor = interceptor; }
/// <summary> /// Registrations the activating. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="Autofac.Core.ActivatingEventArgs<System.Object>"/> instance containing the event data.</param> private static void RegistrationActivating(object sender, ActivatingEventArgs<object> e) { // Ignore AspectConfiguration and IInterceptor types since they're being referenced via the Autofac // registration context. Otherwise calling e.Context.Resolve<IInterceptor> will fail when // the code below executes. if (e.Instance.GetType() == typeof (MasterProxy) || e.Instance is IInterceptor) { return; } var proxy = (MasterProxy)e.Context.Resolve(typeof(MasterProxy)); if (!e.Instance.IsDecorated(proxy.Configuration)) { return; } var pseudoList = new IInterceptor[proxy.Configuration.Interceptors.Count]; pseudoList[0] = proxy; for (var i = 1; i < pseudoList.Length; i++) { pseudoList[i] = new PseudoInterceptor(); } var interfaceTypes = e.Instance.GetType().GetInterfaces(); var targetInterface = interfaceTypes.FirstMatch(proxy.Configuration.Namespaces); e.Instance = new ProxyGenerator().CreateInterfaceProxyWithTargetInterface(targetInterface, e.Instance, pseudoList); }
private StaticInterceptorStub(MethodInfo method, IInterceptor[] interceptors, MethodInfo methodInvocationTarget) { this.method = method; this.interceptors = interceptors; this.methodInvocationTarget = methodInvocationTarget; }
public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors) { if (method.IsAddMethod()) return interceptors.Where(x => x is ListAddInterceptor).ToArray(); if (method.IsSetMethod()) return interceptors.Where(x => x is ListSetInterceptor).ToArray(); if (method.IsRemoveMethod()) return interceptors.Where(x => x is ListRemoveInterceptor).ToArray(); return new IInterceptor[0]; }
/// <summary>Select interceptors which must be applied to the method.</summary> /// <param name="type">The type.</param> /// <param name="method">The method.</param> /// <param name="interceptors">The interceptors.</param> /// <returns>The interceptors after filtering.</returns> public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors) { if (method.IsGetter()) { var propertyInfo = type.GetProperty(method); if (propertyInfo.IsPropertyWithSelectorAttribute()) { return typeof(BaseHtmlElement).IsAssignableFrom(method.ReturnType) ? interceptors.Where(x => x is PropertyInterceptor).ToArray() : interceptors.Where(x => x is CollectionPropertyInterceptor).ToArray(); } } if (method.IsSetter()) { var propertyInfo = type.GetProperty(method); if (propertyInfo.IsPropertyWithSelectorAttribute()) { return interceptors.Where(x => x is InvalidWriteOperationInterceptor).ToArray(); } } return interceptors.Where(x => !(x is PropertyInterceptor) && !(x is CollectionPropertyInterceptor) && !(x is InvalidWriteOperationInterceptor)).ToArray(); }
public EFCustomerRepository(string connectionStringName, ICustomerEntityFactory entityFactory, IInterceptor[] interceptors = null) : base(connectionStringName, factory: entityFactory, interceptors: interceptors) { this.Configuration.AutoDetectChangesEnabled = true; this.Configuration.ProxyCreationEnabled = false; Database.SetInitializer(new ValidateDatabaseInitializer<EFCustomerRepository>()); }
/// <summary> /// The select interceptors. /// </summary> /// <param name="type"> /// The type. /// </param> /// <param name="method"> /// The method. /// </param> /// <param name="interceptors"> /// The interceptors. /// </param> /// <returns> /// The <see cref="IInterceptor[]" />. /// </returns> public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors) { string name = method.Name; if (method.IsSpecialName) { if (name.StartsWith(AopConstants.PropertyGetter, StringComparison.Ordinal)) name = name.Remove(0, AopConstants.PropertyGetter.Length); if (name.StartsWith(AopConstants.PropertySetter, StringComparison.Ordinal)) name = name.Remove(0, AopConstants.PropertySetter.Length); if (name.StartsWith(AopConstants.EventAdder, StringComparison.Ordinal)) name = name.Remove(0, AopConstants.EventAdder.Length); if (name.StartsWith(AopConstants.EventRemover, StringComparison.Ordinal)) name = name.Remove(0, AopConstants.EventRemover.Length); } return interceptors.Where( inter => { var sinter = inter as ISpecificInterceptor; if (sinter != null) { return sinter.Name == name || sinter.Name == AopConstants.InternalUniversalInterceptorName; } return true; }).OrderBy( inter => { var sinter = inter as ISpecificInterceptor; return sinter == null ? 0 : sinter.Order; }).ToArray(); }
protected NhConfigurationBase(IInterceptor interceptor, INhProperties nhProperties, IMappingAssemblies mappingAssemblies, IRegisterEventListener[] registerEventListeners) { if (interceptor == null) { throw new ArgumentNullException("interceptor"); } if (nhProperties == null) { throw new ArgumentNullException("nhProperties"); } if (mappingAssemblies == null) { throw new ArgumentNullException("mappingAssemblies"); } if (registerEventListeners == null) { throw new ArgumentNullException("registerEventListeners"); } Contract.EndContractBlock(); m_Interceptor = interceptor; m_NhProperties = nhProperties; m_MappingAssemblies = mappingAssemblies; m_RegisterEventListeners = registerEventListeners; }
IInterceptor[] IInterceptorSelector.SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors) { if (interceptors.Length == 0) return interceptors; var markers = new List<MarkerBaseAttribute>(); if (type != null) markers.AddRange(type.GetCustomAttributes(typeof(MarkerBaseAttribute), true).Cast<MarkerBaseAttribute>()); if (method != null) markers.AddRange(method.GetCustomAttributes(typeof(MarkerBaseAttribute), true).Cast<MarkerBaseAttribute>()); if (markers.Count == 0) // no marker attributes found, no ordering required return interceptors; markers.Sort((a, b) => a.Order.CompareTo(b.Order)); var sorted = new List<IInterceptor>(); for (int i = 0; i < markers.Count; ++i) { var providers = interceptors.OfType<IInterceptorMarkerProvider>(); var markerType = markers[i].GetType(); var matchingInterceptor = providers.FirstOrDefault(x => x.MarkerType == markerType) as IInterceptor; if (matchingInterceptor != null) sorted.Add(matchingInterceptor); } return sorted.ToArray(); }
public SessionProvider(IConfigurationBuilder builder, IInterceptor interceptor, IWebContext webContext) { nhSessionFactory = builder.BuildSessionFactory(); Debug.WriteLine("Built Session Factory " + DateTime.Now); this.webContext = webContext; this.interceptor = interceptor; }
public virtual object GetProxy(Type type, IInterceptor interceptor) { if (cache.ContainsKey(type)) return cache[type]; cache[type] = CreateProxy(interceptor, type); return cache[type]; }
public IEnumerable<IComponentRegistration> RegistrationsFor(Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor) { var serviceWithType = service as IServiceWithType; if (serviceWithType == null) yield break; var serviceType = serviceWithType.ServiceType; if (!serviceType.IsInterface || !typeof(IEventHandler).IsAssignableFrom(serviceType) || serviceType == typeof(IEventHandler)) yield break; var interfaceProxyType = _proxyBuilder.CreateInterfaceProxyTypeWithoutTarget( serviceType, new Type[0], ProxyGenerationOptions.Default); var rb = RegistrationBuilder .ForDelegate((ctx, parameters) => { var interceptors = new IInterceptor[] { new EventsInterceptor(ctx.Resolve<IEventBus>()) }; var args = new object[] { interceptors, null }; return Activator.CreateInstance(interfaceProxyType, args); }) .As(service); yield return rb.CreateRegistration(); }
public void PostProcess(IServiceRequestResult result) { var instance = result.ActualResult; var instanceTypeName = instance.GetType().FullName; // Ignore any LinFu factories or Snap-specific instances. if (instanceTypeName.Contains("LinFu.") || instanceTypeName == "Snap.AspectConfiguration" || instanceTypeName == "Snap.IMasterProxy" || instanceTypeName == "Snap.MasterProxy") { return; } var proxy = result.Container.GetService<IMasterProxy>(); if (!instance.IsDecorated(proxy.Configuration)) { return; } var pseudoList = new IInterceptor[proxy.Configuration.Interceptors.Count]; pseudoList[0] = proxy; for (var i = 1; i < pseudoList.Length; i++) { pseudoList[i] = new PseudoInterceptor(); } var interfaceTypes = instance.GetType().GetInterfaces(); var targetInterface = interfaceTypes.FirstMatch(proxy.Configuration.Namespaces); result.ActualResult = new ProxyGenerator().CreateInterfaceProxyWithTargetInterface(targetInterface, instance, pseudoList); }
public SessionFactoryBuilder(IDatabaseMappingScheme<MappingConfiguration> mappingScheme, IPersistenceConfigurer persistenceConfigurer, IInterceptor interceptor = null) { _mappingScheme = mappingScheme; _persistenceConfigurer = persistenceConfigurer; _interceptor = interceptor; }
public IInterceptor[] SelectInterceptors(Type type, System.Reflection.MethodInfo method, IInterceptor[] interceptors) { if (method.Name == "FunA") return interceptors; return new IInterceptor[0]; // ... }
public IInterceptor[] SelectInterceptors( Type type, MethodInfo method, IInterceptor[] interceptors ) { if( method.Name.StartsWith( "set_" ) ) return interceptors; return null; }
protected Invocation(object proxy, MethodInfo proxiedMethod, object[] arguments, IInterceptor[] interceptors) { _proxy = proxy; _proxiedMethod = proxiedMethod; _arguments = arguments; _interceptors = interceptors ?? new IInterceptor[0]; }
public MockingProxy(MarshalByRefObject wrappedInstance, IInterceptor interceptor, IMockMixin mockMixin) : base(wrappedInstance.GetType()) { this.WrappedInstance = wrappedInstance; this.interceptor = interceptor; this.mockMixin = mockMixin; }
public InterceptionContext(IInterceptor[] interceptors) { //if (interceptors != null) { _interceptors = new List<IInterceptor>(interceptors); } }
public object Generate(IProxyBuilder builder, ProxyGenerationOptions options, IInterceptor[] interceptors) { var type = GetProxyType(builder); var instance = GetProxyInstance(type,interceptors); var method = GetInvokeDelegate(instance); return method; }
public EFDynamicContentRepository(string nameOrConnectionString, DynamicContentEntityFactory entityFactory, IInterceptor[] interceptors = null) : base(nameOrConnectionString, factory: entityFactory, interceptors: interceptors) { this.Configuration.AutoDetectChangesEnabled = true; this.Configuration.ProxyCreationEnabled = false; Database.SetInitializer(new ValidateDatabaseInitializer<EFDynamicContentRepository>()); }
public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors) { var isCollection = IsCollectionReturnType(method) || IsCollectionParameterType(method); return _Interceptors.Where(e => e.InterceptCollections == isCollection).ToArray(); }
protected AbstractInvocation( object target, object proxy, IInterceptor[] interceptors, Type targetType, MethodInfo targetMethod, MethodInfo interfMethod, object[] arguments) : this(target, proxy, interceptors, targetType, targetMethod, arguments) { this.interfMethod = interfMethod; }
public EFAppConfigRepository(string connectionStringName, IAppConfigEntityFactory entityFactory, IInterceptor[] interceptors = null) : base(connectionStringName, entityFactory, interceptors: interceptors) { Database.SetInitializer(new ValidateDatabaseInitializer<EFAppConfigRepository>()); Configuration.AutoDetectChangesEnabled = true; Configuration.ProxyCreationEnabled = false; }
/// <summary> /// Initializes a new instance of the <see cref="InterceptorAdapter"/> class. /// </summary> /// <param name="interceptor">The interceptor.</param> /// <param name="target">The target.</param> /// <exception cref="ArgumentNullException">The <paramref name="interceptor"/> is <c>null</c>.</exception> /// <exception cref="ArgumentNullException">The <paramref name="target"/> is <c>null</c>.</exception> public InterceptorAdapter(IInterceptor interceptor, object target) { Argument.IsNotNull("interceptor", interceptor); Argument.IsNotNull("target", target); _interceptor = interceptor; _target = target; }
public static IProxy CreateProxy(this Type type, IInterceptor interceptor, params Type[] baseInterfaces) { IProxy proxy = type.CreateProxy(baseInterfaces); proxy.Interceptor = interceptor; return proxy; }
public Redirector(Func<object> getActualTarget, IInterceptor targetInterceptor, IProxyFactory factory, IMethodInvoke<MethodInfo> methodInvoke) : base(methodInvoke) { _getActualTarget = getActualTarget; _interceptor = targetInterceptor; _proxyFactory = factory; }
public ProfiledSqlClientBatchingBatcher(ConnectionManager connectionManager, IInterceptor interceptor) : base(connectionManager, interceptor) { _batchSize = Factory.Settings.AdoBatchSize; _defaultTimeout = PropertiesHelper.GetInt32(global::NHibernate.Cfg.Environment.CommandTimeout, global::NHibernate.Cfg.Environment.Properties, -1); _currentBatch = CreateConfiguredBatch(); _currentBatchCommandsLog = new StringBuilder().AppendLine("Batch commands:"); }
public void SetUp() { mocks = new MockRepository(); expectedSessionFactory = mocks.StrictMock<ISessionFactory>(); expectedEntityInterceptor = mocks.StrictMock<IInterceptor>(); expectedSingleSession = SessionScopeSettings.SINGLESESSION_DEFAULT; expectedDefaultFlushMode = SessionScopeSettings.FLUSHMODE_DEFAULT; }
public GetCatalogPageTask(IInterceptor interceptor, int pageId, string mode) : base(interceptor) { _pageId = pageId; _mode = mode; }
public DatabaseFactoryConfig WithInterceptor(IInterceptor interceptor) { _options.Interceptors.Add(interceptor); return(this); }
public ISession OpenSession(IDbConnection conn, IInterceptor sessionLocalInterceptor) { return(_inner.OpenSession(_liveConnection, sessionLocalInterceptor)); }
public WrappingInterceptor(IInterceptor interfaceInterceptor) { _interfaceInterceptor = interfaceInterceptor; }
/// <summary> /// Actually register the interceptor against this type. /// </summary> /// <param name="container">Container to configure.</param> /// <param name="interceptor">interceptor to register.</param> internal abstract void RegisterInterceptor(IUnityContainer container, IInterceptor interceptor);
/// <summary> /// Initializes a new instance of the <see cref="DynamicProxyInterceptor"/> class. /// </summary> /// <param name="interceptor">An <see cref="IInterceptor"/> instance.</param> public DynamicProxyInterceptor(IInterceptor interceptor) { this.interceptor = interceptor; }
private DbConnectionMetaInfo MapToDatabseConfig(PureDataConfiguration config, IDatabaseConfig databaseConfig) { DbConnectionMetaInfo metaInfo = null; if (config != null && databaseConfig != null) { if (config.Settings != null) { var settings = config.Settings; databaseConfig.ParameterPrefix = settings.ParameterPrefix; databaseConfig.ParameterSuffix = settings.ParameterSuffix; databaseConfig.GlobalTablePrefix = settings.GlobalTablePrefix; databaseConfig.ExecuteTimeout = settings.ExecuteTimeout; databaseConfig.DefaultPageSize = settings.DefaultPageSize; databaseConfig.AutoDisposeConnection = settings.AutoDisposeConnection; databaseConfig.ValidateStopOnFirstFailure = settings.ValidateStopOnFirstFailure; databaseConfig.LoadMapperMode = settings.LoadMapperMode; databaseConfig.EnableDebug = settings.EnableDebug; databaseConfig.EnableIntercept = settings.EnableIntercept; databaseConfig.EnableLogError = settings.EnableLogError; databaseConfig.EnableOrmLog = settings.EnableOrmLog; databaseConfig.EnableInternalLog = settings.EnableInternalLog; databaseConfig.LogWithRawSql = settings.LogWithRawSql; databaseConfig.CategoryLogType = settings.CategoryLogType; if (!string.IsNullOrEmpty(settings.OrmLogsPath)) { databaseConfig.OrmLogsPath = settings.OrmLogsPath; } databaseConfig.MaxServerLogSize = settings.MaxServerLogSize; databaseConfig.EnableOrmCache = settings.EnableOrmCache; databaseConfig.CacheOrmTime = settings.CacheOrmTime; databaseConfig.CacheOrmSingleTime = settings.CacheOrmSingleTime; databaseConfig.OrmCacheCheckPeriod = settings.OrmCacheCheckPeriod; databaseConfig.EnableSqlMap = settings.EnableSqlMap; databaseConfig.NameSpacePrefix = settings.NameSpacePrefix; databaseConfig.FormatSql = settings.FormatSql; databaseConfig.IsWatchSqlMapFile = settings.IsWatchSqlMapFile; databaseConfig.WatchSqlMapInterval = settings.WatchSqlMapInterval; databaseConfig.AutoMigrate = settings.AutoMigrate; databaseConfig.AutoRemoveUnuseColumnInTable = settings.AutoRemoveUnuseColumnInTable; databaseConfig.CanUpdatedWhenTableExisted = settings.CanUpdatedWhenTableExisted; databaseConfig.EnableAutoMigrateLog = settings.EnableAutoMigrateLog; databaseConfig.EnableAutoMigrateDebug = settings.EnableAutoMigrateDebug; databaseConfig.AutoMigrateOnContainTable = settings.AutoMigrateOnContainTable; databaseConfig.AutoMigrateWithoutTable = settings.AutoMigrateWithoutTable; if (!string.IsNullOrEmpty(settings.GlobalIgnoreUpdatedColumns)) { databaseConfig.GlobalIgnoreUpdatedColumns = settings.GlobalIgnoreUpdatedColumns; } databaseConfig.EnableGlobalIgnoreUpdatedColumns = settings.EnableGlobalIgnoreUpdatedColumns; databaseConfig.AutoFilterEmptyValueColumnsWhenTrack = settings.AutoFilterEmptyValueColumnsWhenTrack; //代码生成设置 databaseConfig.EnableCodeGen = settings.EnableCodeGen; databaseConfig.CodeGenType = settings.CodeGenType; databaseConfig.CodeGenClassNameMode = settings.CodeGenClassNameMode; databaseConfig.CodeGenPropertyNameMode = settings.CodeGenPropertyNameMode; databaseConfig.CodeGenProjectName = settings.CodeGenProjectName; databaseConfig.CodeGenNameSpace = settings.CodeGenNameSpace; databaseConfig.CodeGenTableFilter = settings.CodeGenTableFilter; string _basePath = ""; //if (databaseConfig.EnableCodeGen) //{ string[] basePaths = settings.CodeGenBaseDirectory.Split(';'); if (basePaths.Length > 0) { foreach (var basePath in basePaths) { if (System.IO.Directory.Exists(basePath)) { _basePath = basePath; break; } } } if (_basePath == "") { string baseRootPath = System.IO.Path.Combine(PathHelper.GetBaseDirectory(), "generate"); //if (Directory.Exists(baseRootPath)) //{ // DirectoryInfo info = new DirectoryInfo(baseRootPath); // _basePath = info.Parent.FullName; //} _basePath = baseRootPath; } //} databaseConfig.CodeGenBaseDirectory = _basePath; //databaseConfig.EnableConnectionPool = settings.EnableConnectionPool; //databaseConfig.EnableLogConnectionPool = settings.EnableLogConnectionPool; //databaseConfig.MinIdle = settings.MinIdle; //databaseConfig.MaxIdle = settings.MaxIdle; //databaseConfig.InitialSize = settings.InitialSize; //databaseConfig.MaxWaitMillis = settings.MaxWaitMillis; //databaseConfig.MaxTotal = settings.MaxTotal; //databaseConfig.TimeBetweenEvictionRunsMillis = settings.TimeBetweenEvictionRunsMillis; //databaseConfig.MinEvictableIdleTimeMillis = settings.MinEvictableIdleTimeMillis; //databaseConfig.EnableRemoveAbandoned = settings.EnableRemoveAbandoned; //databaseConfig.RemoveAbandonedOnBorrow = settings.RemoveAbandonedOnBorrow; //databaseConfig.RemoveAbandonedOnMaintenance = settings.RemoveAbandonedOnMaintenance; //databaseConfig.RemoveAbandonedTimeout = settings.RemoveAbandonedTimeout; //databaseConfig.NumTestsPerEvictionRun = settings.NumTestsPerEvictionRun; //databaseConfig.SoftMinEvictableIdleTimeMillis = settings.SoftMinEvictableIdleTimeMillis; //databaseConfig.TestOnBorrow = settings.TestOnBorrow; //databaseConfig.TestOnCreate = settings.TestOnCreate; //databaseConfig.TestOnReturn = settings.TestOnReturn; //databaseConfig.TestWhileIdle = settings.TestWhileIdle; //databaseConfig.ValidationQuery = settings.ValidationQuery; databaseConfig.EnableLobConverter = settings.EnableLobConverter; databaseConfig.LobConverterClassName = settings.LobConverterClassName; if (databaseConfig.EnableLobConverter == true) { try { Type type = Type.GetType(databaseConfig.LobConverterClassName); if (type != null) { object obj = Activator.CreateInstance(type, true); LobConverter.Init((ILobParameterConverter)(obj), databaseConfig.EnableLobConverter); } else { Log("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName), MessageType.Error); } } catch (Exception ex) { Log("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName), MessageType.Error); throw new ArgumentException("没有找到相关ILobParameterConverter实现类,LobConverterClassName: " + databaseConfig.LobConverterClassName, ex); } } databaseConfig.BulkOperateClassName = settings.BulkOperateClassName; databaseConfig.EnableDefaultPropertySecurityValidate = settings.EnableDefaultPropertySecurityValidate; databaseConfig.PropertySecurityValidateClassName = settings.PropertySecurityValidateClassName; if (!string.IsNullOrEmpty(settings.BulkOperateClassName)) { try { Type type = Type.GetType(settings.BulkOperateClassName); if (type != null) { IBulkOperate obj = (IBulkOperate)Activator.CreateInstance(type, true); BulkOperateManage.Instance.Register(settings.BulkOperateClassName, obj); } else { Log("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName), MessageType.Error); } } catch (Exception ex) { Log("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName), MessageType.Error); throw new ArgumentException("没有找到相关IBulkOperate实现类,BulkOperateClassName: " + settings.BulkOperateClassName, ex); } } if (!string.IsNullOrEmpty(settings.PropertySecurityValidateClassName)) { try { Type type = Type.GetType(settings.PropertySecurityValidateClassName); if (type != null) { IPropertySecurityValidate obj = (IPropertySecurityValidate)Activator.CreateInstance(type, true); PropertySecurityValidateManage.Instance.Register(settings.PropertySecurityValidateClassName, obj); } else { Log("IPropertySecurityValidate 无法找到实现类, 将启用默认的安全校验器!"); } } catch (Exception ex) { Log("IPropertySecurityValidate 无法找到实现类, 将启用默认的安全校验器!"); // throw new ArgumentException("没有找到相关IBulkOperate实现类,PropertySecurityValidateClassName: " + settings.PropertySecurityValidateClassName, ex); } } } try { if (config.DataSources != null) { string ConnectionString = "", ProviderName = ""; databaseConfig.DataSources = config.DataSources; foreach (var item in config.DataSources) { if (item.IsMaster == true)//是否主数据库 { ConnectionString = item.ConnectionString; ProviderName = item.Provider; break; } } metaInfo = DbConnectionFactory.CreateConnection(ConnectionString, ProviderName); } else { Log("DataSources 不能为空,且必须存在一个Master的数据源!", new ArgumentException("DataSources 不能为空,且必须存在一个Master的数据源!"), MessageType.Error); } } catch (Exception ex) { Log("DataSources 不能为空,且必须存在一个Master的数据源!", ex, MessageType.Error); throw new ArgumentException("DataSources 不能为空,且必须存在一个Master的数据源!", ex); } if (config.MapperSources != null) { Assembly ass = null; string _MapperSourcePath = ""; string path = ""; MapperSource.MapperAssemblyType _MapperAssemblyType = MapperSource.MapperAssemblyType.ClassType; try { databaseConfig.MappingAssemblies.Clear(); foreach (var item in config.MapperSources) { _MapperAssemblyType = item.Type; if (item.Type == MapperSource.MapperAssemblyType.File) { _MapperSourcePath = item.Path; path = FileLoader.GetPath(item.Path); ass = Assembly.LoadFrom(path); databaseConfig.MappingAssemblies.Add(ass); } else if (item.Type == MapperSource.MapperAssemblyType.ClassType) { path = item.ClassName; Type type = Type.GetType(item.ClassName); if (type != null) { ass = type.Assembly; if (ass != null) { databaseConfig.MappingAssemblies.Add(ass); } } else { Log("MapperSource 中存在不正确的Type:" + item.ClassName, new ArgumentException("MapperSource 中存在不正确的Type:" + item.ClassName), MessageType.Error); } } } foreach (var item in PureDataConfigurationLoader.MapperSourceAssemblies) { if (item != null) { databaseConfig.MappingAssemblies.Add(item); } } } catch (Exception ex) { Log("Load MapperSource error on :" + _MapperAssemblyType + ", " + _MapperSourcePath + " , path:" + path, ex, MessageType.Error); throw new ArgumentException("Load MapperSource error on :" + _MapperAssemblyType + ", " + _MapperSourcePath, ex); } } if (config.SqlMapSources != null) { var dirSqlMappers = config.SqlMapSources.Where(p => p.Type == ResourceType.Directory); var fileSqlMappers = config.SqlMapSources.Where(p => p.Type == ResourceType.File); databaseConfig.SqlMapDirPaths = dirSqlMappers.Select(p => p.Path).ToList(); databaseConfig.SqlMapFilePaths = fileSqlMappers.Select(p => p.Path).ToList(); foreach (var item in PureDataConfigurationLoader.SqlMapDirPaths) { if (item != null) { databaseConfig.SqlMapDirPaths.Add(item); } } foreach (var item in PureDataConfigurationLoader.SqlMapFilePaths) { if (item != null) { databaseConfig.SqlMapFilePaths.Add(item); } } } try { if (databaseConfig.EnableIntercept == true) { databaseConfig.Interceptors.Clear(); //if (databaseConfig.EnableDebug && databaseConfig.EnableIntercept) //{ // databaseConfig.Interceptors.Add(OutputSQLIntercept.Instance); // databaseConfig.Interceptors.Add(OutputExceptionIntercept.Instance); //} if (config.Interceptors != null) { IInterceptor ass = null; string path = ""; foreach (var item in config.Interceptors) { ass = null; if (string.IsNullOrEmpty(item.ClassFullName) || string.IsNullOrEmpty(item.AssemblyName)) { continue; } if (item.Type == InterceptorSource.InterceptorType.ConnectionInterceptor) { ass = ReflectionHelper.CreateInstance <IConnectionInterceptor>(item.ClassFullName, item.AssemblyName); } else if (item.Type == InterceptorSource.InterceptorType.ExecutingInterceptor) { ass = ReflectionHelper.CreateInstance <IExecutingInterceptor>(item.ClassFullName, item.AssemblyName); } else if (item.Type == InterceptorSource.InterceptorType.ExceptionInterceptor) { ass = ReflectionHelper.CreateInstance <IExceptionInterceptor>(item.ClassFullName, item.AssemblyName); } else if (item.Type == InterceptorSource.InterceptorType.DataInterceptor) { ass = ReflectionHelper.CreateInstance <IDataInterceptor>(item.ClassFullName, item.AssemblyName); } else if (item.Type == InterceptorSource.InterceptorType.TransactionInterceptor) { ass = ReflectionHelper.CreateInstance <ITransactionInterceptor>(item.ClassFullName, item.AssemblyName); } if (ass != null) { databaseConfig.Interceptors.Add(ass); } } } } } catch (Exception ex) { Log("Load Intercept error !", ex, MessageType.Error); throw new ArgumentException("Load Intercept error !", ex); } if (config.CodeGenTemplates != null) { databaseConfig.CodeGenTemplates = config.CodeGenTemplates; } } return(metaInfo); }
protected virtual ISession OpenSession(IInterceptor sessionLocalInterceptor) { return(Sfi.WithOptions().Interceptor(sessionLocalInterceptor).OpenSession()); }
public Interceptor(MethodInfo method, IInterceptor <TRequest, TResponse> interceptor) { this.method = method; this.interceptor = interceptor; }
/// <summary> /// Delegate opening session to <see cref="IConversation"/> /// </summary> /// <param name="sessionFactory">The factory to use for this type</param> /// <param name="interceptor">An interceptor to include</param> /// <returns>A valid session from the <see cref="ISessionFactory"/>.</returns> public override ISession OpenSession(ISessionFactory sessionFactory, IInterceptor interceptor) { return(conversation.GetSession(sessionFactory, interceptor)); }
public Container(IInterceptor interceptor) { _interceptor = interceptor; }
/// <summary> /// Generates a proxy implementing all the specified interfaces and /// redirecting method invocations to the specifed interceptor. /// </summary> /// <param name="theInterface">Interface to be implemented</param> /// <param name="interceptor">instance of <see cref="IInterceptor"/></param> /// <param name="target">The target object.</param> /// <returns>Proxy instance</returns> public override object CreateProxy(Type theInterface, IInterceptor interceptor, object target) { return(CreateProxy(new Type[] { theInterface }, interceptor, target)); }
public void AfterPropertiesSet(IBeanContextFactory beanContextFactory) { ParamChecker.AssertNotNull(ProxyFactory, "ProxyFactory"); IBeanConfiguration serviceResultcache = beanContextFactory.RegisterBean <ServiceResultCache>().Autowireable <IServiceResultCache>(); beanContextFactory.Link(serviceResultcache, "HandleClearAllCaches").To <IEventListenerExtendable>().With(typeof(ClearAllCachesEvent)); beanContextFactory.RegisterBean <ValueHolderIEC>().Autowireable(typeof(ValueHolderIEC), typeof(IProxyHelper)); beanContextFactory.RegisterBean <CacheHelper>().Autowireable(typeof(ICacheHelper), typeof(ICachePathHelper), typeof(IPrefetchHelper)); IBeanConfiguration prioMembersProvider = beanContextFactory.RegisterBean <PrioMembersProvider>().Autowireable <IPrioMembersProvider>(); beanContextFactory.Link(prioMembersProvider, PrioMembersProvider.handleMetaDataAddedEvent).To <IEventListenerExtendable>() .With(typeof(IEntityMetaDataEvent)); beanContextFactory.RegisterBean <CacheWalker>().Autowireable <ICacheWalker>(); beanContextFactory.RegisterAutowireableBean <ICacheMapEntryTypeProvider, CacheMapEntryTypeProvider>(); beanContextFactory.RegisterAutowireableBean <IRootCacheValueFactory, RootCacheValueFactory>(); //IBeanConfiguration rootCache = beanContextFactory.registerBean<RootCache>("rootCache").autowireable(typeof(RootCache), typeof(IWritableCache)); //if (IsUseSingleChildCache) //{ // beanContextFactory.registerBean<SingletonCacheFactory>("cacheFactory") // .propertyRefs("singletonChildCache") // .autowireable<ICacheFactory>(); // IWritableCache childCache = (IWritableCache)beanContextFactory.registerBean<ChildCache>("singletonChildCache") // .propertyRefs("rootCache") // .autowireable(typeof(ICache)).GetInstance(); // ((RootCache)rootCache.GetInstance()).AddChildCache(childCache); //} //else //{ // rootCache.autowireable(typeof(ICache), typeof(IWritableCache), typeof(ICacheFactory)); //} //beanContextFactory.registerBean<RootCache>(ROOT_CACHE).autowireable<RootCache>(); //beanContextFactory.Link("rootCache").To<IOfflineListenerExtendable>(); beanContextFactory.RegisterBean <CacheRetrieverRegistry>(ROOT_CACHE_RETRIEVER).Autowireable(typeof(ICacheServiceByNameExtendable), typeof(ICacheRetrieverExtendable)); beanContextFactory.RegisterBean <FirstLevelCacheManager>("firstLevelCacheManager").Autowireable(typeof(IFirstLevelCacheExtendable), typeof(IFirstLevelCacheManager)); String rootCacheBridge = "rootCacheBridge"; beanContextFactory.RegisterBean <RootCacheBridge>(rootCacheBridge).PropertyRefs(COMMITTED_ROOT_CACHE, ROOT_CACHE_RETRIEVER); TransactionalRootCacheInterceptor txRcInterceptor = new TransactionalRootCacheInterceptor(); beanContextFactory.RegisterWithLifecycle("txRootCacheInterceptor", txRcInterceptor).PropertyRefs(COMMITTED_ROOT_CACHE, rootCacheBridge) .Autowireable(typeof(ITransactionalRootCache), typeof(ISecondLevelCacheManager)); Object txRcProxy = ProxyFactory.CreateProxy(new Type[] { typeof(IRootCache), typeof(ICacheIntern), typeof(IOfflineListener) }, txRcInterceptor); beanContextFactory.RegisterExternalBean(ROOT_CACHE, txRcProxy).Autowireable(typeof(IRootCache), typeof(ICacheIntern)); if (IsSecondLevelCacheActive) { // One single root cache instance for whole context beanContextFactory.RegisterBean <RootCache>(COMMITTED_ROOT_CACHE).PropertyRef("CacheRetriever", ROOT_CACHE_RETRIEVER) .PropertyValue("Privileged", true); beanContextFactory.Link(CacheModule.COMMITTED_ROOT_CACHE).To <IOfflineListenerExtendable>(); } else { // One root cache instance per thread sequence. Most often used in server environment where the "deactivated" // second level cache means that each thread hold his own, isolated root cache (which gets cleared with each service // request. Effectively this means that the root cache itself only lives per-request and does not hold a longer state IInterceptor threadLocalRootCacheInterceptor = (IInterceptor)beanContextFactory .RegisterBean <ThreadLocalRootCacheInterceptor>("threadLocalRootCacheInterceptor") .PropertyRef("StoredCacheRetriever", CacheModule.ROOT_CACHE_RETRIEVER).PropertyValue("Privileged", true).GetInstance(); RootCache rootCacheProxy = ProxyFactory.CreateProxy <RootCache>(threadLocalRootCacheInterceptor); beanContextFactory.RegisterExternalBean(CacheModule.COMMITTED_ROOT_CACHE, rootCacheProxy).Autowireable <RootCache>(); } beanContextFactory.RegisterBean <CacheEventTargetExtractor>("cacheEventTargetExtractor"); beanContextFactory.Link("cacheEventTargetExtractor").To <IEventTargetExtractorExtendable>().With(typeof(ICache)); beanContextFactory.RegisterBean <CacheFactory>().Autowireable <ICacheFactory>(); IInterceptor cacheProviderInterceptor = (IInterceptor)beanContextFactory .RegisterBean <CacheProviderInterceptor>("cacheProviderInterceptor") .Autowireable(typeof(ICacheProviderExtendable), typeof(ICacheProvider), typeof(ICacheContext)).GetInstance(); ICache cacheProxy = ProxyFactory.CreateProxy <ICache>(new Type[] { typeof(ICacheProvider), typeof(IWritableCache) }, cacheProviderInterceptor); beanContextFactory.RegisterExternalBean("cache", cacheProxy).Autowireable <ICache>(); beanContextFactory.RegisterBean <PagingQueryServiceResultProcessor>("pagingQuerySRP"); beanContextFactory.Link("pagingQuerySRP").To <IServiceResultProcessorExtendable>().With(typeof(IPagingResponse)); beanContextFactory.RegisterBean <CacheProvider>(CacheNamedBeans.CacheProviderSingleton).PropertyValue("CacheType", CacheType.SINGLETON); beanContextFactory.RegisterBean <CacheProvider>(CacheNamedBeans.CacheProviderThreadLocal).PropertyValue("CacheType", CacheType.THREAD_LOCAL); beanContextFactory.RegisterBean <CacheProvider>(CacheNamedBeans.CacheProviderPrototype).PropertyValue("CacheType", CacheType.PROTOTYPE); String defaultCacheProviderBeanName; switch (DefaultCacheType) { case CacheType.PROTOTYPE: { defaultCacheProviderBeanName = CacheNamedBeans.CacheProviderPrototype; break; } case CacheType.SINGLETON: { defaultCacheProviderBeanName = CacheNamedBeans.CacheProviderSingleton; break; } case CacheType.THREAD_LOCAL: { defaultCacheProviderBeanName = CacheNamedBeans.CacheProviderThreadLocal; break; } case CacheType.DEFAULT: { defaultCacheProviderBeanName = CacheNamedBeans.CacheProviderThreadLocal; break; } default: throw new Exception("Not supported type: " + DefaultCacheType); } beanContextFactory.Link(defaultCacheProviderBeanName).To <ICacheProviderExtendable>(); // CacheContextPostProcessor must be registered AFTER CachePostProcessor... Object cachePostProcessor = beanContextFactory.RegisterBean <CachePostProcessor>().GetInstance(); beanContextFactory.RegisterBean <CacheContextPostProcessor>().PropertyValue("CachePostProcessor", cachePostProcessor); if (IsNetworkClientMode && IsCacheServiceBeanActive) { IBeanConfiguration remoteCacheService = beanContextFactory.RegisterBean <ClientServiceBean>(CacheModule.EXTERNAL_CACHE_SERVICE) .PropertyValue("Interface", typeof(ICacheService)) .PropertyValue("SyncRemoteInterface", typeof(ICacheServiceWCF)) .PropertyValue("AsyncRemoteInterface", typeof(ICacheClient)).Autowireable <ICacheService>(); beanContextFactory.RegisterAlias(CacheModule.DEFAULT_CACHE_RETRIEVER, CacheModule.EXTERNAL_CACHE_SERVICE); // register to all entities in a "most-weak" manner beanContextFactory.Link(remoteCacheService).To <ICacheRetrieverExtendable>().With(typeof(Object)); //beanContextFactory.RegisterAlias(CacheModule.ROOT_CACHE_RETRIEVER, CacheModule.EXTERNAL_CACHE_SERVICE); //beanContextFactory.registerBean<CacheServiceDelegate>("cacheService").autowireable<ICacheService>(); } beanContextFactory.RegisterBean <DataObjectMixin>().Autowireable <DataObjectMixin>(); beanContextFactory.RegisterBean <EntityEqualsMixin>().Autowireable <EntityEqualsMixin>(); beanContextFactory.RegisterBean <EmbeddedTypeMixin>().Autowireable <EmbeddedTypeMixin>(); beanContextFactory.RegisterBean <PropertyChangeMixin>().Autowireable(typeof(PropertyChangeMixin), typeof(IPropertyChangeExtensionExtendable), typeof(ICollectionChangeExtensionExtendable)); beanContextFactory.RegisterBean <ValueHolderContainerMixin>().Autowireable <ValueHolderContainerMixin>(); }
/// <summary> /// Begin a new transaction with the given transaction definition. /// </summary> /// <param name="transaction"> /// Transaction object returned by /// <see cref="Spring.Transaction.Support.AbstractPlatformTransactionManager.DoGetTransaction"/>. /// </param> /// <param name="definition"> /// <see cref="Spring.Transaction.ITransactionDefinition"/> instance, describing /// propagation behavior, isolation level, timeout etc. /// </param> /// <remarks> /// Does not have to care about applying the propagation behavior, /// as this has already been handled by this abstract manager. /// </remarks> /// <exception cref="Spring.Transaction.TransactionException"> /// In the case of creation or system errors. /// </exception> protected override void DoBegin(object transaction, ITransactionDefinition definition) { TxScopeTransactionManager.PromotableTxScopeTransactionObject promotableTxScopeTransactionObject = ((HibernateTransactionObject)transaction).PromotableTxScopeTransactionObject; try { DoTxScopeBegin(promotableTxScopeTransactionObject, definition); } catch (Exception e) { throw new CannotCreateTransactionException("Transaction Scope failure on begin", e); } HibernateTransactionObject txObject = (HibernateTransactionObject)transaction; if (DbProvider != null && TransactionSynchronizationManager.HasResource(DbProvider) && !txObject.ConnectionHolder.SynchronizedWithTransaction) { throw new IllegalTransactionStateException( "Pre-bound ADO.NET Connection found - HibernateTransactionManager does not support " + "running within AdoTransactionManager if told to manage the DbProvider itself. " + "It is recommended to use a single HibernateTransactionManager for all transactions " + "on a single DbProvider, no matter whether Hibernate or ADO.NET access."); } ISession session = null; try { if (txObject.SessionHolder == null || txObject.SessionHolder.SynchronizedWithTransaction) { IInterceptor interceptor = EntityInterceptor; ISession newSession = (interceptor != null ? SessionFactory.OpenSession(interceptor) : SessionFactory.OpenSession()); if (log.IsDebugEnabled) { log.Debug("Opened new Session [" + newSession + "] for Hibernate transaction"); } txObject.SetSessionHolder(new SessionHolder(newSession), true); } txObject.SessionHolder.SynchronizedWithTransaction = true; session = txObject.SessionHolder.Session; IDbConnection con = session.Connection; //TODO isolation level mgmt //IsolationLevel previousIsolationLevel = if (definition.ReadOnly && txObject.NewSessionHolder) { // Just set to NEVER in case of a new Session for this transaction. session.FlushMode = FlushMode.Never; } if (!definition.ReadOnly && !txObject.NewSessionHolder) { // We need AUTO or COMMIT for a non-read-only transaction. FlushMode flushMode = session.FlushMode; if (FlushMode.Never == flushMode) { session.FlushMode = FlushMode.Auto; txObject.SessionHolder.PreviousFlushMode = flushMode; } } // Add the Hibernate transaction to the session holder. // for now pass in tx options isolation level. ITransaction hibernateTx = session.BeginTransaction(definition.TransactionIsolationLevel); IDbTransaction adoTx = GetIDbTransaction(hibernateTx); // Add the Hibernate transaction to the session holder. txObject.SessionHolder.Transaction = hibernateTx; // Register transaction timeout. int timeout = DetermineTimeout(definition); if (timeout != DefaultTransactionDefinition.TIMEOUT_DEFAULT) { txObject.SessionHolder.TimeoutInSeconds = timeout; } // Register the Hibernate Session's ADO.NET Connection/TX pair for the DbProvider, if set. if (DbProvider != null) { //investigate passing null for tx. ConnectionHolder conHolder = new ConnectionHolder(con, adoTx); if (timeout != DefaultTransactionDefinition.TIMEOUT_DEFAULT) { conHolder.TimeoutInSeconds = timeout; } if (log.IsDebugEnabled) { log.Debug("Exposing Hibernate transaction as ADO transaction [" + con + "]"); } TransactionSynchronizationManager.BindResource(DbProvider, conHolder); txObject.ConnectionHolder = conHolder; } // Bind the session holder to the thread. if (txObject.NewSessionHolder) { TransactionSynchronizationManager.BindResource(SessionFactory, txObject.SessionHolder); } } catch (Exception ex) { SessionFactoryUtils.CloseSession(session); throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex); } }
/// <summary> /// Initializes a new instance of the <see cref="AbstractBatcher"/> class. /// </summary> /// <param name="connectionManager">The <see cref="ConnectionManager"/> owning this batcher.</param> /// <param name="interceptor"></param> protected AbstractBatcher(ConnectionManager connectionManager, IInterceptor interceptor) { this.connectionManager = connectionManager; this.interceptor = interceptor; factory = connectionManager.Factory; }
public SessionFactoryImpl(Configuration cfg, IMapping mapping, Settings settings, EventListeners listeners) { Init(); log.Info("building session factory"); properties = new Dictionary <string, string>(cfg.Properties); interceptor = cfg.Interceptor; this.settings = settings; sqlFunctionRegistry = new SQLFunctionRegistry(settings.Dialect, cfg.SqlFunctions); eventListeners = listeners; filters = new Dictionary <string, FilterDefinition>(cfg.FilterDefinitions); if (log.IsDebugEnabled) { log.Debug("Session factory constructed with filter configurations : " + CollectionPrinter.ToString(filters)); } if (log.IsDebugEnabled) { log.Debug("instantiating session factory with properties: " + CollectionPrinter.ToString(properties)); } try { if (settings.IsKeywordsImportEnabled) { SchemaMetadataUpdater.Update(this); } if (settings.IsAutoQuoteEnabled) { SchemaMetadataUpdater.QuoteTableAndColumns(cfg); } } catch (NotSupportedException) { // Ignore if the Dialect does not provide DataBaseSchema } #region Caches settings.CacheProvider.Start(properties); #endregion #region Generators identifierGenerators = new Dictionary <string, IIdentifierGenerator>(); foreach (PersistentClass model in cfg.ClassMappings) { if (!model.IsInherited) { IIdentifierGenerator generator = model.Identifier.CreateIdentifierGenerator(settings.Dialect, settings.DefaultCatalogName, settings.DefaultSchemaName, (RootClass)model); identifierGenerators[model.EntityName] = generator; } } #endregion #region Persisters Dictionary <string, ICacheConcurrencyStrategy> caches = new Dictionary <string, ICacheConcurrencyStrategy>(); entityPersisters = new Dictionary <string, IEntityPersister>(); implementorToEntityName = new Dictionary <System.Type, string>(); Dictionary <string, IClassMetadata> classMeta = new Dictionary <string, IClassMetadata>(); foreach (PersistentClass model in cfg.ClassMappings) { model.PrepareTemporaryTables(mapping, settings.Dialect); string cacheRegion = model.RootClazz.CacheRegionName; ICacheConcurrencyStrategy cache; if (!caches.TryGetValue(cacheRegion, out cache)) { cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, cacheRegion, model.IsMutable, settings, properties); if (cache != null) { caches.Add(cacheRegion, cache); if (!allCacheRegions.TryAdd(cache.RegionName, cache.Cache)) { throw new HibernateException("An item with the same key has already been added to allCacheRegions."); } } } IEntityPersister cp = PersisterFactory.CreateClassPersister(model, cache, this, mapping); entityPersisters[model.EntityName] = cp; classMeta[model.EntityName] = cp.ClassMetadata; if (model.HasPocoRepresentation) { implementorToEntityName[model.MappedClass] = model.EntityName; } } classMetadata = new UnmodifiableDictionary <string, IClassMetadata>(classMeta); Dictionary <string, ISet <string> > tmpEntityToCollectionRoleMap = new Dictionary <string, ISet <string> >(); collectionPersisters = new Dictionary <string, ICollectionPersister>(); foreach (Mapping.Collection model in cfg.CollectionMappings) { ICacheConcurrencyStrategy cache = CacheFactory.CreateCache(model.CacheConcurrencyStrategy, model.CacheRegionName, model.Owner.IsMutable, settings, properties); if (cache != null) { allCacheRegions[cache.RegionName] = cache.Cache; } ICollectionPersister persister = PersisterFactory.CreateCollectionPersister(cfg, model, cache, this); collectionPersisters[model.Role] = persister; IType indexType = persister.IndexType; if (indexType != null && indexType.IsAssociationType && !indexType.IsAnyType) { string entityName = ((IAssociationType)indexType).GetAssociatedEntityName(this); ISet <string> roles; if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles)) { roles = new HashSet <string>(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } IType elementType = persister.ElementType; if (elementType.IsAssociationType && !elementType.IsAnyType) { string entityName = ((IAssociationType)elementType).GetAssociatedEntityName(this); ISet <string> roles; if (!tmpEntityToCollectionRoleMap.TryGetValue(entityName, out roles)) { roles = new HashSet <string>(); tmpEntityToCollectionRoleMap[entityName] = roles; } roles.Add(persister.Role); } } Dictionary <string, ICollectionMetadata> tmpcollectionMetadata = new Dictionary <string, ICollectionMetadata>(collectionPersisters.Count); foreach (KeyValuePair <string, ICollectionPersister> collectionPersister in collectionPersisters) { tmpcollectionMetadata.Add(collectionPersister.Key, collectionPersister.Value.CollectionMetadata); } collectionMetadata = new UnmodifiableDictionary <string, ICollectionMetadata>(tmpcollectionMetadata); collectionRolesByEntityParticipant = new UnmodifiableDictionary <string, ISet <string> >(tmpEntityToCollectionRoleMap); #endregion #region Named Queries namedQueries = new Dictionary <string, NamedQueryDefinition>(cfg.NamedQueries); namedSqlQueries = new Dictionary <string, NamedSQLQueryDefinition>(cfg.NamedSQLQueries); sqlResultSetMappings = new Dictionary <string, ResultSetMappingDefinition>(cfg.SqlResultSetMappings); #endregion imports = new Dictionary <string, string>(cfg.Imports); #region after *all* persisters and named queries are registered foreach (IEntityPersister persister in entityPersisters.Values) { persister.PostInstantiate(); } foreach (ICollectionPersister persister in collectionPersisters.Values) { persister.PostInstantiate(); } #endregion #region Serialization info name = settings.SessionFactoryName; try { uuid = (string)UuidGenerator.Generate(null, null); } catch (Exception) { throw new AssertionFailure("Could not generate UUID"); } SessionFactoryObjectFactory.AddInstance(uuid, name, this, properties); #endregion log.Debug("Instantiated session factory"); #region Schema management if (settings.IsAutoCreateSchema) { new SchemaExport(cfg).Create(false, true); } if (settings.IsAutoUpdateSchema) { new SchemaUpdate(cfg).Execute(false, true); } if (settings.IsAutoValidateSchema) { new SchemaValidator(cfg, settings).Validate(); } if (settings.IsAutoDropSchema) { schemaExport = new SchemaExport(cfg); } #endregion #region Obtaining TransactionManager // not ported yet #endregion currentSessionContext = BuildCurrentSessionContext(); if (settings.IsQueryCacheEnabled) { updateTimestampsCache = new UpdateTimestampsCache(settings, properties); queryCache = settings.QueryCacheFactory.GetQueryCache(null, updateTimestampsCache, settings, properties); queryCaches = new ConcurrentDictionary <string, IQueryCache>(); } else { updateTimestampsCache = null; queryCache = null; queryCaches = null; } #region Checking for named queries if (settings.IsNamedQueryStartupCheckingEnabled) { IDictionary <string, HibernateException> errors = CheckNamedQueries(); if (errors.Count > 0) { StringBuilder failingQueries = new StringBuilder("Errors in named queries: "); foreach (KeyValuePair <string, HibernateException> pair in errors) { failingQueries.Append('{').Append(pair.Key).Append('}'); log.Error("Error in named query: " + pair.Key, pair.Value); } throw new HibernateException(failingQueries.ToString()); } } #endregion Statistics.IsStatisticsEnabled = settings.IsStatisticsEnabled; // EntityNotFoundDelegate IEntityNotFoundDelegate enfd = cfg.EntityNotFoundDelegate; if (enfd == null) { enfd = new DefaultEntityNotFoundDelegate(); } entityNotFoundDelegate = enfd; }
protected virtual ISession OpenSession(IInterceptor sessionLocalInterceptor) { lastOpenedSession = sessions.OpenSession(sessionLocalInterceptor); return(lastOpenedSession); }
private SessionImpl OpenSession(IDbConnection connection, bool autoClose, long timestamp, IInterceptor sessionLocalInterceptor) { #pragma warning disable 618 var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled; #pragma warning restore 618 SessionImpl session = new SessionImpl(connection, this, autoClose, timestamp, sessionLocalInterceptor ?? interceptor, settings.DefaultEntityMode, settings.IsFlushBeforeCompletionEnabled, settings.IsAutoCloseSessionEnabled, isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled, settings.ConnectionReleaseMode, settings.DefaultFlushMode); if (sessionLocalInterceptor != null) { // NH specific feature sessionLocalInterceptor.SetSession(session); } return(session); }
public TReturn Get <TQuery, TReturn>(Func <IQueryable <TQuery>, TReturn> query, IInterceptor queryInterceptor, bool stateless = true) where TQuery : class { TReturn result; if (stateless) { using (var session = _sessionFactory.OpenStatelessSession()) { result = query.Invoke(session.Query <TQuery>()); } } else { using (var session = _sessionFactory.OpenSession(queryInterceptor)) { result = query.Invoke(session.Query <TQuery>()); } } return(result); }
/// <summary> /// Initialize a new instance of <see cref="SessionPerConversationScopeSettings"/> with the given values and references. /// </summary> /// <param name="entityInterceptor"> /// Specify the <see cref="IInterceptor"/> to be set on each session provided by the <see cref="SessionPerConversationScope"/> instance. /// </param> /// <param name="defaultFlushMode"> /// Specify the flushmode to be applied on each session provided by the <see cref="SessionScope"/> instance. /// </param> /// <remarks> /// Calling this constructor marks all properties initialized. /// </remarks> public SessionPerConversationScopeSettings(IInterceptor entityInterceptor, FlushMode defaultFlushMode) { this.entityInterceptor = entityInterceptor; this.defaultFlushMode = defaultFlushMode; }
public List <T> Get <T>(Func <IQueryable <T>, List <T> > query, IInterceptor queryInterceptor, bool stateless = true) where T : class { return(Get <T, List <T> >(query, queryInterceptor, stateless)); }
/// <summary> /// Initialize a new instance of <see cref="SessionScopeSettings"/> with default values. /// </summary> /// <remarks> /// Calling this constructor from your derived class leaves <see cref="EntityInterceptor"/> /// uninitialized. See <see cref="ResolveEntityInterceptor"/> for more. /// </remarks> public SessionPerConversationScopeSettings() { this.entityInterceptor = null; this.defaultFlushMode = FLUSHMODE_DEFAULT; }
public object Adapt(object value, IInterceptor interceptor) { return(_inner.Adapt(value, interceptor)); }
/// <summary> /// Allows you to set the interceptor which will be used in all subsequent sessions /// </summary> public void RegisterInterceptor(IInterceptor interceptor) { Check.Require(interceptor != null, "interceptor may not be null"); _registeredInterceptor = interceptor; }
public MyUserServiceProxy(User user, IInterceptor interceptor) { _user = user; _interceptor = interceptor; }
ISessionBuilder ISessionBuilder <ISessionBuilder> .Interceptor(IInterceptor interceptor) { _actualBuilder.Interceptor(interceptor); return(this); }
public NHibernateConfig AddInterceptor(IInterceptor interceptor) { interceptors.Add(interceptor); return(this); }
public ExampleInstaller(IInterceptor interceptor) { this.interceptor = Maybe.Some(interceptor); }
public void AddChild(IInterceptor interceptor) { _childs.Add(interceptor); }
private static ISession DoGetSession( ISessionFactory sessionFactory, IInterceptor entityInterceptor, IAdoExceptionTranslator adoExceptionTranslator, bool allowCreate) { AssertUtils.ArgumentNotNull(sessionFactory, "sessionFactory", "SessionFactory can not be null"); SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.GetResource(sessionFactory); if (sessionHolder != null && !sessionHolder.IsEmpty) { // pre-bound Hibernate Session ISession session = null; if (TransactionSynchronizationManager.SynchronizationActive && sessionHolder.DoesNotHoldNonDefaultSession) { // Spring transaction management is active -> // register pre-bound Session with it for transactional flushing. session = sessionHolder.ValidatedSession; if (!sessionHolder.SynchronizedWithTransaction) { log.Debug("Registering Spring transaction synchronization for existing Hibernate Session"); TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(sessionHolder, sessionFactory, adoExceptionTranslator, false)); sessionHolder.SynchronizedWithTransaction = true; // Switch to FlushMode.AUTO if we're not within a read-only transaction. FlushMode flushMode = session.FlushMode; if (FlushMode.Never == flushMode && !TransactionSynchronizationManager.CurrentTransactionReadOnly) { session.FlushMode = FlushMode.Auto; sessionHolder.PreviousFlushMode = flushMode; } } } else { // No Spring transaction management active -> simply return default thread-bound Session, if any // (possibly from OpenSessionInViewModule) session = sessionHolder.ValidatedSession; } if (session != null) { return(session); } } ISession sess = OpenSession(sessionFactory, entityInterceptor); // Set Session to FlushMode.Never if we're within a read-only transaction. // Use same Session for further Hibernate actions within the transaction. // Thread object will get removed by synchronization at transaction completion. if (TransactionSynchronizationManager.SynchronizationActive) { log.Debug("Registering Spring transaction synchronization for new Hibernate Session"); SessionHolder holderToUse = sessionHolder; if (holderToUse == null) { holderToUse = new SessionHolder(sess); } else { holderToUse.AddSession(sess); } if (TransactionSynchronizationManager.CurrentTransactionReadOnly) { sess.FlushMode = FlushMode.Never; } TransactionSynchronizationManager.RegisterSynchronization( new SpringSessionSynchronization(holderToUse, sessionFactory, adoExceptionTranslator, true)); holderToUse.SynchronizedWithTransaction = true; if (holderToUse != sessionHolder) { TransactionSynchronizationManager.BindResource(sessionFactory, holderToUse); } } // Check whether we are allowed to return the Session. if (!allowCreate && !IsSessionTransactional(sess, sessionFactory)) { CloseSession(sess); throw new InvalidOperationException("No Hibernate Session bound to thread, " + "and configuration does not allow creation of non-transactional one here"); } return(sess); }