Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

455 lines
18 KiB
C#

#region Copyright (c) Microsoft Corporation
/// <copyright company='Microsoft Corporation'>
/// Copyright (c) Microsoft Corporation. All Rights Reserved.
/// Information Contained Herein is Proprietary and Confidential.
/// </copyright>
#endregion
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Web.Services.Description;
using System.Xml;
#if WEB_EXTENSIONS_CODE
using System.Web.Resources;
#else
using Microsoft.VSDesigner.WCF.Resources;
#endif
#if WEB_EXTENSIONS_CODE
namespace System.Web.Compilation.WCFModel
#else
namespace Microsoft.VSDesigner.WCFModel
#endif
{
/// <summary>
/// This class check whether there are duplicated wsdl files in the metadata collection, and report error messages, if any contract is
/// defined differently in two wsdl files.
/// </summary>
internal class WsdlInspector
{
private IList<ProxyGenerationError> importErrors;
private Dictionary<XmlQualifiedName, PortType> portTypes;
private Dictionary<XmlQualifiedName, Message> messages;
/// <summary>
/// constructor
/// </summary>
/// <remarks></remarks>
private WsdlInspector(IList<ProxyGenerationError> importErrors)
{
this.importErrors = importErrors;
this.portTypes = new Dictionary<XmlQualifiedName, PortType>();
this.messages = new Dictionary<XmlQualifiedName, Message>();
}
/// <summary>
/// function to check duplicated items
/// </summary>
/// <param name="wsdlFiles"></param>
/// <param name="importErrors"></param>
/// <remarks></remarks>
internal static void CheckDuplicatedWsdlItems(ICollection<ServiceDescription> wsdlFiles, IList<ProxyGenerationError> importErrors)
{
WsdlInspector inspector = new WsdlInspector(importErrors);
inspector.CheckServiceDescriptions(wsdlFiles);
}
/// <summary>
/// check all duplicated items in a collection of files
/// </summary>
/// <remarks></remarks>
private void CheckServiceDescriptions(ICollection<ServiceDescription> wsdlFiles)
{
foreach (System.Web.Services.Description.ServiceDescription wsdl in wsdlFiles)
{
string targetNamespace = wsdl.TargetNamespace;
if (String.IsNullOrEmpty(targetNamespace))
{
targetNamespace = String.Empty;
}
// check all portTypes...
foreach (PortType portType in wsdl.PortTypes)
{
XmlQualifiedName portTypeName = new XmlQualifiedName(portType.Name, targetNamespace);
PortType definedPortType;
if (portTypes.TryGetValue(portTypeName, out definedPortType))
{
MatchPortTypes(definedPortType, portType);
}
else
{
portTypes.Add(portTypeName, portType);
}
}
// check all messages...
foreach (Message message in wsdl.Messages)
{
XmlQualifiedName messageName = new XmlQualifiedName(message.Name, targetNamespace);
Message definedMessage;
if (messages.TryGetValue(messageName, out definedMessage))
{
MatchMessages(definedMessage, message);
}
else
{
messages.Add(messageName, message);
}
}
}
}
/// <summary>
/// Compare two port type (with same targetNamespace/name)
/// </summary>
/// <remarks></remarks>
private void MatchPortTypes(PortType x, PortType y)
{
Operation[] operationsX = new Operation[x.Operations.Count];
x.Operations.CopyTo(operationsX, 0);
Array.Sort(operationsX, new OperationComparer());
Operation[] operationsY = new Operation[y.Operations.Count];
y.Operations.CopyTo(operationsY, 0);
Array.Sort(operationsY, new OperationComparer());
MatchCollections<Operation>(operationsX, operationsY,
delegate(Operation operationX, Operation operationY)
{
if (operationX != null && operationY != null)
{
int nameDifferent = String.Compare(operationX.Name, operationY.Name, StringComparison.Ordinal);
if (nameDifferent < 0)
{
ReportUniqueOperation(operationX, x, y);
return false;
}
else if (nameDifferent > 0)
{
ReportUniqueOperation(operationY, y, x);
return false;
}
else if (!MatchOperations(operationX, operationY))
{
return false;
}
return true;
}
else if (operationX != null)
{
ReportUniqueOperation(operationX, x, y);
return false;
}
else if (operationY != null)
{
ReportUniqueOperation(operationY, y, x);
return false;
}
return true;
}
);
}
/// <summary>
/// Compare two operations (with same name)
/// </summary>
/// <remarks></remarks>
private bool MatchOperations(Operation x, Operation y)
{
if (!MatchOperationMessages(x.Messages.Input, y.Messages.Input))
{
ReportOperationDefinedDifferently(x, y);
return false;
}
if (!MatchOperationMessages(x.Messages.Output, y.Messages.Output))
{
ReportOperationDefinedDifferently(x, y);
return false;
}
OperationFault[] faultsX = new OperationFault[x.Faults.Count];
x.Faults.CopyTo(faultsX, 0);
Array.Sort(faultsX, new OperationFaultComparer());
OperationFault[] faultsY = new OperationFault[y.Faults.Count];
y.Faults.CopyTo(faultsY, 0);
Array.Sort(faultsY, new OperationFaultComparer());
if (!MatchCollections<OperationFault>(faultsX, faultsY,
delegate(OperationFault faultX, OperationFault faultY)
{
if (faultX != null && faultY != null)
{
return MatchXmlQualifiedNames(faultX.Message, faultY.Message);
}
else if (faultX != null || faultY != null)
{
return false;
}
return true;
}
))
{
ReportOperationDefinedDifferently(x, y);
return false;
}
return true;
}
/// <summary>
/// Compare two messages in operations (with same name)
/// </summary>
/// <remarks></remarks>
private bool MatchOperationMessages(OperationMessage x, OperationMessage y)
{
if (x == null && y == null)
{
return true;
}
else if (x == null || y == null)
{
return false;
}
return MatchXmlQualifiedNames(x.Message, y.Message);
}
/// <summary>
/// Compare two messages defined in wsdl (with same name/targetNamespace)
/// </summary>
/// <remarks></remarks>
private void MatchMessages(Message x, Message y)
{
MessagePart[] partsX = new MessagePart[x.Parts.Count];
x.Parts.CopyTo(partsX, 0);
Array.Sort(partsX, new MessagePartComparer());
MessagePart[] partsY = new MessagePart[y.Parts.Count];
y.Parts.CopyTo(partsY, 0);
Array.Sort(partsY, new MessagePartComparer());
MatchCollections<MessagePart>(partsX, partsY,
delegate(MessagePart partX, MessagePart partY)
{
if (partX != null && partY != null)
{
int nameDifferent = String.Compare(partX.Name, partY.Name, StringComparison.Ordinal);
if (nameDifferent < 0)
{
ReportUniqueMessagePart(partX, x, y);
return false;
}
else if (nameDifferent > 0)
{
ReportUniqueMessagePart(partY, y, x);
return false;
}
else if (!MatchMessageParts(partX, partY))
{
return false;
}
return true;
}
else if (partX != null)
{
ReportUniqueMessagePart(partX, x, y);
return false;
}
else if (partY != null)
{
ReportUniqueMessagePart(partY, y, x);
return false;
}
return true;
}
);
}
/// <summary>
/// Compare two message parts (with same name)
/// </summary>
/// <remarks></remarks>
private bool MatchMessageParts(MessagePart partX, MessagePart partY)
{
if (!MatchXmlQualifiedNames(partX.Type, partY.Type) || !MatchXmlQualifiedNames(partX.Element, partY.Element))
{
ReportMessageDefinedDifferently(partX, partX.Message, partY.Message);
return false;
}
return true;
}
/// <summary>
/// compare two XmlQualifiedName
/// </summary>
/// <remarks></remarks>
private bool MatchXmlQualifiedNames(XmlQualifiedName x, XmlQualifiedName y)
{
if (x != null && y != null)
{
return x == y; // XmlQualifiedName
}
return x == null && y == null;
}
/// <summary>
/// Report an error when we find operation defined in one place but not another
/// </summary>
/// <remarks></remarks>
private void ReportUniqueOperation(Operation operation, PortType portType1, PortType portType2)
{
importErrors.Add(new ProxyGenerationError(
ProxyGenerationError.GeneratorState.MergeMetadata,
String.Empty,
new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_OperationDefinedInOneOfDuplicatedServiceContract,
portType1.Name,
portType1.ServiceDescription.RetrievalUrl,
portType2.ServiceDescription.RetrievalUrl,
operation.Name)
)
)
);
}
/// <summary>
/// Report an error when we find operation defined in two places differently
/// </summary>
/// <remarks></remarks>
private void ReportOperationDefinedDifferently(Operation x, Operation y)
{
importErrors.Add(new ProxyGenerationError(
ProxyGenerationError.GeneratorState.MergeMetadata,
String.Empty,
new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_OperationDefinedDifferently,
x.Name,
x.PortType.Name,
x.PortType.ServiceDescription.RetrievalUrl,
y.PortType.ServiceDescription.RetrievalUrl)
)
)
);
}
/// <summary>
/// Report an error when we find a part of message defined in one place but not another
/// </summary>
/// <remarks></remarks>
private void ReportUniqueMessagePart(MessagePart part, Message message1, Message message2)
{
importErrors.Add(new ProxyGenerationError(
ProxyGenerationError.GeneratorState.MergeMetadata,
String.Empty,
new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_FieldDefinedInOneOfDuplicatedMessage,
message1.Name,
message1.ServiceDescription.RetrievalUrl,
message2.ServiceDescription.RetrievalUrl,
part.Name)
)
)
);
}
/// <summary>
/// Report an error when we find message defined in two places differently
/// </summary>
/// <remarks></remarks>
private void ReportMessageDefinedDifferently(MessagePart part, Message x, Message y)
{
importErrors.Add(new ProxyGenerationError(
ProxyGenerationError.GeneratorState.MergeMetadata,
String.Empty,
new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture, WCFModelStrings.ReferenceGroup_FieldDefinedDifferentlyInDuplicatedMessage,
part.Name,
x.Name,
x.ServiceDescription.RetrievalUrl,
y.ServiceDescription.RetrievalUrl)
)
)
);
}
/// <summary>
/// Helper class to sort Operations
/// </summary>
/// <remarks></remarks>
private class OperationComparer : System.Collections.Generic.IComparer<Operation>
{
public int Compare(Operation x, Operation y)
{
return String.Compare(x.Name, y.Name, StringComparison.Ordinal);
}
}
/// <summary>
/// Helper class to sort OperationFaults
/// </summary>
/// <remarks></remarks>
private class OperationFaultComparer : System.Collections.Generic.IComparer<OperationFault>
{
public int Compare(OperationFault x, OperationFault y)
{
int namespaceResult = String.Compare(x.Message.Namespace, y.Message.Namespace, StringComparison.Ordinal);
if (namespaceResult != 0)
{
return namespaceResult;
}
return String.Compare(x.Message.Name, y.Message.Name, StringComparison.Ordinal);
}
}
/// <summary>
/// Helper class to sort MessageParts
/// </summary>
/// <remarks></remarks>
private class MessagePartComparer : System.Collections.Generic.IComparer<MessagePart>
{
public int Compare(MessagePart x, MessagePart y)
{
return String.Compare(x.Name, y.Name, StringComparison.Ordinal);
}
}
/// <summary>
/// Helper function to compare two collections
/// </summary>
/// <remarks></remarks>
private delegate bool MatchCollectionItemDelegate<T>(T x, T y);
private bool MatchCollections<T>(T[] x, T[] y, MatchCollectionItemDelegate<T> compareItems) where T : class
{
System.Collections.IEnumerator enumeratorX = x.GetEnumerator();
System.Collections.IEnumerator enumeratorY = y.GetEnumerator();
T tX;
T tY;
do
{
tX = enumeratorX.MoveNext() ? (T)enumeratorX.Current : null;
tY = enumeratorY.MoveNext() ? (T)enumeratorY.Current : null;
if (tX != null && tY != null)
{
if (!compareItems(tX, tY))
{
return false;
}
}
}
while (tX != null && tY != null);
return compareItems(tX, tY);
}
}
}