private void ButInsertBefore_Click(object sender, EventArgs e)
{
if (IsFormComplete)
{
var newInterface = new InterfaceImplementation(CecilImporter.Import(TypeDefinition.Module, TypeReferenceEditor.SelectedOperand, TypeDefinition));
var index = TypeDefinition.LegacyInterfaces.IndexOf(SelectedTypeReference);
TypeDefinition.Interfaces.Insert(index, newInterface);
DialogResult = DialogResult.OK;
}
else
{
DialogResult = DialogResult.None;
}
}
public static void AcceptVisitor <TResult> (
this InterfaceImplementation interfaceImplementation,
MetadataVisitor <TResult> visitor)
{
if (!visitor.ShouldTraverseInto(visitor.VisitInterfaceImplementation(interfaceImplementation)))
{
return;
}
if (interfaceImplementation.HasCustomAttributes)
{
interfaceImplementation.CustomAttributes.AcceptVisitor(visitor);
}
interfaceImplementation.InterfaceType.AcceptVisitor(visitor);
}
public ClassWithMixedDependencies(
IInterface interfaceDependency,
AbstractBaseClass abstractBaseClassDependency,
InterfaceImplementation interfaceImplementation,
BaseClassImplementation baseClassImplementation)
{
InterfaceDependency =
interfaceDependency ?? throw new ArgumentNullException(nameof(interfaceDependency));
AbstractBaseClassDependency =
abstractBaseClassDependency
?? throw new ArgumentNullException(nameof(abstractBaseClassDependency));
InterfaceImplementation =
interfaceImplementation ?? throw new ArgumentNullException(nameof(interfaceImplementation));
BaseClassImplementation =
baseClassImplementation ?? throw new ArgumentNullException(nameof(baseClassImplementation));
}
public static bool ImplementsInterface(this TypeDefinition type, InterfaceImplementation baseInterface)
{
if (!type.HasInterfaces)
{
return(false);
}
for (int i = 0; i < type.Interfaces.Count; i++)
{
if (type.Interfaces[i].InterfaceType.FullName == baseInterface.InterfaceType.FullName)
{
return(true);
}
}
return(false);
}
private void InterfaceTypeChange(int Index)
{
InterfaceImplementation Implementation = CommInteraceImp.Values.ToArray()[Index];
ConfigTabs.TabPages.Clear();
_CurrentConfigPanel = Implementation.ConfigPanelInstance();
_CurrentConfigPanel.OnConfigChange += new OnConfigChangeEvent(ConfigPanel_OnConfigChange);
((Control)_CurrentConfigPanel).Dock = DockStyle.Fill;
TabPage ConfigPage = new TabPage(Implementation.Name);
ConfigPage.Controls.Add((Control)_CurrentConfigPanel);
ConfigTabs.TabPages.Add(ConfigPage);
ConfigTabs.TabPages.Add(_BufferPage);
ConfigPanel_OnConfigChange(_CurrentConfigPanel);
}
protected override void InterfaceRemoved(TypeDefinition type, InterfaceImplementation iface)
{
base.InterfaceRemoved(type, iface);
// The static registrar needs access to the interfaces for protocols, so keep them around.
if (!LinkContext.ProtocolImplementations.TryGetValue(type, out var list))
{
LinkContext.ProtocolImplementations [type] = list = new List <TypeDefinition> ();
}
var it = iface.InterfaceType.Resolve();
if (it == null)
{
// The interface type might already have been linked away, so go look for it among those types as well
it = LinkContext.GetLinkedAwayType(iface.InterfaceType, out _);
}
list.Add(it);
}
void GenerateInnerInjectorType(TypeDefinition typeDef, InjectTypeInfo injectTypeInfo)
{
var injectorTypeDef = new TypeDefinition(
"",
"__GeneratedInjector",
TypeAttributes.NestedPrivate | TypeAttributes.Sealed,
module.TypeSystem.Object);
var injectorImpl = new InterfaceImplementation(InjectorTypeRef);
injectorTypeDef.Interfaces.Add(injectorImpl);
GenerateDefaultConstructor(injectorTypeDef);
GenerateInjectMethod(typeDef, injectorTypeDef, injectTypeInfo);
GenerateCreateInstanceMethod(typeDef, injectorTypeDef, injectTypeInfo);
GenerateInjectorGetterMethod(typeDef, injectorTypeDef);
typeDef.NestedTypes.Add(injectorTypeDef);
}
private TypeDefinition createNavigationAction(
TypeDefinition navigationView,
MethodDefinition navigateMethod,
MethodDefinition canNavigateMethod,
int uniqueId)
{
var navigationAction = new TypeDefinition(
navigationView.Namespace,
$"<N>NavigationAction{uniqueId}",
TypeAttributes.NestedPrivate | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit,
TypeSystem.ObjectReference
);
var navigationActionInterface = new InterfaceImplementation(
ModuleDefinition.ImportReference(FindType(Constant.NavigationActionInterfaceFullName))
);
navigationAction.Interfaces.Add(navigationActionInterface);
FieldDefinition viewField = addNavigationViewField(navigationAction, navigationView);
addNavigationViewConstructor(navigationAction, navigationView, viewField);
if (navigateMethod != null)
{
addNavigateAsyncIfDefined(navigationAction, navigateMethod, viewField);
}
else
{
addNavigateAsyncIfNotDefined(navigationAction);
}
if (canNavigateMethod != null)
{
addCanNavigateIfDefined(navigationAction, canNavigateMethod, viewField);
}
else
{
addCanNavigateIfNotDefined(navigationAction);
}
navigationView.NestedTypes.Add(navigationAction);
return(navigationAction);
}
static void Main(string[] args)
{
// AssemblyDefinition assembiy = AssemblyDefinition.ReadAssembly(args[0]);
AssemblyDefinition assembiy = AssemblyDefinition.ReadAssembly("C:\\Users\\huiyh\\source\\repos\\zpvip_2_0_0_im_sdk\\Wuba.ZPVIP\\bin\\x86\\Debug\\zcm.exe");
AssemblyNameDefinition name = assembiy.Name;
var nameName = name.Name;
ModuleDefinition module = assembiy.MainModule;
TypeDefinition type = new TypeDefinition("", "", Mono.Cecil.TypeAttributes.Class);
InterfaceImplementation interfaceImplementation = new InterfaceImplementation(null);
type.Interfaces.Add(interfaceImplementation);
module.Types.Add(type);
foreach (Mono.Cecil.TypeDefinition item in assembiy.MainModule.Types)
{
foreach (MethodDefinition method in item.Methods)
{
if (method.Name.Equals("Main"))
{
//Instruction ins = method.Body.Instructions[0];
//var worker = method.Body.CilWorker;
//worker.InsertBefore(ins, worker.Create(OpCodes.Ldstr, "Method start…"));
//worker.InsertBefore(ins, worker.Create(OpCodes.Call,
// assembiy.MainModule.Import(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }))));
//ins = method.Body.Instructions[method.Body.Instructions.Count - 1];
//worker.InsertBefore(ins, worker.Create(OpCodes.Ldstr, "Method finish…"));
//worker.InsertBefore(ins, worker.Create(OpCodes.Call,
// assembiy.MainModule.Import(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }))));
break;
}
}
}
AssemblyDefinition.CreateAssembly(name, "IL_" + args[0], ModuleKind.Dll);
Console.Read();
}
public static void Patch(AssemblyDefinition assembly)
{
var module = assembly.MainModule;
var outcomeBase = module.GetType(null, "OutcomeBase");
var voidType = module.ImportReference(typeof(void));
var beforeSerialize = new MethodDefinition("OnBeforeSerialize", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final, voidType);
beforeSerialize.NoInlining = true;
beforeSerialize.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
TypeReference debug = null;
module.TryGetTypeReference("UnityEngine.CoreModule", "UnityEngine.Debug", out debug);
var log = new MethodReference("Log", voidType, debug);
log.Parameters.Add(new ParameterDefinition(module.ImportReference(typeof(object))));
var afterDeserialize = new MethodDefinition("OnAfterDeserialize", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final, voidType);
afterDeserialize.NoInlining = true;
afterDeserialize.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
TypeReference callbackReceiver = null;
module.TryGetTypeReference("UnityEngine.CoreModule", "UnityEngine.ISerializationCallbackReceiver", out callbackReceiver);
var impl = new InterfaceImplementation(callbackReceiver);
var iBeforeSerialize = new MethodReference("OnBeforeSerialize", voidType, callbackReceiver);
iBeforeSerialize.HasThis = true;
var iAfterDeserialize = new MethodReference("OnAfterDeserialize", voidType, callbackReceiver);
iAfterDeserialize.HasThis = true;
beforeSerialize.Overrides.Add(iBeforeSerialize);
afterDeserialize.Overrides.Add(iAfterDeserialize);
outcomeBase.Interfaces.Add(impl);
outcomeBase.Methods.Add(beforeSerialize);
outcomeBase.Methods.Add(afterDeserialize);
}
/// <summary>
/// Create the wrapper class for the given type.
/// </summary>
/// <returns>Wrapper type.</returns>
public Type GenerateType()
{
AddMethods();
AddProperties();
AddEvents();
AddConstructors();
int memberCount = 0;
HashSet<Type> implementedInterfaces = GetImplementedInterfacesSet();
foreach (var @interface in _additionalInterfaces)
{
memberCount =
new InterfaceImplementation(_typeBuilder, @interface, _proxyInterceptionPipelineField, true)
.Implement(implementedInterfaces, memberCount);
}
Type result = _typeBuilder.CreateTypeInfo().AsType();
#if DEBUG_SAVE_GENERATED_ASSEMBLY
assemblyBuilder.Save("Unity_ILEmit_DynamicClasses.dll");
#endif
return result;
}
void ConvertInterfaceImplementation(MethodDeclaration member)
{
// members without modifiers are already C# explicit interface implementations, do not convert them
if (member.Modifier == Modifiers.None)
{
return;
}
while (member.InterfaceImplementations.Count > 0)
{
InterfaceImplementation impl = member.InterfaceImplementations[0];
member.InterfaceImplementations.RemoveAt(0);
if (member.Name != impl.MemberName)
{
MethodDeclaration newMember = new MethodDeclaration
{
Name = impl.MemberName,
TypeReference = member.TypeReference,
Parameters = member.Parameters,
Body = new BlockStatement()
};
InvocationExpression callExpression = new InvocationExpression(new IdentifierExpression(member.Name));
foreach (ParameterDeclarationExpression decl in member.Parameters)
{
callExpression.Arguments.Add(new IdentifierExpression(decl.ParameterName));
}
if (member.TypeReference.Type == "System.Void")
{
newMember.Body.AddChild(new ExpressionStatement(callExpression));
}
else
{
newMember.Body.AddChild(new ReturnStatement(callExpression));
}
newMember.InterfaceImplementations.Add(impl);
InsertAfterSibling(member, newMember);
}
}
}
private static void Main(string[] args)
{
foreach (string fileName in new string[] { @"C:\git\corert\bin\Windows_NT.x64.Debug\ILVerification.Tests\Tests\InterfaceImplementation.dll" })
{
Console.WriteLine("Lib: " + fileName);
PEReader peReader = new PEReader(File.OpenRead(fileName));
MetadataReader metadataReader = peReader.GetMetadataReader(MetadataReaderOptions.None);
Console.WriteLine("IsAssembly " + metadataReader.IsAssembly);
foreach (TypeDefinitionHandle td in metadataReader.TypeDefinitions)
{
TypeDefinition typeDefinition = metadataReader.GetTypeDefinition(td);
if (metadataReader.GetString(typeDefinition.Name) != "InvalidReturnTypeM1_InvalidType_InterfaceMethodNotImplemented")
{
continue;
}
Console.WriteLine("TypeDefHandle token:" + metadataReader.GetToken(td).ToString("X8"));
Console.WriteLine("TypeDefinition name: " + metadataReader.GetString(typeDefinition.Name) + ((((int)typeDefinition.Attributes & 0x00000020) == 0x00000020) ? " [IsInterface]" : ""));
Console.WriteLine("Attributes name: " + typeDefinition.Attributes);
foreach (InterfaceImplementationHandle interfaceImplementation in typeDefinition.GetInterfaceImplementations())
{
InterfaceImplementation im = metadataReader.GetInterfaceImplementation(interfaceImplementation);
Console.WriteLine("InterfaceImplementationHandle:" + metadataReader.GetToken(im.Interface).ToString("X8"));
}
foreach (MethodDefinitionHandle mdh in typeDefinition.GetMethods())
{
MethodDefinition md = metadataReader.GetMethodDefinition(mdh);
Console.WriteLine(" Method name: " + metadataReader.GetString(md.Name));
foreach (ParameterHandle ph in md.GetParameters())
{
Parameter parameterDef = metadataReader.GetParameter(ph);
Console.WriteLine(" Param name: " + metadataReader.GetString(parameterDef.Name) + (parameterDef.SequenceNumber == 0 ? "- return value" : ""));
}
Console.WriteLine("MethodDefinitionHandle:" + metadataReader.GetToken(mdh).ToString("X8"));
}
Console.WriteLine("----");
}
}
}
protected override void MarkInterfaceImplementation(TypeDefinition type, InterfaceImplementation iface)
{
if (RegisterProtocols)
{
// If we're registering protocols, we can remove interfaces that represent protocols.
// The linker will automatically mark interfaces a class implements, but we have to
// override the linker behavior for interfaces that represent protocols for those
// interfaces to be removed.
var mark = false;
var interfaceType = iface.InterfaceType.Resolve();
var isProtocol = type.IsNSObject(LinkContext) && interfaceType.HasCustomAttribute(LinkContext, Namespaces.Foundation, "ProtocolAttribute");
if (IgnoreScope(type.Scope))
{
// We're not linking the current assembly, which means the interface should be marked.
mark = true;
}
else if (!isProtocol)
{
// We only skip interfaces that represent protocols.
mark = true;
}
if (!mark)
{
if (isProtocol)
{
LinkContext.StoreProtocolMethods(interfaceType);
}
return;
}
}
base.MarkInterfaceImplementation(type, iface);
}
private void ApplyImplements(ImplementsInfo implements)
{
var interfaceType = _targetModule.ImportReference(implements.TargetType);
var impl = new InterfaceImplementation(interfaceType);
_targetType.Interfaces.Add(impl);
var interfaceTypeDef = interfaceType.Resolve();
foreach (var expectedMethod in interfaceTypeDef.Methods)
{
string expectedParameters = string.Join(",", expectedMethod.Parameters.Select(t => t.ParameterType.FullName).ToArray()); // TODO disgusting
var foundMethod = _mixin.MixinContainer.Methods.SingleOrDefault(t => t.Name == expectedMethod.Name && expectedParameters == string.Join(",", t.Parameters.Select(p => p.ParameterType.FullName).ToArray())); // TODO ewwwwww
if (foundMethod == null)
{
throw new MixinException("Interface Method '" + expectedMethod.FullName + "' not found in mixin class for [Implements] in " + _mixin.MixinContainer.FullName);
}
var newMethod = new MethodDefinition(foundMethod.Name, foundMethod.Attributes, _targetModule.ImportReference(foundMethod.ReturnType));
TransferMethod(newMethod, foundMethod);
_targetType.Methods.Add(newMethod);
}
}
/// <summary>
/// Clones the type.
/// </summary>
protected override void DoClone()
{
Contract.Assert(this.Target != this.CloningContext.RootTarget);
Contract.Assert(this.Target.IsNested);
Contract.Assert(this.Source.IsNested);
if (this.Source.HasSecurityDeclarations)
{
// TODO Nested type security declarations
throw new InvalidOperationException(string.Format(
"Cloning source type may not contain nested types annotated with security attributes: [{0}]",
this.CloningContext.RootSource.FullName));
}
this.Target.Attributes = this.Source.Attributes;
this.Target.DeclaringType = this.CloningContext.RootImport(this.Source.DeclaringType).Resolve();
this.Target.BaseType = this.CloningContext.RootImport(this.Source.BaseType);
foreach (var interfaceImplementation in this.Source.Interfaces)
{
var iiClone = new InterfaceImplementation(this.CloningContext.RootImport(interfaceImplementation.InterfaceType));
if (iiClone.HasCustomAttributes)
{
// TODO support custom attributes on an interface implementation (new in Mono.Cecil 0.10.0)
// (should fit nicely with cloning operations, but it will take a bit of time)
throw new NotSupportedException("Cannont clone an interface implementation with custom attributes");
}
this.Target.Interfaces.Add(iiClone);
}
// TODO look more closely at type packing size
this.Target.PackingSize = this.Source.PackingSize;
// TODO look more closely at type class size
this.Target.ClassSize = this.Source.ClassSize;
}
void ConvertInterfaceImplementation(PropertyDeclaration member)
{
// members without modifiers are already C# explicit interface implementations, do not convert them
if (member.Modifier == Modifiers.None)
{
return;
}
while (member.InterfaceImplementations.Count > 0)
{
InterfaceImplementation impl = member.InterfaceImplementations[0];
member.InterfaceImplementations.RemoveAt(0);
if (member.Name != impl.MemberName)
{
PropertyDeclaration newMember = new PropertyDeclaration(Modifiers.None, null, impl.MemberName, null);
newMember.TypeReference = member.TypeReference;
if (member.HasGetRegion)
{
newMember.GetRegion = new PropertyGetRegion(new BlockStatement(), null);
newMember.GetRegion.Block.AddChild(new ReturnStatement(new IdentifierExpression(member.Name)));
}
if (member.HasSetRegion)
{
newMember.SetRegion = new PropertySetRegion(new BlockStatement(), null);
newMember.SetRegion.Block.AddChild(new ExpressionStatement(
new AssignmentExpression(
new IdentifierExpression(member.Name),
AssignmentOperatorType.Assign,
new IdentifierExpression("value")
)));
}
newMember.Parameters = member.Parameters;
newMember.InterfaceImplementations.Add(impl);
InsertAfterSibling(member, newMember);
}
}
}
private MethodDefinition GetOrCreateUnsubscribeMethod(TypeDefinition targetType, Dictionary <TypeDefinition, MethodDefinition> unsubscribeMethods)
{
if (unsubscribeMethods.TryGetValue(targetType, out var unsubscribeMethod))
{
return(unsubscribeMethod);
}
var attributes = MethodAttributes.Private
| MethodAttributes.Final
| MethodAttributes.Virtual
| MethodAttributes.HideBySig
| MethodAttributes.NewSlot;
unsubscribeMethod = new MethodDefinition(">WeakEvents>Unsubscribe", attributes, _typeSystem.TypeSystem.VoidReference)
{
HasThis = true
};
unsubscribeMethod.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
unsubscribeMethods.Add(targetType, unsubscribeMethod);
targetType.Methods.Add(unsubscribeMethod);
var interfaceImplementation = new InterfaceImplementation(_eventTargetInterface);
targetType.Interfaces.Add(interfaceImplementation);
var interfaceMethod = _eventTargetInterface.GetMethods().Single();
unsubscribeMethod.Overrides.Add(interfaceMethod);
targetType.InsertIntoFinalizer(
Instruction.Create(OpCodes.Ldarg_0),
Instruction.Create(OpCodes.Callvirt, interfaceMethod)
);
return(unsubscribeMethod);
}
public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data)
{
throw new global::System.NotImplementedException("InterfaceImplementation");
}
public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
Debug.Assert((interfaceImplementation != null));
Debug.Assert((interfaceImplementation.InterfaceType != null));
nodeStack.Push(interfaceImplementation.InterfaceType);
interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
interfaceImplementation.InterfaceType = ((TypeReference)(nodeStack.Pop()));
return null;
}
public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
throw new global::System.NotImplementedException("InterfaceImplementation");
}
/// <summary>
/// Adds the methods implementing the <paramref name="interf"/> to the list
/// <paramref name="nodes"/>.
/// </summary>
public virtual void ImplementInterface(IList <AbstractNode> nodes, IReturnType interf, bool explicitImpl, IClass targetClass)
{
ClassFinder context = new ClassFinder(targetClass, targetClass.Region.BeginLine + 1, 0);
Modifiers implicitImplModifier = ConvertModifier(ModifierEnum.Public, context);
Modifiers explicitImplModifier = ConvertModifier(context.Language.ExplicitInterfaceImplementationIsPrivateScope ? ModifierEnum.None : ModifierEnum.Public, context);
List <IEvent> targetClassEvents = targetClass.DefaultReturnType.GetEvents();
bool requireAlternativeImplementation;
foreach (IEvent e in interf.GetEvents())
{
if (!InterfaceMemberAlreadyImplemented(targetClassEvents, e, out requireAlternativeImplementation))
{
EventDeclaration ed = ConvertMember(e, context);
ed.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
ed.InterfaceImplementations.Add(CreateInterfaceImplementation(e, context));
if (context.Language.RequiresAddRemoveRegionInExplicitInterfaceImplementation)
{
ed.AddRegion = new EventAddRegion(null);
ed.AddRegion.Block = CreateNotImplementedBlock();
ed.RemoveRegion = new EventRemoveRegion(null);
ed.RemoveRegion.Block = CreateNotImplementedBlock();
}
targetClassEvents.Add(CloneAndAddExplicitImpl(e, targetClass));
ed.Modifier = explicitImplModifier;
}
else
{
targetClassEvents.Add(e);
ed.Modifier = implicitImplModifier;
}
nodes.Add(ed);
}
}
List <IProperty> targetClassProperties = targetClass.DefaultReturnType.GetProperties();
foreach (IProperty p in interf.GetProperties())
{
if (!InterfaceMemberAlreadyImplemented(targetClassProperties, p, out requireAlternativeImplementation))
{
AttributedNode pd = ConvertMember(p, context);
pd.Attributes.Clear();
if (explicitImpl || requireAlternativeImplementation)
{
InterfaceImplementation impl = CreateInterfaceImplementation(p, context);
if (pd is IndexerDeclaration)
{
((IndexerDeclaration)pd).InterfaceImplementations.Add(impl);
}
else
{
((PropertyDeclaration)pd).InterfaceImplementations.Add(impl);
}
targetClassProperties.Add(CloneAndAddExplicitImpl(p, targetClass));
pd.Modifier = explicitImplModifier;
}
else
{
targetClassProperties.Add(p);
pd.Modifier = implicitImplModifier;
}
nodes.Add(pd);
}
}
List <IMethod> targetClassMethods = targetClass.DefaultReturnType.GetMethods();
foreach (IMethod m in interf.GetMethods())
{
if (!InterfaceMemberAlreadyImplemented(targetClassMethods, m, out requireAlternativeImplementation))
{
MethodDeclaration md = ConvertMember(m, context) as MethodDeclaration;
md.Attributes.Clear();
if (md != null)
{
if (explicitImpl || requireAlternativeImplementation)
{
md.InterfaceImplementations.Add(CreateInterfaceImplementation(m, context));
targetClassMethods.Add(CloneAndAddExplicitImpl(m, targetClass));
md.Modifier = explicitImplModifier;
}
else
{
targetClassMethods.Add(m);
md.Modifier = implicitImplModifier;
}
nodes.Add(md);
}
}
}
}
public static int test() {
InterfaceImplementationAux2 i = new InterfaceImplementation();
return i.method(2);
}
public static TypeDefinition Resolve(this InterfaceImplementation reference)
{
return(reference.InterfaceType.Resolve());
}
public virtual DialogResult ShowDialog(TypeDefinition tdef, InterfaceImplementation selected)
{
TypeDefinition = tdef;
SelectedTypeReference = selected.InterfaceType;
return(ShowDialog());
}
protected override bool ShouldMarkInterfaceImplementation(TypeDefinition type, InterfaceImplementation iface, TypeDefinition resolvedInterfaceType)
{
if (RegisterProtocols)
{
// If we're registering protocols, we can remove interfaces that represent protocols.
// The linker will automatically mark interfaces a class implements, but we have to
// override the linker behavior for interfaces that represent protocols for those
// interfaces to be removed.
var isProtocol = type.IsNSObject(LinkContext) && resolvedInterfaceType.HasCustomAttribute(LinkContext, Namespaces.Foundation, "ProtocolAttribute");
// We're not linking the current assembly, which means the interface should be marked.
if (isProtocol && !IgnoreScope(type.Scope))
{
LinkContext.StoreProtocolMethods(resolvedInterfaceType);
}
}
else if (LinkContext.App.Registrar == Bundler.RegistrarMode.Dynamic)
{
// If we're using the dynamic registrar, we need to mark interfaces that represent protocols
// even if it doesn't look like the interfaces are used, since we need them at runtime.
var isProtocol = type.IsNSObject(LinkContext) && resolvedInterfaceType.HasCustomAttribute(LinkContext, Namespaces.Foundation, "ProtocolAttribute");
if (isProtocol)
{
return(true);
}
}
return(base.ShouldMarkInterfaceImplementation(type, iface, resolvedInterfaceType));
}
public sealed override object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
BeginVisit(interfaceImplementation);
object result = TrackedVisitInterfaceImplementation(interfaceImplementation, data);
EndVisit(interfaceImplementation);
return result;
}
protected virtual void InterfaceRemoved(TypeDefinition type, InterfaceImplementation iface)
{
}
public static void RelinkType(TypeDefinition type)
{
foreach (TypeDefinition nested in type.NestedTypes)
{
RelinkType(nested);
}
type.BaseType = type.BaseType.RelinkedReference(type);
for (int i = 0; i < type.Interfaces.Count; i++)
{
InterfaceImplementation interf = new InterfaceImplementation(type.Interfaces[i].InterfaceType.RelinkedReference(type));
for (int cai = 0; cai < type.Interfaces[i].CustomAttributes.Count; cai++)
{
CustomAttribute oca = type.Interfaces[i].CustomAttributes[cai];
// TODO relink that method
CustomAttribute ca = new CustomAttribute(oca.Constructor /*.Relinked(type)*/, oca.GetBlob());
for (int caii = 0; caii < oca.ConstructorArguments.Count; caii++)
{
//TODO do more with the attributes
CustomAttributeArgument ocaa = oca.ConstructorArguments[caii];
ca.ConstructorArguments.Add(new CustomAttributeArgument(ocaa.Type.RelinkedReference(type),
ocaa.Value is TypeReference ? ocaa.Type.RelinkedReference(type) :
ocaa.Value
));
}
interf.CustomAttributes.Add(ca);
}
type.Interfaces[i] = interf;
}
foreach (FieldDefinition field in type.Fields)
{
field.FieldType = field.FieldType.RelinkedReference(type);
}
foreach (PropertyDefinition property in type.Properties)
{
property.PropertyType = property.PropertyType.RelinkedReference(type);
if (property.GetMethod != null)
{
property.GetMethod.ReturnType = property.GetMethod.ReturnType.RelinkedReference(type);
for (int i = 0; i < property.GetMethod.Parameters.Count; i++)
{
property.GetMethod.Parameters[i].ParameterType = property.GetMethod.Parameters[i].ParameterType.RelinkedReference(type);
}
}
if (property.SetMethod != null)
{
property.SetMethod.ReturnType = property.GetMethod.ReturnType.RelinkedReference(type);
for (int i = 0; i < property.SetMethod.Parameters.Count; i++)
{
property.SetMethod.Parameters[i].ParameterType = property.SetMethod.Parameters[i].ParameterType.RelinkedReference(type);
}
}
}
foreach (MethodDefinition method in type.Methods)
{
method.ReturnType = method.ReturnType.RelinkedReference(method);
for (int i = 0; i < method.Parameters.Count; i++)
{
method.Parameters[i].ParameterType = method.Parameters[i].ParameterType.RelinkedReference(method);
}
for (int i = 0; method.HasBody && i < method.Body.Instructions.Count; i++)
{
Instruction instruction = method.Body.Instructions[i];
object operand = instruction.Operand;
if (operand is MethodReference)
{
operand = ((MethodReference)operand).RelinkedReference(method);
}
else if (operand is FieldReference)
{
FieldReference old = (FieldReference)operand;
FieldReference relink = new FieldReference(old.Name, old.FieldType.RelinkedReference(method), old.DeclaringType.RelinkedReference(method));
operand = type.Module.ImportReference(relink);
}
else if (operand is TypeReference)
{
operand = ((TypeReference)operand).RelinkedReference(method);
}
instruction.Operand = operand;
}
for (int i = 0; method.HasBody && i < method.Body.Variables.Count; i++)
{
method.Body.Variables[i].VariableType = method.Body.Variables[i].VariableType.RelinkedReference(method);
}
}
}
private static TypeDefinitionTreatment GenerateRedirectionInformation(TypeDefinition type, out Collection<MethodDefinition> redirectedMethods, out Collection<KeyValuePair<InterfaceImplementation, InterfaceImplementation>> redirectedInterfaces)
{
bool implementsProjectedInterface = false;
redirectedMethods = null;
redirectedInterfaces = null;
foreach (var implementedInterface in type.Interfaces) {
if (IsRedirectedType (implementedInterface.InterfaceType)) {
implementsProjectedInterface = true;
break;
}
}
if (!implementsProjectedInterface)
return TypeDefinitionTreatment.NormalType;
var allImplementedInterfaces = new HashSet<TypeReference> (new TypeReferenceEqualityComparer ());
redirectedMethods = new Collection<MethodDefinition> ();
redirectedInterfaces = new Collection<KeyValuePair<InterfaceImplementation, InterfaceImplementation>> ();
foreach (var @interface in type.Interfaces) {
var interfaceType = @interface.InterfaceType;
if (IsRedirectedType (interfaceType)) {
allImplementedInterfaces.Add (interfaceType);
CollectImplementedInterfaces (interfaceType, allImplementedInterfaces);
}
}
foreach (var implementedInterface in type.Interfaces) {
var interfaceType = implementedInterface.InterfaceType;
if (IsRedirectedType (implementedInterface.InterfaceType)) {
var etype = interfaceType.GetElementType ();
var unprojectedType = new TypeReference (etype.Namespace, etype.Name, etype.Module, etype.Scope) {
DeclaringType = etype.DeclaringType,
projection = etype.projection
};
RemoveProjection (unprojectedType);
var genericInstanceType = interfaceType as GenericInstanceType;
if (genericInstanceType != null) {
var genericUnprojectedType = new GenericInstanceType (unprojectedType);
foreach (var genericArgument in genericInstanceType.GenericArguments)
genericUnprojectedType.GenericArguments.Add (genericArgument);
unprojectedType = genericUnprojectedType;
}
var unprojectedInterface = new InterfaceImplementation (unprojectedType);
redirectedInterfaces.Add (new KeyValuePair<InterfaceImplementation, InterfaceImplementation> (implementedInterface, unprojectedInterface));
}
}
// Interfaces don't inherit methods of the interfaces they implement
if (!type.IsInterface) {
foreach (var implementedInterface in allImplementedInterfaces) {
RedirectInterfaceMethods (implementedInterface, redirectedMethods);
}
}
return TypeDefinitionTreatment.RedirectImplementedMethods;
}
public DependantTwo(InterfaceImplementation obj)
{
this.obj = obj;
}
public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
Debug.Assert((interfaceImplementation != null));
Debug.Assert((interfaceImplementation.InterfaceType != null));
return interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
}
/// <summary>
/// Copy over type definitions.
/// </summary>
/// <param name="fromModule">Assemblies to copy from.</param>
/// <param name="toModule">Assemblies to copy to.</param>
protected void GenerateTypeDefinitions(ModuleDefinition fromModule, ModuleDefinition toModule)
{
foreach (var typePair in diffTypes)
{
var td = typePair.Value;
var fromType = fromModule.GetType(td.FullName);
if (fromType.BaseType != null)
{
td.BaseType = fromType.BaseType.Relink(Relinker, td);
}
foreach (var diffTypeInterface in fromType.Interfaces)
{
if (td.Interfaces.Any(i => i.InterfaceType.FullName == diffTypeInterface.InterfaceType.FullName))
{
continue;
}
var imp = new InterfaceImplementation(diffTypeInterface.InterfaceType.Relink(Relinker, td));
td.Interfaces.Add(imp);
}
td.IsAbstract = fromType.IsAbstract;
td.IsSequentialLayout = fromType.IsSequentialLayout;
td.IsSealed = fromType.IsSealed;
foreach (var field in GetFieldsToInclude(fromType))
{
var fd = td.Fields.FirstOrDefault(f => f.Name == field.Name);
if (fd == null)
{
fd = new FieldDefinition(field.Name, field.Attributes, field.FieldType.Relink(Relinker, td));
if (field.HasConstant)
{
fd.Constant = field.Constant;
}
td.Fields.Add(fd);
}
else
{
fd.FieldType = field.FieldType.Relink(Relinker, td);
fd.Attributes = field.Attributes;
}
diffFields[fd.FullName] = fd;
}
foreach (var method in GetMethodsToInclude(fromType))
{
var md = td.Methods.FirstOrDefault(m => m.FullName == method.FullName);
if (md == null)
{
md = new MethodDefinition(method.Name, method.Attributes, EmptyType);
td.Methods.Add(md);
md.ImplAttributes = method.ImplAttributes;
md.IsPreserveSig = method.IsPreserveSig;
md.IsPInvokeImpl = method.IsPInvokeImpl;
foreach (var @override in method.Overrides)
{
md.Overrides.Add(@override.Relink(Relinker, td));
}
foreach (var genPara in method.GenericParameters)
{
md.GenericParameters.Add(genPara.Clone(md));
}
md.ReturnType = method.ReturnType.Relink(Relinker, md);
if (method.PInvokeInfo != null)
{
var modRef =
toModule.ModuleReferences.FirstOrDefault(m => m.Name == method.PInvokeInfo.Module.Name);
if (modRef == null)
{
modRef = new ModuleReference(method.PInvokeInfo.Module.Name);
toModule.ModuleReferences.Add(modRef);
}
md.PInvokeInfo = new PInvokeInfo(method.PInvokeInfo.Attributes,
method.PInvokeInfo.EntryPoint, modRef);
}
foreach (var param in method.Parameters)
{
var pd = new ParameterDefinition(param.Name, param.Attributes,
param.ParameterType.Relink(Relinker, md))
{
IsIn = param.IsIn,
IsLcid = param.IsLcid,
IsOptional = param.IsOptional,
IsOut = param.IsOut,
IsReturnValue = param.IsReturnValue,
MarshalInfo = param.MarshalInfo
};
if (param.HasConstant)
{
pd.Constant = param.Constant;
}
md.Parameters.Add(pd);
}
}
else
{
md.ReturnType = method.ReturnType.Relink(Relinker, td);
md.Attributes = method.Attributes;
md.ImplAttributes = method.ImplAttributes;
md.IsPreserveSig = method.IsPreserveSig;
md.IsPInvokeImpl = method.IsPInvokeImpl;
foreach (var param in md.Parameters)
{
param.ParameterType = param.ParameterType.Relink(Relinker, td);
}
}
diffMethods[md.FullName] = md;
}
}
}
/// <summary>
/// Process POCO Type implement ITrackable interface
/// </summary>
/// <param name="type">POCO Type</param>
private void InjectImplInterface(TypeDefinition type)
{
moduleWeaver.LogInfo("Process Type impl Interface");
var attr = type.GetTrackAttribute();
if (attr != null)
{
// Check Type is Implement the ITrackable interface
var hasITrackableInterface = type.Interfaces.Any(i => i.InterfaceType.Name == "ITrackable");
if (hasITrackableInterface)
{
return;
}
if (trackableTypeRef == null)
{
var bronzeAssam = attr.AttributeType.Module.Assembly;
var assName = attr.AttributeType.Scope.Name;
var reference = attr.AttributeType.Module.AssemblyReferences.SingleOrDefault(a => a.Name == assName);
if (reference != null)
{
bronzeAssam = moduleWeaver.ModuleDefinition.AssemblyResolver.Resolve(reference);
}
TypeReference trackableType = bronzeAssam.MainModule.GetTypes().FirstOrDefault(t => t.Name.EndsWith(".ITrackable") || t.Name == "ITrackable");
trackableTypeRef = this.moduleWeaver.ModuleDefinition.ImportReference(trackableType);
}
if (dicPropTypeRef == null)
{
dicPropTypeRef = trackableTypeRef.Resolve().Properties.SingleOrDefault(p => p.Name == "ModifiedProperties").PropertyType;
dicPropTypeRef = moduleWeaver.ModuleDefinition.ImportReference(dicPropTypeRef);
}
var dicTypeDefinition = dicPropTypeRef.Resolve();
// Add IsTracking property
var isTrackingProp = InjectProperty(type, "IsTracking", typeSystem.Boolean, true);
if (!isTrackingProp.FromBaseClass)
{
isTrackingProp.Prop.CustomAttributes.Add(new CustomAttribute(msCoreReferenceFinder.NonSerializedReference));
if (msCoreReferenceFinder.JsonIgnoreAttributeReference != null)
{
isTrackingProp.Prop.CustomAttributes.Add(new CustomAttribute(msCoreReferenceFinder.JsonIgnoreAttributeReference));
}
}
// Add ModifiedProperties property
var modifiedPropertiesProp = InjectProperty(type, "ModifiedProperties", dicPropTypeRef, true);
if (!modifiedPropertiesProp.FromBaseClass)
{
modifiedPropertiesProp.Prop.CustomAttributes.Add(new CustomAttribute(msCoreReferenceFinder.NonSerializedReference));
if (msCoreReferenceFinder.JsonIgnoreAttributeReference != null)
{
modifiedPropertiesProp.Prop.CustomAttributes.Add(new CustomAttribute(msCoreReferenceFinder.JsonIgnoreAttributeReference));
}
}
// Implement the ITrackable interface
if (trackInterfaceImplementation == null)
{
trackInterfaceImplementation = new InterfaceImplementation(trackableTypeRef);
}
type.Interfaces.Add(trackInterfaceImplementation);
if (modifiedPropertiesProp.Field != null)
{
var dicCtor = dicTypeDefinition.GetConstructors().SingleOrDefault(c => c.Parameters.Count == 0);
var dicConstructorInfoRef = type.Module.ImportReference(dicCtor);
dicConstructorInfoRef = dicConstructorInfoRef.MakeGeneric(typeSystem.String, typeSystem.Boolean);
var currentTypeCtor = type.GetConstructors().SingleOrDefault(c => c.Parameters.Count == 0);
if (currentTypeCtor != null)
{
var processor = currentTypeCtor.Body.GetILProcessor();
var firstInstruction = currentTypeCtor.Body.Instructions[1];
var instructions = new List <Instruction>()
{
processor.Create(OpCodes.Ldarg_0),
processor.Create(OpCodes.Newobj, dicConstructorInfoRef),
processor.Create(OpCodes.Stfld, modifiedPropertiesProp.Field),
};
foreach (var instruction in instructions)
{
processor.InsertBefore(firstInstruction, instruction);
}
}
}
foreach (var property in type.Properties)
{
if (property.Name != "IsTracking" && property.Name != "ModifiedProperties" &&
property.SetMethod != null && property.SetMethod.IsPublic)
{
var propFieldStr = $"<{property.Name}>k__BackingField";
var propFieldDef = type.Fields.SingleOrDefault(f => f.Name == propFieldStr);
if (propFieldDef == null)
{
continue;
}
var md = property.SetMethod;
md.Body.Instructions.Clear();
var ins1 = md.Body.Instructions;
moduleWeaver.ModuleDefinition.ImportReference(property.PropertyType);
// // .locals init( [0]bool V_0 )
// // 如果InitLocals=false，则会变成.locals( [0]bool V_0 )
// md.Body.InitLocals = true;
//
// //定义变量
// md.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
// md.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
// //end 定义变量
// IL_0000: nop
ins1.Add(Instruction.Create(OpCodes.Nop));
// IL_0001: ldarg.0
ins1.Add(Instruction.Create(OpCodes.Ldarg_0));
// IL_0002: call instance class [netstandard] System.Collections.Generic.Dictionary`2<string, bool> AssemblyToProcess.Class1::get_ModifiedProperties()
var getModifiedPropertiesMethod = moduleWeaver.ModuleDefinition.ImportReference(modifiedPropertiesProp.Prop.GetMethod);
ins1.Add(Instruction.Create(OpCodes.Call, getModifiedPropertiesMethod));
// IL_0007: ldstr "Prop1"
ins1.Add(Instruction.Create(OpCodes.Ldstr, property.Name));
// IL_000C: ldarg.0
ins1.Add(Instruction.Create(OpCodes.Ldarg_0));
// IL_000D: call instance valuetype[netstandard] System.Nullable`1<valuetype[netstandard] System.DateTime> AssemblyToProcess.Class1::get_Prop1()
ins1.Add(Instruction.Create(OpCodes.Call, property.GetMethod));
// IL_0012: box valuetype [netstandard]System.Nullable`1<valuetype[netstandard] System.DateTime>
ins1.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
// IL_0017: ldarg.1
ins1.Add(Instruction.Create(OpCodes.Ldarg_1));
// IL_0018: box valuetype [netstandard]System.Nullable`1<valuetype[netstandard] System.DateTime>
ins1.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
// IL_001D: call bool[netstandard] System.Object::Equals(object, object)
var objectDefinition = moduleWeaver.FindType("System.Object");
var objectEqualsMethodDefinition = objectDefinition.Methods.First(x => x.Name == "Equals" && x.Parameters.Count == 2);
moduleWeaver.ModuleDefinition.ImportReference(objectEqualsMethodDefinition);
var equalsMd = type.Module.ImportReference(objectEqualsMethodDefinition);
ins1.Add(Instruction.Create(OpCodes.Call, equalsMd));
// IL_0022: ldc.i4.0
ins1.Add(Instruction.Create(OpCodes.Ldc_I4_0));
// IL_0023: ceq
ins1.Add(Instruction.Create(OpCodes.Ceq));
// IL_0025: callvirt instance void class [netstandard] System.Collections.Generic.Dictionary`2<string, bool>::set_Item(!0, !1)
var _set_ItemMothed = dicTypeDefinition.Methods.FirstOrDefault(m => m.Name == "set_Item");
var set_ItemMethodRef = type.Module.ImportReference(_set_ItemMothed);
set_ItemMethodRef = set_ItemMethodRef.MakeGeneric(typeSystem.String, typeSystem.Boolean);
ins1.Add(Instruction.Create(OpCodes.Callvirt, set_ItemMethodRef));
// IL_002A: nop
ins1.Add(Instruction.Create(OpCodes.Nop));
// IL_002B: ldarg.0
ins1.Add(Instruction.Create(OpCodes.Ldarg_0));
// IL_002C: ldarg.1
ins1.Add(Instruction.Create(OpCodes.Ldarg_1));
// IL_002D: stfld valuetype[netstandard]System.Nullable`1<valuetype[netstandard] System.DateTime> AssemblyToProcess.Class1::k__BackingField
ins1.Add(Instruction.Create(OpCodes.Stfld, propFieldDef));
// IL_0032: ret
ins1.Add(Instruction.Create(OpCodes.Ret));
}
}
// foreach (var property in type.Properties)
// {
// if (property.Name != "IsTracking" && property.Name != "ModifiedProperties"
// && property.SetMethod != null && property.SetMethod.IsPublic)
// {
// var propFieldStr = $"<{property.Name}>k__BackingField";
// var propFieldDef = type.Fields.SingleOrDefault(f => f.Name == propFieldStr);
// if (propFieldDef == null)
// {
// continue;
// }
//
// var md = property.SetMethod;
// md.Body.Instructions.Clear();
//
// var ins1 = md.Body.Instructions;
// moduleWeaver.ModuleDefinition.ImportReference(property.PropertyType);
//
// // .locals init( [0]bool V_0 )
// // 如果InitLocals=false，则会变成.locals( [0]bool V_0 )
// md.Body.InitLocals = true;
//
// //定义变量
// md.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
// md.Body.Variables.Add(new VariableDefinition(typeSystem.Boolean));
// //end 定义变量
//
// //IL_0000: nop
// ins1.Add(Instruction.Create(OpCodes.Nop));
//
// //IL_0001: ldarg.0
// ins1.Add(Instruction.Create(OpCodes.Ldarg_0));
//
// //IL_0002: call instance valuetype [mscorlib]System.Nullable`1<valuetype [mscorlib]System.DateTime> AssemblyToProcess.Class1::get_Prop1()
// ins1.Add(Instruction.Create(OpCodes.Call, property.GetMethod));
//
// //IL_0007: box valuetype [mscorlib]System.Nullable`1<valuetype [mscorlib]System.DateTime>
// ins1.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
//
// //IL_000c: ldarg.1
// ins1.Add(Instruction.Create(OpCodes.Ldarg_1));
//
// //IL_000d: box valuetype [mscorlib]System.Nullable`1<valuetype [mscorlib]System.DateTime>
// ins1.Add(Instruction.Create(OpCodes.Box, property.PropertyType));
//
//
// var objectDefinition = moduleWeaver.FindType("System.Object");
// var objectEqualsMethodDefinition = objectDefinition.Methods.First(x => x.Name == "Equals" && x.Parameters.Count == 2);
// moduleWeaver.ModuleDefinition.ImportReference(objectEqualsMethodDefinition);
//
// //IL_0012: call bool [mscorlib]System.Object::Equals(object, object)
// var EqualsMd = type.Module.ImportReference(objectEqualsMethodDefinition);
//
// ins1.Add(Instruction.Create(OpCodes.Call, EqualsMd));
//
// //IL_0017: stloc.0
// ins1.Add(Instruction.Create(OpCodes.Stloc_0));
//
// //IL_0018: ldloc.0
// ins1.Add(Instruction.Create(OpCodes.Ldloc_0));
//
// //IL_0019: ldc.i4.0
// ins1.Add(Instruction.Create(OpCodes.Ldc_I4_0));
//
// //IL_001a: ceq
// ins1.Add(Instruction.Create(OpCodes.Ceq));
//
// //IL_001c: stloc.1
// ins1.Add(Instruction.Create(OpCodes.Stloc_1));
//
// //IL_001d: ldloc.1
// ins1.Add(Instruction.Create(OpCodes.Ldloc_1));
//
// //IL_001e: brfalse.s IL_0034
// var IL_0034 = Instruction.Create(OpCodes.Ldarg_0);
// ins1.Add(Instruction.Create(OpCodes.Brfalse_S, IL_0034));
//
// //IL_0020: nop
// ins1.Add(Instruction.Create(OpCodes.Nop));
//
// //IL_0021: ldarg.0
// ins1.Add(Instruction.Create(OpCodes.Ldarg_0));
//
// //IL_0022: call instance class [mscorlib]System.Collections.Generic.Dictionary`2<string, bool> AssemblyToProcess.Class1::get_ModifiedProperties()
//
// var getModifiedPropertiesMethod = moduleWeaver.ModuleDefinition.ImportReference(modifiedPropertiesProp.Prop.GetMethod);
// ins1.Add(Instruction.Create(OpCodes.Call, getModifiedPropertiesMethod));
//
// //IL_0027: ldstr "Prop1"
// ins1.Add(Instruction.Create(OpCodes.Ldstr, property.Name));
//
// //IL_002c: ldc.i4.1
// ins1.Add(Instruction.Create(OpCodes.Ldc_I4_1));
//
// //IL_002d: callvirt instance void class [mscorlib]System.Collections.Generic.Dictionary`2<string, bool>::set_Item(!0, !1)
// //var _set_ItemMothed = typeof(Dictionary<string, bool>).GetMethod("set_Item", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance);
//
// var _set_ItemMothed = dicTypeDefinition.Methods.FirstOrDefault(m => m.Name == "set_Item");
// var set_ItemMethodRef = type.Module.ImportReference(_set_ItemMothed);
// set_ItemMethodRef = set_ItemMethodRef.MakeGeneric(typeSystem.String, typeSystem.Boolean);
//
// ins1.Add(Instruction.Create(OpCodes.Callvirt, set_ItemMethodRef));
//
// //IL_0032: nop
// ins1.Add(Instruction.Create(OpCodes.Nop));
//
// //IL_0033: nop
// ins1.Add(Instruction.Create(OpCodes.Nop));
//
// //IL_0034: ldarg.0
// ins1.Add(IL_0034);
//
// //IL_0035: ldarg.1
// ins1.Add(Instruction.Create(OpCodes.Ldarg_1));
//
// //IL_0036: stfld valuetype [mscorlib]System.Nullable`1<valuetype [mscorlib]System.DateTime> AssemblyToProcess.Class1::k__BackingField
// ins1.Add(Instruction.Create(OpCodes.Stfld, propFieldDef));
//
// //IL_003b: ret
// ins1.Add(Instruction.Create(OpCodes.Ret));
//
// }
// }
}
}
static void Main(string[] args)
{
InterfaceImplementation serv = new InterfaceImplementation();
serv.PrintHi("vasya");
}
public static string ToString(this MetadataReader reader, InterfaceImplementation x) => $"{{IntImpl[{RowId(x):X}]: {reader.ToString( x.Interface)}}}";
public void VerifyInterfaces()
{
TypeDefinition typeDefinition = _module.MetadataReader.GetTypeDefinition(_typeDefinitionHandle);
EcmaType type = (EcmaType)_module.GetType(_typeDefinitionHandle);
if (type.IsInterface)
{
return;
}
InterfaceImplementationHandleCollection interfaceHandles = typeDefinition.GetInterfaceImplementations();
int count = interfaceHandles.Count;
if (count == 0)
{
return;
}
// Look for duplicates and prepare distinct list of implemented interfaces to avoid
// subsequent error duplication
List <InterfaceMetadataObjects> implementedInterfaces = new List <InterfaceMetadataObjects>();
foreach (InterfaceImplementationHandle interfaceHandle in interfaceHandles)
{
InterfaceImplementation interfaceImplementation = _module.MetadataReader.GetInterfaceImplementation(interfaceHandle);
TypeDesc interfaceTypeDesc = _module.GetType(interfaceImplementation.Interface) as TypeDesc;
if (interfaceTypeDesc == null)
{
ThrowHelper.ThrowTypeLoadException(ExceptionStringID.ClassLoadBadFormat, type);
}
InterfaceMetadataObjects imo = new InterfaceMetadataObjects
{
InterfaceType = interfaceTypeDesc,
InterfaceImplementation = interfaceImplementation
};
if (!implementedInterfaces.Contains(imo))
{
implementedInterfaces.Add(imo);
}
else
{
VerificationError(VerifierError.InterfaceImplHasDuplicate, Format(type), Format(imo.InterfaceType, _module, imo.InterfaceImplementation));
}
}
foreach (InterfaceMetadataObjects implementedInterface in implementedInterfaces)
{
if (!type.IsAbstract)
{
// Look for missing method implementation
foreach (MethodDesc method in implementedInterface.InterfaceType.GetAllMethods())
{
if (!method.IsAbstract)
{
continue;
}
MethodDesc resolvedMethod = type.ResolveInterfaceMethodTarget(method);
if (resolvedMethod is null)
{
VerificationError(VerifierError.InterfaceMethodNotImplemented, Format(type), Format(implementedInterface.InterfaceType, _module, implementedInterface.InterfaceImplementation), Format(method));
}
}
}
}
}
public virtual object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
return base.VisitInterfaceImplementation(interfaceImplementation, data);
}
