System.Diagnostics.ListenerElement.RefreshRuntimeObject C# (CSharp) Method

        internal TraceListener RefreshRuntimeObject(TraceListener listener) {
            _runtimeObject = null;
            try {
                string className = TypeName;
                if (String.IsNullOrEmpty(className)) {
                    // Look it up in SharedListeners and ask the sharedListener to refresh.
                    Debug.Assert(_allowReferences, "_allowReferences must be true if type name is null");

                    if (_attributes != null || ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere || TraceOutputOptions != TraceOptions.None || !String.IsNullOrEmpty(InitData))
                        throw new ConfigurationErrorsException(SR.GetString(SR.Reference_listener_cant_have_properties, Name));

                    if (DiagnosticsConfiguration.SharedListeners == null)
                        throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
                    
                    ListenerElement sharedListener = DiagnosticsConfiguration.SharedListeners[Name];
                    if (sharedListener == null)
                        throw new ConfigurationErrorsException(SR.GetString(SR.Reference_to_nonexistent_listener, Name));
                    else {
                        _runtimeObject = sharedListener.RefreshRuntimeObject(listener);
                        return (TraceListener) _runtimeObject;
                    }
                }
                else {
                    // We're the element with the type and initializeData info.  First see if those two are the same as they were.
                    // If not, create a whole new object, otherwise, just update the other properties.
                    if (Type.GetType(className) != listener.GetType() || InitData != listener.initializeData) {
                        // type or initdata changed
                        return GetRuntimeObject();
                    }
                    else {
                        listener.SetAttributes(Attributes);
                        listener.TraceOutputOptions = TraceOutputOptions;
                    
                        if (ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere)
                            listener.Filter = Filter.RefreshRuntimeObject(listener.Filter);
                        else
                            listener.Filter = null;

                        _runtimeObject = listener;
                        return listener;
                    }
                }
            }
            catch (ArgumentException e) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Could_not_create_listener, Name), e);
            }
            
        }
        

        internal TraceListener RefreshRuntimeObject(TraceListener listener)
        {
            TraceListener listener2;

            base._runtimeObject = null;
            try
            {
                string typeName = this.TypeName;
                if (string.IsNullOrEmpty(typeName))
                {
                    if (((this._attributes != null) || (base.ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere)) || ((this.TraceOutputOptions != TraceOptions.None) || !string.IsNullOrEmpty(base.InitData)))
                    {
                        throw new ConfigurationErrorsException(System.SR.GetString("Reference_listener_cant_have_properties", new object[] { this.Name }));
                    }
                    if (DiagnosticsConfiguration.SharedListeners == null)
                    {
                        throw new ConfigurationErrorsException(System.SR.GetString("Reference_to_nonexistent_listener", new object[] { this.Name }));
                    }
                    ListenerElement element = DiagnosticsConfiguration.SharedListeners[this.Name];
                    if (element == null)
                    {
                        throw new ConfigurationErrorsException(System.SR.GetString("Reference_to_nonexistent_listener", new object[] { this.Name }));
                    }
                    base._runtimeObject = element.RefreshRuntimeObject(listener);
                    return((TraceListener)base._runtimeObject);
                }
                if ((Type.GetType(typeName) != listener.GetType()) || (base.InitData != listener.initializeData))
                {
                    return(this.GetRuntimeObject());
                }
                listener.SetAttributes(this.Attributes);
                listener.TraceOutputOptions = this.TraceOutputOptions;
                if ((base.ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.SetHere) || (base.ElementInformation.Properties[_propFilter.Name].ValueOrigin == PropertyValueOrigin.Inherited))
                {
                    listener.Filter = this.Filter.RefreshRuntimeObject(listener.Filter);
                }
                else
                {
                    listener.Filter = null;
                }
                base._runtimeObject = listener;
                listener2           = listener;
            }
            catch (ArgumentException exception)
            {
                throw new ConfigurationErrorsException(System.SR.GetString("Could_not_create_listener", new object[] { this.Name }), exception);
            }
            return(listener2);
        }