public TEventType GetEvent <TEventType>() where TEventType : BaseEvent
{
_rwl.EnterUpgradeableReadLock();
try
{
TEventType eventInstance = _events.SingleOrDefault(evt => evt.GetType() == typeof(TEventType)) as TEventType;
if (eventInstance == null)
{
_rwl.EnterWriteLock();
try
{
eventInstance = _events.SingleOrDefault(evt => evt.GetType() == typeof(TEventType)) as TEventType;
if (eventInstance == null)
{
eventInstance = Activator.CreateInstance <TEventType>();
_events.Add(eventInstance);
}
}
finally
{
_rwl.ExitWriteLock();
}
}
return(eventInstance);
}
finally
{
_rwl.ExitUpgradeableReadLock();
}
}
/// <summary>
/// Lấy một thể hiện của một kiểu sự kiện.
/// </summary>
/// <typeparam name="TEventType">Kiểu sự kiện để lấy</typeparam>
/// <returns>Một thể hiện của kiểu <typeparamref name="TEventType"/></returns>
public TEventType GetEvent <TEventType>() where TEventType : Event, new()
{
//---------------------------------------------------------------------------
// Duyệt trong Dictionary tìm sự kiện theo kiễu dữ liệu được chỉ định.
// Nếu đã tồn tại sự kiện có kiểu đã cho thì trả về sự kiện đó.
// Ngược lại, tạo một thể hiện mới của sự kiện có kiểu đã cho và trả về nó.
//---------------------------------------------------------------------------
lock (_events)
{
if (!_events.TryGetValue(typeof(TEventType), out Event existingEvent))
{
TEventType newEvent = new TEventType
{
SynchronizationContext = syncContext
};
_events[typeof(TEventType)] = newEvent;
return(newEvent);
}
else
{
return((TEventType)existingEvent);
}
}
}
public TEventType GetOrCreate(IInputDevice device)
{
TEventType item = pool.Add();
item.Device = device;
return(item);
}
//----------------------------------------------------------------------------------------
// Construction
//----------------------------------------------------------------------------------------
protected Event(Database db, DBTables.LeagueMeets.Row row, TEventType type, TEventStatus status) : base(db)
{
EventCode = row.EventCode.Value;
Name = row.Name.Value;
Start = row.Start.DateTimeOffset;
End = row.End.DateTimeOffset;
Type = type;
Status = status;
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase
{
TEventType eventInstance = _events.FirstOrDefault(evt => evt.GetType() == typeof(TEventType)) as TEventType;
if (eventInstance == null)
{
eventInstance = Activator.CreateInstance <TEventType>();
_events.Add(eventInstance);
}
return(eventInstance);
}
public TEventType GetEvent<TEventType>()
where TEventType : EventBase, new()
{
if (_events.TryGetValue(typeof(TEventType), out var existingEvent))
{
return (TEventType)existingEvent;
}
var newEvent = new TEventType();
_events[typeof(TEventType)] = newEvent;
return newEvent;
}
protected static TEventType GetAndStoreEvent <TEventType>()
{
Type t = typeof(TEventType);
if (!_events.ContainsKey(t))
{
TEventType evnt = (TEventType)Activator.CreateInstance <TEventType>();
_events.Add(t, evnt);
}
return((TEventType)_events[t]);
}
/// <summary>
/// Get an event representation. The event Type signifies the sort of situation that we are interested in raising or being notified of,
/// and the payload type represents the precise type of data payload we are interested in.
/// </summary>
/// <typeparam name="TEventType"></typeparam>
/// <typeparam name="TPayload"></typeparam>
/// <returns></returns>
public static TEventType Get <TEventType, TPayload>() where TEventType : AggregateEvent <TPayload>
{
Type t = typeof(TEventType);
if (!_events.ContainsKey(t))
{
ConstructorInfo noArgs = t.GetConstructor(Type.EmptyTypes);
TEventType evnt = (TEventType)noArgs.Invoke(null);
_events.Add(t, evnt);
}
return((TEventType)_events[t]);
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
if (_events.ContainsKey(typeof(TEventType)))
{
return(_events[typeof(TEventType)] as TEventType);
}
else
{
TEventType e = Activator.CreateInstance <TEventType>();
_events.Add(typeof(TEventType), e);
return(e);
}
}
/// <inheritdoc />
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
if (_events.TryGetValue(typeof(TEventType), out var eventBase))
{
return((TEventType)eventBase);
}
// No event registered yet, so we create a new one
var newEvent = new TEventType();
_events[typeof(TEventType)] = newEvent;
return(newEvent);
}
/// <summary>
/// Get specify event by type from pool
/// </summary>
/// <typeparam name="TEventType"></typeparam>
/// <returns></returns>
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (events)
{
if (!this.events.ContainsKey(typeof(TEventType)))
{
TEventType newEvent = new TEventType();
this.events.Add(typeof(TEventType), newEvent);
}
return(this.events[typeof(TEventType)] as TEventType);
}
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
EventBase eventBase = (EventBase)null;
if (this.events.TryGetValue(typeof(TEventType), out eventBase))
{
return((TEventType)eventBase);
}
TEventType instance = Activator.CreateInstance <TEventType>();
this.events[typeof(TEventType)] = (EventBase)instance;
return(instance);
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (_events)
{
if (!_events.TryGetValue(typeof(TEventType), out EventBase eventBase))
{
var value = new TEventType();
value.SynchronizationContext = _syncContext;
_events[typeof(TEventType)] = value;
return(value);
}
return((TEventType)eventBase);
}
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
EventBase existingEvent = null;
if (!this.events.TryGetValue(typeof(TEventType), out existingEvent))
{
TEventType newEvent = new TEventType();
this.events[typeof(TEventType)] = newEvent;
return(newEvent);
}
else
{
return((TEventType)existingEvent);
}
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (this._events) {
if (!this._events.TryGetValue(typeof(TEventType), out EventBase existingEvent))
{
TEventType newEvent = new TEventType();
newEvent.SynchronizationContext = this._syncContext;
this._events[typeof(TEventType)] = newEvent;
return(newEvent);
}
else
{
return(( TEventType )existingEvent);
}
}
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (this.events)
{
EventBase existingEvent;
if (!this.events.TryGetValue(typeof(TEventType), out existingEvent))
{
var newEvent = new TEventType();
newEvent.SynchronizationContext = this.syncContext;
this.events[typeof(TEventType)] = newEvent;
return(newEvent);
} // if
return((TEventType)existingEvent);
} // lock
} // GetEvent()
public TEventType GetEvent <TEventType>() where TEventType : AsyncEvent, new()
{
lock (_events)
{
AsyncEvent existingEvent;
if (_events.TryGetValue(typeof(TEventType), out existingEvent))
{
return((TEventType)existingEvent);
}
TEventType newEvent = new TEventType();
newEvent.ApplyContext(_syncContext);
_events[typeof(TEventType)] = newEvent;
return(newEvent);
}
}
public static TEventType GetEvent <TEventType>() where TEventType : BaseEvent, new()
{
lock (events)
{
BaseEvent existEvent = null;
if (!events.TryGetValue(typeof(TEventType), out existEvent))
{
// 如果找不到key的item 就创建一个添加到字典中
TEventType newEvent = new TEventType();
newEvent.SynchronizationContext = syncContext;
events[typeof(TEventType)] = newEvent;
return(newEvent);
}
else
{
return((TEventType)existEvent);
}
}
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase
{
TEventType eventInstance = null;
foreach (EventBase eventBase in _events)
{
if (eventBase.GetType() == typeof(TEventType))
{
eventInstance = eventBase as TEventType;
break;
}
}
if (eventInstance == null)
{
eventInstance = Activator.CreateInstance <TEventType>();
eventInstance.LogMgr = _logMgr;
_events.Add(eventInstance);
}
return(eventInstance);
}
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (Events)
{
EventBase existingEvent;
if (!Events.TryGetValue(typeof(TEventType), out existingEvent))
{
var newEvent = new TEventType
{
SynchronizationContext = Context
};
Events[typeof(TEventType)] = newEvent;
return(newEvent);
}
return((TEventType)existingEvent);
}
}
///<inheritdoc/>
public TEventType GetEvent <TEventType>() where TEventType : EventBase, new()
{
lock (_events)
{
if (!_events.TryGetValue(typeof(TEventType), out var existingEvent))
{
var newEvent = new TEventType
{
SynchronizationContext = _synchronizationContext
};
_events[typeof(TEventType)] = newEvent;
return(newEvent);
}
else
{
return((TEventType)existingEvent);
}
}
}
public IEvent CreateNewEvent(
ulong idRundownEvent = 0,
ulong idEventBinding = 0,
VideoLayer videoLayer = VideoLayer.None,
TEventType eventType = TEventType.Rundown,
TStartType startType = TStartType.None,
TPlayState playState = TPlayState.Scheduled,
DateTime scheduledTime = default(DateTime),
TimeSpan duration = default(TimeSpan),
TimeSpan scheduledDelay = default(TimeSpan),
TimeSpan scheduledTC = default(TimeSpan),
Guid mediaGuid = default(Guid),
string eventName = "",
DateTime startTime = default(DateTime),
TimeSpan startTC = default(TimeSpan),
TimeSpan?requestedStartTime = null,
TimeSpan transitionTime = default(TimeSpan),
TimeSpan transitionPauseTime = default(TimeSpan),
TTransitionType transitionType = TTransitionType.Cut,
TEasing transitionEasing = TEasing.Linear,
double?audioVolume = null,
ulong idProgramme = 0,
string idAux = "",
bool isEnabled = true,
bool isHold = false,
bool isLoop = false,
bool isCGEnabled = false,
byte crawl = 0,
byte logo = 0,
byte parental = 0,
AutoStartFlags autoStartFlags = AutoStartFlags.None,
string command = null,
IDictionary <string, string> fields = null,
TemplateMethod method = TemplateMethod.Add,
int templateLayer = -1
)
{
return(Query <Event>(parameters: new object[] { idRundownEvent, idEventBinding, videoLayer, eventType, startType, playState, scheduledTime, duration, scheduledDelay, scheduledTC, mediaGuid, eventName,
startTime, startTC, requestedStartTime, transitionTime, transitionPauseTime, transitionType, transitionEasing, audioVolume, idProgramme, idAux, isEnabled, isHold, isLoop, isCGEnabled,
crawl, logo, parental, autoStartFlags, command, fields, method, templateLayer }));
}
/// <summary>
/// Recupera a instancia do evento.
/// </summary>
/// <typeparam name="TEventType">Tipo do evento que será recuperado.</typeparam>
/// <returns>Instancia do objeto do evento do tipo <typeparamref name="TEventType"/>.</returns>
public TEventType GetEvent <TEventType>() where TEventType : DomainEventBase, new()
{
DomainEventBase existingEvent = null;
var type = typeof(TEventType);
var found = false;
lock (_events)
found = _events.TryGetValue(type, out existingEvent);
if (!found)
{
TEventType newEvent = new TEventType();
lock (_events)
if (!_events.ContainsKey(type))
{
_events.Add(type, newEvent);
}
return(newEvent);
}
else
{
return((TEventType)existingEvent);
}
}
internal Event(
Engine engine,
UInt64 idRundownEvent,
UInt64 idEventBinding,
VideoLayer videoLayer,
TEventType eventType,
TStartType startType,
TPlayState playState,
DateTime scheduledTime,
TimeSpan duration,
TimeSpan scheduledDelay,
TimeSpan scheduledTC,
Guid mediaGuid,
string eventName,
DateTime startTime,
TimeSpan startTC,
TimeSpan?requestedStartTime,
TimeSpan transitionTime,
TimeSpan transitionPauseTime,
TTransitionType transitionType,
TEasing transitionEasing,
double?audioVolume,
UInt64 idProgramme,
string idAux,
bool isEnabled,
bool isHold,
bool isLoop,
AutoStartFlags autoStartFlags,
bool isCGEnabled,
byte crawl,
byte logo,
byte parental,
short routerPort,
RecordingInfo recordingInfo)
{
_engine = engine;
_rundownSync = engine.RundownSync;
Id = idRundownEvent;
IdEventBinding = idEventBinding;
_layer = videoLayer;
_eventType = eventType;
_startType = startType;
_playState = playState == TPlayState.Paused ? TPlayState.Scheduled: playState == TPlayState.Fading ? TPlayState.Played : playState;
_scheduledTime = scheduledTime;
_duration = duration;
_scheduledDelay = scheduledDelay;
_scheduledTc = scheduledTC;
_eventName = eventName;
_startTime = startTime;
_startTc = startTC;
_requestedStartTime = requestedStartTime;
_transitionTime = transitionTime;
_transitionPauseTime = transitionPauseTime;
_transitionType = transitionType;
_transitionEasing = transitionEasing;
_audioVolume = audioVolume;
_idProgramme = idProgramme;
_idAux = idAux;
_isEnabled = isEnabled;
_isHold = isHold;
_isLoop = isLoop;
_isCGEnabled = isCGEnabled;
_crawl = crawl;
_logo = logo;
_parental = parental;
_autoStartFlags = autoStartFlags;
_mediaGuid = mediaGuid;
_subEvents = new Lazy <SynchronizedCollection <Event> >(() =>
{
var result = new SynchronizedCollection <Event>();
if (Id == 0)
{
return(result);
}
var seList = DatabaseProvider.Database.ReadSubEvents(_engine, this);
foreach (Event e in seList)
{
e.Parent = this;
result.Add(e);
}
return(result);
});
_next = new Lazy <Event>(() =>
{
var next = (Event)DatabaseProvider.Database.ReadNext(_engine, this);
if (next != null)
{
next.Prior = this;
}
return(next);
});
_prior = new Lazy <Event>(() =>
{
Event prior = null;
if (startType == TStartType.After && IdEventBinding > 0)
{
prior = (Event)DatabaseProvider.Database.ReadEvent(_engine, IdEventBinding);
}
if (prior != null)
{
prior.Next = this;
}
return(prior);
});
_parent = new Lazy <Event>(() =>
{
if ((startType == TStartType.WithParent || startType == TStartType.WithParentFromEnd) && IdEventBinding > 0)
{
return((Event)DatabaseProvider.Database.ReadEvent(_engine, IdEventBinding));
}
return(null);
});
_rights = new Lazy <List <IAclRight> >(() =>
{
var rights = DatabaseProvider.Database.ReadEventAclList <EventAclRight>(this, _engine.AuthenticationService as IAuthenticationServicePersitency);
rights.ForEach(r => ((EventAclRight)r).Saved += AclEvent_Saved);
return(rights);
});
_routerPort = routerPort;
_recordingInfo = recordingInfo;
FieldLengths = DatabaseProvider.Database.EventFieldLengths;
}
//----------------------------------------------------------------------------------------
// Construction
//----------------------------------------------------------------------------------------
public ThisEvent(Database db, DBTables.LeagueMeets.Row row, TEventType type, TEventStatus status) : base(db, row, type, status)
{
}
internal Event(
Engine engine,
UInt64 idRundownEvent,
UInt64 idEventBinding,
VideoLayer videoLayer,
TEventType eventType,
TStartType startType,
TPlayState playState,
DateTime scheduledTime,
TimeSpan duration,
TimeSpan scheduledDelay,
TimeSpan scheduledTC,
Guid mediaGuid,
string eventName,
DateTime startTime,
TimeSpan startTC,
TimeSpan?requestedStartTime,
TimeSpan transitionTime,
TimeSpan transitionPauseTime,
TTransitionType transitionType,
TEasing transitionEasing,
decimal?audioVolume,
UInt64 idProgramme,
string idAux,
bool isEnabled,
bool isHold,
bool isLoop,
AutoStartFlags autoStartFlags,
bool isCGEnabled,
byte crawl,
byte logo,
byte parental)
{
_engine = engine;
_id = idRundownEvent;
_idEventBinding = idEventBinding;
_layer = videoLayer;
_eventType = eventType;
_startType = startType;
_playState = playState == TPlayState.Paused ? TPlayState.Scheduled: playState == TPlayState.Fading ? TPlayState.Played : playState;
_scheduledTime = scheduledTime;
_duration = duration;
_scheduledDelay = scheduledDelay;
_scheduledTc = scheduledTC;
_eventName = eventName;
_startTime = startTime;
_startTc = startTC;
_requestedStartTime = requestedStartTime;
_transitionTime = transitionTime;
_transitionPauseTime = transitionPauseTime;
_transitionType = transitionType;
_transitionEasing = transitionEasing;
_audioVolume = audioVolume;
_idProgramme = idProgramme;
_idAux = idAux;
_isEnabled = isEnabled;
_isHold = isHold;
_isLoop = isLoop;
_isCGEnabled = isCGEnabled;
_crawl = crawl;
_logo = logo;
_parental = parental;
_autoStartFlags = autoStartFlags;
_setMedia(null, mediaGuid);
_subEvents = new Lazy <SynchronizedCollection <Event> >(() =>
{
var result = new SynchronizedCollection <Event>();
if (_id != 0)
{
var seList = Engine.DbReadSubEvents(this);
foreach (Event e in seList)
{
e.Parent = this;
result.Add(e);
}
}
return(result);
});
_next = new Lazy <Event>(() =>
{
var next = (Event)Engine.DbReadNext(this);
if (next != null)
{
next.Prior = this;
}
return(next);
});
_prior = new Lazy <Event>(() =>
{
Event prior = null;
if (startType == TStartType.After && _idEventBinding > 0)
{
prior = (Event)Engine.DbReadEvent(_idEventBinding);
}
return(prior);
});
_parent = new Lazy <Event>(() =>
{
if ((startType == TStartType.WithParent || startType == TStartType.WithParentFromEnd) && _idEventBinding > 0)
{
return((Event)Engine.DbReadEvent(_idEventBinding));
}
return(null);
});
}
public void Enqueue(TEventType item)
{
item.Device = null;
pool.Remove(item);
}
