/// <summary>
/// Implements all given abstract methods by throwing
/// <see cref="NotSupportedException"/>s.
/// </summary>
/// <param name="typeBuilder">The type builder to use.</param>
/// <param name="methods">The methods to implement.</param>
/// <param name="errorMessage">
/// The error message to use for all exceptions.
/// </param>
private static void ImplementNotSupported(
TypeBuilder typeBuilder,
ImportMethod[] methods,
string errorMessage)
{
foreach (var importMethod in methods)
{
// Define the implementation method
var notImplementedMethod =
importMethod.DefineImplementationMethod(typeBuilder);
DefineWrapperParameters(
notImplementedMethod,
importMethod.GetParameters());
// Define wrapper method body
var generator = new ILEmitter(notImplementedMethod.GetILGenerator());
generator.EmitConstant(errorMessage);
generator.EmitNewObject(NotSupportedExceptionConstructor);
generator.Emit(OpCodes.Throw);
generator.Emit(OpCodes.Ret);
// Define method override
typeBuilder.DefineMethodOverride(
notImplementedMethod,
importMethod.Method);
}
}
/// <summary>
/// Implements the <see cref="RuntimeAPI.IsSupported"/> property.
/// </summary>
private static void ImplementIsSupported <T>(
TypeBuilder typeBuilder,
bool isSupported)
where T : RuntimeAPI
{
var abstractMethod = typeof(T)
.GetProperty(nameof(RuntimeAPI.IsSupported))
.GetGetMethod();
var wrapperMethod = typeBuilder.DefineMethod(
abstractMethod.Name,
abstractMethod.Attributes & ~ImplAttributesToClear,
abstractMethod.GetReturnType(),
Array.Empty <Type>());
var generator = new ILEmitter(wrapperMethod.GetILGenerator());
generator.EmitConstant(Convert.ToInt32(isSupported));
generator.Emit(OpCodes.Ret);
typeBuilder.DefineMethodOverride(wrapperMethod, abstractMethod);
}