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>
}