/// <summary>
/// Registers the specified component name.
/// </summary>
/// <param name="componentName">Name of the component.</param>
/// <param name="registration">The registration.</param>
/// <param name="ignoreUpdates">If set to true, then duplicate registrations are ignored rather than updated.</param>
public void Register(string componentName, ComponentRegistration registration, bool ignoreUpdates)
{
if (ignoreUpdates)
{
components.TryAdd(componentName, registration);
return;
}
components[componentName] = registration;
}
/// <summary>
/// Entfernt das Abonnement eines Ereignisses einer Serverkomponente.
/// </summary>
/// <param name="interfaceName">Schnittstellenname der Serverkomponente</param>
/// <param name="correlation">Korrelationsinformation</param>
public void RemoveEventHandler(string interfaceName, DelegateCorrelationInfo correlation)
{
// Wenn kein Schnittstellenname angegeben wurde ...
if (string.IsNullOrEmpty(interfaceName))
{
// Ausnahme werfen
throw new ArgumentException(LanguageResource.ArgumentException_InterfaceNameMissing, "interfaceName");
}
// Wenn für den angegebenen Schnittstellennamen keine Komponente registriert ist ...
if (!_host.ComponentRegistry.ContainsKey(interfaceName))
{
// Ausnahme erzeugen
throw new KeyNotFoundException(string.Format("Für die angegebene Schnittstelle '{0}' ist keine Komponente registiert.", interfaceName));
}
// Komponentenregistrierung abrufen
ComponentRegistration registration = _host.ComponentRegistry[interfaceName];
// Wenn die Komponente nicht Singletonaktiviert ist ...
if (registration.ActivationType != ActivationType.Singleton)
{
// Prozedur abbrechen
return;
}
// Komponenteninstanz erzeugen
object instance = _host.GetComponentInstance(registration);
// Implementierungstyp abrufen
Type type = instance.GetType();
// Liste für Übergabe der Korrelationsinformation erzeugen
List <DelegateCorrelationInfo> correlationSet = new List <DelegateCorrelationInfo>();
correlationSet.Add(correlation);
// Client- und Server-Komponente miteinander verdrahten
RemoveClientServerWires(type, instance, correlationSet, registration.EventWirings);
}
/// <summary>
/// Tries to get the component registration.
/// </summary>
/// <param name="componentName">Name of the component.</param>
/// <param name="registration">The registration.</param>
public bool TryGetRegistration(string componentName, out ComponentRegistration registration)
{
return(components.TryGetValue(componentName, out registration));
}
/// <summary>
/// Processes resource clean up logic for a specified registered component.
/// </summary>
/// <param name="regEntry">Component registration</param>
/// <param name="instance">Component instance to clean up</param>
public void CleanUpComponentInstance(ComponentRegistration regEntry, object instance)
{
_catalog.CleanUpComponentInstance(regEntry, instance);
}
/// <summary>
/// Processes resource clean up logic for a specified registered Singleton activated component.
/// </summary>
/// <param name="regEntry">Component registration</param>
public void CleanUpComponentInstance(ComponentRegistration regEntry)
{
_catalog.CleanUpComponentInstance(regEntry);
}
/// <summary>
/// Returns an instance of a specified registered component.
/// </summary>
/// <param name="registration">Component registration</param>
/// <returns>Component instance</returns>
public object GetComponentInstance(ComponentRegistration registration)
{
return(_catalog.GetComponentInstance(registration));
}
/// <summary>
/// Gibt eine Instanz einer registrierten Komponente zurück.
/// </summary>
/// <param name="registration">Komponentenregistrierung</param>
/// <returns>Komponenten-Instanz</returns>
internal object GetComponentInstance(ComponentRegistration registration)
{
// Aufruf an Komponentenkatalog weiterleiten
return(_catalog.GetComponentInstance(registration));
}
/// <summary>
/// Tries to get the component registration.
/// </summary>
/// <param name="componentName">Name of the component.</param>
/// <param name="registration">The registration.</param>
public bool TryGetRegistration(string componentName, out ComponentRegistration registration)
{
return components.TryGetValue(componentName, out registration);
}
/// <summary>
/// Ruft eine bestimmte Methode einer Komponente auf und übergibt die angegebene Nachricht als Parameter.
/// Für jeden Aufruf wird temporär eine neue Instanz der Komponente erstellt.
/// </summary>
/// <param name="trackingID">Aufrufschlüssel zur Nachverfolgung</param>
/// <param name="interfaceName">Name der Komponentenschnittstelle</param>
/// <param name="delegateCorrelationSet">Korrelationssatz für die Verdrahtung bestimmter Delegaten oder Ereignisse mit entfernten Methoden</param>
/// <param name="methodName">Methodenname</param>
/// <param name="paramDefs">Parameter-Definitionen</param>
/// <param name="args">Parameter</param>
/// <returns>Rückgabewert</returns>
public object Invoke(Guid trackingID, string interfaceName, List <DelegateCorrelationInfo> delegateCorrelationSet, string methodName, ParameterInfo[] paramDefs, params object[] args)
{
// Wenn kein Schnittstellenname angegeben wurde ...
if (string.IsNullOrEmpty(interfaceName))
{
// Ausnahme werfen
throw new ArgumentException(LanguageResource.ArgumentException_InterfaceNameMissing, "interfaceName");
}
// Wenn kein Methodenname angegben wurde ...
if (string.IsNullOrEmpty(methodName))
{
// Ausnahme werfen
throw new ArgumentException(LanguageResource.ArgumentException_MethodNameMissing, "methodName");
}
// Ggf. BeforeInvoke-Abos verarbeiten
ProcessBeforeInvoke(trackingID, ref interfaceName, ref delegateCorrelationSet, ref methodName, ref args);
// Wenn für den angegebenen Schnittstellennamen keine Komponente registriert ist ...
if (!_host.ComponentRegistry.ContainsKey(interfaceName))
{
// Ausnahme erzeugen
KeyNotFoundException ex = new KeyNotFoundException(string.Format("Für die angegebene Schnittstelle '{0}' ist keine Komponente registiert.", interfaceName));
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = ex
});
// Ausnahme werfen
throw ex;
}
// Komponentenregistrierung abrufen
ComponentRegistration registration = _host.ComponentRegistry[interfaceName];
// Komponenteninstanz erzeugen
object instance = _host.GetComponentInstance(registration);
// Implementierungstyp abrufen
Type type = instance.GetType();
// Auflistung für Ereignisverdrahtungen
Dictionary <Guid, Delegate> wiringList = null;
// Wenn die Komponente SingleCallaktiviert ist ...
if (registration.ActivationType == ActivationType.SingleCall)
{
// Auflistung für Ereignisverdrahtungen erzeugen
wiringList = new Dictionary <Guid, Delegate>();
// Bei Bedarf Client- und Server-Komponente miteinander verdrahten
CreateClientServerWires(type, instance, delegateCorrelationSet, wiringList);
}
// Transaktionsbereich
TransactionScope scope = null;
// Kontextdaten aus dem Aufrufkontext lesen (Falls welche hinterlegt sind)
LogicalCallContextData data = CallContext.GetData("__ZyanContextData_" + _host.Name) as LogicalCallContextData;
// Wenn Kontextdaten übertragen wurden ...
if (data != null)
{
// Wenn ein Sitzungsschlüssel übertragen wurde ...
if (data.Store.ContainsKey("sessionid"))
{
// Sitzungsschlüssel lesen
Guid sessionID = (Guid)data.Store["sessionid"];
// Wenn eine Sitzung mit dem angegebenen Schlüssel existiert ...
if (_host.SessionManager.ExistSession(sessionID))
{
// Sitzung abrufen
ServerSession session = _host.SessionManager.GetSessionBySessionID(sessionID);
// Sitzung verlängern
session.Timestamp = DateTime.Now;
// Aktuelle Sitzung im Threadspeicher ablegen
ServerSession.CurrentSession = session;
}
else
{
// Ausnahme erzeugen
InvalidSessionException ex = new InvalidSessionException(string.Format("Sitzungsschlüssel '{0}' ist ungültig! Bitte melden Sie sich erneut am Server an.", sessionID.ToString()));
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = ex
});
// Ausnahme werfen
throw ex;
}
}
// Wenn eine Transaktion übertragen wurde ...
if (data.Store.ContainsKey("transaction"))
{
// Transaktionsbereich erzeugen
scope = new TransactionScope((Transaction)data.Store["transaction"]);
}
}
else
{
// Ausnahme erzeugen
SecurityException ex = new SecurityException(LanguageResource.SecurityException_ContextInfoMissing);
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = ex
});
// Ausnahme werfen
throw ex;
}
// Rückgabewert
object returnValue = null;
// Typen-Array (zur Ermittlung der passenden Signatur) erzeugen
Type[] types = new Type[paramDefs.Length];
// Auflistung der Indizes von Parametern, für die eine Delegatenverdrahtung notwendig ist
Dictionary <int, DelegateInterceptor> delegateParamIndexes = new Dictionary <int, DelegateInterceptor>();
// Alle Parametertypen durchlaufen
for (int i = 0; i < paramDefs.Length; i++)
{
// Typ in Array einfügen
types[i] = paramDefs[i].ParameterType;
// Versuchen den aktuellen Parameter in eine Delegaten-Abfangvorrichtung zu casten
DelegateInterceptor delegateParamInterceptor = args[i] as DelegateInterceptor;
// Wenn aktuelle Parameter eine Delegaten-Abfangvorrichtung ist ...
if (delegateParamInterceptor != null)
{
// Parameter der Delegaten-Verdrahtungsliste zufügen
delegateParamIndexes.Add(i, delegateParamInterceptor);
}
}
// Ausnahme-Schalter
bool exceptionThrown = false;
try
{
// Metadaten der aufzurufenden Methode abrufen
MethodInfo methodInfo = type.GetMethod(methodName, types);
// Metadaten der Parameter abrufen
ParameterInfo[] serverMethodParamDefs = methodInfo.GetParameters();
// Delegaten-Verdrahtungsliste durchlaufen
foreach (int index in delegateParamIndexes.Keys)
{
// Abfangvorrichtung adressieren
DelegateInterceptor delegateParamInterceptor = delegateParamIndexes[index];
// Metadaten des passenden Parameters der Serverkomponenten-Methode adressieren
ParameterInfo serverMethodParamDef = serverMethodParamDefs[index];
// Dynamischen Draht erzeugen
object dynamicWire = DynamicWireFactory.Instance.CreateDynamicWire(type, serverMethodParamDef.ParameterType, delegateParamInterceptor);
// Typ des dynamischen Drahtes ermitteln
Type dynamicWireType = dynamicWire.GetType();
// Dynamischen Draht mit Client-Fernsteuerung verdrahten
dynamicWireType.GetProperty("Interceptor").SetValue(dynamicWire, delegateParamInterceptor, null);
// Delegat zu dynamischem Draht erzeugen
Delegate dynamicWireDelegate = Delegate.CreateDelegate(serverMethodParamDef.ParameterType, dynamicWire, dynamicWireType.GetMethod("In"));
// Abfangvorrichtung durch dynamischen Draht austauschen
args[index] = dynamicWireDelegate;
}
// Methode aufrufen
returnValue = methodInfo.Invoke(instance, args);
}
catch (Exception ex)
{
// Ausnahme-Schalter setzen
exceptionThrown = true;
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = ex
});
// Ausnahme weiterwerfen
throw ex;
}
finally
{
// Wenn ein Transaktionsbereich existiert ...
if (scope != null)
{
// Wenn keine Ausnahme aufgetreten ist ...
if (!exceptionThrown)
{
// Transaktionsbereich abschließen
scope.Complete();
}
// Transaktionsbereich entsorgen
scope.Dispose();
}
// Wenn die Komponente SingleCallaktiviert ist ...
if (registration.ActivationType == ActivationType.SingleCall)
{
// Verdrahtung aufheben
RemoveClientServerWires(type, instance, delegateCorrelationSet, wiringList);
}
}
// Ggf. AfterInvoke-Abos verarbeiten
ProcessAfterInvoke(trackingID, ref interfaceName, ref delegateCorrelationSet, ref methodName, ref args, ref returnValue);
// Rückgabewert zurückgeben
return(returnValue);
}