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);
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeGeneratorContext"/> class.
/// </summary>
/// <param name="metadataSet">The metadata set.</param>
/// <param name="codeGeneratorOptions">The code generator options.</param>
public CodeGeneratorContext(MetadataSet metadataSet, CodeGeneratorOptions codeGeneratorOptions)
{
MetadataSet = metadataSet;
CodeDomProvider = CodeDomProvider.CreateProvider(codeGeneratorOptions.CodeLanguage.ToString());
CodeCompileUnit = new CodeCompileUnit();
CodeGeneratorOptions = codeGeneratorOptions;
}
private void AddDocumentToSet(MetadataSet metadataSet, object document)
{
System.Web.Services.Description.ServiceDescription serviceDescription = document as System.Web.Services.Description.ServiceDescription;
System.Xml.Schema.XmlSchema schema = document as System.Xml.Schema.XmlSchema;
XmlElement policy = document as XmlElement;
if (serviceDescription != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
}
else if (schema != null)
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
}
else if ((policy != null) && MetadataSection.IsPolicyElement(policy))
{
metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(policy, null));
}
else
{
MetadataSection item = new MetadataSection {
Metadata = document
};
metadataSet.MetadataSections.Add(item);
}
}
/// <summary>
/// Retrieves and imports meta data for a given WSDL document specified by
/// WsdlDocument property.
/// </summary>
/// <param name="options">The metadata resolving options.</param>
/// <returns>A collection of service metadata in XML form.</returns>
public static MetadataSet GetMetadataSet(MetadataResolverOptions options)
{
if (options == null)
{
throw new ArgumentException("options could not be null.");
}
if (string.IsNullOrEmpty(options.MetadataLocation))
{
throw new ArgumentException("MetadataLocation option could not be null or an empty string.");
}
try
{
// First download the contracts if they are accessed over the web.
DownloadContract(options);
// Try to run RPC2DocumentLiteral converter.
TryTranslateRpc2DocumentLiteral(options);
MetadataSet metadataSet = new MetadataSet();
XmlDocument doc = new XmlDocument();
doc.Load(options.MetadataLocation);
MetadataSection ms = new MetadataSection(null, null, doc);
metadataSet.MetadataSections.Add(ms);
ResolveImports(options, metadataSet);
return metadataSet;
}
catch (Exception ex)
{
// TODO: Log exception.
throw new MetadataResolveException("Could not resolve metadata", ex);
}
}
private static void CreateHttpGetChannelDispatcher(ServiceHostBase host, Uri listenUri, MetadataSet metadata)
{
//创建Binding
TextMessageEncodingBindingElement messageEncodingElement = new TextMessageEncodingBindingElement() { MessageVersion = MessageVersion.None };
HttpTransportBindingElement transportElement = new HttpTransportBindingElement();
Utility.SetPropertyValue(transportElement, "Method", "GET");
Binding binding = new CustomBinding(messageEncodingElement, transportElement);
//创建ChannelListener
IChannelListener listener = binding.BuildChannelListener<IReplyChannel>(listenUri, string.Empty, ListenUriMode.Explicit, new BindingParameterCollection());
ChannelDispatcher dispatcher = new ChannelDispatcher(listener, "ServiceMetadataBehaviorHttpGetBinding", binding) { MessageVersion = binding.MessageVersion };
//创建EndpointDispatcher
EndpointDispatcher endpoint = new EndpointDispatcher(new EndpointAddress(listenUri), "IHttpGetMetadata", "http://www.artech.com/");
//创建DispatchOperation，并设置DispatchMessageFormatter和OperationInvoker
DispatchOperation operation = new DispatchOperation(endpoint.DispatchRuntime, "Get", "*", "*");
operation.Formatter = Utility.CreateInstance<IDispatchMessageFormatter>(MessageOperationFormatterType, Type.EmptyTypes, new object[0]);
MethodInfo method = typeof(IHttpGetMetadata).GetMethod("Get");
operation.Invoker = Utility.CreateInstance<IOperationInvoker>(SyncMethodInvokerType, new Type[] { typeof(MethodInfo) }, new object[] { method });
endpoint.DispatchRuntime.Operations.Add(operation);
//设置SingletonInstanceContext和InstanceContextProvider
MetadataProvisionService serviceInstance = new MetadataProvisionService(metadata);
endpoint.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, serviceInstance);
endpoint.DispatchRuntime.InstanceContextProvider = Utility.CreateInstance<IInstanceContextProvider>(SingletonInstanceContextProviderType, new Type[] { typeof(DispatchRuntime) }, new object[] { endpoint.DispatchRuntime });
dispatcher.Endpoints.Add(endpoint);
//设置ContractFilter和AddressFilter
endpoint.ContractFilter = new MatchAllMessageFilter();
endpoint.AddressFilter = new MatchAllMessageFilter();
host.ChannelDispatchers.Add(dispatcher);
}
public WebServiceDiscoveryResultWCF (DiscoveryClientProtocol protocol, MetadataSet metadata, WebReferenceItem item, ReferenceGroup refGroup, ClientOptions defaultOptions): base (WebReferencesService.WcfEngine, item)
{
this.refGroup = refGroup;
this.protocol = protocol;
this.metadata = metadata;
this.defaultOptions = defaultOptions;
}
private static void WriterMetadata(MetadataSet metadata)
{
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
static TestMetadata()
{
DataContractSerializer serializer = new DataContractSerializer(typeof(MetadataSet));
using (MemoryStream stream = new MemoryStream(Encoding.Default.GetBytes(Resources.RestaurantMetadata)))
{
metadataSet = (MetadataSet)serializer.ReadObject(stream);
}
}
void GetServices(MetadataSet metadata)
{
foreach (MetadataSection section in metadata.MetadataSections) {
var service = section.Metadata as WebServices.ServiceDescription;
if (service != null) {
Services.Add(service);
}
}
}
/// <summary>
/// Generates the service model client code for the endpoint.
/// </summary>
/// <param name="endpointAddress">The metadata endpoint address.</param>
/// <param name="mexMode">The metadata exchange client mode.</param>
/// <param name="operationTimeout">The operation time.</param>
/// <param name="codeFilePath">The full path an file name where the C# code is written</param>
public static void GenerateServiceModelClientCode(EndpointAddress endpointAddress,
MetadataExchangeClientMode mexMode, TimeSpan operationTimeout, string codeFilePath)
{
// Get the meta data set from the endpoint.
System.ServiceModel.Description.MetadataSet docs =
Nequeo.Net.ServiceModel.ServiceModelInformation.GetServiceMetadata(endpointAddress, mexMode, operationTimeout);
// Generate the code file
GenerateServiceModelClient(docs, codeFilePath);
}
/// <summary>
/// Generates the service model client configuration code for the endpoint.
/// </summary>
/// <param name="endpointAddress">The metadata endpoint address.</param>
/// <param name="mexMode">The metadata exchange client mode.</param>
/// <param name="operationTimeout">The operation time.</param>
/// <param name="xmlFile">The name of the file where client configuration is written,
/// the file is created in the same path as the application configuration file (debug or release).</param>
public static void GenerateServiceModelClientConfigurationCode(EndpointAddress endpointAddress,
MetadataExchangeClientMode mexMode, TimeSpan operationTimeout, string xmlFile)
{
// Get the meta data set from the endpoint.
System.ServiceModel.Description.MetadataSet docs =
Nequeo.Net.ServiceModel.ServiceModelInformation.GetServiceMetadata(endpointAddress, mexMode, operationTimeout);
// Generate the code file
GenerateServiceModelEndpoints(docs, xmlFile, Nequeo.Handler.Common.InfoHelper.GetApplicationConfigurationFile());
}
public static MetadataSet GetMetadataSet (Stream stream)
{
var dr = new ContractReference ();
var doc = (WebServices.Description.ServiceDescription) dr.ReadDocument (stream);
var metadata = new MetadataSet ();
metadata.MetadataSections.Add (
new MetadataSection (MetadataSection.ServiceDescriptionDialect, "", doc));
return metadata;
}
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();
}
public ServiceDescription GetFlattenedServiceDescription(MetadataSet metadataSet)
{
var obj = Assembly.GetAssembly(typeof(WsdlExporter)).GetType("System.ServiceModel.Description.WsdlHelper", true)
.GetMethod("GetSingleWsdl", BindingFlags.Static | BindingFlags.Public)
.Invoke(null, new object[1] { metadataSet });
if (obj is ServiceDescription)
return (ServiceDescription)obj;
return null;
}
void CreateGenerator()
{
metadata = new MetadataSet();
fakeProject = MockRepository.GenerateStub<IProjectWithServiceReferences>();
fakeProxyGenerator = MockRepository.GenerateStub<IServiceReferenceProxyGenerator>();
fakeReferenceMapGenerator = MockRepository.GenerateStub<IServiceReferenceMapGenerator>();
fileGenerator = new ServiceReferenceFileGenerator(fakeProxyGenerator, fakeReferenceMapGenerator);
fakeFileSystem = MockRepository.GenerateStub<IFileSystem>();
generator = new ServiceReferenceGenerator(fakeProject, fileGenerator, fakeFileSystem);
}
public WsdlImporter CreateDataContractSerializerImporter(MetadataSet metaData)
{
Collection<IWsdlImportExtension> wsdlImportExtensions = ClientSection.GetSection().Metadata.LoadWsdlImportExtensions();
for (int i = 0; i < wsdlImportExtensions.Count; i++)
{
if (wsdlImportExtensions[i].GetType() == typeof(XmlSerializerMessageContractImporter))
{
wsdlImportExtensions.RemoveAt(i);
}
}
return new WsdlImporter(metaData, null, wsdlImportExtensions);
}
private static void GetMetadataViaHttpGet()
{
MetadataSet metadata = new MetadataSet();
HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://127.0.0.1:3721/calculatorservice/metadata");
request.Method = "Get";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (XmlReader reader = XmlDictionaryReader.CreateTextReader(response.GetResponseStream(), new XmlDictionaryReaderQuotas()))
{
System.Web.Services.Description.ServiceDescription serviceDesc = System.Web.Services.Description.ServiceDescription.Read(reader);
metadata.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDesc));
}
WriterMetadata(metadata);
}
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);
}
}
void GenerateServiceReferenceProxy(MetadataSet metadata)
{
ServiceReferenceFileName referenceFileName = project.GetServiceReferenceFileName(Namespace);
CreateFolderForFileIfFolderMissing(referenceFileName.Path);
fileGenerator.ServiceReferenceNamespace = Namespace;
fileGenerator.GenerateProxyFile(metadata, referenceFileName.Path);
ServiceReferenceMapFileName mapFileName = project.GetServiceReferenceMapFileName(Namespace);
var mapFile = new ServiceReferenceMapFile(mapFileName);
fileGenerator.GenerateServiceReferenceMapFile(mapFile);
project.AddServiceReferenceProxyFile(referenceFileName);
project.AddServiceReferenceMapFile(mapFileName);
}
public override MetadataSet GetGeneratedMetadata ()
{
if (metadata != null)
return metadata;
metadata = new MetadataSet ();
foreach (WSServiceDescription sd in GeneratedWsdlDocuments)
metadata.MetadataSections.Add (
MetadataSection.CreateFromServiceDescription (sd));
foreach (XmlSchema xs in GeneratedXmlSchemas.Schemas ())
metadata.MetadataSections.Add (
MetadataSection.CreateFromSchema (xs));
return metadata;
}
private static void CustomizeMexEndpoints(ServiceDescription description, ServiceHostBase host, MetadataSet metadata)
{
foreach (ChannelDispatcher channelDispatcher in host.ChannelDispatchers)
{
foreach (EndpointDispatcher endpoint in channelDispatcher.Endpoints)
{
if (endpoint.ContractName == MexContractName && endpoint.ContractNamespace == MexContractNamespace)
{
DispatchRuntime dispatchRuntime = endpoint.DispatchRuntime;
dispatchRuntime.InstanceContextProvider = Utility.CreateInstance<IInstanceContextProvider>(SingletonInstanceContextProviderType, new Type[] { typeof(DispatchRuntime) }, new object[] { dispatchRuntime });
MetadataProvisionService serviceInstance = new MetadataProvisionService(metadata);
dispatchRuntime.SingletonInstanceContext = new InstanceContext(host, serviceInstance);
}
}
}
}
internal static bool IsSupported ()
{
if (runtimeSupport != null)
return runtimeSupport.Value;
try {
// Test runtime support.
var ms = new MetadataSet ();
var importer = new WsdlImporter (ms);
importer.State.GetType ();
runtimeSupport = true;
return true;
} catch {
runtimeSupport = false;
return false;
}
}
/// <summary>
/// Resolves metadata from the specified URL.
/// </summary>
/// <param name="url">The URL.</param>
/// <returns>A list of metadata sections.</returns>
public static IEnumerable<MetadataSection> Resolve(string url)
{
MetadataSet metadataSet = new MetadataSet();
DiscoveryClientProtocol discoveryClient = new DiscoveryClientProtocol
{
UseDefaultCredentials = true,
AllowAutoRedirect = true
};
discoveryClient.DiscoverAny(url);
discoveryClient.ResolveAll();
foreach (object document in discoveryClient.Documents.Values)
{
AddDocumentToSet(metadataSet, document);
}
return metadataSet.MetadataSections;
}
public WebService(string path)
{
var metadataAddress = new EndpointAddress(path);
var mexClient = new MetadataExchangeClient(metadataAddress.Uri, MetadataExchangeClientMode.HttpGet);
mexClient.ResolveMetadataReferences = true;
var metadata = mexClient.GetMetadata(metadataAddress.Uri, MetadataExchangeClientMode.HttpGet);
var metadataSet = new MetadataSet(metadata.MetadataSections);
var importer = new WsdlImporter(metadataSet);
AllWsdlDocuments = importer.WsdlDocuments;
AllContracts = importer.ImportAllContracts();
AllBindings = importer.ImportAllBindings();
AllEndpoints = importer.ImportAllEndpoints();
//AllContracts.First().Operations.First().
}
static void Main(string[] args)
{
MetadataSet metadata = new MetadataSet();
string address = "http://127.0.0.1:3721/calculatorservice/metadata";
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
request.Method = "Get";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (XmlReader reader = XmlDictionaryReader.CreateTextReader(response.GetResponseStream(), new XmlDictionaryReaderQuotas()))
{
System.Web.Services.Description.ServiceDescription serviceDesc = System.Web.Services.Description.ServiceDescription.Read(reader);
metadata.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDesc));
}
using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
{
metadata.WriteTo(writer);
}
Process.Start("metadata.xml");
}
private XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var sb = new StringBuilder();
var w = new StringWriter(sb, CultureInfo.InvariantCulture);
var writer = XmlWriter.Create(w);
metadataSet.WriteTo(writer);
writer.Flush();
w.Flush();
var input = new StringReader(sb.ToString());
var reader = new XmlTextReader(input);
return XmlDictionaryReader.CreateDictionaryReader(reader);
}
public WsdlImporter (
MetadataSet metadata,
IEnumerable<IPolicyImportExtension> policyImportExtensions,
IEnumerable<IWsdlImportExtension> wsdlImportExtensions)
: base (policyImportExtensions)
{
if (metadata == null)
throw new ArgumentNullException ("metadata");
if (wsdlImportExtensions == null) {
wsdl_extensions = new KeyedByTypeCollection<IWsdlImportExtension> ();
wsdl_extensions.Add (new DataContractSerializerMessageContractImporter ());
wsdl_extensions.Add (new XmlSerializerMessageContractImporter ());
wsdl_extensions.Add (new MessageEncodingBindingElementImporter ());
wsdl_extensions.Add (new TransportBindingElementImporter ());
wsdl_extensions.Add (new StandardBindingImporter ());
} else {
wsdl_extensions = new KeyedByTypeCollection<IWsdlImportExtension> (wsdlImportExtensions);
}
// It is okay to fill these members immediately when WsdlImporter.ctor() is invoked
// i.e. after this .ctor(), those metadata docs are not considered anymore.
this.metadata = metadata;
this.wsdl_documents = new ServiceDescriptionCollection ();
this.xmlschemas = new XmlSchemaSet ();
this.policies = new List<XmlElement> ();
this.contractHash = new Dictionary<PortType, ContractDescription> ();
this.bindingHash = new Dictionary<WSBinding, ServiceEndpoint> ();
this.endpointHash = new Dictionary<Port, ServiceEndpoint> ();
foreach (MetadataSection ms in metadata.MetadataSections) {
if (ms.Dialect == MetadataSection.ServiceDescriptionDialect &&
ms.Metadata.GetType () == typeof (WSServiceDescription))
wsdl_documents.Add ((WSServiceDescription) ms.Metadata);
else
if (ms.Dialect == MetadataSection.XmlSchemaDialect &&
ms.Metadata.GetType () == typeof (XmlSchema))
xmlschemas.Add ((XmlSchema) ms.Metadata);
}
}
public static CodeCompileUnit Import (MetadataSet metadata, ImportOptions options)
{
var importer = new WsdlImporter (metadata);
var xsdImporter = new XsdDataContractImporter ();
xsdImporter.Options = options;
importer.State.Add (typeof(XsdDataContractImporter), xsdImporter);
var contracts = importer.ImportAllContracts ();
CodeCompileUnit ccu = new CodeCompileUnit ();
var generator = new ServiceContractGenerator (ccu);
if (contracts.Count != 1)
throw new InvalidOperationException (string.Format (
"Metadata import failed: found {0} contracts.", contracts.Count));
var contract = contracts.First ();
generator.GenerateServiceContractType (contract);
return ccu;
}
private static XmlDictionaryReader CreateMetadataReader(Uri mexAddress)
{
var metadataSet = new MetadataSet();
var metadataReference = new MetadataReference(new EndpointAddress(mexAddress), AddressingVersion.WSAddressing10);
var metadataSection = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, metadataReference);
metadataSet.MetadataSections.Add(metadataSection);
var stringBuilder = new StringBuilder();
using(var stringWriter = new StringWriter(stringBuilder, CultureInfo.InvariantCulture))
{
var xmlWriter = XmlWriter.Create(stringWriter);
metadataSet.WriteTo(xmlWriter);
xmlWriter.Flush();
stringWriter.Flush();
var stringReader = new StringReader(stringBuilder.ToString());
var xmlTextReader = new XmlTextReader(stringReader);
var result = XmlDictionaryReader.CreateDictionaryReader(xmlTextReader);
return result;
}
}
private WsdlImporter CreateImporterFromMetadata(MetadataSet metaDocs)
{
var importer = new WsdlImporter(metaDocs);
object dataContractImporter;
XsdDataContractImporter xsdDcImporter;
if (!importer.State.TryGetValue(typeof(XsdDataContractImporter), out dataContractImporter))
{
Console.WriteLine("Couldn't find the XsdDataContractImporter! Adding custom importer.");
xsdDcImporter = new XsdDataContractImporter { Options = new ImportOptions() };
importer.State.Add(typeof(XsdDataContractImporter), xsdDcImporter);
}
else
{
xsdDcImporter = (XsdDataContractImporter)dataContractImporter;
if (xsdDcImporter.Options == null)
{
Console.WriteLine("There were no ImportOptions on the importer.");
xsdDcImporter.Options = new ImportOptions();
}
}
return importer;
}
public WsdlImporter (
MetadataSet metadata,
IEnumerable<IPolicyImportExtension> policyImportExtensions,
IEnumerable<IWsdlImportExtension> wsdlImportExtensions)
: base (policyImportExtensions)
{
if (metadata == null)
throw new ArgumentNullException ("metadata");
if (wsdlImportExtensions == null) {
wsdl_extensions = new KeyedByTypeCollection<IWsdlImportExtension> ();
wsdl_extensions.Add (new StandardBindingImporter ());
wsdl_extensions.Add (new TransportBindingElementImporter ());
//wsdl_extensions.Add (new MessageEncodingBindingElementImporter ());
wsdl_extensions.Add (new XmlSerializerMessageContractImporter ());
wsdl_extensions.Add (new DataContractSerializerMessageContractImporter ());
} else {
wsdl_extensions = new KeyedByTypeCollection<IWsdlImportExtension> (wsdlImportExtensions);
}
this.metadata = metadata;
this.wsdl_documents = new ServiceDescriptionCollection ();
this.xmlschemas = new XmlSchemaSet ();
this.policies = new List<XmlElement> ();
foreach (MetadataSection ms in metadata.MetadataSections) {
if (ms.Dialect == MetadataSection.ServiceDescriptionDialect &&
ms.Metadata.GetType () == typeof (WSServiceDescription))
wsdl_documents.Add ((WSServiceDescription) ms.Metadata);
else
if (ms.Dialect == MetadataSection.XmlSchemaDialect &&
ms.Metadata.GetType () == typeof (XmlSchema))
xmlschemas.Add ((XmlSchema) ms.Metadata);
}
}
public static WsdlNS.ServiceDescription GetSingleWsdl(MetadataSet metadataSet)
{
if (metadataSet.MetadataSections.Count < 1)
{
return null;
}
List<WsdlNS.ServiceDescription> wsdls = new List<WsdlNS.ServiceDescription>();
List<XmlSchema> xsds = new List<XmlSchema>();
foreach (MetadataSection section in metadataSet.MetadataSections)
{
if (section.Metadata is WsdlNS.ServiceDescription)
{
wsdls.Add((WsdlNS.ServiceDescription)section.Metadata);
}
if (section.Metadata is XmlSchema)
{
xsds.Add((XmlSchema)section.Metadata);
}
}
VerifyContractNamespace(wsdls);
WsdlNS.ServiceDescription singleWsdl = GetSingleWsdl(CopyServiceDescriptionCollection(wsdls));
// Inline XML schemas
foreach (XmlSchema schema in xsds)
{
XmlSchema newSchema = CloneXsd(schema);
RemoveSchemaLocations(newSchema);
singleWsdl.Types.Schemas.Add(newSchema);
}
return singleWsdl;
}
void GetMetadata()
{
if (WsdlUrl == null)
{
return;
}
MetadataSet metadata = ext.Metadata;
int xs_i = 0, wsdl_i = 0;
//Dictionary keyed by namespace
StringDictionary wsdl_strings = new StringDictionary();
StringDictionary xsd_strings = new StringDictionary();
foreach (MetadataSection section in metadata.MetadataSections)
{
string key;
XmlSchema xs = section.Metadata as XmlSchema;
if (xs != null)
{
key = String.Format("xsd{0}", xs_i++);
schemas [key] = xs;
xsd_strings [xs.TargetNamespace] = key;
continue;
}
WSServiceDescription wsdl = section.Metadata as WSServiceDescription;
if (wsdl == null)
{
continue;
}
//if (wsdl.TargetNamespace == "http://tempuri.org/")
if (wsdl.Services.Count > 0)
{
key = "wsdl";
}
else
{
key = String.Format("wsdl{0}", wsdl_i++);
}
wsdl_documents [key] = wsdl;
wsdl_strings [wsdl.TargetNamespace] = key;
}
string base_url = WsdlUrl.ToString();
foreach (WSServiceDescription wsdl in wsdl_documents.Values)
{
foreach (Import import in wsdl.Imports)
{
if (!String.IsNullOrEmpty(import.Location))
{
continue;
}
import.Location = String.Format("{0}?wsdl={1}", base_url, wsdl_strings [import.Namespace]);
}
foreach (XmlSchema schema in wsdl.Types.Schemas)
{
foreach (XmlSchemaObject obj in schema.Includes)
{
XmlSchemaImport imp = obj as XmlSchemaImport;
if (imp == null || imp.SchemaLocation != null)
{
continue;
}
imp.SchemaLocation = String.Format("{0}?xsd={1}", base_url, xsd_strings [imp.Namespace]);
}
}
}
}
private void HandleResult(IAsyncResult result)
{
MetadataSet metadataSet = this.client.EndGetMetadata(result);
this.endpointCollection = MetadataResolver.ImportEndpoints(metadataSet, this.knownContracts, this.client);
}
internal GetResponse(MetadataSet metadataSet)
: this()
{
this.metadataSet = metadataSet;
}
public WsdlImporter(MetadataSet metadata)
: this(metadata, null, null)
{
}
private MetadataSet Read67_MetadataSet(bool isNullable, bool checkType)
{
XmlQualifiedName type = checkType ? base.GetXsiType() : null;
bool flag = false;
if (isNullable)
{
flag = base.ReadNull();
}
if (((checkType && this.processOuterElement) && (type != null)) && ((type.Name != this.id3_MetadataSet) || (type.Namespace != this.id2_Item)))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(base.CreateUnknownTypeException(type));
}
if (flag)
{
return(null);
}
MetadataSet o = new MetadataSet();
Collection <MetadataSection> metadataSections = o.MetadataSections;
Collection <System.Xml.XmlAttribute> attributes = o.Attributes;
while (base.Reader.MoveToNextAttribute())
{
if (!base.IsXmlnsAttribute(base.Reader.Name))
{
System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute)base.Document.ReadNode(base.Reader);
base.ParseWsdlArrayType(attr);
attributes.Add(attr);
}
}
base.Reader.MoveToElement();
if (base.Reader.IsEmptyElement)
{
base.Reader.Skip();
return(o);
}
base.Reader.ReadStartElement();
base.Reader.MoveToContent();
int whileIterations = 0;
int readerCount = base.ReaderCount;
while ((base.Reader.NodeType != XmlNodeType.EndElement) && (base.Reader.NodeType != XmlNodeType.None))
{
if (base.Reader.NodeType == XmlNodeType.Element)
{
if ((base.Reader.LocalName == this.id4_MetadataSection) && (base.Reader.NamespaceURI == this.id2_Item))
{
if (metadataSections == null)
{
base.Reader.Skip();
}
else
{
metadataSections.Add(this.Read66_MetadataSection(false, true));
}
}
else
{
base.UnknownNode(o, "http://schemas.xmlsoap.org/ws/2004/09/mex:MetadataSection");
}
}
else
{
base.UnknownNode(o, "http://schemas.xmlsoap.org/ws/2004/09/mex:MetadataSection");
}
base.Reader.MoveToContent();
base.CheckReaderCount(ref whileIterations, ref readerCount);
}
base.ReadEndElement();
return(o);
}
