private static SoapBinding GetSoapBinding(WsdlEndpointConversionContext endpointContext, WsdlExporter exporter)
{
EnvelopeVersion item = null;
SoapBinding soapBinding = null;
object obj = null;
object obj1 = new object();
if (exporter.State.TryGetValue(obj1, out obj))
{
Dictionary <System.Web.Services.Description.Binding, EnvelopeVersion> bindings = obj as Dictionary <System.Web.Services.Description.Binding, EnvelopeVersion>;
if (bindings != null && bindings.ContainsKey(endpointContext.WsdlBinding))
{
item = bindings[endpointContext.WsdlBinding];
}
}
if (item == EnvelopeVersion.None)
{
return(null);
}
foreach (object extension in endpointContext.WsdlBinding.Extensions)
{
SoapBinding soapBinding1 = extension as SoapBinding;
if (soapBinding1 == null)
{
continue;
}
soapBinding = soapBinding1;
}
return(soapBinding);
}
internal static void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context, Uri uri)
{
LocationOverrideExporter locationExporter = new LocationOverrideExporter(uri);
locationExporter.ExportEndpoint(exporter, context);
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension)inner).ExportEndpoint(exporter, context);
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter,
WsdlEndpointConversionContext context)
{
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension)_innerBindingElement).ExportEndpoint(exporter, context);
}
private static WsdlNS.SoapBinding GetSoapBinding(WsdlEndpointConversionContext endpointContext, WsdlExporter exporter)
{
EnvelopeVersion envelopeVersion = null;
WsdlNS.SoapBinding existingSoapBinding = null;
object versions = null;
object SoapVersionStateKey = new object();
//get the soap version state
if (exporter.State.TryGetValue(SoapVersionStateKey, out versions))
{
Dictionary <WsdlNS.Binding, EnvelopeVersion> vd = (Dictionary <WsdlNS.Binding, EnvelopeVersion>)versions;
if (versions != null && vd.ContainsKey(endpointContext.WsdlBinding))
{
envelopeVersion = vd[endpointContext.WsdlBinding];
}
}
if (envelopeVersion == EnvelopeVersion.None)
{
return(null);
}
//get existing soap binding
foreach (object o in endpointContext.WsdlBinding.Extensions)
{
if (o is WsdlNS.SoapBinding)
{
existingSoapBinding = (WsdlNS.SoapBinding)o;
}
}
return(existingSoapBinding);
}
public void Mtom_Policy()
{
var label = new TestLabel("Mtom_Policy");
var contract = new ContractDescription("MyContract");
var binding = new BasicHttpBinding();
binding.MessageEncoding = WSMessageEncoding.Mtom;
var endpoint = new ServiceEndpoint(
contract, binding, new EndpointAddress(HttpUri));
var exporter = new WsdlExporter();
exporter.ExportEndpoint(endpoint);
Assert.That(exporter.GeneratedWsdlDocuments, Is.Not.Null, label.Get());
Assert.That(exporter.GeneratedWsdlDocuments.Count, Is.EqualTo(1), label.Get());
var wsdl = exporter.GeneratedWsdlDocuments [0];
Assert.That(wsdl.Bindings, Is.Not.Null, label.Get());
Assert.That(wsdl.Bindings.Count, Is.EqualTo(1), label.Get());
var wsb = wsdl.Bindings [0];
label.EnterScope("Binding");
Assert.That(wsb.Extensions, Is.Not.Null, label.Get());
Assert.That(wsb.Extensions.Count, Is.EqualTo(2), label.Get());
label.LeaveScope();
label.EnterScope("Extensions");
WS.SoapBinding soap = null;
XmlElement xml = null;
foreach (var extension in wsb.Extensions)
{
if (extension is WS.SoapBinding)
{
soap = (WS.SoapBinding)extension;
}
else if (extension is XmlElement)
{
xml = (XmlElement)extension;
}
else
{
Assert.Fail("Unknown extension.", label);
}
}
Assert.That(soap, Is.Not.Null, label.Get());
Assert.That(xml, Is.Not.Null, label.Get());
label.LeaveScope();
label.EnterScope("Policy");
var assertions = BindingTestAssertions.AssertPolicy(wsdl, xml, label);
Assert.That(assertions.Count, Is.EqualTo(1), label.Get());
var assertion = assertions [0];
Assert.That(assertion.NamespaceURI, Is.EqualTo("http://schemas.xmlsoap.org/ws/2004/09/policy/optimizedmimeserialization"), label.Get());
Assert.That(assertion.LocalName, Is.EqualTo("OptimizedMimeSerialization"), label.Get());
label.LeaveScope();
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
SetSoapVersion(context, exporter, MessageVersion.Envelope);
}
/// <summary>
/// Invokes SoapHelper.SetSoapVersion as used from original encoders. Seeds the metadata with the appropriate
/// <see cref="SoapBinding"/> element to ensure WSDL renders.
/// </summary>
/// <param name="endpointContext"></param>
/// <param name="exporter"></param>
/// <param name="version"></param>
static void SetSoapVersion(WsdlEndpointConversionContext endpointContext, WsdlExporter exporter, EnvelopeVersion version)
{
SetSoapVersionMethod.Invoke(null, new object[] { endpointContext, exporter, version });
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
XmlCommentsExporter.ExportEndpoint(exporter, Format);
}
void System.ServiceModel.Description.IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension)this.CreateMetadataTemplateBindingElement()).ExportEndpoint(exporter, context);
}
void System.ServiceModel.Description.IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
}
//</snippet1>
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
Console.WriteLine("ExportEndpoint called.");
}
/// <summary>
/// Initializes a new instance of the <see cref="WcfWsdlExport"/> class.
/// </summary>
/// <param name="exporter">The exporter.</param>
/// <param name="context">The context.</param>
internal WcfCustomWsdlExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
_exporter = exporter;
_context = context;
}
//<snippet1>
// <snippet6>
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
// </snippet6>
// <snippet5>
// Add a custom DCAnnotationSurrogate to write data contract comments into the XSD.
object dataContractExporter;
XsdDataContractExporter xsdDCExporter;
if (!exporter.State.TryGetValue(typeof(XsdDataContractExporter), out dataContractExporter))
{
xsdDCExporter = new XsdDataContractExporter(exporter.GeneratedXmlSchemas);
exporter.State.Add(typeof(XsdDataContractExporter), xsdDCExporter);
}
else
{
xsdDCExporter = (XsdDataContractExporter)dataContractExporter;
}
if (xsdDCExporter.Options == null)
{
xsdDCExporter.Options = new ExportOptions();
}
xsdDCExporter.Options.DataContractSurrogate = new DCAnnotationSurrogate();
// </snippet5>
// <snippet7>
Console.WriteLine("Inside ExportContract");
if (context.Contract != null)
{
// Inside this block it is the contract-level comment attribute.
// This.Text returns the string for the contract attribute.
// Set the doc element; if this isn't done first, there is no XmlElement in the
// DocumentElement property.
context.WsdlPortType.Documentation = string.Empty;
// Contract comments.
XmlDocument owner = context.WsdlPortType.DocumentationElement.OwnerDocument;
XmlElement summaryElement = Formatter.CreateSummaryElement(owner, this.Text);
context.WsdlPortType.DocumentationElement.AppendChild(summaryElement);
foreach (OperationDescription op in context.Contract.Operations)
{
Operation operation = context.GetOperation(op);
object[] opAttrs = op.SyncMethod.GetCustomAttributes(typeof(WsdlDocumentationAttribute), false);
if (opAttrs.Length == 1)
{
string opComment = ((WsdlDocumentationAttribute)opAttrs[0]).Text;
// This.Text returns the string for the operation-level attributes.
// Set the doc element; if this isn't done first, there is no XmlElement in the
// DocumentElement property.
operation.Documentation = String.Empty;
// Operation C# triple comments.
XmlDocument opOwner = operation.DocumentationElement.OwnerDocument;
XmlElement newSummaryElement = Formatter.CreateSummaryElement(opOwner, opComment);
operation.DocumentationElement.AppendChild(newSummaryElement);
// Get returns information
ParameterInfo returnValue = op.SyncMethod.ReturnParameter;
object[] returnAttrs = returnValue.GetCustomAttributes(typeof(WsdlParameterDocumentationAttribute), false);
if (returnAttrs.Length == 1)
{
// <returns>text.</returns>
XmlElement returnsElement =
Formatter.CreateReturnsElement(
opOwner,
((WsdlParameterDocumentationAttribute)returnAttrs[0]).ParamComment
);
operation.DocumentationElement.AppendChild(returnsElement);
}
// Get parameter information.
ParameterInfo[] args = op.SyncMethod.GetParameters();
for (int i = 0; i < args.Length; i++)
{
object[] docAttrs
= args[i].GetCustomAttributes(typeof(WsdlParameterDocumentationAttribute), false);
if (docAttrs.Length != 0)
{
// <param name="Int1">Text.</param>
XmlElement newParamElement = opOwner.CreateElement("param");
XmlAttribute paramName = opOwner.CreateAttribute("name");
paramName.Value = args[i].Name;
newParamElement.InnerText
= ((WsdlParameterDocumentationAttribute)docAttrs[0]).ParamComment;
newParamElement.Attributes.Append(paramName);
operation.DocumentationElement.AppendChild(newParamElement);
}
}
}
}
}
// </snippet7>
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
this.ReplaceEnumerationClassParametersWithEnums(context);
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension)InnerMessageEncodingBindingElement).ExportEndpoint(exporter, context);
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
/* intentionally not implemented */
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
((IWsdlExportExtension)_innerFormatterBehavior).ExportEndpoint(exporter, context);
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter,
WsdlContractConversionContext context)
{
throw new NotImplementedException();
}
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext)
{
throw new NotImplementedException();
}
public void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context)
{
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
Debug.WriteLine("Inside ExportContract");
if (contractDescription != null)
{
// Inside this block it is the contract-level comment attribute.
// This.Text returns the string for the contract attribute.
// Set the doc element; if this isn't done first, there is no XmlElement in the
// DocumentElement property.
context.WsdlPortType.Documentation = string.Empty;
// Contract comments.
XmlDocument owner = context.WsdlPortType.DocumentationElement.OwnerDocument;
XmlElement summaryElement = owner.CreateElement("summary");
summaryElement.InnerText = this.Text;
context.WsdlPortType.DocumentationElement.AppendChild(summaryElement);
}
else
{
Operation operation = context.GetOperation(operationDescription);
if (operation != null)
{
// We are dealing strictly with the operation here.
// This.Text returns the string for the operation-level attributes.
// Set the doc element; if this isn't done first, there is no XmlElement in the
// DocumentElement property.
operation.Documentation = String.Empty;
// Operation C# triple comments.
XmlDocument owner = operation.DocumentationElement.OwnerDocument;
XmlElement newSummaryElement = owner.CreateElement("summary");
newSummaryElement.InnerText = this.Text;
operation.DocumentationElement.AppendChild(newSummaryElement);
// Get returns information
ParameterInfo returnValue = operationDescription.SyncMethod.ReturnParameter;
object[] returnAttrs = returnValue.GetCustomAttributes(typeof(WsdlParamOrReturnDocumentationAttribute), false);
if (returnAttrs.Length != 0)
{
// <returns>text.</returns>
XmlElement returnsElement = owner.CreateElement("returns");
returnsElement.InnerText = ((WsdlParamOrReturnDocumentationAttribute)returnAttrs[0]).ParamComment;
operation.DocumentationElement.AppendChild(returnsElement);
}
// Get parameter information.
ParameterInfo[] args = operationDescription.SyncMethod.GetParameters();
for (int i = 0; i < args.Length; i++)
{
object[] docAttrs = args[i].GetCustomAttributes(typeof(WsdlParamOrReturnDocumentationAttribute), false);
if (docAttrs.Length == 1)
{
// <param name="Int1">Text.</param>
XmlElement newParamElement = owner.CreateElement("param");
XmlAttribute paramName = owner.CreateAttribute("name");
paramName.Value = args[i].Name;
newParamElement.InnerText = ((WsdlParamOrReturnDocumentationAttribute)docAttrs[0]).ParamComment;
newParamElement.Attributes.Append(paramName);
operation.DocumentationElement.AppendChild(newParamElement);
}
}
}
}
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
XmlCommentsExporter.ExportContract(exporter, context, Format);
}
internal static void ExportWsdlEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext,
string wsdlTransportUri, AddressingVersion addressingVersion)
{
ExportWsdlEndpoint(exporter, endpointContext, wsdlTransportUri, endpointContext.Endpoint.Address, addressingVersion);
}
