|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.Workflow.Activities
{
using System;
using System.ComponentModel;
using System.Drawing.Design;
using System.Diagnostics.CodeAnalysis;
using System.Net.Security;
using System.Reflection;
using System.ServiceModel;
using System.Workflow.Activities.Design;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Compiler;
[Obsolete("The System.Workflow.* types are deprecated. Instead, please use the new types from System.Activities.*")]
public sealed class OperationInfo : OperationInfoBase
{
[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
internal static readonly DependencyProperty ContractNameProperty =
DependencyProperty.Register("ContractName",
typeof(string), typeof(OperationInfo),
new PropertyMetadata(null, DependencyPropertyOptions.Metadata));
[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
internal static readonly DependencyProperty IsOneWayProperty =
DependencyProperty.Register("IsOneWay",
typeof(bool), typeof(OperationInfo),
new PropertyMetadata(false, DependencyPropertyOptions.Metadata));
[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
internal static readonly DependencyProperty ParametersProperty =
DependencyProperty.Register("Parameters",
typeof(OperationParameterInfoCollection), typeof(OperationInfo),
new PropertyMetadata(null, DependencyPropertyOptions.Metadata | DependencyPropertyOptions.ReadOnly,
new Attribute[] {
new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)
}
));
[SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
internal static readonly DependencyProperty ProtectionLevelProperty =
DependencyProperty.Register("ProtectionLevel",
typeof(ProtectionLevel?), typeof(OperationInfo),
new PropertyMetadata(null, DependencyPropertyOptions.Metadata));
public OperationInfo()
{
this.SetReadOnlyPropertyValue(OperationInfo.ParametersProperty,
new OperationParameterInfoCollection(this));
}
public string ContractName
{
get
{
return (string) this.GetValue(OperationInfo.ContractNameProperty);
}
set
{
this.SetValue(OperationInfo.ContractNameProperty, value);
}
}
[DefaultValue(false)]
public bool HasProtectionLevel
{
get
{
return (this.ProtectionLevel != null);
}
}
[DefaultValue(false)]
public bool IsOneWay
{
get
{
return (bool) this.GetValue(OperationInfo.IsOneWayProperty);
}
set
{
this.SetValue(OperationInfo.IsOneWayProperty, value);
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public OperationParameterInfoCollection Parameters
{
get
{
return (OperationParameterInfoCollection) this.GetValue(OperationInfo.ParametersProperty);
}
}
[DefaultValue(null)]
public ProtectionLevel? ProtectionLevel
{
get
{
return (ProtectionLevel?) this.GetValue(OperationInfo.ProtectionLevelProperty);
}
set
{
this.SetValue(OperationInfo.ProtectionLevelProperty, value);
}
}
public override OperationInfoBase Clone()
{
OperationInfo clonedOperation = (OperationInfo) base.Clone();
clonedOperation.ContractName = this.ContractName;
clonedOperation.IsOneWay = this.IsOneWay;
if (this.HasProtectionLevel)
{
clonedOperation.ProtectionLevel = this.ProtectionLevel;
}
foreach (OperationParameterInfo parameter in this.Parameters)
{
clonedOperation.Parameters.Add(parameter.Clone());
}
return clonedOperation;
}
public override bool Equals(object obj)
{
if (!base.Equals(obj))
{
return false;
}
OperationInfo operationInfo = obj as OperationInfo;
if (operationInfo == null)
{
return false;
}
if (String.Compare(operationInfo.ContractName, this.ContractName, StringComparison.Ordinal) != 0)
{
return false;
}
if (operationInfo.IsOneWay != this.IsOneWay)
{
return false;
}
if (operationInfo.HasProtectionLevel != this.HasProtectionLevel)
{
return false;
}
if (operationInfo.ProtectionLevel != this.ProtectionLevel)
{
return false;
}
if (operationInfo.Parameters.Count != this.Parameters.Count)
{
return false;
}
foreach (OperationParameterInfo parameter in operationInfo.Parameters)
{
OperationParameterInfo correspondingParameter = this.Parameters[parameter.Name];
if (correspondingParameter == null)
{
return false;
}
if (!parameter.Equals(correspondingParameter))
{
return false;
}
}
return true;
}
public override int GetHashCode()
{
return base.GetHashCode();
}
public override string ToString()
{
string returnValue = string.Empty;
if (!string.IsNullOrEmpty(this.Name))
{
returnValue = this.Name;
if (!string.IsNullOrEmpty(this.ContractName))
{
returnValue = this.ContractName + "." + returnValue;
}
}
return returnValue;
}
protected internal override string GetContractFullName(IServiceProvider provider)
{
return this.ContractName;
}
protected internal override Type GetContractType(IServiceProvider provider)
{
Type contractType = DynamicContractTypeBuilder.GetContractType(this, this.ParentDependencyObject as ReceiveActivity);
if (contractType == null && !this.IsReadOnly)
{
Activity owner = this.ParentDependencyObject as Activity;
if (owner != null)
{
owner.RootActivity.RemoveProperty(DynamicContractTypeBuilder.DynamicContractTypesProperty);
}
contractType = DynamicContractTypeBuilder.GetContractType(this, this.ParentDependencyObject as ReceiveActivity);
}
return contractType;
}
internal protected override bool GetIsOneWay(IServiceProvider provider)
{
return this.IsOneWay;
}
internal protected override MethodInfo GetMethodInfo(IServiceProvider provider)
{
if (string.IsNullOrEmpty(this.Name))
{
return null;
}
MethodInfo methodInfo = null;
if (this.IsReadOnly)
{
if (this.UserData.Contains(OperationInfoBase.MethodInfoProperty))
{
methodInfo = this.UserData[OperationInfoBase.MethodInfoProperty] as MethodInfo;
}
if (methodInfo != null)
{
return methodInfo;
}
}
methodInfo = InternalGetMethodInfo(provider);
if (methodInfo == null && !this.IsReadOnly)
{
Activity owner = this.ParentDependencyObject as Activity;
if (owner != null)
{
owner.RootActivity.RemoveProperty(DynamicContractTypeBuilder.DynamicContractTypesProperty);
}
methodInfo = InternalGetMethodInfo(provider);
}
if (this.IsReadOnly)
{
this.UserData[OperationInfoBase.MethodInfoProperty] = methodInfo;
}
return methodInfo;
}
internal protected override OperationParameterInfoCollection GetParameters(IServiceProvider provider)
{
return this.Parameters;
}
internal void ResetProtectionLevel()
{
this.ProtectionLevel = null;
}
MethodInfo InternalGetMethodInfo(IServiceProvider provider)
{
Type type = this.GetContractType(provider);
if (type != null)
{
foreach (MethodInfo methodInfo in type.GetMethods())
{
object[] operationContractAttribs =
methodInfo.GetCustomAttributes(typeof(OperationContractAttribute), true);
if (operationContractAttribs != null && operationContractAttribs.Length > 0)
{
string operationName =
((OperationContractAttribute) operationContractAttribs[0]).Name;
if (string.IsNullOrEmpty(operationName) &&
string.Compare(methodInfo.Name, this.Name, StringComparison.Ordinal) == 0)
{
return methodInfo;
}
else if (string.Compare(operationName, this.Name, StringComparison.Ordinal) == 0)
{
return methodInfo;
}
}
}
}
return null;
}
}
}
|