public override string ToString()
{
return(UnderlyingMethod
.GetInternalSymbol()
.GetISymbol()
.ToDisplayString(SymbolDisplayFormat.ILVisualizationFormat));
}
public override object Apply(object component,
object parent,
IReadOnlyDictionary <string, object> parameters)
{
var parms = MapParameters(UnderlyingMethod, parent, parameters);
return(DoAddChild(parent, UnderlyingMethod.Invoke(null, parms)));
}
public override bool Equals(object o)
{
var other = o as InheritedMethodInfo;
return(other != null &&
UnderlyingMethod.Equals(other.UnderlyingMethod) &&
ReflectedType.Equals(other.ReflectedType));
}
public override bool Equals(object o)
{
var other = o as ProjectingMethodInfo;
return(other != null &&
Projector == other.Projector &&
UnderlyingMethod.Equals(other.UnderlyingMethod));
}
public override string GetDocumentationCommentXml(
CultureInfo preferredCulture = null,
bool expandIncludes = false,
CancellationToken cancellationToken = default(CancellationToken)
)
{
return(UnderlyingMethod.GetDocumentationCommentXml(
preferredCulture,
expandIncludes,
cancellationToken
));
}
/// <summary>
/// Executes the specified this action on the specified target.
/// </summary>
/// <param name="actionMessage">The action message.</param>
/// <param name="handlingNode">The node.</param>
/// <param name="context">The context.</param>
public override void Execute(ActionMessage actionMessage, IInteractionNode handlingNode, object context)
{
try
{
var parameters = MessageBinder.DetermineParameters(
actionMessage,
UnderlyingRequirements,
handlingNode,
context
);
TryUpdateTrigger(actionMessage, handlingNode, true);
foreach (var filter in UnderlyingFilters.PreProcessors)
{
if (filter.Execute(actionMessage, handlingNode, parameters))
{
continue;
}
TryUpdateTrigger(actionMessage, handlingNode, false);
return;
}
var outcome = new MessageProcessingOutcome(
UnderlyingMethod.Invoke(handlingNode.MessageHandler.Unwrap(), parameters),
UnderlyingMethod.Info.ReturnType,
false
);
foreach (var filter in UnderlyingFilters.PostProcessors)
{
filter.Execute(actionMessage, handlingNode, outcome);
}
HandleOutcome(actionMessage, handlingNode, outcome);
}
catch (Exception ex)
{
TryUpdateTrigger(actionMessage, handlingNode, false);
if (!TryApplyRescue(actionMessage, handlingNode, ex))
{
Log.Error(ex);
throw;
}
OnCompleted();
}
}
public void Read(ObjectReader reader)
{
var type = reader.ReadType().UnderlyingType;
var methodName = reader.PrimitiveReader.ReadString();
var genericArgumentsCount = reader.PrimitiveReader.ReadInt32();
var genericArguments = new Type[genericArgumentsCount];
for (int i = 0; i < genericArgumentsCount; i++)
{
genericArguments[i] = reader.ReadType().UnderlyingType;
}
var parametersCount = reader.PrimitiveReader.ReadInt32();
if (genericArgumentsCount > 0)
{
var parameters = new TypeOrGenericTypeArgument[parametersCount];
for (int i = 0; i < parameters.Length; i++)
{
var genericType = reader.PrimitiveReader.ReadBoolean();
parameters[i] = genericType ?
new TypeOrGenericTypeArgument(reader.PrimitiveReader.ReadInt32()) :
new TypeOrGenericTypeArgument(reader.ReadType().UnderlyingType);
}
UnderlyingMethod = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault(m =>
m.IsGenericMethod &&
m.GetGenericMethodDefinition().Name == methodName &&
m.GetGenericArguments().Length == genericArgumentsCount &&
CompareGenericArguments(m.GetGenericMethodDefinition().GetParameters(), parameters));
if (UnderlyingMethod != null)
{
UnderlyingMethod = UnderlyingMethod.MakeGenericMethod(genericArguments);
}
}
else
{
var types = new Type[parametersCount];
for (int i = 0; i < types.Length; i++)
{
types[i] = reader.ReadType().UnderlyingType;
}
UnderlyingMethod = type.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
}
}
public void Write(ObjectWriter writer)
{
writer.TouchAndWriteTypeId(UnderlyingMethod.ReflectedType);
var methodParameters = UnderlyingMethod.GetParameters();
if (UnderlyingMethod.IsGenericMethod)
{
var genericDefinition = UnderlyingMethod.GetGenericMethodDefinition();
var genericArguments = UnderlyingMethod.GetGenericArguments();
var genericMethodParamters = genericDefinition.GetParameters();
writer.PrimitiveWriter.Write(genericDefinition.Name);
writer.PrimitiveWriter.Write(genericArguments.Length);
for (int i = 0; i < genericArguments.Length; i++)
{
writer.TouchAndWriteTypeId(genericArguments[i]);
}
writer.PrimitiveWriter.Write(genericMethodParamters.Length);
for (int i = 0; i < genericMethodParamters.Length; i++)
{
writer.PrimitiveWriter.Write(genericMethodParamters[i].ParameterType.IsGenericParameter);
if (genericMethodParamters[i].ParameterType.IsGenericParameter)
{
writer.PrimitiveWriter.Write(genericMethodParamters[i].ParameterType.GenericParameterPosition);
}
else
{
writer.TouchAndWriteTypeId(methodParameters[i].ParameterType);
}
}
}
else
{
writer.PrimitiveWriter.Write(UnderlyingMethod.Name);
writer.PrimitiveWriter.Write(0); // no generic arguments
writer.PrimitiveWriter.Write(methodParameters.Length);
foreach (var p in methodParameters)
{
writer.TouchAndWriteTypeId(p.ParameterType);
}
}
}
/// <summary>
/// Executes the specified this action on the specified target.
/// </summary>
/// <param name="actionMessage">The action message.</param>
/// <param name="handlingNode">The node.</param>
/// <param name="context">The context.</param>
public override void Execute(ActionMessage actionMessage, IInteractionNode handlingNode, object context)
{
try
{
var parameters = MessageBinder.DetermineParameters(
actionMessage,
UnderlyingRequirements,
handlingNode,
context
);
TryUpdateTrigger(actionMessage, handlingNode, true);
CurrentTask = UnderlyingMethod.CreateBackgroundTask(handlingNode.MessageHandler.Unwrap(), parameters);
foreach (var filter in UnderlyingFilters.PreProcessors)
{
if (filter.Execute(actionMessage, handlingNode, parameters))
{
continue;
}
TryUpdateTrigger(actionMessage, handlingNode, false);
return;
}
DoExecute(actionMessage, handlingNode, parameters);
}
catch (Exception ex)
{
TryUpdateTrigger(actionMessage, handlingNode, false);
if (!TryApplyRescue(actionMessage, handlingNode, ex))
{
Log.Error(ex);
throw;
}
OnCompleted();
}
}
protected override IEnumerable <CSharpAttributeData> GetCustomAttributesToEmit(ModuleCompilationState compilationState)
{
return(UnderlyingMethod.GetCustomAttributesToEmit(compilationState));
}
public override int GetHashCode() => UnderlyingMethod.GetHashCode();
internal override UnmanagedCallersOnlyAttributeData?GetUnmanagedCallersOnlyAttributeData(bool forceComplete) => UnderlyingMethod.GetUnmanagedCallersOnlyAttributeData(forceComplete);
internal override ImmutableArray <string> GetAppliedConditionalSymbols()
{
return(UnderlyingMethod.GetAppliedConditionalSymbols());
}
internal override IEnumerable <Microsoft.Cci.SecurityAttribute> GetSecurityInformation()
{
return(UnderlyingMethod.GetSecurityInformation());
}
public override DllImportData GetDllImportData()
{
return(UnderlyingMethod.GetDllImportData());
}
internal override bool IsMetadataNewSlot(bool ignoreInterfaceImplementationChanges = false)
{
return(UnderlyingMethod.IsMetadataNewSlot(ignoreInterfaceImplementationChanges));
}
public override int GetHashCode()
{
return(UnderlyingMethod.GetHashCode() ^ ReflectedType.GetHashCode());
}
public override bool Equals([NotNullWhen(true)] object?o)
{
return(o is InheritedMethodInfo other &&
UnderlyingMethod.Equals(other.UnderlyingMethod) &&
ReflectedType.Equals(other.ReflectedType));
}
protected override IEnumerable <CSharpAttributeData> GetCustomAttributesToEmit(PEModuleBuilder moduleBuilder)
{
return(UnderlyingMethod.GetCustomAttributesToEmit(moduleBuilder));
}
protected override IEnumerable <CSharpAttributeData> GetCustomAttributesToEmit()
{
return(UnderlyingMethod.GetCustomAttributesToEmit());
}
public override int GetHashCode()
{
return(Projector.GetHashCode() ^ UnderlyingMethod.GetHashCode());
}
public override bool Equals([NotNullWhen(true)] object?o)
{
return(o is ProjectingMethodInfo other &&
Projector == other.Projector &&
UnderlyingMethod.Equals(other.UnderlyingMethod));
}
public override object Apply(object component, object parent, IReadOnlyDictionary <string, object> parameters)
{
object[] items = MapParameters(UnderlyingMethod, parent, parameters);
return(UnderlyingMethod.Invoke(null, items));
}
public override object Apply(object component, object parent, IReadOnlyDictionary <string, object> parameters)
{
object[] mappedParameters = MapParameters(UnderlyingMethod, parent, parameters);
UnderlyingMethod.Invoke(component, mappedParameters);
return(mappedParameters[0]);
}
