mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
455 lines
18 KiB
C#
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);
|
|
}
|
|
|
|
}
|
|
}
|
|
|