Разрешение перегрузки работает для обычного метода, но не для конструктора

Хотя до сих пор неясно, чего именно вы пытаетесь достичь, ответ — единственное разумное место для обмена кодом. Вот попытка решить вашу проблему с Option Strict On, используя интерфейс для определения свойств, которые должен иметь класс, чтобы быть переданным Foo для его построения.

Обратите внимание на комментарии в коде, которые также помогают объяснить ситуацию.

Это абстрагирует вещи, так что Foo не нужно знать обо всех типах, производных от A — он знает только об интерфейсе. Фактически, он «инвертирует» отношение, чтобы A и его производные типы знали, что необходимо для Foo (для каждого интерфейса). Остальное — это реализация X и Y, где теперь живут определения предложений с 1 по 4 (вместо различных перегруженных конструкторов Foo). Это сокращает количество конструкторов для Foo до одного.

Логика преобразования свойств класса, производного от A, в свойства Foo должна где-то жить. Выталкивая эту логику из Foo в производные классы, вы можете избежать проблем сужения, которые Option Strict Off откладывает до времени выполнения. Кроме того, добавить новый класс Z, производный от A, очень просто, и вам не нужно изменять Foo, чтобы сразу же использовать его.

Но опять же, поскольку не совсем ясно, что вы собираетесь делать с этим примером кода, трудно понять, «работает» ли этот подход для того, о чем вы думаете, или нет.

Option Strict On

Module Module1
    Sub Main()
        Dim Param As A = New X
        Dim Thing As New Foo(Param)

        Param = New Y
        Thing = New Foo(Param)

        'if you make a new class Z which Inherits A, it will immediately be translatable to Foo
        'albeit with all String.Empty properties unless you override the properties from A
    End Sub

End Module

'Defines what a Foo wants, what a Foo needs
Public Interface IPropertiesForFoo
    ReadOnly Property Common As String
    ReadOnly Property Prop1 As String
    ReadOnly Property Prop2 As String
    ReadOnly Property Prop3 As String
    ReadOnly Property Prop4 As String
End Interface

Public MustInherit Class A
    Implements IPropertiesForFoo

    Public Property Common As String


#Region "IPropertiesForFoo implementation"
    'these are Overridable, so derived classes can choose what to change and what not to
    'note these are all Protected, so only derived classes know about them.  Users of A may not care.

    'This is just one choice;
    ' you could also use Throw New NotImplementedException (instead of Return String.Empty)
    ' and force derived classes to handle every property

    Protected Overridable ReadOnly Property IPropertiesForFoo_Prop1 As String Implements IPropertiesForFoo.Prop1
        Get
            Return String.Empty
        End Get
    End Property

    Protected Overridable ReadOnly Property IPropertiesForFoo_Prop2 As String Implements IPropertiesForFoo.Prop2
        Get
            Return String.Empty
        End Get
    End Property

    Protected Overridable ReadOnly Property IPropertiesForFoo_Prop3 As String Implements IPropertiesForFoo.Prop3
        Get
            Return String.Empty
        End Get
    End Property

    Protected Overridable ReadOnly Property IPropertiesForFoo_Prop4 As String Implements IPropertiesForFoo.Prop4
        Get
            Return String.Empty
        End Get
    End Property

    'private, and doesn't need to be Overridable, as Common can map directly
    Private ReadOnly Property IPropertiesForFoo_Common As String Implements IPropertiesForFoo.Common
        Get
            Return Common
        End Get
    End Property
#End Region
End Class

Public Class X
    Inherits A

    Public Property Unique1 As String
    Public Property Unique2 As String

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop1 As String
        Get
            Return Unique1
        End Get
    End Property

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop2 As String
        Get
            Return Unique2
        End Get
    End Property

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop3 As String
        Get
            Return "Some value"
        End Get
    End Property

    'doesn't need to override Prop4; leave it as String.Empty
End Class

Public Class Y
    Inherits A

    Public Property Unique3 As String
    Public Property Unique4 As String

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop1 As String
        Get
            Return "Some value"
        End Get
    End Property

    'doesn't need to override Prop2; leave it as String.Empty

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop3 As String
        Get
            Return Unique3
        End Get
    End Property

    Protected Overrides ReadOnly Property IPropertiesForFoo_Prop4 As String
        Get
            Return Unique4
        End Get
    End Property
End Class


Public Class Foo

    Public Sub New(v As IPropertiesForFoo)
        Common = v.Common
        Prop1 = v.Prop1
        Prop2 = v.Prop2
        Prop3 = v.Prop3
        Prop4 = v.Prop4
    End Sub

    Public ReadOnly Property Common As String
    Public ReadOnly Property Prop1 As String
    Public ReadOnly Property Prop2 As String
    Public ReadOnly Property Prop3 As String
    Public ReadOnly Property Prop4 As String


End Class

Если на то пошло, в зависимости от того, что на самом деле делает остальная часть Foo, вам может даже не понадобиться Foo - просто пропустите свои экземпляры A, поскольку они также IPropertiesForFoo. Затем извлеките их свойства, помеченные как Prop1, Prop2, по мере необходимости. (Опять же, ваш упрощенный пример исходного кода недостаточно намекает на более широкий контекст, чтобы понять, подходит ли этот подход или нет.)

Я уверен, что многие люди снова скажут мне, что я не должен поступать таким образом, но вот что я сделал, чтобы действительно решить проблему, когда мне это было нужно:

Public Class Foo
    Public Sub New(v As X)
    End Sub

    Public Sub New(v As Y)
    End Sub

    Public Shared Function Create(v As X) As Foo
        Return New Foo(v)
    End Function

    Public Shared Function Bar(v As Y) As Foo
        Return New Foo(v)
    End Function
End Class

Что позволяет мне использовать Foo вот так:

Dim Param As Object = New Y
Foo.Create(Param)

Да, вышеприведенное использует позднее связывание и слабо типизированный код. Но он также сводит к минимуму избыточный код, не требует длинного определения или реализации интерфейса, по-прежнему полностью предсказуем и делает именно то, что мне нужно. Я считаю такие функции полезными и действительными при использовании в правильном контексте.

Я все еще хотел бы получить ответ на вопрос, почему разрешение перегрузки работает с обычным методом, но не с конструктором. Но пока, я думаю, мне просто придется согласиться на этот обходной путь.