latebinder.vb

大名鼎鼎的mono是.NET平台的跨平台（支持linux

                                End If
                            ElseIf type1isParamArray And Not type2isParamArray Then
                                current = SignatureCompare.Right
                                paramArrayDecision = True
                            ElseIf type2isParamArray And Not type1isParamArray Then
                                current = SignatureCompare.Left
                                paramArrayDecision = True
                            End If
                        End If
                        'End If
                    End If
                Else
                    If f1i = TypeConversion.Equal And f2i = TypeConversion.Widening Then
                        current = SignatureCompare.Left
                    ElseIf f1i = TypeConversion.Widening And f2i = TypeConversion.Equal Then
                        current = SignatureCompare.Right
                    Else
                        'if we get here that means 
                        ' f1i = TypeConversion.Equal And  f2i = TypeConversion.Equal
                        current = SignatureCompare.Equal
                    End If
                End If

                If current = SignatureCompare.Ambiguity Then 'no need to check anymore
                    Return SignatureCompare.Ambiguity
                End If

                ' now collate previous comparison result with current
                Select Case previous
                    Case SignatureCompare.Equal
                        previous = current
                    Case SignatureCompare.Left
                        If current = SignatureCompare.Right Then ' previous was f1 and now we get f2
                            Return SignatureCompare.Ambiguity
                        End If
                        'result stays f1 and we continue
                    Case SignatureCompare.Right
                        If current = SignatureCompare.Left Then ' previous was f2 and neow we get f1
                            Return SignatureCompare.Ambiguity
                        End If
                        ' result stays f2 and we continue
                End Select
            Next

            If previous = SignatureCompare.Equal Or paramArrayDecision Then
                If params1.Length <> args.Length Or params2.Length <> args.Length Then
                    ' occurs only if we're dealing with param arrays
                    Dim isParamArray1 As Boolean = IsParamArray(params1, params1.Length - 1)
                    Dim isParamArray2 As Boolean = IsParamArray(params2, params2.Length - 1)
                    If isParamArray1 And isParamArray2 Then
                        ' if both methods have param array - its ambiguity
                        Return SignatureCompare.Ambiguity
                    Else
                        If isParamArray1 Then ' first is param array - choose second
                            Return SignatureCompare.Right
                        ElseIf isParamArray2 Then ' second is param array - choose first
                            Return SignatureCompare.Left
                        End If
                    End If
                End If
            End If
            Return previous
        End Function

        Private Function CompareWideningTypes(ByVal f1 As Type, ByVal f2 As Type, ByVal type1isParamArray As Boolean, ByVal type2isParamArray As Boolean) As SignatureCompare
            If f1 Is f2 Then
                If type1isParamArray And type2isParamArray Then
                    Return SignatureCompare.Ambiguity
                ElseIf type1isParamArray And Not type2isParamArray Then
                    Return SignatureCompare.Right
                ElseIf type2isParamArray And Not type1isParamArray Then
                    Return SignatureCompare.Left
                End If
            End If
            Return CompareWideningTypes(f1, f2)
        End Function

        Private Function CompareWideningTypesWithNothing(ByVal f1 As Type, ByVal f2 As Type) As SignatureCompare
            If f1 Is f2 Then
                Return SignatureCompare.Equal
            End If

            Dim typeCode1 As TypeCode = Type.GetTypeCode(f1)
            Dim typeCode2 As TypeCode = Type.GetTypeCode(f2)

            If f1.IsPrimitive And f2.IsPrimitive Then
                If typeCode1 >= TypeCode.Byte And typeCode1 <= TypeCode.UInt64 Then
                    If typeCode2 >= TypeCode.Byte And typeCode2 <= TypeCode.UInt64 Then
                        'primitives between byte and ulong are compared by size, the smaller is better
                        If typeCode1 < typeCode2 Then
                            Return SignatureCompare.Left
                        Else
                            Return SignatureCompare.Right
                        End If
                    End If
                End If
            Else
                If f1.IsPrimitive Or f2.IsPrimitive Then
                    If f1.IsPrimitive Then
                        If f2 Is GetType(Object) Then 'primitive is better than object
                            Return SignatureCompare.Left
                        End If

                        If typeCode1 = TypeCode.Char And typeCode2 = TypeCode.String Then 'char is better that string
                            Return SignatureCompare.Left
                        End If
                    ElseIf f2.IsPrimitive Then
                        If f1 Is GetType(Object) Then 'primitive is better than object
                            Return SignatureCompare.Right
                        End If

                        If typeCode2 = TypeCode.Char And typeCode1 = TypeCode.String Then 'char is better that string
                            Return SignatureCompare.Right
                        End If
                    End If
                Else
                    'both f1 and f2 are not primitives - subclass is better that superclass
                    If f1.IsSubclassOf(f2) Then    'f1 is a subclass of f2
                        Return SignatureCompare.Left
                    ElseIf f2.IsSubclassOf(f1) Then 'f2 is a subclass of f1
                        Return SignatureCompare.Right
                    End If
                End If
            End If
            ' the rest of the cases are ambiguos
            Return SignatureCompare.Ambiguity
        End Function
        Private Function CompareWideningTypes(ByVal f1 As Type, ByVal f2 As Type) As SignatureCompare

            If f1 Is f2 Then
                Return SignatureCompare.Equal
            End If

            Dim typeCode1 As TypeCode = Type.GetTypeCode(f1)
            Dim typeCode2 As TypeCode = Type.GetTypeCode(f2)

            If f1.IsPrimitive And f2.IsPrimitive Then
                If typeCode1 < typeCode2 Then
                    Return SignatureCompare.Left
                Else
                    Return SignatureCompare.Right
                End If
            Else

                If typeCode1 = TypeCode.String Then
                    Return SignatureCompare.Left
                ElseIf typeCode2 = TypeCode.String Then
                    Return SignatureCompare.Right
                End If


                If f1.IsPrimitive Then ' and f2 is not primitive
                    Return SignatureCompare.Left
                End If

                If f2.IsPrimitive Then  ' and f1 is not primitive
                    Return SignatureCompare.Right
                End If

                'f1 and f2 are not primitives => f1, f2 have some kind of inheritance relation

                ' object is preferred over a string - inspite of inheritance relation
                If f1 Is GetType(Object) And f2 Is GetType(String) Then
                    Return SignatureCompare.Left
                ElseIf f2 Is GetType(Object) And f1 Is GetType(String) Then
                    Return SignatureCompare.Right
                End If

                ' "pure" inheritance logic : prefer subclass over supeclass
                If f1.IsSubclassOf(f2) Then    'f1 is a subclass of f2
                    Return SignatureCompare.Left
                ElseIf f2.IsSubclassOf(f1) Then 'f2 is a subclass of f1
                    Return SignatureCompare.Right
                End If

            End If
        End Function

        Private Function GetArgumentType(ByVal args() As Object, ByVal number As Integer) As Type
            If number <= args.Length - 1 Then
                If Not args(number) Is Nothing Then
                    Return args(number).GetType()
                End If
            End If
            Return Nothing
        End Function
        Private Function GetParameterType(ByVal parameters() As ParameterInfo, ByVal number As Integer) As Type
            Dim ptype As Type
            If number < parameters.Length - 1 Then
                ptype = parameters(number).ParameterType
            ElseIf number = parameters.Length - 1 Then
                If IsParamArray(parameters, number) Then
                    ptype = parameters(number).ParameterType.GetElementType()
                Else
                    ptype = parameters(number).ParameterType
                End If
            Else
                If IsParamArray(parameters, parameters.Length - 1) Then
                    ptype = parameters(parameters.Length - 1).ParameterType.GetElementType()
                Else
                    Return Nothing
                End If
            End If

            If ptype.IsByRef Then
                ptype = ptype.GetElementType()
            End If

            Return ptype
        End Function

        Private Function IsParamArray(ByVal parameters() As ParameterInfo, ByVal index As Integer) As Boolean
            If parameters.Length = 0 Then
                Return False
            End If

            If index >= parameters.Length Then
                index = parameters.Length - 1
            End If

            Dim attrs() As Object = parameters(index).GetCustomAttributes(True)
            For i As Integer = 0 To attrs.Length - 1
                If TypeOf attrs(i) Is ParamArrayAttribute Then
                    Return True
                End If
            Next

            Return False
        End Function

        Private Function FilterMethodsByParameterName(ByVal methods() As MethodBase, ByVal names() As String) As MethodBase()
            If names Is Nothing Then
                Return methods
            End If

            Dim match(methods.Length - 1) As MethodBase
            Dim matchCount As Integer = 0
            For i As Integer = 0 To methods.Length - 1
                Dim parameters() As ParameterInfo = methods(i).GetParameters()
                Dim paramNames(parameters.Length) As String
                For j As Integer = 0 To parameters.Length - 1
                    paramNames(j) = parameters(j).Name
                Next

                Dim nameMatch As Boolean = True
                For j As Integer = 0 To names.Length - 1
                    If Array.IndexOf(paramNames, names(j)) = -1 Then
                        nameMatch = False
                        Exit For
                    End If
                Next

                If nameMatch Then
                    match(matchCount) = methods(i)
                    matchCount += 1
                End If
            Next

            If matchCount = 0 Then
                Return Nothing
            End If

            ReDim Preserve match(matchCount - 1)
            Return match
        End Function

        Private Function IsGetterThatReturnObjectWithIndexer(ByVal method As MethodBase, ByRef args() As Object) As Boolean
            If (method.Name.StartsWith("get_")) Then
                Dim minfo As MethodInfo = CType(method, MethodInfo)
                Dim retType As Type = minfo.ReturnType
                If (retType.IsArray) Then
                    _invokeNext = retType.GetMethod("get_Item")
                    _invokeNextArgs = args
                    _wasIncompleteInvocation = True
                    args = Nothing
                    Return True
                End If

                Dim newMethod As MethodInfo = retType.GetMethod("get_Blubber")
                If (Not newMethod Is Nothing) Then