|
//------------------------------------------------------------------------------
// <copyright file="ProtocolReflector.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Services.Description {
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Collections;
using System;
using System.Reflection;
using System.Security.Permissions;
using System.Collections.Generic;
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
[PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
public abstract class ProtocolReflector {
ServiceDescriptionReflector reflector;
LogicalMethodInfo method;
Operation operation;
OperationBinding operationBinding;
Port port;
PortType portType;
Binding binding;
WebMethodAttribute methodAttr;
Message inputMessage;
Message outputMessage;
MessageCollection headerMessages;
ServiceDescription bindingServiceDescription;
CodeIdentifiers portNames;
bool emptyBinding;
internal void Initialize(ServiceDescriptionReflector reflector) {
this.reflector = reflector;
}
internal bool IsEmptyBinding { get { return emptyBinding; } }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Service"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Service Service {
get { return reflector.Service; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ServiceDescription"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public ServiceDescription ServiceDescription {
get { return reflector.ServiceDescription; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ServiceDescriptions"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public ServiceDescriptionCollection ServiceDescriptions {
get { return reflector.ServiceDescriptions; }
}
internal List<Action<Uri>> UriFixups { get { return this.reflector.UriFixups; } }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Schemas"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSchemas Schemas {
get { return reflector.Schemas; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.SchemaExporter"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSchemaExporter SchemaExporter {
get { return reflector.SchemaExporter; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ReflectionImporter"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlReflectionImporter ReflectionImporter {
get { return reflector.ReflectionImporter; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.DefaultNamespace"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public string DefaultNamespace {
get { return reflector.ServiceAttribute.Namespace; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ServiceUrl"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public string ServiceUrl {
get { return reflector.ServiceUrl; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ServiceType"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Type ServiceType {
get { return reflector.ServiceType; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Method"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public LogicalMethodInfo Method {
get { return method; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Binding"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Binding Binding {
get { return binding; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.PortType"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public PortType PortType {
get { return portType; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Port"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Port Port {
get { return port; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Operation"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Operation Operation {
get { return operation; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.OperationBinding"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public OperationBinding OperationBinding {
get { return operationBinding; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.MethodAttribute"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public WebMethodAttribute MethodAttribute {
get { return methodAttr; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.Methods"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public LogicalMethodInfo[] Methods {
get { return reflector.Methods; }
}
internal Hashtable ReflectionContext {
get { return reflector.ReflectionContext; }
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.InputMessage"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Message InputMessage {
get {
if (inputMessage == null) {
string messageName = XmlConvert.EncodeLocalName(methodAttr.MessageName.Length == 0 ? Method.Name : methodAttr.MessageName);
bool diffNames = messageName != Method.Name;
inputMessage = new Message();
inputMessage.Name = messageName + ProtocolName + "In";
OperationInput input = new OperationInput();
if (diffNames) input.Name = messageName;
input.Message = new XmlQualifiedName(inputMessage.Name, bindingServiceDescription.TargetNamespace);
operation.Messages.Add(input);
OperationBinding.Input = new InputBinding();
if (diffNames) OperationBinding.Input.Name = messageName;
}
return inputMessage;
}
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.OutputMessage"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public Message OutputMessage {
get {
if (outputMessage == null) {
string messageName = XmlConvert.EncodeLocalName(methodAttr.MessageName.Length == 0 ? Method.Name : methodAttr.MessageName);
bool diffNames = messageName != Method.Name;
outputMessage = new Message();
outputMessage.Name = messageName + ProtocolName + "Out";
OperationOutput output = new OperationOutput();
if (diffNames) output.Name = messageName;
output.Message = new XmlQualifiedName(outputMessage.Name, bindingServiceDescription.TargetNamespace);
operation.Messages.Add(output);
OperationBinding.Output = new OutputBinding();
if (diffNames) OperationBinding.Output.Name = messageName;
}
return outputMessage;
}
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.HeaderMessages"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public MessageCollection HeaderMessages {
get {
if (headerMessages == null) {
headerMessages = new MessageCollection(bindingServiceDescription);
}
return headerMessages;
}
}
void MoveToMethod(LogicalMethodInfo method) {
this.method = method;
this.methodAttr = method.MethodAttribute;
}
class ReflectedBinding {
internal ReflectedBinding() { }
internal ReflectedBinding(WebServiceBindingAttribute bindingAttr) {
this.bindingAttr = bindingAttr;
}
public WebServiceBindingAttribute bindingAttr;
public ArrayList methodList;
}
internal void Reflect() {
emptyBinding = false;
Hashtable bindings = new Hashtable();
Hashtable reflectedBindings = new Hashtable();
for (int i = 0; i < reflector.Methods.Length; i++) {
MoveToMethod(reflector.Methods[i]);
string bindingName = ReflectMethodBinding();
if (bindingName == null) bindingName = string.Empty;
ReflectedBinding reflectedBinding = (ReflectedBinding)reflectedBindings[bindingName];
if (reflectedBinding == null) {
reflectedBinding = new ReflectedBinding();
reflectedBinding.bindingAttr = WebServiceBindingReflector.GetAttribute(method, bindingName);
if (reflectedBinding.bindingAttr == null || (bindingName.Length == 0 && reflectedBinding.bindingAttr.Location.Length > 0)) {
reflectedBinding.bindingAttr = new WebServiceBindingAttribute();
}
reflectedBindings.Add(bindingName, reflectedBinding);
}
if (reflectedBinding.bindingAttr.Location.Length == 0) {
if (reflectedBinding.methodList == null)
reflectedBinding.methodList = new ArrayList();
reflectedBinding.methodList.Add(method);
bindings[reflectedBinding.bindingAttr.Name] = method;
}
else {
AddImport(reflectedBinding.bindingAttr.Namespace, reflectedBinding.bindingAttr.Location);
}
}
foreach (ReflectedBinding reflectedBinding in reflectedBindings.Values) {
ReflectBinding(reflectedBinding);
}
// Only check for empty binding if we do not have real bindings
if (reflectedBindings.Count == 0) {
// It should be possible to get the value for WebReference.ServiceLocationUrl even if the web service has no web methods.
// This is a common scenario for Whitehorse during the early stages of development when a user is defining the web
// components and their inter-connections, but not the details of whatmethods will be present on each web service.
// get all WebServiceBindings
emptyBinding = true;
ReflectedBinding binding = null;
object[] attrs = ServiceType.GetCustomAttributes(typeof(WebServiceBindingAttribute), false);
for (int i = 0; i < attrs.Length; i++) {
WebServiceBindingAttribute bindingAttribute = (WebServiceBindingAttribute)attrs[i];
if (bindings[bindingAttribute.Name] != null)
continue;
if (binding != null) {
binding = null;
break;
}
binding = new ReflectedBinding(bindingAttribute);
}
if (binding != null) ReflectBinding(binding);
}
Type[] interfaces = ServiceType.GetInterfaces();
// iterate through all the interfaces for this type
foreach (Type bindingInterface in interfaces) {
object[] attrs = bindingInterface.GetCustomAttributes(typeof(WebServiceBindingAttribute), false);
for (int i = 0; i < attrs.Length; i++) {
WebServiceBindingAttribute bindingAttribute = (WebServiceBindingAttribute)attrs[i];
if (bindings[bindingAttribute.Name] != null)
continue;
ReflectBinding(new ReflectedBinding(bindingAttribute));
}
}
ReflectDescription();
}
void AddImport(string ns, string location) {
foreach (Import import in ServiceDescription.Imports) {
if (import.Namespace == ns && import.Location == location) {
return;
}
}
Import newImport = new Import();
newImport.Namespace = ns;
newImport.Location = location;
ServiceDescription.Imports.Add(newImport);
}
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.GetServiceDescription"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public ServiceDescription GetServiceDescription(string ns) {
ServiceDescription description = ServiceDescriptions[ns];
if (description == null) {
description = new ServiceDescription();
description.TargetNamespace = ns;
ServiceDescriptions.Add(description);
}
return description;
}
void ReflectBinding(ReflectedBinding reflectedBinding) {
string bindingName = XmlConvert.EncodeLocalName(reflectedBinding.bindingAttr.Name);
string bindingNamespace = reflectedBinding.bindingAttr.Namespace;
if (bindingName.Length == 0) bindingName = Service.Name + ProtocolName;
if (bindingNamespace.Length == 0) bindingNamespace = ServiceDescription.TargetNamespace;
WsiProfiles claims = WsiProfiles.None;
if (reflectedBinding.bindingAttr.Location.Length > 0) {
// If a URL is specified for the WSDL, file, then we just import the
// binding from there instead of generating it in this WSDL file.
portType = null;
binding = null;
}
else {
bindingServiceDescription = GetServiceDescription(bindingNamespace);
CodeIdentifiers bindingNames = new CodeIdentifiers();
foreach (Binding b in bindingServiceDescription.Bindings)
bindingNames.AddReserved(b.Name);
bindingName = bindingNames.AddUnique(bindingName, binding);
portType = new PortType();
binding = new Binding();
portType.Name = bindingName;
binding.Name = bindingName;
binding.Type = new XmlQualifiedName(portType.Name, bindingNamespace);
claims = reflectedBinding.bindingAttr.ConformsTo & this.ConformsTo;
if (reflectedBinding.bindingAttr.EmitConformanceClaims && claims != WsiProfiles.None) {
ServiceDescription.AddConformanceClaims(binding.GetDocumentationElement(), claims);
}
bindingServiceDescription.Bindings.Add(binding);
bindingServiceDescription.PortTypes.Add(portType);
}
if (portNames == null) {
portNames = new CodeIdentifiers();
foreach (Port p in Service.Ports)
portNames.AddReserved(p.Name);
}
port = new Port();
port.Binding = new XmlQualifiedName(bindingName, bindingNamespace);
port.Name = portNames.AddUnique(bindingName, port);
Service.Ports.Add(port);
BeginClass();
if (reflectedBinding.methodList != null && reflectedBinding.methodList.Count > 0) {
foreach (LogicalMethodInfo method in reflectedBinding.methodList) {
MoveToMethod(method);
operation = new Operation();
operation.Name = XmlConvert.EncodeLocalName(method.Name);
if (methodAttr.Description != null && methodAttr.Description.Length > 0)
operation.Documentation = methodAttr.Description;
operationBinding = new OperationBinding();
operationBinding.Name = operation.Name;
inputMessage = null;
outputMessage = null;
headerMessages = null;
if (ReflectMethod()) {
if (inputMessage != null) bindingServiceDescription.Messages.Add(inputMessage);
if (outputMessage != null) bindingServiceDescription.Messages.Add(outputMessage);
if (headerMessages != null) {
foreach (Message headerMessage in headerMessages) {
bindingServiceDescription.Messages.Add(headerMessage);
}
}
binding.Operations.Add(operationBinding);
portType.Operations.Add(operation);
}
}
}
if (binding != null && claims == WsiProfiles.BasicProfile1_1 && ProtocolName == "Soap") {
BasicProfileViolationCollection warnings = new BasicProfileViolationCollection();
WebServicesInteroperability.AnalyzeBinding(binding, bindingServiceDescription, ServiceDescriptions, warnings);
if (warnings.Count > 0) {
throw new InvalidOperationException(Res.GetString(Res.WebWsiViolation, ServiceType.FullName, warnings.ToString()));
}
}
EndClass();
}
internal virtual WsiProfiles ConformsTo { get { return WsiProfiles.None; } }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ProtocolName"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public abstract string ProtocolName { get; }
// These overridable methods have no parameters. The subclass uses properties on this
// base object to obtain the information. This allows us to grow the set of
// information passed to the methods over time w/o breaking anyone. They are protected
// instead of public because this object is passed to extensions and we don't want
// those calling these methods.
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.BeginClass"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected virtual void BeginClass() { }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ReflectMethod"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected abstract bool ReflectMethod();
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ReflectMethodBinding"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected virtual string ReflectMethodBinding() { return string.Empty; }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.EndClass"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected virtual void EndClass() { }
/// <include file='doc\ProtocolReflector.uex' path='docs/doc[@for="ProtocolReflector.ReflectDescription"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected virtual void ReflectDescription() {
}
}
}
|