/// <summary>
/// Processes BeforeInvoke event subscriptions (if there any).
/// </summary>
/// <param name="details">Invocation details</param>
private void ProcessBeforeInvoke(InvocationDetails details)
{
if (_host.HasBeforeInvokeSubscriptions())
{
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = details.TrackingID,
InterfaceName = details.InterfaceName,
DelegateCorrelationSet = details.DelegateCorrelationSet,
MethodName = details.MethodName,
Arguments = details.Args,
Cancel = false
};
_host.OnBeforeInvoke(cancelArgs);
if (cancelArgs.Cancel)
{
if (cancelArgs.CancelException == null)
{
cancelArgs.CancelException = new InvokeCanceledException();
}
throw cancelArgs.CancelException.PreserveStackTrace();
}
details.InterfaceName = cancelArgs.InterfaceName;
details.DelegateCorrelationSet = cancelArgs.DelegateCorrelationSet;
details.MethodName = cancelArgs.MethodName;
details.Args = cancelArgs.Arguments;
}
}
/// <summary>
/// Fires the BeforeInvoke event.
/// </summary>
/// <param name="e">Event arguments.</param>
protected internal virtual void OnBeforeInvoke(BeforeInvokeEventArgs e)
{
if (BeforeInvoke != null)
{
BeforeInvoke(this, e);
}
}
/// <summary>
/// Feuert das BeforeInvoke-Ereignis.
/// </summary>
/// <param name="e">Ereignisargumente</param>
protected internal virtual void OnBeforeInvoke(BeforeInvokeEventArgs e)
{
// Wenn für BeforeInvoke Ereignisprozeduren registriert sind ...
if (BeforeInvoke != null)
{
// Ereignis feuern
BeforeInvoke(this, e);
}
}
/// <summary>
/// Verarbeitet BeforeInvoke-Abos (falls welche registriert sind).
/// </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 und Ereignisse mit entfernten Methoden</param>
/// <param name="methodName">Methodenname</param>
/// <param name="args">Parameter</param>
private void ProcessBeforeInvoke(Guid trackingID, ref string interfaceName, ref List <DelegateCorrelationInfo> delegateCorrelationSet, ref string methodName, ref object[] args)
{
// Wenn BeforeInvoke-Abos vorhanden sind ...
if (_host.HasBeforeInvokeSubscriptions())
{
// Ereignisargumente für BeforeInvoke erstellen
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = interfaceName,
DelegateCorrelationSet = delegateCorrelationSet,
MethodName = methodName,
Arguments = args,
Cancel = false
};
// BeforeInvoke-Ereignis feuern
_host.OnBeforeInvoke(cancelArgs);
// Wenn der Aufruf abgebrochen werden soll ...
if (cancelArgs.Cancel)
{
// Wenn keine Abbruchausnahme definiert ist ...
if (cancelArgs.CancelException == null)
{
// Standard-Abbruchausnahme erstellen
cancelArgs.CancelException = new InvokeCanceledException();
}
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = cancelArgs.CancelException
});
// Abbruchausnahme werfen
throw cancelArgs.CancelException;
}
else // Wenn der Aufruf nicht abgebrochen werden soll ...
{
// Einstellungen der Ereignisargumente übernehmen
interfaceName = cancelArgs.InterfaceName;
delegateCorrelationSet = cancelArgs.DelegateCorrelationSet;
methodName = cancelArgs.MethodName;
args = cancelArgs.Arguments;
}
}
}
/// <summary>
/// Invokes a remote method.
/// </summary>
/// <param name="methodCallMessage">Remoting message.</param>
/// <returns>Remoting response message</returns>
private ReturnMessage InvokeRemoteMethod(IMethodCallMessage methodCallMessage)
{
Guid trackingID = Guid.NewGuid();
try
{
object returnValue = null;
List <DelegateCorrelationInfo> correlationSet = null;
if (_activationType == ActivationType.SingleCall)
{
correlationSet = _delegateCorrelationSet;
}
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
Cancel = false
};
_connection.OnBeforeInvoke(cancelArgs);
if (cancelArgs.Cancel)
{
if (cancelArgs.CancelException == null)
{
cancelArgs.CancelException = new InvokeCanceledException();
}
_connection.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = cancelArgs.CancelException
});
throw cancelArgs.CancelException.PreserveStackTrace();
}
// Prepare generic method arguments
Type[] genericArgs = null;
if (methodCallMessage.MethodBase.IsGenericMethod)
{
genericArgs = methodCallMessage.MethodBase.GetGenericArguments();
}
var paramDefs = methodCallMessage.MethodBase.GetParameters();
var paramTypes = paramDefs.Select(p => p.ParameterType).ToArray();
try
{
object[] checkedArgs = InterceptDelegateParameters(methodCallMessage);
returnValue = _remoteDispatcher.Invoke(trackingID, _uniqueName, correlationSet, methodCallMessage.MethodName, genericArgs, paramTypes, checkedArgs);
AfterInvokeEventArgs afterInvokeArgs = new AfterInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
ReturnValue = returnValue
};
_connection.OnAfterInvoke(afterInvokeArgs);
}
catch (InvalidSessionException)
{
if (_autoLoginOnExpiredSession)
{
if (_connection.Reconnect())
{
returnValue = _remoteDispatcher.Invoke(trackingID, _uniqueName, correlationSet, methodCallMessage.MethodName, genericArgs, paramTypes, methodCallMessage.Args);
}
else
{
throw;
}
}
else
{
throw;
}
}
var container = returnValue as CustomSerializationContainer;
if (container != null)
{
var serializationHandler = _connection.SerializationHandling[container.HandledType];
if (serializationHandler == null)
{
throw new KeyNotFoundException(string.Format(LanguageResource.KeyNotFoundException_SerializationHandlerNotFound, container.HandledType.FullName));
}
returnValue = serializationHandler.Deserialize(container.DataType, container.Data);
}
return(new ReturnMessage(returnValue, null, 0, methodCallMessage.LogicalCallContext, methodCallMessage));
}
catch (Exception ex)
{
if (_connection.ErrorHandlingEnabled)
{
throw;
}
else
{
return(new ReturnMessage(ex, methodCallMessage));
}
}
}
/// <summary>
/// Invokes a remote method.
/// </summary>
/// <param name="methodCallMessage">Remoting message.</param>
/// <returns>Remoting response message</returns>
private ReturnMessage InvokeRemoteMethod(IMethodCallMessage methodCallMessage)
{
Guid trackingID = Guid.NewGuid();
try
{
object returnValue = null;
List<DelegateCorrelationInfo> correlationSet = null;
if (_activationType == ActivationType.SingleCall)
correlationSet = _delegateCorrelationSet;
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
Cancel = false
};
_connection.OnBeforeInvoke(cancelArgs);
if (cancelArgs.Cancel)
{
if (cancelArgs.CancelException == null)
cancelArgs.CancelException = new InvokeCanceledException();
_connection.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = cancelArgs.CancelException });
throw cancelArgs.CancelException.PreserveStackTrace();
}
// Prepare generic method arguments
Type[] genericArgs = null;
if (methodCallMessage.MethodBase.IsGenericMethod)
{
genericArgs = methodCallMessage.MethodBase.GetGenericArguments();
}
var paramDefs = methodCallMessage.MethodBase.GetParameters();
var paramTypes = paramDefs.Select(p => p.ParameterType).ToArray();
try
{
object[] checkedArgs = InterceptDelegateParameters(methodCallMessage);
returnValue = _remoteDispatcher.Invoke(trackingID, _uniqueName, correlationSet, methodCallMessage.MethodName, genericArgs, paramTypes, checkedArgs);
AfterInvokeEventArgs afterInvokeArgs = new AfterInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
ReturnValue = returnValue
};
_connection.OnAfterInvoke(afterInvokeArgs);
}
catch (InvalidSessionException)
{
if (_autoLoginOnExpiredSession)
{
if (_connection.Reconnect())
returnValue = _remoteDispatcher.Invoke(trackingID, _uniqueName, correlationSet, methodCallMessage.MethodName, genericArgs, paramTypes, methodCallMessage.Args);
else
throw;
}
else
{
throw;
}
}
var container = returnValue as CustomSerializationContainer;
if (container != null)
{
var serializationHandler = _connection.SerializationHandling[container.HandledType];
if (serializationHandler == null)
throw new KeyNotFoundException(string.Format(LanguageResource.KeyNotFoundException_SerializationHandlerNotFound, container.HandledType.FullName));
returnValue = serializationHandler.Deserialize(container.DataType, container.Data);
}
return new ReturnMessage(returnValue, null, 0, methodCallMessage.LogicalCallContext, methodCallMessage);
}
catch (Exception ex)
{
if (_connection.ErrorHandlingEnabled)
throw;
else
return new ReturnMessage(ex, methodCallMessage);
}
}
/// <summary>
/// Fires the BeforeInvoke event.
/// </summary>
/// <param name="e">Event arguments.</param>
protected internal virtual void OnBeforeInvoke(BeforeInvokeEventArgs e)
{
BeforeInvoke?.Invoke(this, e);
}
/// <summary>
/// Processes BeforeInvoke event subscriptions (if there any).
/// </summary>
/// <param name="details">Invocation details</param>
private void ProcessBeforeInvoke(InvocationDetails details)
{
if (_host.HasBeforeInvokeSubscriptions())
{
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = details.TrackingID,
InterfaceName = details.InterfaceName,
DelegateCorrelationSet = details.DelegateCorrelationSet,
MethodName = details.MethodName,
Arguments = details.Args,
Cancel = false
};
_host.OnBeforeInvoke(cancelArgs);
if (cancelArgs.Cancel)
{
if (cancelArgs.CancelException == null)
cancelArgs.CancelException = new InvokeCanceledException();
throw cancelArgs.CancelException.PreserveStackTrace();
}
details.InterfaceName = cancelArgs.InterfaceName;
details.DelegateCorrelationSet = cancelArgs.DelegateCorrelationSet;
details.MethodName = cancelArgs.MethodName;
details.Args = cancelArgs.Arguments;
}
}
/// <summary>
/// Führt einen entfernten Methodenaufruf aus.
/// </summary>
/// <param name="methodCallMessage">Remoting-Nachricht mit Details für den entfernten Methodenaufruf</param>
/// <returns>Remoting Antwortnachricht</returns>
private IMessage InvokeRemoteMethod(IMethodCallMessage methodCallMessage)
{
// Aufrufschlüssel vergeben
Guid trackingID = Guid.NewGuid();
try
{
// Variable für Rückgabewert
object returnValue = null;
// Variable für Verdrahtungskorrelationssatz
List<DelegateCorrelationInfo> correlationSet = null;
// Wenn die Komponente SingleCallaktiviert ist ...
if (_activationType == ActivationType.SingleCall)
// Korrelationssatz übernehmen (wird mit übertragen)
correlationSet = _delegateCorrelationSet;
// Ereignisargumente für BeforeInvoke erstellen
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
Cancel = false
};
// BeforeInvoke-Ereignis feuern
_connection.OnBeforeInvoke(cancelArgs);
// Wenn der Aufruf abgebrochen werden soll ...
if (cancelArgs.Cancel)
{
// Wenn keine Abbruchausnahme definiert ist ...
if (cancelArgs.CancelException == null)
// Standard-Abbruchausnahme erstellen
cancelArgs.CancelException = new InvokeCanceledException();
// InvokeCanceled-Ereignis feuern
_connection.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = cancelArgs.CancelException });
// Abbruchausnahme werfen
throw cancelArgs.CancelException;
}
// Parametertypen ermitteln
ParameterInfo[] paramDefs = methodCallMessage.MethodBase.GetParameters();
try
{
// Ggf. Delegaten-Parameter abfangen
object[] checkedArgs = InterceptDelegateParameters(methodCallMessage);
// Entfernten Methodenaufruf durchführen
returnValue = _remoteInvoker.Invoke(trackingID, _interfaceType.FullName, correlationSet, methodCallMessage.MethodName, paramDefs, checkedArgs);
// Ereignisargumente für AfterInvoke erstellen
AfterInvokeEventArgs afterInvokeArgs = new AfterInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
ReturnValue = returnValue
};
// AfterInvoke-Ereignis feuern
_connection.OnAfterInvoke(afterInvokeArgs);
}
catch (InvalidSessionException)
{
// Wenn automatisches Anmelden bei abgelaufener Sitzung aktiviert ist ...
if (_autoLoginOnExpiredSession)
{
// Neu anmelden
_remoteInvoker.Logon(_sessionID, _autoLoginCredentials);
// Entfernten Methodenaufruf erneut versuchen
returnValue = _remoteInvoker.Invoke(trackingID, _interfaceType.FullName, correlationSet, methodCallMessage.MethodName, paramDefs, methodCallMessage.Args);
}
}
// Remoting-Antwortnachricht erstellen und zurückgeben
return new ReturnMessage(returnValue, null, 0, methodCallMessage.LogicalCallContext, methodCallMessage);
}
catch (TargetInvocationException targetInvocationException)
{
// Aufrufausnahme als Remoting-Nachricht zurückgeben
return new ReturnMessage(targetInvocationException, methodCallMessage);
}
catch (SocketException socketException)
{
// TCP-Sockelfehler als Remoting-Nachricht zurückgeben
return new ReturnMessage(socketException, methodCallMessage);
}
catch (InvalidSessionException sessionException)
{
// Sitzungsfehler als Remoting-Nachricht zurückgeben
return new ReturnMessage(sessionException, methodCallMessage);
}
}
/// <summary>
/// Führt einen entfernten Methodenaufruf aus.
/// </summary>
/// <param name="methodCallMessage">Remoting-Nachricht mit Details für den entfernten Methodenaufruf</param>
/// <returns>Remoting Antwortnachricht</returns>
private IMessage InvokeRemoteMethod(IMethodCallMessage methodCallMessage)
{
// Aufrufschlüssel vergeben
Guid trackingID = Guid.NewGuid();
try
{
// Variable für Rückgabewert
object returnValue = null;
// Variable für Verdrahtungskorrelationssatz
List <DelegateCorrelationInfo> correlationSet = null;
// Wenn die Komponente SingleCallaktiviert ist ...
if (_activationType == ActivationType.SingleCall)
{
// Korrelationssatz übernehmen (wird mit übertragen)
correlationSet = _delegateCorrelationSet;
}
// Ereignisargumente für BeforeInvoke erstellen
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
Cancel = false
};
// BeforeInvoke-Ereignis feuern
_connection.OnBeforeInvoke(cancelArgs);
// Wenn der Aufruf abgebrochen werden soll ...
if (cancelArgs.Cancel)
{
// Wenn keine Abbruchausnahme definiert ist ...
if (cancelArgs.CancelException == null)
{
// Standard-Abbruchausnahme erstellen
cancelArgs.CancelException = new InvokeCanceledException();
}
// InvokeCanceled-Ereignis feuern
_connection.OnInvokeCanceled(new InvokeCanceledEventArgs()
{
TrackingID = trackingID, CancelException = cancelArgs.CancelException
});
// Abbruchausnahme werfen
throw cancelArgs.CancelException;
}
// Parametertypen ermitteln
ParameterInfo[] paramDefs = methodCallMessage.MethodBase.GetParameters();
try
{
// Ggf. Delegaten-Parameter abfangen
object[] checkedArgs = InterceptDelegateParameters(methodCallMessage);
// Entfernten Methodenaufruf durchführen
returnValue = _remoteInvoker.Invoke(trackingID, _interfaceType.FullName, correlationSet, methodCallMessage.MethodName, paramDefs, checkedArgs);
// Ereignisargumente für AfterInvoke erstellen
AfterInvokeEventArgs afterInvokeArgs = new AfterInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = _interfaceType.FullName,
DelegateCorrelationSet = correlationSet,
MethodName = methodCallMessage.MethodName,
Arguments = methodCallMessage.Args,
ReturnValue = returnValue
};
// AfterInvoke-Ereignis feuern
_connection.OnAfterInvoke(afterInvokeArgs);
}
catch (InvalidSessionException)
{
// Wenn automatisches Anmelden bei abgelaufener Sitzung aktiviert ist ...
if (_autoLoginOnExpiredSession)
{
// Neu anmelden
_remoteInvoker.Logon(_sessionID, _autoLoginCredentials);
// Entfernten Methodenaufruf erneut versuchen
returnValue = _remoteInvoker.Invoke(trackingID, _interfaceType.FullName, correlationSet, methodCallMessage.MethodName, paramDefs, methodCallMessage.Args);
}
}
// Remoting-Antwortnachricht erstellen und zurückgeben
return(new ReturnMessage(returnValue, null, 0, methodCallMessage.LogicalCallContext, methodCallMessage));
}
catch (TargetInvocationException targetInvocationException)
{
// Aufrufausnahme als Remoting-Nachricht zurückgeben
return(new ReturnMessage(targetInvocationException, methodCallMessage));
}
catch (SocketException socketException)
{
// TCP-Sockelfehler als Remoting-Nachricht zurückgeben
return(new ReturnMessage(socketException, methodCallMessage));
}
catch (InvalidSessionException sessionException)
{
// Sitzungsfehler als Remoting-Nachricht zurückgeben
return(new ReturnMessage(sessionException, methodCallMessage));
}
}
/// <summary>
/// Verarbeitet BeforeInvoke-Abos (falls welche registriert sind).
/// </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 und Ereignisse mit entfernten Methoden</param>
/// <param name="methodName">Methodenname</param>
/// <param name="args">Parameter</param>
private void ProcessBeforeInvoke(Guid trackingID, ref string interfaceName, ref List<DelegateCorrelationInfo> delegateCorrelationSet, ref string methodName, ref object[] args)
{
// Wenn BeforeInvoke-Abos vorhanden sind ...
if (_host.HasBeforeInvokeSubscriptions())
{
// Ereignisargumente für BeforeInvoke erstellen
BeforeInvokeEventArgs cancelArgs = new BeforeInvokeEventArgs()
{
TrackingID = trackingID,
InterfaceName = interfaceName,
DelegateCorrelationSet = delegateCorrelationSet,
MethodName = methodName,
Arguments = args,
Cancel = false
};
// BeforeInvoke-Ereignis feuern
_host.OnBeforeInvoke(cancelArgs);
// Wenn der Aufruf abgebrochen werden soll ...
if (cancelArgs.Cancel)
{
// Wenn keine Abbruchausnahme definiert ist ...
if (cancelArgs.CancelException == null)
// Standard-Abbruchausnahme erstellen
cancelArgs.CancelException = new InvokeCanceledException();
// InvokeCanceled-Ereignis feuern
_host.OnInvokeCanceled(new InvokeCanceledEventArgs() { TrackingID = trackingID, CancelException = cancelArgs.CancelException });
// Abbruchausnahme werfen
throw cancelArgs.CancelException;
}
else // Wenn der Aufruf nicht abgebrochen werden soll ...
{
// Einstellungen der Ereignisargumente übernehmen
interfaceName = cancelArgs.InterfaceName;
delegateCorrelationSet = cancelArgs.DelegateCorrelationSet;
methodName = cancelArgs.MethodName;
args = cancelArgs.Arguments;
}
}
}
