protected virtual void Dispose(bool disposing)
{
if (Disposed)
{
return;
}
if (disposing)
{
if (EventListeners.Count != 0)
{
EventListeners.Dispose();
if (_isDisposableType)
{
foreach (var unknown in CurrentCollection)
{
var i = (IDisposable)unknown;
i.Dispose();
}
}
CurrentCollection.Clear();
}
}
Disposed = true;
}
public void Register(EventListeners eventListeners)
{
foreach (IEventHandler handler in this.handlers)
{
handler.Register(eventListeners);
}
}
private static void AddListenerInternal(string messageName, GameObject lifecycleObject, Delegate handler)
{
#if LOG_ADD_LISTENER
Debug.Log(string.Format("MESSENGER add listener {0} at {1}", handler, messageName), lifecycleObject);
#endif
// don't add dead listeners
if (lifecycleObject == null)
{
return;
}
// prepare
if (!eventTable.ContainsKey(messageName))
{
eventTable[messageName] = new EventListeners();
}
// add
eventTable[messageName].Listeners.Add(new ListenerLifecyclePair()
{
Listener = handler,
LifecycleObject = lifecycleObject,
});
}
/**
* Create an audit reader associated with an open session.
* @param session An open session.
* @return An audit reader associated with the given sesison. It shouldn't be used
* after the session is closed.
* @throws AuditException When the given required listeners aren't installed.
*/
public static IAuditReader Get(ISession session)
{
ISessionImplementor sessionImpl;
if (!(session is ISessionImplementor))
{
sessionImpl = (ISessionImplementor)session.SessionFactory.GetCurrentSession();
}
else
{
sessionImpl = (ISessionImplementor)session;
}
EventListeners listeners = sessionImpl.Listeners;
foreach (IPostInsertEventListener listener in listeners.PostInsertEventListeners)
{
if (listener is AuditEventListener)
{
if (ArraysTools.ArrayIncludesInstanceOf(listeners.PostUpdateEventListeners, typeof(AuditEventListener)) &&
ArraysTools.ArrayIncludesInstanceOf(listeners.PostDeleteEventListeners, typeof(AuditEventListener)))
{
return(new AuditReader(((AuditEventListener)listener).getVerCfg(), session,
sessionImpl));
}
}
}
throw new AuditException("You need to install the org.hibernate.envers.event.AuditEventListener " +
"class as post insert, update and delete event listener.");
}
public static EventListener CreateEventListener(ConsoleOptions options)
{
var eventListeners = new List <EventListener>();
if (options.HasStoryOutput)
{
eventListeners.Add(EventListeners.FileOutputEventListener(options.StoryOutput));
}
if (options.HasStoryXmlOutput)
{
eventListeners.Add(EventListeners.XmlWriterEventListener(options.Xml));
}
if (options.Console)
{
eventListeners.Add(EventListeners.ColorfulConsoleOutputEventListener());
}
if (eventListeners.Count == 0)
{
eventListeners.Add(EventListeners.ColorfulConsoleOutputEventListener());
}
if (options.Codegen)
{
eventListeners.Add(EventListeners.CodeGenEventListener(System.Console.Out));
}
return(new MultiOutputEventListener(eventListeners.ToArray()));
}
public FormViewModel(Form model)
{
Model = model;
Name = Model.Name;
Title = Model.Title;
EventListeners.AddRange(Model.EventListeners);
RootElement = FormElementViewModelFactory.CreateComposite(Model.RootElement);
EventListeners.CollectionChanged += EventListenersOnCollectionChanged;
}
public void addEventListener(String Event, object function)
{
System.Diagnostics.Debug.WriteLine(String.Format("addEventListener(Event = {0}, Function = {1})", Event, function.ToString()));
if (EventListeners.ContainsKey(Event))
{
EventListeners.Remove(Event);
}
EventListeners.Add(Event, function);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this.gameObject);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawAreaCircle"/> class.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="cx">The cx.</param>
/// <param name="cy">The cy.</param>
/// <param name="radius">The radius.</param>
/// <param name="listeners">The listeners.</param>
public DrawAreaCircle(IDocument document,
string cx, string cy, string radius, EventListeners listeners)
: base(document)
{
this.CX = cx;
this.CY = cy;
this.Radius = radius;
if (listeners != null)
{
this.Content.Add(listeners);
}
}
private static void PurgeDeadListeners(EventListeners l)
{
var listeners = l.Listeners;
for (int i = 0; i < listeners.Count; ++i)
{
if (listeners[i].LifecycleObject == null)
{
// dead listener found -> remove
listeners.RemoveAt(i);
--i;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawAreaRectangle"/> class.
/// </summary>
/// <param name="document">The document.</param>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="listeners">The listeners.</param>
public DrawAreaRectangle(IDocument document,
string x, string y, string width, string height,
EventListeners listeners)
: base(document)
{
this.X = x;
this.Y = y;
this.Width = width;
this.Height = height;
if (listeners != null)
{
this.Content.Add(listeners);
}
}
public static NHibernate.Cfg.Configuration RegisterEntityNameResolver(this NHibernate.Cfg.Configuration configuration)
{
EventListeners listeners = configuration.EventListeners;
var entityNameResolver = new EntityNameResolver();
listeners.MergeEventListeners =
new[] { entityNameResolver }.Concat(listeners.MergeEventListeners).ToArray();
listeners.UpdateEventListeners =
new[] { entityNameResolver }.Concat(listeners.UpdateEventListeners).ToArray();
listeners.SaveOrUpdateEventListeners =
new[] { entityNameResolver }.Concat(listeners.SaveOrUpdateEventListeners).ToArray();
listeners.SaveEventListeners =
new[] { entityNameResolver }.Concat(listeners.SaveEventListeners).ToArray();
listeners.PersistEventListeners =
new[] { entityNameResolver }.Concat(listeners.PersistEventListeners).ToArray();
configuration.Interceptor = new EntityNameInterceptor();
return(configuration);
}
public void FrameWriteTest()
{
try
{
TextDocument textdocument = new TextDocument();
textdocument.New();
// Create a frame incl. graphic file
Frame frame = FrameBuilder.BuildStandardGraphicFrame(
textdocument, "frame1", "graphic1", _imagefile);
// Create some event listeners (using OpenOffice friendly syntax).
EventListener script1 = new EventListener(textdocument,
"dom:mouseover", "javascript",
"vnd.sun.star.script:HelloWorld.helloworld.js?language=JavaScript&location=share");
EventListener script2 = new EventListener(textdocument,
"dom:mouseout", "javascript",
"vnd.sun.star.script:HelloWorld.helloworld.js?language=JavaScript&location=share");
EventListeners listeners = new EventListeners(textdocument, new EventListener[] { script1, script2 });
// Create and add some area rectangles
DrawAreaRectangle[] rects = new DrawAreaRectangle[2];
rects[0] = new DrawAreaRectangle(textdocument, "4cm", "4cm", "2cm", "2cm");
rects[0].Href = @"http://www.eduworks.com";
rects[1] = new DrawAreaRectangle(textdocument, "1cm", "1cm", "2cm", "2cm", listeners);
// Create and add an image map, referencing the area rectangles
ImageMap map = new ImageMap(textdocument, rects);
frame.Content.Add(map);
// Add the frame to the text document
textdocument.Content.Add(frame);
// Save the document
textdocument.SaveTo(_framefile3);
textdocument.Dispose();
}
catch (Exception ex)
{
//Console.Write(ex.Message);
}
}
public void EventListenerTest()
{
try
{
TextDocument textdocument = new TextDocument();
textdocument.New();
// Create a frame (GraphicName == name property of frame)
Frame frame = new Frame(textdocument, "frame1", "img1", _imagefile);
// Create some event listeners (using OpenOffice friendly syntax).
EventListener script1 = new EventListener(textdocument,
"dom:mouseover", "javascript",
"vnd.sun.star.script:HelloWorld.helloworld.js?language=JavaScript&location=share");
EventListener script2 = new EventListener(textdocument,
"dom:mouseout", "javascript",
"vnd.sun.star.script:HelloWorld.helloworld.js?language=JavaScript&location=share");
EventListeners listeners = new EventListeners(textdocument, new EventListener[] { script1, script2 });
// Create and add some area rectangles; reuse event listeners
DrawAreaRectangle[] rects = new DrawAreaRectangle[2];
rects[0] = new DrawAreaRectangle(textdocument, "4cm", "4cm", "2cm", "2cm", listeners);
//Reuse a clone of the EventListener
rects[1] = new DrawAreaRectangle(textdocument, "1cm", "1cm", "2cm", "2cm", (EventListeners)listeners.Clone());
// Create and add an image map, referencing the area rectangles
ImageMap map = new ImageMap(textdocument, rects);
frame.Content.Add(map);
// Add the frame to the text document
textdocument.Content.Add(frame);
// Save the document
textdocument.SaveTo(_framefile);
textdocument.Dispose();
}
catch (Exception ex)
{
//Console.Write(ex.Message);
}
}
public bool _LoadTextureResource(TPF tex, int index, AccessLevel al, GameType type)
{
lock (LoadingLock)
{
if (IsLoaded)
{
Unload();
}
AccessLevel = AccessLevel.AccessLoading;
Resource = new TextureResource(tex, index);
Resource._LoadTexture(al);
// Prevent any new completion handlers from being added while executing them all
// Any subsequent pending handlers will be executed after this is done
WeakReference <IResourceEventListener>[] listeners;
lock (HandlerLock)
{
IsLoaded = true;
listeners = EventListeners.ToArray();
}
foreach (var listener in listeners)
{
try
{
IResourceEventListener l;
bool succ = listener.TryGetTarget(out l);
if (succ)
{
l.OnResourceLoaded(this);
}
}
catch (Exception e)
{
System.Console.WriteLine("blah");
}
}
AccessLevel = al;
}
return(true);
}
public override bool Execute()
{
if (TestAssemblies.Length == 0)
{
throw new ArgumentException("At least one test assembly is required");
}
var logString = new StringBuilder();
TextWriter msbuildLogWriter = new StringWriter(logString);
var output = new PlainTextOutput(msbuildLogWriter);
WriteHeaderInto(output);
var config = NBehaveConfiguration.New
.DontIsolateInAppDomain()
.SetScenarioFiles(ScenarioFiles)
.SetDryRun(DryRun)
.SetAssemblies(TestAssemblies)
.SetEventListener(EventListeners.CreateEventListenerUsing(msbuildLogWriter, TextOutputFile, XmlOutputFile));
var runner = RunnerFactory.CreateTextRunner(config);
FeatureResults = runner.Run();
if (DryRun)
{
return(true);
}
var message = logString.ToString();
Log.LogMessage(message);
if (FailBuild && FailBuildBasedOn(FeatureResults))
{
return(false);
}
return(true);
}
public void Start(TflProcess process)
{
if (_started)
{
return;
}
_started = true;
Name = process.Name;
foreach (var log in process.Log)
{
switch (log.Provider)
{
case "file":
log.Folder = log.Folder.Replace('/', '\\');
log.File = log.File.Replace('/', '\\');
log.Folder = (log.Folder.Equals(Common.DefaultValue) ? "logs" : log.Folder).TrimEnd('\\') + "\\";
log.File = (log.File.Equals(Common.DefaultValue) ? "tfl-" + process.Name + ".log" : log.File).TrimStart('\\');
var fileListener = new ObservableEventListener();
fileListener.EnableEvents(TflEventSource.Log, (EventLevel)Enum.Parse(typeof(EventLevel), log.Level));
SinkSubscriptions.Add(fileListener.LogToRollingFlatFile(log.Folder + log.File, 5000, "yyyy-MM-dd", RollFileExistsBehavior.Increment, RollInterval.Day, new LegacyLogFormatter(), 0, log.Async));
EventListeners.Add(fileListener);
break;
case "mail":
if (log.Subject.Equals(Common.DefaultValue))
{
log.Subject = process.Name + " " + log.Level;
}
var mailListener = new ObservableEventListener();
mailListener.EnableEvents(TflEventSource.Log, EventLevel.Error);
SinkSubscriptions.Add(mailListener.LogToEmail(log));
EventListeners.Add(mailListener);
break;
}
}
}
public static Configuration RegisterDisableAutoDirtyCheckListeners(this Configuration configuration)
{
EventListeners listeners = configuration.EventListeners;
var readOnlyEntityListener = new ResetReadOnlyEntityListener();
var readOnlyEntityLoadListener = new SetReadOnlyEntityPostLoadListener();
listeners.PersistEventListeners =
new[] { readOnlyEntityListener }.Concat(listeners.PersistEventListeners).ToArray();
listeners.MergeEventListeners =
new[] { readOnlyEntityListener }.Concat(listeners.MergeEventListeners).ToArray();
listeners.UpdateEventListeners =
new[] { readOnlyEntityListener }.Concat(listeners.UpdateEventListeners).ToArray();
listeners.SaveOrUpdateEventListeners =
new[] { readOnlyEntityListener }.Concat(listeners.SaveOrUpdateEventListeners).ToArray();
listeners.DeleteEventListeners =
new[] { new ResetReadOnlyEntityDeleteListener() }.Concat(listeners.DeleteEventListeners).ToArray();
listeners.PostLoadEventListeners =
new[] { readOnlyEntityLoadListener }.Concat(listeners.PostLoadEventListeners).ToArray();
listeners.LockEventListeners =
listeners.LockEventListeners.Concat(new[] { readOnlyEntityLoadListener }).ToArray();
return(configuration);
}
protected override void ExecuteTask()
{
if (TestAssemblies.FileNames.Count == 0)
{
throw new BuildException("At least one test assembly is required");
}
var nantLogWriter = new LogWriter(this, Level.Info, CultureInfo.InvariantCulture);
var output = new PlainTextOutput(nantLogWriter);
WriteHeaderInto(output);
var listener = EventListeners.CreateEventListenerUsing(nantLogWriter,
TextOutputFile,
XmlOutputFile);
var runner = NBehaveConfiguration
.New
.SetDryRun(DryRun)
.SetScenarioFiles(ScenarioFiles.FileNames.Cast <string>().ToList())
.SetAssemblies(TestAssemblies.FileNames.Cast <string>().ToList())
.SetEventListener(listener)
.Build();
var results = runner.Run();
if (DryRun)
{
return;
}
if (FailBuild)
{
FailBuildBasedOn(results);
}
}
/// <summary>
/// Validate if all listeners are properly registered, if a listener
/// is properly setup, copy its non-replay counterpart's settings over to the
/// replay listener.
/// </summary>
protected virtual void ValidateReplayListeners()
{
if (EventListeners.Count != ReplayListeners.Count)
{
Logger.LogCritical("Amount of Event listeners is not equal to the amount of Replay listeners");
throw new BusConfigurationException(
$"There are {EventListeners.Count} event listeners but {ReplayListeners.Count} replay listeners");
}
foreach (MicroserviceReplayListener listener in ReplayListeners)
{
MicroserviceListener normalListener = EventListeners.Find(e => listener.Queue == e.Queue);
if (normalListener == null)
{
Logger.LogCritical($"ReplayListener of {listener.Queue} has no non-replay counterpart.");
throw new BusConfigurationException($"ReplayListener of {listener.Queue} has no non-replay counterpart.");
}
Logger.LogDebug($"Applying configuration of listener for queue {listener.Queue} to replay listener");
listener.ApplyListenerSettings(normalListener);
}
}
public void Scenario(TestExecution testExecution)
{
var featureBuilder = new StringBuilder();
featureBuilder.AppendLine(string.Format(SCENARIO_FORMAT, testExecution.Summary, testExecution.IssueKey));
string description = Regex.Replace(testExecution.IssueDescription, HTML_TAG_PATTERN, "");
description = description.Substring(0, description.IndexOf(END_OF_TEST));
featureBuilder.AppendLine(description);
List <IEventListener> eventListeners = new List <IEventListener>();
eventListeners.Add(EventListeners.ColorfulConsoleOutputEventListener());
eventListeners.Add(new LoggingStoryReporter());
if (Settings.UpdateExecutionStatus)
{
eventListeners.Add(new ZapiStoryReporter(ZapiClient, testExecution.Id, Settings.PassExecutionStatus, Settings.FailExecutionStatus, Settings.unexecutedStatus, Settings.workInProgress));
}
eventListeners.Add(new InconclusiveStoryReporter());
featureBuilder.ToString().ExecuteText(typeof(GeneralSteps).Assembly, eventListeners.ToArray());
}
/// <summary>
/// Initialize the SessionFactory for the given or the
/// default location.
/// </summary>
public virtual void AfterPropertiesSet()
{
// Create Configuration instance.
Configuration config = NewConfiguration();
if (this.dbProvider != null)
{
config.SetProperty(Environment.ConnectionString, dbProvider.ConnectionString);
config.SetProperty(Environment.ConnectionProvider, typeof(DbProviderWrapper).AssemblyQualifiedName);
configTimeDbProvider = this.dbProvider;
}
if (ExposeTransactionAwareSessionFactory)
{
// Set ICurrentSessionContext implementation,
// providing the Spring-managed ISession s current Session.
// Can be overridden by a custom value for the corresponding Hibernate property
// config.SetProperty(Environment.CurrentSessionContextClass, typeof(SpringSessionContext).AssemblyQualifiedName);
config.SetProperty(Environment.CurrentSessionContextClass, typeof(WcfOperationSessionContext).AssemblyQualifiedName);
}
if (this.entityInterceptor != null)
{
// Set given entity interceptor at SessionFactory level.
config.SetInterceptor(this.entityInterceptor);
}
if (this.namingStrategy != null)
{
// Pass given naming strategy to Hibernate Configuration.
config.SetNamingStrategy(this.namingStrategy);
}
if (this.filterDefinitions != null)
{
// Register specified NHibernate FilterDefinitions.
for (int i = 0; i < this.filterDefinitions.Length; i++)
{
config.AddFilterDefinition(this.filterDefinitions[i]);
}
}
if (this.hibernateProperties != null)
{
if (config.GetProperty(Environment.ConnectionProvider) != null &&
hibernateProperties.Contains(Environment.ConnectionProvider))
{
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Overriding use of Spring's Hibernate Connection Provider with [" +
hibernateProperties[Environment.ConnectionProvider] + "]");
}
#endregion
config.Properties.Remove(Environment.ConnectionProvider);
}
Dictionary <string, string> genericHibernateProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
genericHibernateProperties.Add((string)entry.Key, (string)entry.Value);
}
config.AddProperties(genericHibernateProperties);
}
if (this.mappingAssemblies != null)
{
foreach (string assemblyName in mappingAssemblies)
{
config.AddAssembly(assemblyName);
}
}
if (this.mappingResources != null)
{
IResourceLoader loader = this.ResourceLoader;
if (loader == null)
{
loader = this.applicationContext;
}
foreach (string resourceName in mappingResources)
{
config.AddInputStream(loader.GetResource(resourceName).InputStream);
}
}
if (configFilenames != null)
{
foreach (string configFilename in configFilenames)
{
config.Configure(configFilename);
}
}
if (this.eventListeners != null)
{
// Register specified NHibernate event listeners.
foreach (DictionaryEntry entry in eventListeners)
{
ListenerType listenerType;
try
{
listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), (string)entry.Key);
}
catch
{
throw new ArgumentException(string.Format("Unable to parse string '{0}' as valid {1}", entry.Key, typeof(ListenerType)));
}
object listenerObject = entry.Value;
if (listenerObject is ICollection)
{
ICollection listeners = (ICollection)listenerObject;
EventListeners listenerRegistry = config.EventListeners;
// create the array and check that types are valid at the same time
ArrayList items = new ArrayList(listeners);
object[] listenerArray = (object[])items.ToArray(listenerRegistry.GetListenerClassFor(listenerType));
config.SetListeners(listenerType, listenerArray);
}
else
{
config.SetListener(listenerType, listenerObject);
}
}
}
// Perform custom post-processing in subclasses.
PostProcessConfiguration(config);
// Build SessionFactory instance.
log.Info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = NewSessionFactory(config);
AfterSessionFactoryCreation();
// set config time DB provider back to null
configTimeDbProvider = null;
}
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);
allCacheRegions.Add(cache.RegionName, cache.Cache);
}
}
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 ThreadSafeDictionary <string, IQueryCache>(new Dictionary <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;
}
public abstract void Register(EventListeners eventListeners);
/// <summary>
/// Initialize the SessionFactory for the given or the
/// default location.
/// </summary>
public virtual void AfterPropertiesSet()
{
// Create Configuration instance.
Configuration config = NewConfiguration();
if (this.dbProvider != null)
{
config.SetProperty(Environment.ConnectionString, dbProvider.ConnectionString);
config.SetProperty(Environment.ConnectionProvider, typeof(DbProviderWrapper).AssemblyQualifiedName);
configTimeDbProvider = this.dbProvider;
}
if (ExposeTransactionAwareSessionFactory)
{
// Set ICurrentSessionContext implementation,
// providing the Spring-managed ISession s current Session.
// Can be overridden by a custom value for the corresponding Hibernate property
config.SetProperty(Environment.CurrentSessionContextClass, typeof(SpringSessionContext).AssemblyQualifiedName);
}
if (this.entityInterceptor != null)
{
// Set given entity interceptor at SessionFactory level.
config.SetInterceptor(this.entityInterceptor);
}
if (this.namingStrategy != null)
{
// Pass given naming strategy to Hibernate Configuration.
config.SetNamingStrategy(this.namingStrategy);
}
#if NH_2_1
if (this.typeDefinitions != null)
{
// Register specified Hibernate type definitions.
IDictionary <string, string> typedProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
typedProperties.Add((string)entry.Key, (string)entry.Value);
}
Dialect dialect = Dialect.GetDialect(typedProperties);
Mappings mappings = config.CreateMappings(dialect);
for (int i = 0; i < this.typeDefinitions.Length; i++)
{
IObjectDefinition typeDef = this.typeDefinitions[i];
Dictionary <string, string> typedParamMap = new Dictionary <string, string>();
foreach (DictionaryEntry entry in typeDef.PropertyValues)
{
typedParamMap.Add((string)entry.Key, (string)entry.Value);
}
mappings.AddTypeDef(typeDef.ObjectTypeName, typeDef.ObjectTypeName, typedParamMap);
}
}
#endif
if (this.filterDefinitions != null)
{
// Register specified NHibernate FilterDefinitions.
for (int i = 0; i < this.filterDefinitions.Length; i++)
{
config.AddFilterDefinition(this.filterDefinitions[i]);
}
}
#if NH_2_1
// check whether proxy factory has been initialized
if (config.GetProperty(Environment.ProxyFactoryFactoryClass) == null &&
(hibernateProperties == null || !hibernateProperties.Contains(Environment.ProxyFactoryFactoryClass)))
{
// nothing set by user, lets use Spring.NET's proxy factory factory
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Setting proxy factory to Spring provided one as user did not specify any");
}
#endregion
config.Properties.Add(
Environment.ProxyFactoryFactoryClass, typeof(Bytecode.ProxyFactoryFactory).AssemblyQualifiedName);
}
#endif
if (this.hibernateProperties != null)
{
if (config.GetProperty(Environment.ConnectionProvider) != null &&
hibernateProperties.Contains(Environment.ConnectionProvider))
{
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Overriding use of Spring's Hibernate Connection Provider with [" +
hibernateProperties[Environment.ConnectionProvider] + "]");
}
#endregion
config.Properties.Remove(Environment.ConnectionProvider);
}
Dictionary <string, string> genericHibernateProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
genericHibernateProperties.Add((string)entry.Key, (string)entry.Value);
}
config.AddProperties(genericHibernateProperties);
}
if (this.mappingAssemblies != null)
{
foreach (string assemblyName in mappingAssemblies)
{
config.AddAssembly(assemblyName);
}
}
if (this.mappingResources != null)
{
IResourceLoader loader = this.ResourceLoader;
if (loader == null)
{
loader = this.applicationContext;
}
foreach (string resourceName in mappingResources)
{
config.AddInputStream(loader.GetResource(resourceName).InputStream);
}
}
if (configFilenames != null)
{
foreach (string configFilename in configFilenames)
{
config.Configure(configFilename);
}
}
#if NH_2_1
// Tell Hibernate to eagerly compile the mappings that we registered,
// for availability of the mapping information in further processing.
PostProcessMappings(config);
config.BuildMappings();
if (this.entityCacheStrategies != null)
{
// Register cache strategies for mapped entities.
foreach (string className in this.entityCacheStrategies.Keys)
{
String[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.entityCacheStrategies.GetProperty(className));
if (strategyAndRegion.Length > 1)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0]);
}
}
}
if (this.collectionCacheStrategies != null)
{
// Register cache strategies for mapped collections.
foreach (string collRole in collectionCacheStrategies.Keys)
{
string[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.collectionCacheStrategies.GetProperty(collRole));
if (strategyAndRegion.Length > 1)
{
throw new Exception("Collection cache concurrency strategy region definition not supported yet");
//config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0]);
}
}
}
#endif
if (this.eventListeners != null)
{
// Register specified NHibernate event listeners.
foreach (DictionaryEntry entry in eventListeners)
{
ListenerType listenerType;
try
{
listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), (string)entry.Key);
}
catch
{
throw new ArgumentException(string.Format("Unable to parse string '{0}' as valid {1}", entry.Key, typeof(ListenerType)));
}
object listenerObject = entry.Value;
if (listenerObject is ICollection)
{
ICollection listeners = (ICollection)listenerObject;
EventListeners listenerRegistry = config.EventListeners;
// create the array and check that types are valid at the same time
ArrayList items = new ArrayList(listeners);
object[] listenerArray = (object[])items.ToArray(listenerRegistry.GetListenerClassFor(listenerType));
config.SetListeners(listenerType, listenerArray);
}
else
{
config.SetListener(listenerType, listenerObject);
}
}
}
// Perform custom post-processing in subclasses.
PostProcessConfiguration(config);
#if NH_2_1
if (BytecodeProvider != null)
{
// set custom IBytecodeProvider
Environment.BytecodeProvider = BytecodeProvider;
}
else
{
// use Spring's as default
// Environment.BytecodeProvider = new Bytecode.BytecodeProvider(this.applicationContext);
}
#endif
// Build SessionFactory instance.
log.Info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = NewSessionFactory(config);
AfterSessionFactoryCreation();
// set config time DB provider back to null
configTimeDbProvider = null;
}
/// <summary>
/// Register a listener for a specific event with topic expressions
/// </summary>
protected virtual void RegisterEventListener(TypeInfo type, MethodInfo method)
{
Logger.LogDebug($"Checking if method {method.Name} is a suitable event listener");
if (!IsMethodSuitableEvent(method, false))
{
Logger.LogCritical($"Method {method.Name} does not have a proper event listener signature in type {type.Name}");
throw new BusConfigurationException($"Method {method.Name} does not have a proper eventlistener signature in type {type.Name}");
}
Logger.LogDebug($"Evaluating parameter type {type.Name} of method {method.Name}");
Type parameterType = method.GetParameters().FirstOrDefault()?.ParameterType;
TopicAttribute[] topicAttributes = method.GetCustomAttributes <TopicAttribute>()
.ToArray();
string[] topicPatterns = topicAttributes
.Select(e => e.TopicPattern)
.ToArray();
Regex[] topicRegularExpressions = topicAttributes
.Select(e => e.TopicRegularExpression)
.ToArray();
Logger.LogDebug($"Found topic patterns {string.Join(", ", topicPatterns)} on method {method.Name} in type {type.Name}");
Logger.LogTrace($"Adding MicroserviceListener with type {type.Name} and method {method.Name}");
EventListeners.Add(new MicroserviceListener
{
TopicExpressions = topicPatterns,
TopicRegularExpressions = topicRegularExpressions,
Callback = message =>
{
Logger.LogDebug($"Attempting to instantiate type {type.Name}");
object instance = InstantiatePopulatedType(type);
Logger.LogTrace($"Retrieving string data from message with id {message.CorrelationId}");
string text = Encoding.Unicode.GetString(message.Body);
Logger.LogTrace("Checking if parameter type is equal to a string");
if (parameterType == StringType)
{
Logger.LogTrace($"Parameter type is a string, invoking method for message {message.CorrelationId} with body {text}");
method.Invoke(instance, new object[] { text });
return;
}
try
{
Logger.LogTrace($"Deserialized object from message with id {message.CorrelationId} and body {text}");
object jsonObject = JsonConvert.DeserializeObject(text, parameterType);
Logger.LogTrace($"Invoking method {method.Name} with message id {message.CorrelationId} and instance " +
$"of supposed type {type.Name} and actual type {jsonObject?.GetType().Name} with data {text}");
method.Invoke(instance, new[] { jsonObject });
}
catch (JsonReaderException readerException)
{
Logger.LogCritical($"JsonReaderException occured while deserializing message with type {message.EventType} and topic {message.Topic}," +
$" consider changing the parameter type of method {method.Name} of type {type.Name} to string. Data: {text}, exception: {readerException.Message}");
throw;
}
}
});
}
public override void Register(EventListeners eventListeners)
{
eventListeners.UpdateEventListeners = new[] { this };
}
public void Dispose()
{
EventListeners eventListeners = _session.GetSessionImplementation().Listeners;
switch (_type)
{
case ListenerType.Autoflush:
eventListeners.AutoFlushEventListeners = _autoFlushEventListeners;
break;
case ListenerType.Merge:
eventListeners.MergeEventListeners = _mergeEventListeners;
break;
case ListenerType.Create:
eventListeners.PersistEventListeners = _persistEventListeners;
break;
case ListenerType.CreateOnFlush:
eventListeners.PersistOnFlushEventListeners = _persistOnFlushEventListeners;
break;
case ListenerType.Delete:
eventListeners.DeleteEventListeners = _deleteEventListeners;
break;
case ListenerType.DirtyCheck:
eventListeners.DirtyCheckEventListeners = _dirtyCheckEventListeners;
break;
case ListenerType.Evict:
eventListeners.EvictEventListeners = _evictEventListeners;
break;
case ListenerType.Flush:
eventListeners.FlushEventListeners = _flushEventListeners;
break;
case ListenerType.FlushEntity:
eventListeners.FlushEntityEventListeners = _flushEntityEventListeners;
break;
case ListenerType.Load:
eventListeners.LoadEventListeners = _loadEventListeners;
break;
case ListenerType.LoadCollection:
eventListeners.InitializeCollectionEventListeners = _initializeCollectionEventListeners;
break;
case ListenerType.Lock:
eventListeners.LockEventListeners = _lockEventListeners;
break;
case ListenerType.Refresh:
eventListeners.RefreshEventListeners = _refreshEventListeners;
break;
case ListenerType.Replicate:
eventListeners.ReplicateEventListeners = _replicateEventListeners;
break;
case ListenerType.SaveUpdate:
eventListeners.SaveOrUpdateEventListeners = _saveOrUpdateEventListeners;
break;
case ListenerType.Save:
eventListeners.SaveEventListeners = _saveEventListeners;
break;
case ListenerType.PreUpdate:
eventListeners.PreUpdateEventListeners = _preUpdateEventListeners;
break;
case ListenerType.Update:
eventListeners.UpdateEventListeners = _updateEventListeners;
break;
case ListenerType.PreLoad:
eventListeners.PreLoadEventListeners = _preLoadEventListeners;
break;
case ListenerType.PreDelete:
eventListeners.PreDeleteEventListeners = _preDeleteEventListeners;
break;
case ListenerType.PreInsert:
eventListeners.PreInsertEventListeners = _preInsertEventListeners;
break;
case ListenerType.PostLoad:
eventListeners.PostLoadEventListeners = _postLoadEventListeners;
break;
case ListenerType.PostInsert:
eventListeners.PostInsertEventListeners = _postInsertEventListeners;
break;
case ListenerType.PostUpdate:
eventListeners.PostUpdateEventListeners = _postUpdateEventListeners;
break;
case ListenerType.PostDelete:
eventListeners.PostDeleteEventListeners = _postDeleteEventListeners;
break;
case ListenerType.PostCommitUpdate:
eventListeners.PostCommitUpdateEventListeners = _postCommitUpdateEventListeners;
break;
case ListenerType.PostCommitInsert:
eventListeners.PostCommitInsertEventListeners = _postCommitInsertEventListeners;
break;
case ListenerType.PostCommitDelete:
eventListeners.PostCommitDeleteEventListeners = _postCommitDeleteEventListeners;
break;
case ListenerType.PreCollectionRecreate:
eventListeners.PreCollectionRecreateEventListeners = _preCollectionRecreateEventListeners;
break;
case ListenerType.PreCollectionRemove:
eventListeners.PreCollectionRemoveEventListeners = _preCollectionRemoveEventListeners;
break;
case ListenerType.PreCollectionUpdate:
eventListeners.PreCollectionUpdateEventListeners = _preCollectionUpdateEventListeners;
break;
case ListenerType.PostCollectionRecreate:
eventListeners.PostCollectionRecreateEventListeners = _postCollectionRecreateEventListeners;
break;
case ListenerType.PostCollectionRemove:
eventListeners.PostCollectionRemoveEventListeners = _postCollectionRemoveEventListeners;
break;
case ListenerType.PostCollectionUpdate:
eventListeners.PostCollectionUpdateEventListeners = _postCollectionUpdateEventListeners;
break;
}
}
public ListenerDisabler(ISession session, ListenerType type, object listener)
{
_session = session;
_type = type;
EventListeners eventListeners = _session.GetSessionImplementation().Listeners;
switch (type)
{
case ListenerType.Autoflush:
_autoFlushEventListeners = eventListeners.AutoFlushEventListeners;
eventListeners.AutoFlushEventListeners =
_autoFlushEventListeners.Where(eventListener => eventListeners != listener).ToArray();
break;
case ListenerType.Merge:
_mergeEventListeners = eventListeners.MergeEventListeners;
eventListeners.MergeEventListeners =
_mergeEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Create:
_persistEventListeners = eventListeners.PersistEventListeners;
eventListeners.PersistEventListeners =
_persistEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.CreateOnFlush:
_persistOnFlushEventListeners = eventListeners.PersistOnFlushEventListeners;
eventListeners.PersistOnFlushEventListeners =
_persistOnFlushEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Delete:
_deleteEventListeners = eventListeners.DeleteEventListeners;
eventListeners.DeleteEventListeners =
_deleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.DirtyCheck:
_dirtyCheckEventListeners = eventListeners.DirtyCheckEventListeners;
eventListeners.DirtyCheckEventListeners =
_dirtyCheckEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Evict:
_evictEventListeners = eventListeners.EvictEventListeners;
eventListeners.EvictEventListeners =
_evictEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Flush:
_flushEventListeners = eventListeners.FlushEventListeners;
eventListeners.FlushEventListeners =
_flushEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.FlushEntity:
_flushEntityEventListeners = eventListeners.FlushEntityEventListeners;
eventListeners.FlushEntityEventListeners =
_flushEntityEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Load:
_loadEventListeners = eventListeners.LoadEventListeners;
eventListeners.LoadEventListeners =
_loadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.LoadCollection:
_initializeCollectionEventListeners = eventListeners.InitializeCollectionEventListeners;
eventListeners.InitializeCollectionEventListeners =
_initializeCollectionEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Lock:
_lockEventListeners = eventListeners.LockEventListeners;
eventListeners.LockEventListeners =
_lockEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Refresh:
_refreshEventListeners = eventListeners.RefreshEventListeners;
eventListeners.RefreshEventListeners =
_refreshEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Replicate:
_replicateEventListeners = eventListeners.ReplicateEventListeners;
eventListeners.ReplicateEventListeners =
_replicateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.SaveUpdate:
_saveOrUpdateEventListeners = eventListeners.SaveOrUpdateEventListeners;
eventListeners.SaveOrUpdateEventListeners =
_saveOrUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Save:
_saveEventListeners = eventListeners.SaveEventListeners;
eventListeners.SaveEventListeners =
_saveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreUpdate:
_preUpdateEventListeners = eventListeners.PreUpdateEventListeners;
eventListeners.PreUpdateEventListeners =
_preUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Update:
_updateEventListeners = eventListeners.UpdateEventListeners;
eventListeners.UpdateEventListeners =
_updateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreLoad:
_preLoadEventListeners = eventListeners.PreLoadEventListeners;
eventListeners.PreLoadEventListeners =
_preLoadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreDelete:
_preDeleteEventListeners = eventListeners.PreDeleteEventListeners;
eventListeners.PreDeleteEventListeners =
_preDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreInsert:
_preInsertEventListeners = eventListeners.PreInsertEventListeners;
eventListeners.PreInsertEventListeners =
_preInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostLoad:
_postLoadEventListeners = eventListeners.PostLoadEventListeners;
eventListeners.PostLoadEventListeners =
_postLoadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostInsert:
_postInsertEventListeners = eventListeners.PostInsertEventListeners;
eventListeners.PostInsertEventListeners =
_postInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostUpdate:
_postUpdateEventListeners = eventListeners.PostUpdateEventListeners;
eventListeners.PostUpdateEventListeners =
_postUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostDelete:
_postDeleteEventListeners = eventListeners.PostDeleteEventListeners;
eventListeners.PostDeleteEventListeners =
_postDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitUpdate:
_postCommitUpdateEventListeners = eventListeners.PostCommitUpdateEventListeners;
eventListeners.PostCommitUpdateEventListeners =
_postCommitUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitInsert:
_postCommitInsertEventListeners = eventListeners.PostCommitInsertEventListeners;
eventListeners.PostCommitInsertEventListeners =
_postCommitInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitDelete:
_postCommitDeleteEventListeners = eventListeners.PostCommitDeleteEventListeners;
eventListeners.PostCommitDeleteEventListeners =
_postCommitDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionRecreate:
_preCollectionRecreateEventListeners = eventListeners.PreCollectionRecreateEventListeners;
eventListeners.PreCollectionRecreateEventListeners =
_preCollectionRecreateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionRemove:
_preCollectionRemoveEventListeners = eventListeners.PreCollectionRemoveEventListeners;
eventListeners.PreCollectionRemoveEventListeners =
_preCollectionRemoveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionUpdate:
_preCollectionUpdateEventListeners = eventListeners.PreCollectionUpdateEventListeners;
eventListeners.PreCollectionUpdateEventListeners =
_preCollectionUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionRecreate:
_postCollectionRecreateEventListeners = eventListeners.PostCollectionRecreateEventListeners;
eventListeners.PostCollectionRecreateEventListeners =
_postCollectionRecreateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionRemove:
_postCollectionRemoveEventListeners = eventListeners.PostCollectionRemoveEventListeners;
eventListeners.PostCollectionRemoveEventListeners =
_postCollectionRemoveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionUpdate:
_postCollectionUpdateEventListeners = eventListeners.PostCollectionUpdateEventListeners;
eventListeners.PostCollectionUpdateEventListeners =
_postCollectionUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
}
}
public void Raise()
{
EventListeners.Invoke();
}
