Блог

Я спрашиваю на случай, если я упускаю что-то очевидное, но мне кажется, я, возможно, наткнулся на ошибку.Компилятор NET.

У меня есть два проекта в .NET-решении, один visual basic, один C #.

Код на C #, состоящий из трех перегруженных статических методов со значениями по умолчанию:

 public static class Class1
{

    public static void TestFunc(int val1, int val2 = 0)
    {
    }

    public static void TestFunc(int val1 = 0)
    {
    }

    public static void TestFunc(string val1, int val2 = 0)
    { 
    }
}
 

Код Visual basic, вызывающий один из перегруженных методов:

 Option Explicit On
Option Strict On
Imports ClassLibrary1

Module Module1
    Sub Main()
        Dim x As Integer
        Class1.TestFunc(x, 0)
    End Sub
End Module
 

Компиляция этого кода завершится неудачно, сказав:

‘TestFunc’ неоднозначен, потому что в классе ‘ClassLibrary1.Class1’ существует несколько типов членов с таким именем.

Почему он считает этот метод неоднозначным? Существует только один Class1.TestFunc с сигнатурой (int, int). Это ошибка, или я что-то упустил?

В конечном счете, похоже, все сводится к тому, как C # реализует необязательные параметры в вашем первом статическом методе. Если вы удалите значение по умолчанию для этого, ваше решение должно скомпилироваться.

 public static void TestFunc(int val1, int val2) 
{ 
} 
 

На самом деле, в этом случае я несколько удивлен, что C # компилируется. Вы должны либо использовать необязательные параметры в C #, либо перегружать, но не оба. Например, как бы вы разрешили неоднозначность следующего:

 public static void TestFunc(int val1, int val2 = 0)     
{     
}     

public static void TestFunc(int val1)     
{     
}  
 

Если я передам следующее, какой из двух методов должен быть выполнен — один с необязательным параметром или второй без второго параметра?

 TestFunc(1)
 

Лучшим решением, если вы хотите включить необязательные параметры в свою реализацию на C #, было бы объединить первый и второй методы и при необходимости проверить значение по умолчанию:

 public static void TestFunc(int val1, int val2 = 0)
{
}

public static void TestFunc(string val1, int val2 = 0)
{
}
 

Обратите внимание, что с помощью этой версии VB может устранить неоднозначность, какой метод вызывать.

Если вы попытаетесь скомпилировать это в VB.NET вы получите

 Sub TestFunc(ByVal val1 As Integer, Optional ByVal val2 As Integer = 0)

End Sub

Sub TestFunc(Optional ByVal val1 As Integer = 0)

End Sub
 

вы получите Public Sub TestFunc(val1 As Integer, [val2 As Integer = 0])' and 'Public Sub TestFunc([val1 As Integer = 0])' cannot overload each other because they differ only by optional parameters.

поэтому я скажу, что VB.NET является более ограниченным, чем C #, в перегрузке необязательных параметров.

TestFunc неоднозначен из-за параметра по умолчанию. Когда вызывается TestFunc(x), он не уверен, вызывает ли он TestFunc с одним параметром или TestFunc с параметрами по умолчанию 2. 2-й параметр является параметром по умолчанию.

Редактировать

Когда этот вопрос был впервые опубликован, оба:

Option Strict On

и

Option Explicit On

не были заданы в вопросе, поэтому это кардинально меняет ответ.

Оригинальный ответ перед вопросом редактировать

Потому что это:

  public static void TestFunc(int val1, int val2 = 0) 
    { 
    } 
 

Неоднозначно для:

 public static void TestFunc(string val1, int val2 = 0) 
    {  
    } 
 

VB.net может преобразовать целое число в строку.

В спецификации языка Visual Basic 10 указано, что.

Считается, что метод с необязательными параметрами имеет несколько сигнатур, по одной для каждого набора параметров, которые могут быть переданы вызывающим объектом. Например, следующий метод имеет три соответствующие сигнатуры:

  Sub F(x As Short, _
       Optional y As Integer = 10, _
       Optional z As Long = 20)
 

Итак, у вас TestFunc(int val1, int val2 = 0) есть две подписи в VB, которые конфликтуют с TestFunc(int val1) so TestFunc неоднозначно.

Я не могу найти ничего в спецификации C #, в которой говорится, что необязательные параметры обрабатываются как методы с несколькими сигнатурами. Из поведения, которое вы видите, я предполагаю, что в C # они не считаются имеющими несколько подписей, в противном случае вы получите ошибку компилятора, что означает, что она действительна в C #. Я предполагаю, что C # выберет метод, который вызывается на основе некоторых правил, поскольку он не может вызывать оба for TestFunc(0) .