Example #1
0
        protected List <TypeDependency> PatchDependency(ModuleDef module, IEnumerable <TypeDependency> dependencies)
        {
            List <TypeDependency> owned = new List <TypeDependency>();

            foreach (TypeDependency type in dependencies)
            {
                if (!TryResolve(module, type.Descriptor.Signature, out TypeDef typeDef))
                {
                    continue;
                }
                owned.Add(type);
                typeDef.MakeAccessible(type.Descriptor.AccessLevel);
                foreach (FieldDescriptor field in type.FieldDependencies)
                {
                    FieldDef fieldDef = Resolve(module, field.Signature);
                    fieldDef.MakeAccessible(field.AccessLevel);
                    fieldDef.IsInitOnly &= field.IsInitOnly;
                }
                foreach (MethodDescriptor method in type.MethodDependencies)
                {
                    MethodDef methodDef = Resolve(module, method.Signature);
                    methodDef.MakeAccessible(method.AccessLevel);
                    if (method.ReturnType != null && !module.ToSig(typeSubstitutions.Substitute(method.ReturnType)).IsAssignable(methodDef.ReturnType, AccessMode.Write))
                    {
                        throw new PatchException("dependency and original have incompatible types");
                    }
                    // TODO: Add other checks (e.g. virtual)
                    foreach (ParameterDescriptor parameter in method.Parameters)
                    {
                        ParamDef parameterDef = Resolve(module, parameter.Signature);
                        parameterDef.MakeAccessible(parameter.AccessMode);
                    }
                }
            }
            return(owned);
        }