C# MethodDefinition.GetDexNameAttribute方法代码示例

 private static string GetFinalImplementationName(MethodDefinition impl)
 {
     string finalName;
     var importAttr = impl.GetDexOrJavaImportAttribute();
     if (importAttr != null)
     {
         string descriptor, className;
         importAttr.GetDexOrJavaImportNames(impl, out finalName, out descriptor, out className);
     }
     else
     {
         var dexNameAttr = impl.GetDexNameAttribute();
         finalName = dexNameAttr.ConstructorArguments[0].Value.ToString();
     }
     return finalName;
 }

        /// <summary>
        /// Perform name conversion
        /// </summary>
        protected virtual string GetMethodName(MethodDefinition method, DexTargetPackage targetPackage)
        {
            // Handle special names
            switch (method.Name)
            {
                case ".ctor":
                    return "<init>";
                case ".cctor":
                    return "<clinit>";
            }

            // Handle regular names
            // Test for overrides of dex/java imported methods
            var javaBaseMethod = method.GetDexImportBaseMethod() ?? method.GetJavaImportBaseMethod();
            if (javaBaseMethod != null)
            {
                var javaMethodRef = javaBaseMethod.GetReference(targetPackage, compiler.Module);
                return javaMethodRef.Name;
            }

            // Test for overrides of interface methods
            var interfaceJavaBaseMethod = method.GetDexImportBaseInterfaceMethod() ?? method.GetJavaImportBaseInterfaceMethod();
            if (interfaceJavaBaseMethod != null)
            {
                var javaMethodRef = interfaceJavaBaseMethod.GetReference(targetPackage, compiler.Module);
                return javaMethodRef.Name;                
            }

            // If a dex name is specified, use that
            var dexName = method.GetDexNameAttribute();
            if (dexName != null)
            {
                return (string) dexName.ConstructorArguments[0].Value;
            }

            return NameConverter.GetConvertedName(xMethod);
        }

            /// <summary>
            /// Convert the given interface method if it has explicit implementations.
            /// </summary>
            private void ConvertInterfaceMethod(TypeDefinition iType, MethodDefinition iMethod, Dictionary<TypeDefinition, List<TypeDefinition>> interfaceToImplementingTypes)
            {
                var implementations = GetImplementations(iMethod, interfaceToImplementingTypes);
                var iMethodIsJavaWithGenericParams = iMethod.IsJavaMethodWithGenericParams();
                var iMethodContainsGenericParams = iMethod.ContainsGenericParameter;
                if (!iMethodIsJavaWithGenericParams && !iMethodContainsGenericParams && (!implementations.Any(x => x.Item2.IsExplicitImplementation())))
                {
                    // There are no explicit implementation.
                    // No need to convert
                    return;
                }

                // Rename method
                string newName;
                bool createExplicitStubs = true;
                var oldName = iMethod.Name;
                var attr = iMethod.GetDexOrJavaImportAttribute();
                if (attr != null)
                {
                    string className;
                    string memberName;
                    string descriptor;
                    attr.GetDexOrJavaImportNames(iMethod, out memberName, out descriptor, out className);
                    newName = memberName;
                }
                else if ((attr = iMethod.GetDexNameAttribute()) != null)
                {
                    newName = (string) (attr.ConstructorArguments[0].Value);
                    createExplicitStubs = false;
                }
                else
                {
                    var module = reachableContext.Compiler.Module;
                    var xiType = XBuilder.AsTypeReference(module, iType);
                    newName = methodNames.GetUniqueName(NameConverter.GetConvertedName(xiType) + "_" + iMethod.Name);
                    oldName = newName;
                }

                Rename(iMethod, newName);
              
                // Update implementations
                foreach (var typeAndImpl in implementations)
                {
                    var type = typeAndImpl.Item1;
                    var impl = typeAndImpl.Item2;

                    if (impl.IsExplicitImplementation())
                    {
                        // Convert to implicit
                        impl.IsPublic = true;

                        // Rename
                        Rename(impl, newName);
                        // Update names of overrides
                        foreach (var @override in impl.Overrides)
                        {
                            @override.Name = newName;
                        }
                    }
                    else if (!(impl.HasDexImportAttribute() || impl.HasJavaImportAttribute()))
                    {
                        // Add stub redirecting explicit implementation to implicit implementation
                        if (createExplicitStubs/* && !type.IsInterface TODO: check what to do with interfaces*/)
                        {
                            CreateExplicitStub(type, impl, newName, oldName, iMethod, iMethodIsJavaWithGenericParams /*|| iMethodContainsGenericParams*/);
                        }
                    }
                }
            }