void IWsdlImportExtension.ImportContract (WsdlImporter importer,
WsdlContractConversionContext context)
{
if (!enabled)
return;
if (importer == null)
throw new ArgumentNullException ("importer");
if (context == null)
throw new ArgumentNullException ("context");
if (this.importer != null || this.context != null)
throw new SystemException ("INTERNAL ERROR: unexpected recursion of ImportContract method call");
#if USE_DATA_CONTRACT_IMPORTER
dc_importer = new XsdDataContractImporter ();
schema_set_in_use = new XmlSchemaSet ();
schema_set_in_use.Add (importer.XmlSchemas);
foreach (WSDL wsdl in importer.WsdlDocuments)
foreach (XmlSchema xs in wsdl.Types.Schemas)
schema_set_in_use.Add (xs);
dc_importer.Import (schema_set_in_use);
#endif
this.importer = importer;
this.context = context;
try {
DoImportContract ();
} finally {
this.importer = null;
this.context = null;
}
}
static void UseWcf()
{
/*
动态下载服务元数据
*/
MetadataExchangeClient metaExchangeClient =
new MetadataExchangeClient(
new Uri("http://localhost:8002/ManualService"),
MetadataExchangeClientMode.HttpGet
);
//下载元数据
MetadataSet metadataSet = metaExchangeClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metadataSet);
ServiceEndpointCollection endpointCollection = importer.ImportAllEndpoints();
IManulService manulProxy = null;
foreach (ServiceEndpoint endPointItem in endpointCollection)
{
manulProxy = new ChannelFactory<IManulService>(
endPointItem.Binding,
endPointItem.Address
).CreateChannel();
((IChannel)manulProxy).Open();
Console.WriteLine("WCF调用结果为：{0}",
manulProxy.GetData());
((IChannel)manulProxy).Close();
}
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer,
WsdlContractConversionContext context)
{
if (!enabled)
{
return;
}
if (importer == null)
{
throw new ArgumentNullException("importer");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (this.importer != null || this.context != null)
{
throw new SystemException("INTERNAL ERROR: unexpected recursion of ImportContract method call");
}
this.importer = importer;
this.context = context;
try {
DoImportContract();
} finally {
this.importer = null;
this.context = null;
}
}
static void Generate(string url, TextWriter writer)
{
var cr = new ContractReference();
cr.Url = url;
var protocol = new DiscoveryClientProtocol();
var wc = new WebClient();
using (var stream = wc.OpenRead(cr.Url))
protocol.Documents.Add(cr.Url, cr.ReadDocument(stream));
var mset = ToMetadataSet(protocol);
var importer = new WsdlImporter(mset);
var xsdImporter = new XsdDataContractImporter();
var options = new ImportOptions();
options.ReferencedCollectionTypes.Add(typeof(LinkedList<>));
xsdImporter.Options = options;
importer.State.Add(typeof(XsdDataContractImporter), xsdImporter);
Collection<ContractDescription> contracts = importer.ImportAllContracts();
CodeCompileUnit ccu = new CodeCompileUnit();
CodeNamespace cns = new CodeNamespace("TestNamespace");
ccu.Namespaces.Add(cns);
var generator = new ServiceContractGenerator(ccu);
foreach (var cd in contracts)
generator.GenerateServiceContractType(cd);
var provider = new CSharpCodeProvider();
provider.GenerateCodeFromCompileUnit(ccu, writer, null);
}
protected override void Init(WsdlImporter importer)
{
if (dc_importer == null)
{
dc_importer = importer.GetState <XsdDataContractImporter> ();
}
}
protected override void Init(WsdlImporter importer)
{
if (ccu == null)
{
ccu = importer.GetState <CodeCompileUnit> ();
}
}
static internal void ImportMessageBinding(WsdlImporter importer, WsdlEndpointConversionContext endpointContext, Type schemaImporterType)
{
// All the work is done in ImportMessageContract call
bool isReferencedContract = IsReferencedContract(importer, endpointContext);
MarkSoapExtensionsAsHandled(endpointContext.WsdlBinding);
foreach (WsdlNS.OperationBinding wsdlOperationBinding in endpointContext.WsdlBinding.Operations)
{
OperationDescription operation = endpointContext.GetOperationDescription(wsdlOperationBinding);
if (isReferencedContract || OperationHasBeenHandled(operation))
{
MarkSoapExtensionsAsHandled(wsdlOperationBinding);
if (wsdlOperationBinding.Input != null)
{
MarkSoapExtensionsAsHandled(wsdlOperationBinding.Input);
}
if (wsdlOperationBinding.Output != null)
{
MarkSoapExtensionsAsHandled(wsdlOperationBinding.Output);
}
foreach (WsdlNS.MessageBinding wsdlMessageBinding in wsdlOperationBinding.Faults)
{
MarkSoapExtensionsAsHandled(wsdlMessageBinding);
}
}
}
}
private static void GenerateCodeDomTree(WsdlImporter wsdlImporter, ServiceContractGenerator contractGenerator)
{
Collection<ContractDescription> contracts = wsdlImporter.ImportAllContracts();
Collection<Binding> bindings = wsdlImporter.ImportAllBindings();
ServiceEndpointCollection endpoints = wsdlImporter.ImportAllEndpoints();
if (wsdlImporter.Errors.Any(e => !e.IsWarning))
{
throw new CodeGenerationException(wsdlImporter.Errors);
}
foreach (ContractDescription contract in contracts)
{
//TODO:Alex:Make the naming scheme customisable.
contract.Name = "I" + contract.Name.Replace("Interface", string.Empty);
contractGenerator.GenerateServiceContractType(contract);
}
foreach (Binding binding in bindings)
{
string bindingSectionName, configurationName;
contractGenerator.GenerateBinding(binding, out bindingSectionName, out configurationName);
}
foreach (ServiceEndpoint endpoint in endpoints)
{
ChannelEndpointElement channelElement;
contractGenerator.GenerateServiceEndpoint(endpoint, out channelElement);
}
}
private static ServiceEndpointCollection ResolveContracts(
IEnumerable <ContractDescription> contracts,
Func <MetadataSet> metadataGetter)
{
if (contracts == null)
{
throw new ArgumentNullException("contracts");
}
List <ContractDescription> list = new List <ContractDescription> (contracts);
if (list.Count == 0)
{
throw new ArgumentException("There must be atleast one ContractDescription", "contracts");
}
MetadataSet metadata = metadataGetter();
WsdlImporter importer = new WsdlImporter(metadata);
ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
ServiceEndpointCollection ret = new ServiceEndpointCollection();
foreach (ContractDescription contract in list)
{
Collection <ServiceEndpoint> colln =
endpoints.FindAll(new QName(contract.Name, contract.Namespace));
for (int i = 0; i < colln.Count; i++)
{
ret.Add(colln [i]);
}
}
return(ret);
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer, WsdlContractConversionContext contractContext)
{
if (contractContext == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("contractContext"));
MessageContractImporter.ImportMessageContract(importer, contractContext, MessageContractImporter.XmlSerializerSchemaImporter.Get(importer));
}
void IWsdlImportExtension.ImportContract (WsdlImporter importer,
WsdlContractConversionContext context)
{
if (!enabled)
return;
if (importer == null)
throw new ArgumentNullException ("importer");
if (context == null)
throw new ArgumentNullException ("context");
if (this.importer != null || this.context != null)
throw new SystemException ("INTERNAL ERROR: unexpected recursion of ImportContract method call");
dc_importer = new XsdDataContractImporter ();
schema_set_in_use = new XmlSchemaSet ();
schema_set_in_use.Add (importer.XmlSchemas);
foreach (WSDL wsdl in importer.WsdlDocuments)
foreach (XmlSchema xs in wsdl.Types.Schemas)
schema_set_in_use.Add (xs);
// commenting out this import operation, but might be required (I guess not).
//dc_importer.Import (schema_set_in_use);
schema_set_in_use.Compile ();
this.importer = importer;
this.context = context;
try {
DoImportContract ();
} finally {
this.importer = null;
this.context = null;
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
#pragma warning suppress 56506 // [....], these properties cannot be null in this context
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
#pragma warning suppress 56506 // [....], CustomBinding.Elements never be null
TransportBindingElement transportBindingElement = GetBindingElements(context).Find<TransportBindingElement>();
bool transportHandledExternaly = (transportBindingElement != null) && !StateHelper.IsRegisteredTransportBindingElement(importer, context);
if (transportHandledExternaly)
return;
#pragma warning suppress 56506 // [....], these properties cannot be null in this context
WsdlNS.SoapBinding soapBinding = (WsdlNS.SoapBinding)context.WsdlBinding.Extensions.Find(typeof(WsdlNS.SoapBinding));
if (soapBinding != null && transportBindingElement == null)
{
CreateLegacyTransportBindingElement(importer, soapBinding, context);
}
// Try to import WS-Addressing address from the port
if (context.WsdlPort != null)
{
ImportAddress(context, transportBindingElement);
}
}
void NoExtensionsSetup ()
{
XmlReaderSettings xs = new XmlReaderSettings ();
xs.IgnoreWhitespace = true;
xtr = XmlTextReader.Create ("Test/System.ServiceModel.Description/dump.xml", xs);
xtr.Read ();
//FIXME: skipping Headers
while (xtr.LocalName != "Body") {
if (!xtr.Read ())
return;
}
//Move to <Metadata ..
xtr.Read ();
ms = MetadataSet.ReadFrom (xtr);
//MyWsdlImportExtension mw = new MyWsdlImportExtension ();
List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
//list.Add (mw);
list.Add (new DataContractSerializerMessageContractImporter ());
/*list.Add (new MessageEncodingBindingElementImporter ());
list.Add (new TransportBindingElementImporter ());
list.Add (new StandardBindingImporter ());*/
wi = new WsdlImporter (ms, null, list);
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context != null && context.WsdlBinding != null && ContainsHttpBindingExtension(context.WsdlBinding))
{
httpBindingContracts.Add(context.ContractConversionContext.Contract);
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer,
WsdlEndpointConversionContext context)
{
for (int i = 0; i < context.WsdlBinding.Extensions.Count; i ++) {
if (context.WsdlBinding.Extensions [i] is SoapBinding) {
SoapBinding transport = context.WsdlBinding.Extensions [i] as SoapBinding;
if (transport.Transport != SoapBinding.HttpTransport)
//FIXME: not http
return;
if (! (context.Endpoint.Binding is CustomBinding))
//FIXME:
throw new Exception ();
((CustomBinding) context.Endpoint.Binding).Elements.Add (new HttpTransportBindingElement ());
//((CustomBinding) context.Endpoint.Binding).Scheme = "http";
for (int j = 0; j < context.WsdlPort.Extensions.Count; j ++) {
SoapAddressBinding address = context.WsdlPort.Extensions [j] as SoapAddressBinding;
if (address == null)
continue;
context.Endpoint.Address = new EndpointAddress (address.Location);
context.Endpoint.ListenUri = new Uri (address.Location);
}
break;
}
}
}
static void GenerateVBCodeForService(Uri metadataAddress, string outputFile)
{
MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress, MetadataExchangeClientMode.HttpGet);
mexClient.ResolveMetadataReferences = true;
MetadataSet metaDocs = mexClient.GetMetadata();
WsdlImporter importer = new WsdlImporter(metaDocs);
ServiceContractGenerator generator = new ServiceContractGenerator();
System.Collections.ObjectModel.Collection<ContractDescription> contracts = importer.ImportAllContracts();
foreach (ContractDescription contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
throw new ApplicationException("There were errors during code compilation.");
// Write the code dom.
System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
options.BracingStyle = "C";
System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VB");
System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
codeDomProvider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, textWriter, options);
textWriter.Close();
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
if (endpointContext == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("endpointContext"));
MessageContractImporter.ImportMessageBinding(importer, endpointContext, typeof(MessageContractImporter.XmlSerializerSchemaImporter));
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress, BindingElement bindingElement)
{
var binding = new CustomBinding(bindingElement);
var MEXClient = new MetadataExchangeClient(binding);
var metadata = MEXClient.GetMetadata(new EndpointAddress(mexAddress));
var importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer, WsdlContractConversionContext contractContext)
{
if (contractContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("contractContext"));
}
MessageContractImporter.ImportMessageContract(importer, contractContext, MessageContractImporter.XmlSerializerSchemaImporter.Get(importer));
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
if (endpointContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("endpointContext"));
}
MessageContractImporter.ImportMessageBinding(importer, endpointContext, typeof(MessageContractImporter.XmlSerializerSchemaImporter));
}
public void ImportEndpoint (WsdlImporter importer, WsdlEndpointConversionContext context)
{
// Only import the binding, not the endpoint.
if (context.WsdlPort == null)
return;
DoImportEndpoint (context);
}
void IWsdlImportExtension.ImportEndpoint (WsdlImporter importer,
WsdlEndpointConversionContext context)
{
if (!Enabled)
return;
impl.ImportEndpoint (importer, context);
}
private static void CreateLegacyTransportBindingElement(WsdlImporter importer, SoapBinding soapBinding, WsdlEndpointConversionContext context)
{
TransportBindingElement item = CreateTransportBindingElements(soapBinding.Transport, null);
if (item != null)
{
ConvertToCustomBinding(context).Elements.Add(item);
StateHelper.RegisterTransportBindingElement(importer, context);
}
}
public ServiceMetadataInformation ImportMetadata(Collection<MetadataSection> metadataCollection, MetadataImporterSerializerFormatMode formatMode)
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeDomProvider codeDomProvider = m_CodeDomProviderFactory.CreateProvider();
WsdlImporter importer = new WsdlImporter(new MetadataSet(metadataCollection));
switch (formatMode)
{
case MetadataImporterSerializerFormatMode.DataContractSerializer:
AddStateForDataContractSerializerImport(importer, formatMode, codeCompileUnit, codeDomProvider);
break;
case MetadataImporterSerializerFormatMode.XmlSerializer:
AddStateForXmlSerializerImport(importer, codeCompileUnit, codeDomProvider);
break;
case MetadataImporterSerializerFormatMode.Auto:
AddStateForDataContractSerializerImport(importer, formatMode, codeCompileUnit, codeDomProvider);
AddStateForXmlSerializerImport(importer, codeCompileUnit, codeDomProvider);
break;
}
if (!importer.State.ContainsKey(typeof(WrappedOptions)))
{
importer.State.Add(typeof(WrappedOptions), new WrappedOptions
{
WrappedFlag = false
});
}
Collection<Binding> bindings = importer.ImportAllBindings();
Collection<ContractDescription> contracts = importer.ImportAllContracts();
ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
Collection<MetadataConversionError> importErrors = importer.Errors;
bool success = true;
if (importErrors != null)
{
foreach (MetadataConversionError error in importErrors)
{
if (!error.IsWarning)
{
success = false;
break;
}
}
}
if (!success)
{
//TODO: Throw exception
}
return new ServiceMetadataInformation(codeCompileUnit, codeDomProvider)
{
Bindings = bindings,
Contracts = contracts,
Endpoints = endpoints
};
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer,
WsdlEndpointConversionContext context)
{
if (!Enabled)
{
return;
}
impl.ImportEndpoint(importer, context);
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
if (endpointContext == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext");
#pragma warning suppress 56506 // [....], endpointContext.Endpoint is never null
if (endpointContext.Endpoint.Binding == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointContext.Binding");
if (endpointContext.Endpoint.Binding is CustomBinding)
{
BindingElementCollection elements = ((CustomBinding)endpointContext.Endpoint.Binding).Elements;
Binding binding;
TransportBindingElement transport = elements.Find<TransportBindingElement>();
if (transport is HttpTransportBindingElement)
{
if (WSHttpBindingBase.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (WSDualHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (BasicHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (NetHttpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
}
else if (transport is MsmqTransportBindingElement && NetMsmqBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
else if (transport is NamedPipeTransportBindingElement && NetNamedPipeBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
#pragma warning disable 0618
else if (transport is PeerTransportBindingElement && NetPeerTcpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
#pragma warning restore 0618
else if (transport is TcpTransportBindingElement && NetTcpBinding.TryCreate(elements, out binding))
{
SetBinding(endpointContext.Endpoint, binding);
}
}
}
public static void Run(Uri uri, string cache)
{
ServicePointManager.ServerCertificateValidationCallback = Validator;
MetadataSet doc;
string tempfile = null;
bool needsDownload;
if (cache == null) {
needsDownload = true;
tempfile = Path.GetTempFileName ();
cache = tempfile;
} else {
needsDownload = !File.Exists (cache);
}
if (needsDownload) {
Console.WriteLine ("Downloading service metadata ...");
DownloadXml (uri, cache);
Console.WriteLine ("Downloaded service metadata into {0}.", cache);
}
try {
doc = LoadMetadata (uri, cache);
} finally {
if (tempfile != null)
File.Delete (tempfile);
}
var importer = new WsdlImporter (doc);
var bindings = importer.ImportAllBindings ();
var endpoints = importer.ImportAllEndpoints ();
foreach (var error in importer.Errors) {
if (error.IsWarning)
Console.WriteLine ("WARNING: {0}", error.Message);
else
Console.WriteLine ("ERROR: {0}", error.Message);
}
Console.WriteLine ("DONE IMPORTING: {0} {1}", bindings.Count, endpoints.Count);
foreach (var binding in bindings)
Console.WriteLine ("BINDING: {0}", binding);
foreach (var endpoint in endpoints)
Console.WriteLine ("ENDPOINT: {0}", endpoint.Address);
foreach (var endpoint in endpoints) {
try {
Run (endpoint);
} catch (Exception ex) {
Console.WriteLine ("ERROR ({0}): {1}", endpoint.Address, ex);
}
}
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress,Binding binding,TokenProvider tokenProvider)
{
dynamic extendedBinding = binding;
extendedBinding.MaxReceivedMessageSize *= MessageSizeMultiplier;
MetadataExchangeClient mexClient = new MetadataExchangeClient(extendedBinding);
mexClient.SetServiceBusCredentials(tokenProvider);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
public ClientServiceGenerator(MetadataSet metadataSet, PrimaryCodeGenerationOptions options, CodeDomProvider codeProvider)
{
Enforce.IsNotNull(metadataSet, "metadataSet");
this.options = Enforce.IsNotNull(options, "options");
this.codeProvider = Enforce.IsNotNull(codeProvider, "codeProvider");
compileUnit = new CodeCompileUnit();
wsdlImporter = new WsdlImporter(metadataSet);
InitializeConfiguration();
}
static ServiceEndpointCollection QueryMexEndpoint(string mexAddress,BindingElement bindingElement)
{
dynamic element = bindingElement;
element.MaxReceivedMessageSize *= MessageSizeMultiplier;
CustomBinding binding = new CustomBinding(element);
MetadataExchangeClient mexClient = new MetadataExchangeClient(binding);
MetadataSet metadata = mexClient.GetMetadata(new EndpointAddress(mexAddress));
MetadataImporter importer = new WsdlImporter(metadata);
return importer.ImportAllEndpoints();
}
public static void GenerateFromWsdl(Uri uri, string wsdlFilename,
string xmlFilename, string xsdFilename)
{
var doc = Utils.LoadMetadata (uri, wsdlFilename);
var importer = new WsdlImporter (doc);
var endpoints = importer.ImportAllEndpoints ();
var config = new Configuration ();
foreach (var endpoint in endpoints)
config.AddEndpoint (endpoint);
Generator.Write (xmlFilename, xsdFilename, config);
}
/// <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());
}
}
public CodeCompileUnit GenerateCodeFromImportedContracts(WsdlImporter importer)
{
var generator = new ServiceContractGenerator();
var contracts = importer.ImportAllContracts();
foreach (var contract in contracts)
{
generator.GenerateServiceContractType(contract);
}
if (generator.Errors.Count != 0)
throw new Exception("There were errors during code compilation.");
var targetCompileUnit = generator.TargetCompileUnit;
return targetCompileUnit;
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
#pragma warning suppress 56506 // [....], these properties cannot be null in this context
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
BindingElementCollection bindingElements = GetBindingElements(context);
MessageEncodingBindingElement messageEncodingBindingElement = bindingElements.Find<MessageEncodingBindingElement>();
TextMessageEncodingBindingElement textEncodingBindingElement = messageEncodingBindingElement as TextMessageEncodingBindingElement;
if (messageEncodingBindingElement != null)
{
Type elementType = messageEncodingBindingElement.GetType();
if (elementType != typeof(TextMessageEncodingBindingElement)
&& elementType != typeof(BinaryMessageEncodingBindingElement)
&& elementType != typeof(MtomMessageEncodingBindingElement))
return;
}
EnsureMessageEncoding(context, messageEncodingBindingElement);
foreach (OperationBinding wsdlOperationBinding in context.WsdlBinding.Operations)
{
OperationDescription operation = context.GetOperationDescription(wsdlOperationBinding);
for (int i = 0; i < operation.Messages.Count; i++)
{
MessageDescription message = operation.Messages[i];
MessageBinding wsdlMessageBinding = context.GetMessageBinding(message);
ImportMessageSoapAction(context.ContractConversionContext, message, wsdlMessageBinding, i != 0 /*isResponse*/);
}
foreach (FaultDescription fault in operation.Faults)
{
FaultBinding wsdlFaultBinding = context.GetFaultBinding(fault);
if (wsdlFaultBinding != null)
{
ImportFaultSoapAction(context.ContractConversionContext, fault, wsdlFaultBinding);
}
}
}
}
public static void GenerateConfig(MetadataSet metadata, Configuration config)
{
WsdlImporter importer = new WsdlImporter (metadata);
var endpoints = importer.ImportAllEndpoints ();
var generator = new ServiceContractGenerator (config);
generator.Options = ServiceContractGenerationOptions.None;
foreach (var endpoint in endpoints) {
ChannelEndpointElement channelElement;
generator.GenerateServiceEndpoint (endpoint, out channelElement);
}
}
private static void TraceWsdlImportErrors(WsdlImporter importer)
{
foreach (MetadataConversionError error in importer.Errors)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
Hashtable hashtable2 = new Hashtable(2);
hashtable2.Add("IsWarning", error.IsWarning);
hashtable2.Add("Message", error.Message);
Hashtable dictionary = hashtable2;
TraceUtility.TraceEvent(TraceEventType.Warning, 0x8003d, System.ServiceModel.SR.GetString("TraceCodeWsmexNonCriticalWsdlExportError"), new DictionaryTraceRecord(dictionary), null, null);
}
}
}
public static void CheckImportErrors (WsdlImporter importer, TestLabel label)
{
bool foundErrors = false;
foreach (var error in importer.Errors) {
if (error.IsWarning)
Console.WriteLine ("WARNING ({0}): {1}", label, error.Message);
else {
Console.WriteLine ("ERROR ({0}): {1}", label, error.Message);
foundErrors = true;
}
}
if (foundErrors)
Assert.Fail ("Found import errors", label);
}
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));
}
}
}
static void TraceWsdlImportErrors(WsdlImporter importer)
{
foreach (MetadataConversionError error in importer.Errors)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
Hashtable h = new Hashtable(2)
{
{ "IsWarning", error.IsWarning },
{ "Message", error.Message }
};
TraceUtility.TraceEvent(TraceEventType.Warning, TraceCode.WsmexNonCriticalWsdlExportError,
SR.GetString(SR.TraceCodeWsmexNonCriticalWsdlExportError), new DictionaryTraceRecord(h), null, null);
}
}
}
public void ImportContract(WsdlImporter importer,
WsdlContractConversionContext context)
{
if (importer == null)
{
throw new ArgumentNullException("importer");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (this.importer != null || this.context != null)
{
throw new SystemException("INTERNAL ERROR: unexpected recursion of ImportContract method call");
}
schema_set_in_use = new XmlSchemaSet();
schema_set_in_use.Add(importer.XmlSchemas);
foreach (WSDL wsdl in importer.WsdlDocuments)
{
foreach (XmlSchema xs in wsdl.Types.Schemas)
{
schema_set_in_use.Add(xs);
}
}
schema_set_in_use.Compile();
this.importer = importer;
this.context = context;
try
{
DoImportContract();
}
finally
{
this.importer = null;
this.context = null;
}
}
private static ServiceEndpointCollection ImportEndpoints(MetadataSet metadataSet, IEnumerable <ContractDescription> contracts, MetadataExchangeClient client)
{
ServiceEndpointCollection endpoints = new ServiceEndpointCollection();
WsdlImporter importer = new WsdlImporter(metadataSet);
importer.State.Add("MetadataExchangeClientKey", client);
foreach (ContractDescription description in contracts)
{
importer.KnownContracts.Add(WsdlExporter.WsdlNamingHelper.GetPortTypeQName(description), description);
}
foreach (ContractDescription description2 in contracts)
{
foreach (ServiceEndpoint endpoint in importer.ImportEndpoints(description2))
{
endpoints.Add(endpoint);
}
}
if (importer.Errors.Count > 0)
{
TraceWsdlImportErrors(importer);
}
return(endpoints);
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer,
WsdlEndpointConversionContext context)
{
}
void IWsdlImportExtension.ImportContract(WsdlImporter importer,
WsdlContractConversionContext context)
{
}
void System.ServiceModel.Description.IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
{
}
public void ImportEndpoint(WsdlImporter importer,
WsdlEndpointConversionContext context)
{
}
void System.ServiceModel.Description.IWsdlImportExtension.ImportContract(WsdlImporter importer, WsdlContractConversionContext contractContext)
{
}
protected abstract void Init(WsdlImporter importer);