public void NamedServiceBinding () { SoapServerType sst = new SoapServerType (typeof (EdaInterface), WebServiceProtocols.HttpSoap); new ServerType (typeof (EdaInterface)); SoapServerMethod m = sst.GetMethod ("urn:localBinding:local:LocalBindingMethod"); Assert.IsNotNull (m, "#1"); m = sst.GetMethod ("somethingFoo"); Assert.IsNull (m, "#2"); MethodInfo mi = typeof (EdaInterface).GetMethod ("BindingMethod"); Assert.IsNotNull ("#3-1"); m = sst.GetMethod (mi); // ... so, MethodInfo does not work as a key here. Assert.IsNull (m, "#3-2"); }
internal override bool Initialize() { // try to guess the request version so we can handle any exceptions that might come up GuessVersion(); message = new SoapServerMessage(this); onewayInitException = null; if (null == (serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type)) && null == (serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type, true))) { lock (InternalSyncObject) { if (null == (serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type)) && null == (serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type, true))) { bool excludeSchemeHostPortFromCachingKey = this.IsCacheUnderPressure(typeof(SoapServerProtocol), Type); serverType = new SoapServerType(Type, protocolsSupported); AddToCache(typeof(SoapServerProtocol), Type, serverType, excludeSchemeHostPortFromCachingKey); } } } // We delay throwing any exceptions out of the extension until we determine if the method is one-way or not. Exception extensionException = null; try { message.highPriConfigExtensions = SoapMessage.InitializeExtensions(serverType.HighPriExtensions, serverType.HighPriExtensionInitializers); // // Allow derived classes to modify the high priority extensions list. // message.highPriConfigExtensions = ModifyInitializedExtensions(PriorityGroup.High, message.highPriConfigExtensions); // For one-way methods we rely on Request.InputStream guaranteeing that the entire request body has arrived message.SetStream(Request.InputStream); #if DEBUG //Debug.Assert(message.Stream.CanSeek, "Web services SOAP handler assumes a seekable stream."); // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (!message.Stream.CanSeek) throw new InvalidOperationException("Non-Seekable stream " + message.Stream.GetType().FullName + " Web services SOAP handler assumes a seekable stream."); #endif message.InitExtensionStreamChain(message.highPriConfigExtensions); message.SetStage(SoapMessageStage.BeforeDeserialize); message.ContentType = Request.ContentType; message.ContentEncoding = Request.Headers[ContentType.ContentEncoding]; message.RunExtensions(message.highPriConfigExtensions, false); extensionException = message.Exception; } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", e); extensionException = e; } // set this here since we might throw before we init the other extensions message.allExtensions = message.highPriConfigExtensions; // maybe the extensions that just ran changed some of the request data so we can make a better version guess GuessVersion(); try { this.serverMethod = RouteRequest(message); // the RouteRequest impl should throw an exception if it can't route the request but just in case... if (this.serverMethod == null) throw new SoapException(Res.GetString(Res.UnableToHandleRequest0), new XmlQualifiedName(Soap.Code.Server, Soap.Namespace)); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (helper.RequestNamespace != null) SetHelper(SoapServerProtocolHelper.GetHelper(this, helper.RequestNamespace)); // version mismatches override other errors CheckHelperVersion(); throw; } this.isOneWay = serverMethod.oneWay; if (extensionException == null) { try { SoapReflectedExtension[] otherReflectedExtensions = (SoapReflectedExtension[]) CombineExtensionsHelper(serverMethod.extensions, serverType.LowPriExtensions, typeof(SoapReflectedExtension)); object[] otherInitializers = (object[]) CombineExtensionsHelper(serverMethod.extensionInitializers, serverType.LowPriExtensionInitializers, typeof(object)); message.otherExtensions = SoapMessage.InitializeExtensions(otherReflectedExtensions, otherInitializers); // // Allow derived classes to modify the other extensions list. // message.otherExtensions = ModifyInitializedExtensions(PriorityGroup.Low, message.otherExtensions); message.allExtensions = (SoapExtension[]) CombineExtensionsHelper(message.highPriConfigExtensions, message.otherExtensions, typeof(SoapExtension)); } catch (Exception e) { if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) { throw; } if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", e); extensionException = e; } } if (extensionException != null) { if (isOneWay) onewayInitException = extensionException; else if (extensionException is SoapException) throw extensionException; else throw SoapException.Create(Version, Res.GetString(Res.WebConfigExtensionError), new XmlQualifiedName(Soap.Code.Server, Soap.Namespace), extensionException); } return true; }
internal override bool Initialize() { this.GuessVersion(); this.message = new SoapServerMessage(this); this.onewayInitException = null; this.serverType = (SoapServerType)base.GetFromCache(typeof(SoapServerProtocol), base.Type); if (this.serverType == null) { lock (ServerProtocol.InternalSyncObject) { this.serverType = (SoapServerType)base.GetFromCache(typeof(SoapServerProtocol), base.Type); if (this.serverType == null) { this.serverType = new SoapServerType(base.Type, this.protocolsSupported); base.AddToCache(typeof(SoapServerProtocol), base.Type, this.serverType); } } } Exception innerException = null; try { this.message.highPriConfigExtensions = SoapMessage.InitializeExtensions(this.serverType.HighPriExtensions, this.serverType.HighPriExtensionInitializers); this.message.highPriConfigExtensions = this.ModifyInitializedExtensions(PriorityGroup.High, this.message.highPriConfigExtensions); this.message.SetStream(base.Request.InputStream); this.message.InitExtensionStreamChain(this.message.highPriConfigExtensions); this.message.SetStage(SoapMessageStage.BeforeDeserialize); this.message.ContentType = base.Request.ContentType; this.message.ContentEncoding = base.Request.Headers["Content-Encoding"]; this.message.RunExtensions(this.message.highPriConfigExtensions, false); innerException = this.message.Exception; } catch (Exception exception2) { if (((exception2 is ThreadAbortException) || (exception2 is StackOverflowException)) || (exception2 is OutOfMemoryException)) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", exception2); } innerException = exception2; } this.message.allExtensions = this.message.highPriConfigExtensions; this.GuessVersion(); try { this.serverMethod = this.RouteRequest(this.message); if (this.serverMethod == null) { throw new SoapException(System.Web.Services.Res.GetString("UnableToHandleRequest0"), new XmlQualifiedName("Server", "http://schemas.xmlsoap.org/soap/envelope/")); } } catch (Exception exception3) { if (((exception3 is ThreadAbortException) || (exception3 is StackOverflowException)) || (exception3 is OutOfMemoryException)) { throw; } if (this.helper.RequestNamespace != null) { this.SetHelper(SoapServerProtocolHelper.GetHelper(this, this.helper.RequestNamespace)); } this.CheckHelperVersion(); throw; } this.isOneWay = this.serverMethod.oneWay; if (innerException == null) { try { SoapReflectedExtension[] reflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(this.serverMethod.extensions, this.serverType.LowPriExtensions, typeof(SoapReflectedExtension)); object[] extensionInitializers = (object[])CombineExtensionsHelper(this.serverMethod.extensionInitializers, this.serverType.LowPriExtensionInitializers, typeof(object)); this.message.otherExtensions = SoapMessage.InitializeExtensions(reflectedExtensions, extensionInitializers); this.message.otherExtensions = this.ModifyInitializedExtensions(PriorityGroup.Low, this.message.otherExtensions); this.message.allExtensions = (SoapExtension[])CombineExtensionsHelper(this.message.highPriConfigExtensions, this.message.otherExtensions, typeof(SoapExtension)); } catch (Exception exception4) { if (((exception4 is ThreadAbortException) || (exception4 is StackOverflowException)) || (exception4 is OutOfMemoryException)) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", exception4); } innerException = exception4; } } if (innerException != null) { if (!this.isOneWay) { if (innerException is SoapException) { throw innerException; } throw SoapException.Create(this.Version, System.Web.Services.Res.GetString("WebConfigExtensionError"), new XmlQualifiedName("Server", "http://schemas.xmlsoap.org/soap/envelope/"), innerException); } this.onewayInitException = innerException; } return(true); }
public void ConstructorHttpGet () { SoapServerType st = new SoapServerType (typeof (EdaInterface), WebServiceProtocols.HttpGet); // I wonder if this property makes sense here ... Assert.IsTrue (st.ServiceRoutingOnSoapAction, "#1"); }
public void GetMethodNullKey () { SoapServerType sst = new SoapServerType (typeof (EdaInterface), WebServiceProtocols.HttpSoap); sst.GetMethod (null); }
internal override bool Initialize() { // try to guess the request version so we can handle any exceptions that might come up GuessVersion(); message = new SoapServerMessage(this); onewayInitException = null; serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type); if (serverType == null) { lock (Type){ serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type); if (serverType == null) { serverType = new SoapServerType(Type, versionsSupported); AddToCache(typeof(SoapServerProtocol), Type, serverType); } } } // We delay throwing any exceptions out of the extension until we determine if the method is one-way or not. Exception extensionException = null; try { message.highPriConfigExtensions = SoapMessage.InitializeExtensions(serverType.HighPriExtensions, serverType.HighPriExtensionInitializers); // For one-way methods we rely on Request.InputStream guaranteeing that the entire request body has arrived message.SetStream(Request.InputStream); Debug.Assert(message.Stream.CanSeek, "Web services SOAP handler assumes a seekable stream."); message.InitExtensionStreamChain(message.highPriConfigExtensions); message.SetStage(SoapMessageStage.BeforeDeserialize); message.ContentType = Request.ContentType; message.ContentEncoding = Request.Headers[ContentType.ContentEncoding]; message.RunExtensions(message.highPriConfigExtensions); } catch (Exception e) { extensionException = e; } // set this here since we might throw before we init the other extensions message.allExtensions = message.highPriConfigExtensions; // maybe the extensions that just ran changed some of the request data so we can make a better version guess GuessVersion(); try { this.serverMethod = helper.RouteRequest(); // the RouteRequest impl should throw an exception if it can't route the request but just in case... if (this.serverMethod == null) { throw new SoapException(Res.GetString(Res.UnableToHandleRequest0), new XmlQualifiedName(Soap.ServerCode, Soap.Namespace)); } } catch (Exception) { if (helper.RequestNamespace != null) { SetHelper(SoapServerProtocolHelper.GetHelper(this, helper.RequestNamespace)); } // version mismatches override other errors CheckHelperVersion(); throw; } this.isOneWay = serverMethod.oneWay; if (extensionException == null) { try { SoapReflectedExtension[] otherReflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(serverMethod.extensions, serverType.LowPriExtensions, typeof(SoapReflectedExtension)); object[] otherInitializers = (object[])CombineExtensionsHelper(serverMethod.extensionInitializers, serverType.LowPriExtensionInitializers, typeof(object)); message.otherExtensions = SoapMessage.InitializeExtensions(otherReflectedExtensions, otherInitializers); message.allExtensions = (SoapExtension[])CombineExtensionsHelper(message.highPriConfigExtensions, message.otherExtensions, typeof(SoapExtension)); } catch (Exception e) { extensionException = e; } } if (extensionException != null) { if (isOneWay) { onewayInitException = extensionException; } else { throw new SoapException(Res.GetString(Res.WebConfigExtensionError), new XmlQualifiedName(Soap.ServerCode, Soap.Namespace), extensionException); } } return(true); }