static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (contractContext != null)
{
OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationMessage);
if (wsaAction == null && soapAction != null)
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = soapAction;
}
}
//
}
else
{
//
}
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
if (this.Enable)
{
XsdDataContractExporter dataContractExporter;
object dataContractExporterObj = null;
if (exporter.State.TryGetValue(typeof(XsdDataContractExporter), out dataContractExporterObj))
{
dataContractExporter = dataContractExporterObj as XsdDataContractExporter;
}
else
{
XmlSchemaSet set = exporter.GeneratedXmlSchemas;
//Annotation.GetSchemaAnnotation(set);
//set.Compile();
dataContractExporter = new XsdDataContractExporter(set);
exporter.State.Add(typeof(XsdDataContractExporter), dataContractExporter);
}
if (dataContractExporter.Options == null)
{
dataContractExporter.Options = new ExportOptions();
}
if (dataContractExporter.Options.DataContractSurrogate == null)
{
dataContractExporter.Options.DataContractSurrogate = new DataContractAnnotationSurrogate()
{
ExportAsText = this.ExportAsText, IsBehaviorExtension = this.IsBehaviorExtensions
}
}
;
}
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
if (exporter == null)
{
throw new ArgumentNullException("exporter");
}
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();
}
if (xsdDCExporter.Options.DataContractSurrogate == null)
{
xsdDCExporter.Options.DataContractSurrogate = new AllowNonSerializableTypesSurrogate();
}
}
private static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (contractContext != null)
{
OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationMessage);
if (wsaAction == null && soapAction != null)
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = soapAction;
}
}
//CONSIDER, hsomu: If WS-Addressing action was found, we should verify that it is the same as the SOAP action
// (for the request message).
}
else
{
//CONSIDER, hsomu: verify SOAP action matches referenced contract.operation.message
}
}
/// <summary>
/// When ExportContract is called to generate the necessary metadata, we inspect the service
/// contract and build a list of parameters that we'll need to adjust the XSD for later.
/// </summary>
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
_requiredParameter = new List <RequiredMessagePart>();
foreach (var operation in context.Contract.Operations)
{
var inputMessage = operation.Messages.Where(m => m.Direction == MessageDirection.Input).First();
var parameters = operation.SyncMethod.GetParameters();
Debug.Assert(parameters.Length == inputMessage.Body.Parts.Count);
for (int i = 0; i < parameters.Length; i++)
{
object[] attributes = parameters[i].GetCustomAttributes(typeof(OptionalAttribute), false);
if (attributes.Length == 0)
{
// The parameter has no [Optional] attribute, add it to the list of parameters
// that we need to adjust the XML schema for later on.
_requiredParameter.Add(new RequiredMessagePart()
{
Namespace = inputMessage.Body.Parts[i].Namespace,
Message = operation.Name,
Name = inputMessage.Body.Parts[i].Name
});
}
}
}
}
//
// IWsdlExportExtension Implementation
//
public void ExportContract(
WsdlExporter exporter,
WsdlContractConversionContext context
)
{
// never called
}
internal static void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context, XmlCommentFormat format)
{
InitXsdDataContractExporter(exporter, format);
XmlDocument commentsDoc = XmlCommentsUtils.LoadXmlComments(context.Contract.ContractType, true);
if (commentsDoc == null)
{
return;
}
string comment = XmlCommentsUtils.GetFormattedComment(commentsDoc, context.Contract.ContractType, format);
if (comment != null)
{
context.WsdlPortType.Documentation = comment;
}
foreach (Operation op in context.WsdlPortType.Operations)
{
OperationDescription opDescription = context.GetOperationDescription(op);
MemberInfo mi = opDescription.SyncMethod;
if (mi == null)
{
mi = opDescription.BeginMethod;
}
comment = XmlCommentsUtils.GetFormattedComment(commentsDoc, mi, format);
if (comment != null)
{
op.Documentation = comment;
}
}
}
/// <summary>
/// When ExportContract is called to generate the necessary metadata, we inspect the service
/// contract and build a list of parameters that we'll need to adjust the XSD for later.
/// </summary>
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
_Namespaces = new Dictionary <string, XSDNamespace>();
if (!string.IsNullOrWhiteSpace(HeaderComment))
{
context.WsdlPortType.Documentation = string.Empty;
XmlDocument owner = context.WsdlPortType.DocumentationElement.OwnerDocument;
XmlElement summaryElement = owner.CreateElement("summary");
summaryElement.InnerText = HeaderComment;
context.WsdlPortType.DocumentationElement.AppendChild(summaryElement);
}
foreach (var operation in context.Contract.Operations)
{
foreach (MessageDescription message in operation.Messages.Where(m => m.Direction == MessageDirection.Input))
{
var parameters = operation.SyncMethod.GetParameters();
Debug.Assert(parameters.Length == message.Body.Parts.Count);
for (int i = 0; i < parameters.Length; i++)
{
foreach (PropertyInfo pi in parameters[i].ParameterType.GetProperties())
{
ExtractAttributes(pi, message, operation, message.Body.Parts[0]);
}
}
}
}
}
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
foreach (Operation operation in context.WsdlPortType.Operations)
{
var operationDescription = context.GetOperationDescription(operation);
operationDescription.OperationBehaviors.Add(this);
}
}
private static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string str = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (((contractContext != null) && (WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(contractContext.GetOperationFault(fault)) == null)) && (str != null))
{
fault.Action = str;
}
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
if (_dcs != null && _dcs is IWsdlExportExtension)
{
((IWsdlExportExtension)_dcs).ExportContract(exporter, context);
}
else if (_xcs != null && _xcs is IWsdlExportExtension)
{
((IWsdlExportExtension)_xcs).ExportContract(exporter, context);
}
}
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
foreach (Operation operation in context.WsdlPortType.Operations)
{
var description = context.Contract.Operations.Find(operation.Name);
if (description == null)
{
continue;
}
description.OperationBehaviors.Add(this);
}
}
internal static void Export(WsdlExporter exporter, WsdlContractConversionContext context)
{
foreach (OperationDescription op in context.Contract.Operations)
{
SoapHeaderAttribute[] soapHeaders = (SoapHeaderAttribute[])op.SyncMethod.GetCustomAttributes(typeof(SoapHeaderAttribute), false);
if (soapHeaders.Length > 0)
{
foreach (SoapHeaderAttribute soapHeader in soapHeaders)
{
AddSoapHeader(op, soapHeader);
}
}
}
}
/// <summary>Called when importing a contract.</summary>
/// <param name="importer">The importer.</param>
/// <param name="context">The import context to be modified.</param>
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
// Ensure that the client class has been appropriately created in order for us to add methods to it.
context.Contract.Behaviors.Add(new TaskAsyncServiceContractGenerationExtension());
// For each operation, add a task-based async equivalent.
foreach (Operation operation in context.WsdlPortType.Operations)
{
var description = context.Contract.Operations.Find(operation.Name);
if (description != null)
{
description.Behaviors.Add(new TaskAsyncOperationContractGenerationExtension());
}
}
}
/// <summary>
/// When the contract is exported, we add "CyclicReferencesAwareAttribute" to the export so that the WSDL importer knows
/// where to add the attribute on the client side. Yes, I'll admit it's a little kludge, but it seems to work.
/// </summary>
/// <param name="exporter"></param>
/// <param name="context"></param>
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
if (_contractDescription != null)
{
context.WsdlPortType.Documentation = "CyclicReferencesAwareAttribute";
}
else
{
Operation operation = context.GetOperation(_operationDescription);
if (operation != null)
{
operation.Documentation = "CyclicReferencesAwareAttribute";
}
}
}
private static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string str = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (((contractContext != null) && (WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(contractContext.GetOperationMessage(message)) == null)) && (str != null))
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = str;
}
}
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
string documentation = GetDocumentation(context.WsdlPortType);
context.Contract.Behaviors.Add(new XmlCommentsSvcExtension(this, documentation));
foreach (Operation operation in context.WsdlPortType.Operations)
{
documentation = GetDocumentation(operation);
if (!String.IsNullOrEmpty(documentation))
{
OperationDescription operationDescription = context.Contract.Operations.Find(operation.Name);
operationDescription.Behaviors.Add(new XmlCommentsOpExtension(this, documentation));
}
}
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
// Build the custom header description
var headerDescription = new MessageHeaderDescription(CustomHeader.Name, CustomHeader.Namespace);
headerDescription.Type = typeof(CustomHeader);
// Loop through all the operations defined for the contract and add custom SOAP header to the WSDL
foreach (OperationDescription op in context.Contract.Operations)
{
foreach (MessageDescription messageDescription in op.Messages)
{
messageDescription.Headers.Add(headerDescription);
}
}
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
// This is either for a service contract or operation, so set documentation accordingly.
if (_contractDescription != null)
{
// Attribute was applied to a contract.
context.WsdlPortType.Documentation = this.Text;
}
else
{
// Attribute was applied to an operation.
Operation operation = context.GetOperation(_operationDescription);
if (operation != null)
{
operation.Documentation = this.Text;
}
}
}
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
// Operation Documentation
foreach (Operation operation in context.WsdlPortType.Operations)
{
// Operations with the CyclicReferencesAwareAttribute should have a documentation item
// See CyclicReferencesAwareAttribute::ExportContract for more info
if (operation.Documentation != null && operation.Documentation == "CyclicReferencesAwareAttribute")
{
OperationDescription operationDescription = context.Contract.Operations.Find(operation.Name);
if (operationDescription != null)
{
// System examines the operation behaviors to see whether any implement IWsdlImportExtension.
operationDescription.Behaviors.Add(new CyclicReferencesAwareAttributeImporter());
}
}
}
}
static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (contractContext != null)
{
OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault);
if (wsaAction == null && soapAction != null)
{
fault.Action = soapAction;
}
//
}
else
{
//
}
}
private static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (contractContext != null)
{
OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault);
if (wsaAction == null && soapAction != null)
{
fault.Action = soapAction;
}
//CONSIDER, hsomu: If WS-Addressing action was found, we should verify that it is the same as the SOAP action
// (for the request message).
}
else
{
//CONSIDER, hsomu: verify SOAP action matches referenced contract.operation.message
}
}
// <snippet4>
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
Console.Write("ImportContract");
// Contract Documentation
if (context.WsdlPortType.Documentation != null)
{
context.Contract.Behaviors.Add(new WsdlDocumentationImporter(context.WsdlPortType.Documentation));
}
// Operation Documentation
foreach (Operation operation in context.WsdlPortType.Operations)
{
if (operation.Documentation != null)
{
OperationDescription operationDescription = context.Contract.Operations.Find(operation.Name);
if (operationDescription != null)
{
operationDescription.Behaviors.Add(new WsdlDocumentationImporter(operation.Documentation));
}
}
}
}
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
// Contract documentation
if (context.WsdlPortType.Documentation != null)
{
context.Contract.Behaviors.Add(new WsdlDocumentationImporter(context.WsdlPortType.DocumentationElement));
}
// Operation documentation
foreach (Operation operation in context.WsdlPortType.Operations)
{
if (operation.Documentation == null)
{
continue;
}
var operationDescription = context.Contract.Operations.Find(operation.Name);
operationDescription?.Behaviors.Add(new WsdlDocumentationImporter(operation.DocumentationElement));
}
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
Dictionary <string, MessageHeaderDescription> allHeaders = new Dictionary <string, MessageHeaderDescription>();
foreach (OperationDescription op in context.Contract.Operations)
{
Dictionary <string, SoapHeaderDirection> headerTypes = new Dictionary <string, SoapHeaderDirection>();
List <MessageHeaderDescription> headers = new List <MessageHeaderDescription>();
foreach (MessageDescription msg in op.Messages)
{
foreach (MessageHeaderDescription msgHeader in msg.Headers)
{
SoapHeaderDirection direction = MessageDirectionToSoapHeaderDirection(msg.Direction);
SoapHeaderDirection currentDirection;
if (headerTypes.TryGetValue(msgHeader.Name, out currentDirection))
{
headerTypes[msgHeader.Name] = currentDirection | direction;
}
else
{
headers.Add(msgHeader);
headerTypes[msgHeader.Name] = direction;
}
}
msg.Headers.Clear();
}
Dictionary <MessageHeaderDescription, SoapHeaderDirection> msgHeaders = new Dictionary <MessageHeaderDescription, SoapHeaderDirection>();
foreach (MessageHeaderDescription msgHeader in headers)
{
msgHeaders[msgHeader] = headerTypes[msgHeader.Name];
allHeaders[msgHeader.Name] = msgHeader;
}
op.Behaviors.Add(new SoapHeaderOpExtension(msgHeaders));
}
if (allHeaders.Count > 0) //If any Soap header exists, mark the contract with SoapHeaders attribute
{
context.Contract.Behaviors.Add(new SoapHeaderSvcExtension(allHeaders));
}
}
private void ReplaceEnumerationClassParametersWithEnums(WsdlContractConversionContext context)
{
foreach (var operation in context.Contract.Operations)
{
foreach (var message in operation.Messages)
{
foreach (var part in message.Body.Parts)
{
if (part.Type.IsAssignableFrom(typeof(Expression)))
{
part.Type = typeof(ExpressionNode);
}
//Type enumType;
//if (this.surrogate.Generator.TryGetEnumByType(part.Type, out enumType))
//{
// part.Type = enumType;
//}
}
}
}
}
public void ImportContract(WsdlImporter importer, WsdlContractConversionContext context)
{
// Contract Documentation
if (context.WsdlPortType.Documentation != null)
{
// System examines the contract behaviors to see whether any implement IWsdlImportExtension.
context.Contract.Behaviors.Add(new WsdlDocumentationImporter(context.WsdlPortType.Documentation));
}
// Operation Documentation
foreach (Operation operation in context.WsdlPortType.Operations)
{
if (operation.Documentation != null)
{
OperationDescription operationDescription = context.Contract.Operations.Find(operation.Name);
if (operationDescription != null)
{
// System examines the operation behaviors to see whether any implement IWsdlImportExtension.
operationDescription.Behaviors.Add(new WsdlDocumentationImporter(operation.Documentation));
}
}
}
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
XsdDataContractExporter xsdInventoryExporter;
object dataContractExporter;
if (!exporter.State.TryGetValue(typeof(XsdDataContractExporter), out dataContractExporter))
{
xsdInventoryExporter = new XsdDataContractExporter(exporter.GeneratedXmlSchemas);
exporter.State.Add(typeof(XsdDataContractExporter), xsdInventoryExporter);
}
else
{
xsdInventoryExporter = (XsdDataContractExporter)dataContractExporter;
}
if (xsdInventoryExporter.Options == null)
{
xsdInventoryExporter.Options = new ExportOptions();
}
xsdInventoryExporter.Options.DataContractSurrogate = this.surrogate;
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter,
WsdlContractConversionContext context)
{
throw new NotImplementedException();
}
public void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context)
{
((IWsdlExportExtension)InnerMessageEncodingBindingElement).ExportContract(exporter, context);
}
