/// <summary>
/// Writes a new property value
/// </summary>
/// <param name="context">Evaluation context</param>
/// <param name="obj">Instance or null if it's a static property</param>
/// <param name="value">New value</param>
/// <param name="invokeAttr">Binding flags</param>
/// <param name="index">Property indexes</param>
public void SetValue(object context, object obj, object value, DmdBindingFlags invokeAttr, object[] index)
{
var method = GetSetMethod(nonPublic: true);
if ((object)method == null)
{
throw new ArgumentException();
}
object[] parameters;
if (index == null || index.Length == 0)
{
parameters = new[] { value }
}
;
else
{
parameters = new object[index.Length + 1];
int i = 0;
for (; i < index.Length; i++)
{
parameters[i] = index[i];
}
parameters[i] = value;
}
method.Invoke(context, obj, invokeAttr, parameters);
}
/// <summary>
/// Gets a global method
/// </summary>
/// <param name="name">Method name</param>
/// <param name="bindingAttr">Binding attributes</param>
/// <param name="callConvention">Calling convention</param>
/// <param name="types">Method parameter types or null</param>
/// <returns></returns>
public DmdMethodInfo GetMethod(string name, DmdBindingFlags bindingAttr, DmdCallingConventions callConvention, IList <DmdType> types)
{
if (types == null)
{
return(GlobalType.GetMethod(name, bindingAttr));
}
return(GlobalType.GetMethod(name, bindingAttr, callConvention, types));
}
public static bool IsMatch(DmdMemberInfo member, string name, DmdBindingFlags bindingAttr)
{
if ((bindingAttr & DmdBindingFlags.IgnoreCase) != 0)
{
return(StringComparer.OrdinalIgnoreCase.Equals(member.Name, name));
}
return(StringComparer.Ordinal.Equals(member.Name, name));
}
public static bool IsMatch(DmdMethodBase method, DmdBindingFlags bindingAttr, DmdCallingConventions callConvention, IList <DmdType> types)
{
if (!IsMatch(method, bindingAttr, callConvention))
{
return(false);
}
return(IsMatch(method, types));
}
/// <summary>
/// Gets the property value
/// </summary>
/// <param name="context">Evaluation context</param>
/// <param name="obj">Instance or null if it's a static property</param>
/// <param name="invokeAttr">Binding flags</param>
/// <param name="index">Property indexes</param>
/// <returns></returns>
public object GetValue(object context, object obj, DmdBindingFlags invokeAttr, object[] index)
{
var method = GetGetMethod(nonPublic: true);
if ((object)method == null)
{
throw new ArgumentException();
}
return(method.Invoke(context, obj, invokeAttr, index));
}
static DmdFieldInfo?TryGetBuilderFieldByname(DmdType type)
{
foreach (var name in KnownMemberNames.builderFieldNames)
{
const DmdBindingFlags flags = DmdBindingFlags.Instance | DmdBindingFlags.Public | DmdBindingFlags.NonPublic;
if (type.GetField(name, flags) is DmdFieldInfo field)
{
return(field);
}
}
return(null);
}
public static bool IsMatch(DmdType type, string @namespace, string name, DmdBindingFlags bindingAttr)
{
// Namespace comparison is exact
if (@namespace != null && type.Namespace != @namespace)
{
return(false);
}
if ((bindingAttr & DmdBindingFlags.IgnoreCase) != 0)
{
return(StringComparer.OrdinalIgnoreCase.Equals(type.Name, name));
}
return(StringComparer.Ordinal.Equals(type.Name, name));
}
public static bool IsMatch(DmdType type, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (type.IsPublic || type.IsNestedPublic)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
return((attr & bindingAttr) == attr);
}
public static bool IsMatch(DmdEventInfo @event, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (@event.AddMethod?.IsPublic == true || @event.RemoveMethod?.IsPublic == true || @event.RaiseMethod?.IsPublic == true)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
if (@event.AddMethod?.IsStatic == true || @event.RemoveMethod?.IsStatic == true || @event.RaiseMethod?.IsStatic == true)
{
attr |= DmdBindingFlags.Static;
}
else
{
attr |= DmdBindingFlags.Instance;
}
if ((object)@event.ReflectedType != @event.DeclaringType)
{
var method = @event.AddMethod;
if ((object)method != null)
{
if (method.IsStatic)
{
if (method.IsPrivate)
{
return(false);
}
attr |= DmdBindingFlags.FlattenHierarchy;
}
else
{
if (!(method.IsVirtual || method.IsAbstract) && method.IsPrivate)
{
return(false);
}
}
}
}
return((attr & bindingAttr) == attr);
}
public static bool IsMatch(DmdPropertyInfo property, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (property.GetMethod?.IsPublic == true || property.SetMethod?.IsPublic == true)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
if (property.GetMethod?.IsStatic == true || property.SetMethod?.IsStatic == true)
{
attr |= DmdBindingFlags.Static;
}
else
{
attr |= DmdBindingFlags.Instance;
}
if ((object)property.ReflectedType != property.DeclaringType)
{
var method = property.GetMethod;
if ((object)method != null)
{
if (method.IsStatic)
{
if (method.IsPrivate)
{
return(false);
}
attr |= DmdBindingFlags.FlattenHierarchy;
}
else
{
if (!(method.IsVirtual || method.IsAbstract) && method.IsPrivate)
{
return(false);
}
}
}
}
return((attr & bindingAttr) == attr);
}
DbgDotNetRawValue?ReadField_CorDebug(DbgDotNetValueImpl obj, string fieldName1, string?fieldName2)
{
const DmdBindingFlags fieldFlags = DmdBindingFlags.Public | DmdBindingFlags.NonPublic | DmdBindingFlags.Instance;
var field = obj.Type.GetField(fieldName1, fieldFlags);
if (field is null && !(fieldName2 is null))
{
field = obj.Type.GetField(fieldName2, fieldFlags);
}
Debug2.Assert(!(field is null));
if (field is null)
{
return(null);
}
var dnAppDomain = ((DbgCorDebugInternalAppDomainImpl)obj.Type.AppDomain.GetDebuggerAppDomain().InternalAppDomain).DnAppDomain;
var corFieldDeclType = GetType(dnAppDomain.CorAppDomain, field.DeclaringType !);
var objValue = DbgCorDebugInternalRuntimeImpl.TryGetObjectOrPrimitiveValue(obj.TryGetCorValue(), out int hr);
if (objValue is null)
{
return(null);
}
if (objValue.IsObject)
{
// This isn't a generic read-field method, so we won't try to load any classes by calling cctors.
var fieldValue = objValue.GetFieldValue(corFieldDeclType.Class, (uint)field.MetadataToken, out hr);
if (fieldValue is null)
{
return(null);
}
DbgDotNetValue?dnValue = null;
try {
dnValue = CreateDotNetValue_CorDebug(fieldValue, field.AppDomain, tryCreateStrongHandle: false);
return(dnValue.GetRawValue());
}
finally {
dnValue?.Dispose();
}
}
return(null);
}
public static bool IsMatch(DmdFieldInfo field, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (field.IsPublic)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
if (field.IsStatic)
{
attr |= DmdBindingFlags.Static;
}
else
{
attr |= DmdBindingFlags.Instance;
}
if ((object)field.ReflectedType != field.DeclaringType)
{
if (field.IsStatic)
{
if (field.IsPrivate)
{
return(false);
}
attr |= DmdBindingFlags.FlattenHierarchy;
}
else
{
if (field.IsPrivate)
{
return(false);
}
}
}
return((attr & bindingAttr) == attr);
}
public static bool IsMatch(DmdMethodBase method, DmdBindingFlags bindingAttr)
{
var attr = DmdBindingFlags.Default;
if (method.IsPublic)
{
attr |= DmdBindingFlags.Public;
}
else
{
attr |= DmdBindingFlags.NonPublic;
}
if (method.IsStatic)
{
attr |= DmdBindingFlags.Static;
}
else
{
attr |= DmdBindingFlags.Instance;
}
if ((object)method.ReflectedType != method.DeclaringType)
{
if (method.IsStatic)
{
if (method.IsPrivate)
{
return(false);
}
attr |= DmdBindingFlags.FlattenHierarchy;
}
else
{
if (!(method.IsVirtual || method.IsAbstract) && method.IsPrivate)
{
return(false);
}
}
}
return((attr & bindingAttr) == attr);
}
/// <summary> /// Gets all global fields /// </summary> /// <param name="bindingFlags">Binding attributes</param> /// <returns></returns> public DmdFieldInfo[] GetFields(DmdBindingFlags bindingFlags) => GlobalType.GetFields(bindingFlags);
public sealed override void SetValue(object context, object obj, object value, DmdBindingFlags invokeAttr) => AppDomain.StoreField(context, this, obj, value);
/// <summary> /// Calls the method /// </summary> /// <param name="context">Evaluation context</param> /// <param name="obj">Instance or null if it's a static method</param> /// <param name="invokeAttr">Binding flags</param> /// <param name="parameters">Parameters</param> /// <returns></returns> public abstract object Invoke(object context, object obj, DmdBindingFlags invokeAttr, object[] parameters);
public sealed override object Invoke(object context, DmdBindingFlags invokeAttr, object[] parameters) => AppDomain.CreateInstance(context, this, parameters);
/// <summary> /// Creates an instance of a type /// </summary> /// <param name="context">Evaluation context</param> /// <param name="typeName">Fully qualified name of type to create</param> /// <param name="ignoreCase">true to ignore case</param> /// <param name="bindingAttr">Binding attributes</param> /// <param name="args">Constructor arguments or null</param> public object?CreateInstance(object?context, string typeName, bool ignoreCase, DmdBindingFlags bindingAttr, object?[]?args) => CreateInstance(context, typeName, ignoreCase, bindingAttr, args, (IList <DmdType>?)null);
/// <summary>
/// Creates an instance of a type
/// </summary>
/// <param name="context">Evaluation context</param>
/// <param name="typeName">Fully qualified name of type to create</param>
/// <param name="ignoreCase">true to ignore case</param>
/// <param name="bindingAttr">Binding attributes</param>
/// <param name="args">Constructor arguments or null</param>
/// <param name="argTypes">Constructor parameter types or null</param>
/// <returns></returns>
public object?CreateInstance(object?context, string typeName, bool ignoreCase, DmdBindingFlags bindingAttr, object?[]?args, IList <DmdType>?argTypes)
{
args = args ?? Array.Empty <object?>();
if (!(argTypes is null) && args.Length != argTypes.Count)
{
throw new ArgumentException();
}
var type = GetType(typeName, false, ignoreCase);
if (type is null)
{
return(null);
}
DmdConstructorInfo?ctor;
if (!(argTypes is null))
{
ctor = type.GetConstructor(bindingAttr, argTypes);
}
public sealed override object Invoke(object context, object obj, DmdBindingFlags invokeAttr, object[] parameters) => AppDomain.Invoke(context, this, obj, parameters);
/// <summary> /// Creates an instance of a type /// </summary> /// <param name="context">Evaluation context</param> /// <param name="typeName">Fully qualified name of type to create</param> /// <param name="ignoreCase">true to ignore case</param> /// <param name="bindingAttr">Binding attributes</param> /// <param name="args">Constructor arguments or null</param> /// <param name="argTypes">Constructor parameter types or null</param> /// <returns></returns> public object CreateInstance(object context, string typeName, bool ignoreCase, DmdBindingFlags bindingAttr, object[] args, IList <Type> argTypes) => CreateInstance(context, typeName, ignoreCase, bindingAttr, args, argTypes.ToDmdType(AppDomain));
/// <summary> /// Sets a new value /// </summary> /// <param name="context">Evaluation context</param> /// <param name="obj">Instance or null if it's a static field</param> /// <param name="value">New value</param> /// <param name="invokeAttr">Binding attributes</param> public abstract void SetValue(object context, object obj, object value, DmdBindingFlags invokeAttr);
/// <summary> /// Gets a global field /// </summary> /// <param name="name">Field name</param> /// <param name="bindingAttr">Binding attributes</param> /// <returns></returns> public DmdFieldInfo GetField(string name, DmdBindingFlags bindingAttr) => GlobalType.GetField(name, bindingAttr);
/// <summary> /// Gets global methods /// </summary> /// <param name="bindingFlags">Binding attributes</param> /// <returns></returns> public DmdMethodInfo[] GetMethods(DmdBindingFlags bindingFlags) => GlobalType.GetMethods(bindingFlags);
public static bool IsMatch(DmdMethodBase method, DmdBindingFlags bindingAttr, DmdCallingConventions callConvention) => IsMatch(method, bindingAttr) && IsMatch(method, callConvention);
/// <summary> /// Gets a global method /// </summary> /// <param name="name">Method name</param> /// <param name="bindingAttr">Binding attributes</param> /// <param name="callConvention">Calling convention</param> /// <param name="types">Method parameter types or null</param> /// <returns></returns> public DmdMethodInfo GetMethod(string name, DmdBindingFlags bindingAttr, DmdCallingConventions callConvention, IList <Type> types) => GetMethod(name, bindingAttr, callConvention, types.ToDmdType(AppDomain));
/// <summary>
/// Creates an instance of a type
/// </summary>
/// <param name="context">Evaluation context</param>
/// <param name="typeName">Fully qualified name of type to create</param>
/// <param name="ignoreCase">true to ignore case</param>
/// <param name="bindingAttr">Binding attributes</param>
/// <param name="args">Constructor arguments or null</param>
/// <param name="argTypes">Constructor parameter types or null</param>
/// <returns></returns>
public object CreateInstance(object context, string typeName, bool ignoreCase, DmdBindingFlags bindingAttr, object[] args, IList <DmdType> argTypes)
{
args = args ?? Array.Empty <object>();
if (argTypes != null && args.Length != argTypes.Count)
{
throw new ArgumentException();
}
var type = GetType(typeName, false, ignoreCase);
if ((object)type == null)
{
return(null);
}
DmdConstructorInfo ctor;
if (argTypes != null)
{
ctor = type.GetConstructor(bindingAttr, argTypes);
}
else
{
ctor = null;
foreach (var c in type.GetConstructors(bindingAttr))
{
if (c.GetMethodSignature().GetParameterTypes().Count != args.Length)
{
continue;
}
if ((object)ctor != null)
{
return(null);
}
ctor = c;
}
}
return(ctor?.Invoke(context, args));
}
