예제 #1
0
        /// <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;
        }
예제 #2
0
        /// <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);
        }
예제 #3
0
 /// <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));
 }
예제 #4
0
 /// <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);
 }
예제 #5
0
 /// <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);
 }
예제 #6
0
 /// <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));
 }
예제 #7
0
 /// <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));
 }
예제 #8
0
 /// <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);
 }
예제 #9
0
        /// <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);
        }