public override bool Equals(object obj)
{
MetadataOnlyMethodInfo metadataOnlyMethodInfo = obj as MetadataOnlyMethodInfo;
if (metadataOnlyMethodInfo == null)
{
return(false);
}
if (!this.DeclaringType.Equals(metadataOnlyMethodInfo.DeclaringType))
{
return(false);
}
if (!this.IsGenericMethod)
{
return(metadataOnlyMethodInfo.GetHashCode() == this.GetHashCode());
}
if (!metadataOnlyMethodInfo.IsGenericMethod)
{
return(false);
}
Type[] genericArguments = this.GetGenericArguments();
Type[] typeArray = metadataOnlyMethodInfo.GetGenericArguments();
if ((int)genericArguments.Length != (int)typeArray.Length)
{
return(false);
}
for (int i = 0; i < (int)genericArguments.Length; i++)
{
if (!genericArguments[i].Equals(typeArray[i]))
{
return(false);
}
}
return(true);
}
private static void ConstructParameters(StringBuilder sb, ParameterInfo[] parameters, CallingConventions callingConvention)
{
Type[] parameterType = new Type[(int)parameters.Length];
for (int i = 0; i < (int)parameters.Length; i++)
{
parameterType[i] = parameters[i].ParameterType;
}
MetadataOnlyMethodInfo.ConstructParameters(sb, parameterType, callingConvention);
}
internal static string CommonToString(MethodInfo m)
{
StringBuilder stringBuilder = new StringBuilder();
MetadataOnlyCommonType.TypeSigToString(m.ReturnType, stringBuilder);
stringBuilder.Append(" ");
MetadataOnlyMethodInfo.ConstructMethodString(m, stringBuilder);
return(stringBuilder.ToString());
}
public virtual MethodBase CreateMethodOrConstructor(MetadataOnlyModule resolver, Token methodDef, Type[] typeArgs, Type[] methodArgs)
{
MetadataOnlyMethodInfo metadataOnlyMethodInfo = new MetadataOnlyMethodInfo(resolver, methodDef, typeArgs, methodArgs);
if (DefaultFactory.IsRawConstructor(metadataOnlyMethodInfo))
{
return(this.CreateConstructorInfo(metadataOnlyMethodInfo));
}
return(this.CreateMethodInfo(metadataOnlyMethodInfo));
}
public override MethodInfo MakeGenericMethod(params Type[] types)
{
if (!this.IsGenericMethodDefinition)
{
throw new InvalidOperationException();
}
GenericContext genericContext = new GenericContext(this.m_context.TypeArgs, types);
return((MethodInfo)MetadataOnlyMethodInfo.Create(this.m_resolver, this.m_methodDef, genericContext));
}
internal static MethodBody TryCreate(MetadataOnlyMethodInfo method)
{
MetadataOnlyModule resolver = method.Resolver;
MethodBody methodBody = null;
if (resolver.Factory.TryCreateMethodBody(method, ref methodBody))
{
return(methodBody);
}
return(MetadataOnlyMethodBodyWorker.Create(method));
}
internal static MethodBody Create(MetadataOnlyMethodInfo method)
{
MetadataOnlyModule resolver = method.Resolver;
uint methodRva = resolver.GetMethodRva(method.MetadataToken);
if (methodRva == 0)
{
return(null);
}
return(new MetadataOnlyMethodBodyWorker(method, MetadataOnlyMethodBodyWorker.GetMethodHeader(methodRva, resolver)));
}
public MetadataOnlyMethodInfo(MetadataOnlyMethodInfo method)
{
this.m_resolver = method.m_resolver;
this.m_methodDef = method.m_methodDef;
this.m_tOwner = method.m_tOwner;
this.m_descriptor = method.m_descriptor;
this.m_name = method.m_name;
this.m_attrs = method.m_attrs;
this.m_returnParameter = method.m_returnParameter;
this.m_methodBody = method.m_methodBody;
this.m_declaringTypeDef = method.m_declaringTypeDef;
this.m_sigBlob = method.m_sigBlob;
this.m_typeArgs = method.m_typeArgs;
this.m_methodArgs = method.m_methodArgs;
this.m_context = method.m_context;
this.m_fullyInitialized = method.m_fullyInitialized;
}
private static void ConstructMethodString(MethodInfo m, StringBuilder sb)
{
sb.Append(m.Name);
string str = "";
if (m.IsGenericMethod)
{
sb.Append("[");
Type[] genericArguments = m.GetGenericArguments();
for (int i = 0; i < (int)genericArguments.Length; i++)
{
Type type = genericArguments[i];
sb.Append(str);
MetadataOnlyCommonType.TypeSigToString(type, sb);
str = ",";
}
sb.Append("]");
}
sb.Append("(");
MetadataOnlyMethodInfo.ConstructParameters(sb, m.GetParameters(), m.CallingConvention);
sb.Append(")");
}
protected MetadataOnlyMethodBody(MetadataOnlyMethodInfo method)
{
this.m_method = method;
}
public MetadataOnlyMethodBodyWorker(MetadataOnlyMethodInfo method, MetadataOnlyMethodBodyWorker.IMethodHeader header) : base(method)
{
this.m_header = header;
}
public virtual MetadataOnlyMethodInfo CreateMethodInfo(MetadataOnlyMethodInfo method)
{
return(new MetadataOnlyMethodInfo(method));
}
public virtual bool TryCreateMethodBody(MetadataOnlyMethodInfo method, ref MethodBody body)
{
return(false);
}
public override string ToString()
{
return(MetadataOnlyMethodInfo.CommonToString(this));
}