private Header[] GetChannelHeaders(ITransportHeaders requestHeaders, out string soapActionToVerify) { string str3; string str4; soapActionToVerify = null; string uRI = (string)requestHeaders["__RequestUri"]; string uri = (string)requestHeaders["SOAPAction"]; if (uri == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } uri = HttpEncodingHelper.DecodeUri(uri); soapActionToVerify = uri; if (!SoapServices.GetTypeAndMethodNameFromSoapAction(uri, out str3, out str4)) { Type serverTypeForUri = RemotingServices.GetServerTypeForUri(uRI); if (serverTypeForUri == null) { throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_TypeNotFoundFromUri"), new object[] { uRI })); } str3 = "clr:" + serverTypeForUri.FullName + ", " + serverTypeForUri.Assembly.GetName().Name; } else { str3 = "clr:" + str3; } int num = 2; Header[] headerArray = new Header[num]; headerArray[0] = new Header("__Uri", uRI); headerArray[1] = new Header("__TypeName", str3); return(headerArray); }
} // Properties // Helper method for analyzing headers private Header[] GetChannelHeaders(ITransportHeaders requestHeaders, out String soapActionToVerify) { soapActionToVerify = null; // transport sink removes any channel specific information String objectURI = (String)requestHeaders[CommonTransportKeys.RequestUri]; // see if a unique SOAPAction is present (if more than one SOAPAction is present some // scenarios won't work, but one-many soap action to method base relationships are // for interop scenarios only) String soapAction = (String)requestHeaders["SOAPAction"]; if (soapAction == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } soapAction = HttpEncodingHelper.DecodeUri(soapAction); soapActionToVerify = soapAction; String typeName, methodName; if (!SoapServices.GetTypeAndMethodNameFromSoapAction(soapAction, out typeName, out methodName)) { // This means there are multiple methods for this soap action, so we will have to // settle for the type based off of the uri. Type type = RemotingServices.GetServerTypeForUri(objectURI); if (type == null) { throw new RemotingException( String.Format( CultureInfo.CurrentCulture, CoreChannel.GetResourceString( "Remoting_TypeNotFoundFromUri"), objectURI)); } // @todo: This throws away the version, culture and public key token typeName = "clr:" + type.FullName + ", " + type.Assembly.GetName().Name; } else { typeName = "clr:" + typeName; } // Create a new header array and pass it back. int headerLen = 2; Header[] h = new Header[headerLen]; h[0] = new Header("__Uri", objectURI); h[1] = new Header("__TypeName", typeName); return(h); } // GetChannelHeaders
public void TestSoapActions() { string act; MethodBase mb; mb = typeof(SoapTest).GetMethod("FesAlgo"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual("myaction", act, "S1"); mb = typeof(SoapTest).GetMethod("FesAlgoMes"); SoapServices.RegisterSoapActionForMethodBase(mb, "anotheraction"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual("anotheraction", act, "S2"); mb = typeof(SoapTest).GetMethod("FesAlgoMesEspecial"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual(GetClassNs(typeof(SoapTest)) + "#FesAlgoMesEspecial", act, "S3"); string typeName, methodName; bool res; res = SoapServices.GetTypeAndMethodNameFromSoapAction("myaction", out typeName, out methodName); Assert.IsTrue(res, "M1"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M2"); Assert.AreEqual("FesAlgo", methodName, "M3"); res = SoapServices.GetTypeAndMethodNameFromSoapAction("anotheraction", out typeName, out methodName); Assert.IsTrue(res, "M4"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M5"); Assert.AreEqual("FesAlgoMes", methodName, "M6"); res = SoapServices.GetTypeAndMethodNameFromSoapAction(GetClassNs(typeof(SoapTest)) + "#FesAlgoMesEspecial", out typeName, out methodName); Assert.IsTrue(res, "M7"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M8"); Assert.AreEqual("FesAlgoMesEspecial", methodName, "M9"); }
String GetHeaders(ISmtpMessage smtpMessage, ref Smtp.Fields headers, ref String contentType, ref Header[] msgHeaders) { // Get the headers from the message object headers = smtpMessage.Fields; #if _DEBUG long count = headers.Count; InternalRemotingServices.RemotingTrace(" Count of fields " + count); for (long i = 0; i < count; i++) { //InternalRemotingServices.RemotingTrace(" Field " + i + " " + headers[i].Name + " " + headers[i].Value); } #endif // Get the content type string Field typeField = headers["urn:schemas:mailheader:contenttype"]; if (null == typeField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingContentType")); } contentType = (String)(typeField.Value); InternalRemotingServices.RemotingTrace("Content type " + typeField.Name + " " + contentType); // Extract the requested uri from the mail header Field uriField = headers["urn:schemas:mailheader:requesteduri"]; if (null == uriField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingRequestedURIHeader")); } String uriValue = (String)uriField.Value; if (null == uriValue) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingRequestedURIHeader")); } // process SoapAction (extract the type and the name of the method to be invoked) Field actionField = headers["urn:schemas:mailheader:soapaction"]; if (null == actionField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } String actionValue = (String)actionField.Value; if (null == actionValue) { throw new FormatException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } String typeName, methodName; if (!SoapServices.GetTypeAndMethodNameFromSoapAction(actionValue, out typeName, out methodName)) { // This means there are multiple methods for this soap action, so we will have to // settle for the type based off of the uri. Type type = RemotingServices.GetServerTypeForUri(uriValue); typeName = type.FullName + ", " + type.Module.Assembly.GetName().Name; } // BUGBUG: need code to verify soap action after the message has been deserialized. // this will probably be done once we have the new activation scenario working. msgHeaders = new Header[3]; msgHeaders[0] = new Header("__Uri", uriValue); msgHeaders[1] = new Header("__TypeName", typeName); msgHeaders[2] = new Header("__MethodName", methodName); // Extract the message sequence number field from the // mail header Field seqField = headers["urn:schemas:mailheader:soapmsgseqnum"]; if (null == seqField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingSoapMsgSeqNum")); } String seqValue = (String)(seqField.Value); InternalRemotingServices.RemotingTrace("Guid value " + seqValue); return(seqValue); }
public static void Main(string[] args) { //<snippet101> // Convert a CLR namespace and assembly name into an XML namespace. string xmlNamespace = SoapServices.CodeXmlNamespaceForClrTypeNamespace( "ExampleNamespace", "AssemblyName"); Console.WriteLine("The name of the XML namespace is {0}.", xmlNamespace); //</snippet101> //<snippet102> // Extract a CLR namespace and assembly name from an XML namespace. string typeNamespace; string assemblyName; SoapServices.DecodeXmlNamespaceForClrTypeNamespace(xmlNamespace, out typeNamespace, out assemblyName); Console.WriteLine("The name of the CLR namespace is {0}.", typeNamespace); Console.WriteLine("The name of the CLR assembly is {0}.", assemblyName); //</snippet102> //<snippet103> // Get the XML element name and the XML namespace for // an Interop type. string xmlElement; bool isSoapTypeAttribute = SoapServices.GetXmlElementForInteropType( typeof(ExampleNamespace.ExampleClass), out xmlElement, out xmlNamespace); // Print whether the requested value was flagged // with a SoapTypeAttribute. if (isSoapTypeAttribute) { Console.WriteLine( "The requested value was flagged " + "with the SoapTypeAttribute."); } else { Console.WriteLine( "The requested value was not flagged " + "with the SoapTypeAttribute."); } // Print the XML element and the XML namespace. Console.WriteLine( "The XML element for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlElement); Console.WriteLine( "The XML namespace for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlNamespace); //</snippet103> //<snippet104> // Get the XML type name and the XML type namespace for // an Interop type. string xmlTypeName; string xmlTypeNamespace; isSoapTypeAttribute = SoapServices.GetXmlTypeForInteropType( typeof(ExampleNamespace.ExampleClass), out xmlTypeName, out xmlTypeNamespace); // Print whether the requested value was flagged // with a SoapTypeAttribute. if (isSoapTypeAttribute) { Console.WriteLine( "The requested value was flagged " + "with the SoapTypeAttribute."); } else { Console.WriteLine( "The requested value was not flagged " + "with the SoapTypeAttribute."); } // Print the XML type name and the XML type namespace. Console.WriteLine( "The XML type for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlTypeName); Console.WriteLine( "The XML type namespace for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlTypeNamespace); //</snippet104> //<snippet105> // Print the XML namespace for a method invocation and its // response. System.Reflection.MethodBase getHelloMethod = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); string methodCallXmlNamespace = SoapServices.GetXmlNamespaceForMethodCall(getHelloMethod); string methodResponseXmlNamespace = SoapServices.GetXmlNamespaceForMethodResponse(getHelloMethod); Console.WriteLine( "The XML namespace for the invocation of the method " + "GetHello in ExampleClass is {0}.", methodResponseXmlNamespace); Console.WriteLine( "The XML namespace for the response of the method " + "GetHello in ExampleClass is {0}.", methodCallXmlNamespace); //</snippet105> //<snippet106> // Determine whether an XML namespace represents a CLR namespace. string clrNamespace = SoapServices.XmlNsForClrType; if (SoapServices.IsClrTypeNamespace(clrNamespace)) { Console.WriteLine( "The namespace {0} is a CLR namespace.", clrNamespace); } else { Console.WriteLine( "The namespace {0} is not a CLR namespace.", clrNamespace); } //</snippet106> //<snippet130> // Print the XML namespace for the CLR types. Console.WriteLine( "The XML namespace for the CLR types " + "is {0}.", SoapServices.XmlNsForClrType); //</snippet130> //<snippet131> // Print the XML namespace for the CLR types // that have an assembly but no common language runtime namespace. Console.WriteLine( "The XML namespace for the CLR types " + "that have an assembly but no namespace, is {0}.", SoapServices.XmlNsForClrTypeWithAssembly); //</snippet131> //<snippet132> // Print the XML namespace for the CLR types // that are a part of the Mscorlib.dll. Console.WriteLine( "The XML namespace for the CLR types " + "that are part of the Mscorlib.dll, is {0}.", SoapServices.XmlNsForClrTypeWithNs); //</snippet132> //<snippet133> // Print the XML namespace for the CLR types // that have both an assembly and a common language runtime // namespace. Console.WriteLine( "The XML namespace for the CLR types " + "that have both an assembly and a namespace, is {0}.", SoapServices.XmlNsForClrTypeWithNsAndAssembly); //</snippet133> //<snippet140> // Get the SOAP action for the method. System.Reflection.MethodBase getHelloMethodBase = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); string getHelloSoapAction = SoapServices.GetSoapActionFromMethodBase(getHelloMethodBase); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", getHelloSoapAction); bool isSoapActionValid = SoapServices.IsSoapActionValidForMethodBase( getHelloSoapAction, getHelloMethodBase); if (isSoapActionValid) { Console.WriteLine( "The SOAP action, {0}, " + "is valid for ExampleClass.GetHello", getHelloSoapAction); } else { Console.WriteLine( "The SOAP action, {0}, " + "is not valid for ExampleClass.GetHello", getHelloSoapAction); } // Register the SOAP action for the GetHello method. SoapServices.RegisterSoapActionForMethodBase(getHelloMethodBase); // Get the type and the method names encoded into the SOAP action. string encodedTypeName; string encodedMethodName; SoapServices.GetTypeAndMethodNameFromSoapAction( getHelloSoapAction, out encodedTypeName, out encodedMethodName); Console.WriteLine( "The type name encoded in this SOAP action is {0}.", encodedTypeName); Console.WriteLine( "The method name encoded in this SOAP action is {0}.", encodedMethodName); //</snippet140> //<snippet150> // Get the name and the type of the field using its XML // element name and its XML namespace. For this query to work, // the containing type must be preloaded, and the XML element // name and the XML namespace must be explicitly declared on // the field using a SoapFieldAttribute. // Preload the containing type. SoapServices.PreLoad(typeof(ExampleNamespace.ExampleClass)); // Get the name and the type of a field that will be // serialized as an XML element. Type containingType = typeof(ExampleNamespace.ExampleClass); string xmlElementNamespace = "http://example.org/ExampleFieldNamespace"; string xmlElementName = "ExampleFieldElementName"; Type fieldType; string fieldName; SoapServices.GetInteropFieldTypeAndNameFromXmlElement( containingType, xmlElementName, xmlElementNamespace, out fieldType, out fieldName); Console.WriteLine( "The type of the field is {0}.", fieldType); Console.WriteLine( "The name of the field is {0}.", fieldName); // Get the name and the type of a field that will be // serialized as an XML attribute. string xmlAttributeNamespace = "http://example.org/ExampleAttributeNamespace"; string xmlAttributeName = "ExampleFieldAttributeName"; SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute( containingType, xmlAttributeName, xmlAttributeNamespace, out fieldType, out fieldName); Console.WriteLine( "The type of the field is {0}.", fieldType); Console.WriteLine( "The name of the field is {0}.", fieldName); //</snippet150> //<snippet160> string interopTypeXmlElementName = "ExampleClassElementName"; string interopTypeXmlNamespace = "http://example.org/ExampleXmlNamespace"; Type interopType = SoapServices.GetInteropTypeFromXmlElement( interopTypeXmlElementName, interopTypeXmlNamespace); Console.WriteLine("The interop type is {0}.", interopType); string interopTypeXmlTypeName = "ExampleXmlTypeName"; string interopTypeXmlTypeNamespace = "http://example.org/ExampleXmlTypeNamespace"; interopType = SoapServices.GetInteropTypeFromXmlType( interopTypeXmlTypeName, interopTypeXmlTypeNamespace); Console.WriteLine("The interop type is {0}.", interopType); //</snippet160> //<snippet170> // Get the method base object for the GetHello method. System.Reflection.MethodBase methodBase = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); // Print its current SOAP action. Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); // Set the SOAP action of the GetHello method to a new value. string newSoapAction = "http://example.org/ExampleSoapAction#NewSoapAction"; SoapServices.RegisterSoapActionForMethodBase( methodBase, newSoapAction); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); // Reset the SOAP action of the GetHello method to its default // value, which is determined using its SoapMethod attribute. SoapServices.RegisterSoapActionForMethodBase(methodBase); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); //</snippet170> //<snippet120> // Register all types in the assembly with the SoapType attribute. System.Reflection.Assembly executingAssembly = System.Reflection.Assembly.GetExecutingAssembly(); SoapServices.PreLoad(executingAssembly); //</snippet120> //<snippet121> // Register a specific type with the SoapType attribute. Type exampleType = typeof(ExampleNamespace.ExampleClass); SoapServices.PreLoad(exampleType); //</snippet121> //<snippet180> // Get the currently registered type for the given XML element // and namespace. string registeredXmlElementName = "ExampleClassElementName"; string registeredXmlNamespace = "http://example.org/ExampleXmlNamespace"; Type registeredType = SoapServices.GetInteropTypeFromXmlElement( registeredXmlElementName, registeredXmlNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); // Register a new type for the XML element and namespace. SoapServices.RegisterInteropXmlElement( registeredXmlElementName, registeredXmlNamespace, typeof(String)); // Get the currently registered type for the given XML element // and namespace. registeredType = SoapServices.GetInteropTypeFromXmlElement( registeredXmlElementName, registeredXmlNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); //</snippet180> //<snippet190> // Get the currently registered type for the given XML element // and namespace. string registeredXmlTypeName = "ExampleXmlTypeName"; string registeredXmlTypeNamespace = "http://example.org/ExampleXmlTypeNamespace"; registeredType = SoapServices.GetInteropTypeFromXmlType( registeredXmlTypeName, registeredXmlTypeNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); // Register a new type for the XML element and namespace. SoapServices.RegisterInteropXmlType( registeredXmlTypeName, registeredXmlTypeNamespace, typeof(String)); // Get the currently registered type for the given XML element // and namespace. registeredType = SoapServices.GetInteropTypeFromXmlType( registeredXmlTypeName, registeredXmlTypeNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); //</snippet190> }