Palabra clave "Sobrecarga" en VB.NET

Question

¿Realmente necesita esta palabra clave para sobrecargar métodos? ¿Cuál es la diferencia entre usar la palabra clave overloads y simplemente tener diferentes firmas de métodos?

Answer 1

Dentro de la misma clase, la palabra clave Overloads es opcional, pero si un método se declara Overloads o Overrides, debe usarlo para todas las sobrecargas de ese método.

' this is okay 
Sub F1(s as String) 
Sub F1(n as Integer) 

' This is also okay 
Overloads Sub F2(s as String) 
Overloads Sub F2(n as Integer) 

' Error 
Overloads Sub F3(s as String) 
Sub F3(n as Integer) 

Sin embargo, se vuelve más complicado cuando se sobrecarga métodos de clase base en una clase derivada.

Si una clase base tiene varios métodos sobrecargados y desea agregar un método sobrecargado en una clase derivada, debe marcar el método en la clase derivada con la palabra clave Overloads, de lo contrario, todos los métodos sobrecargados en la clase base no disponible en la clase derivada.

Ver MSDN para más detalles.

Answer 2

Fue una consideración de diseño. Por supuesto que (VB) podría haber sido diseñado para inferir sobrecarga por la firma de la función (como en C#), por lo que la palabra clave Overloads podría haberse omitido, pero al final está en línea con la expresividad de Visual Basic (que algunos consideran por encima) y fue solo una decisión de diseño del lenguaje.

Answer 3

La clave Overloads es completamente opcional, no veo ventajas en su uso.

Answer 4

Miky D tiene razón. No hay diferencia entre un método sobrecargado declarado Overloads y otro que no lo hace.

Solo quería señalar que la palabra clave Sobrecarga es obligatoria cuando se declara Sobreescribe o Sobrecarga otro método con el mismo nombre. Por ejemplo, si se reemplaza el método Equals así:

Public Overrides Function Equals(ByVal obj As Object) As Boolean ... 

entonces usted quiere crear una sobrecarga de la siguiente manera:

Public Function Equals(ByVal otherProduct As Product) As Boolean ... 

obtendrá el siguiente error:

"function 'Equals' must be declared 'Overloads' because another 'Equals' 
is declared 'Overloads' or 'Overrides'." 

Obtendrá el mismo error si alguien declaró un método como Sobrecargas y desea sobrecargar ese método. Deberá agregar la palabra clave Sobrecarga a su método o eliminarla del otro método.

Personalmente nunca declaro un método sobrecargado Sobrecargas a menos que no tenga la opción, como en la situación anterior.

Answer 5

Me encontré con una situación en la que tenía que usar la palabra clave Sobrecarga.

Tenía una clase para padres y una clase heredada.

Public Class DataManager 

    Public MustOverride Function LoadDataSet(ByVal TableName as String, ByVal SQL as SQLObject) as DataSet 

    Public Function LoadDataSet(ByVal TableName as String, ByVal SQL as String) as DataSet 
    Return LoadDataSet(TableName, new SQLObject(SQL)) 
    End Function 
End Class 

Public Class OracleDataManager 
    Inherits DataManager 

    Public Overloads Overrides Function LoadDataSet(ByVal TableName as String, ByVal SQLObj as SQLObject) as DataSet 
    // code here 
    End Function 

End Class 

En este ejemplo, tuve que usar la palabra clave de las sobrecargas.

Answer 6

Esto aparece alto en los resultados de Google, y creo que podría explicarse más claramente aquí.

No hay ninguna razón para usar la palabra clave Overloads cuando está sobrecargando varios métodos dentro de la misma clase. La razón principal por la que usaría Overloads es permitir que una clase derivada llame a un método de su clase base que tiene el mismo nombre que el método sobrecargado, pero con una firma diferente.

Supongamos que tiene dos clases, Foo y SonOfFoo, donde SonOfFoo hereda de Foo. Si Foo implementa un método llamado DoSomething y SonOfFoo implementa el método con el mismo nombre, el método SonOfFoo ocultará la implementación de la clase principal ... incluso si los dos métodos toman diferentes parámetros. Al especificar la palabra clave Overloads, la clase derivada llamará a las sobrecargas de la clase padre del método.

Aquí hay algo de código para demostrar lo anterior, con las clases Foo y SonOfFoo implementadas como se ha descrito, y otro par de clases, Bar y SonOfBar que utilizan el Overloads palabra clave:

Class Foo 
    Public Sub DoSomething(ByVal text As String) 
     Console.WriteLine("Foo did: " + text) 
    End Sub 
End Class 

Class SonOfFoo 
    Inherits Foo 

    Public Sub DoSomething(ByVal number As Integer) 
     Console.WriteLine("SonOfFoo did: " + number.ToString()) 
    End Sub 
End Class 

Class Bar 
    Public Sub DoSomething(ByVal text As String) 
     Console.WriteLine("Bar did: " + text) 
    End Sub 
End Class 

Class SonOfBar 
    Inherits Bar 

    Public Overloads Sub DoSomething(ByVal number As Integer) 
     Console.WriteLine("SonOfBar did: " + number.ToString()) 
    End Sub 
End Class 

Sub Main() 
    Dim fooInstance As Foo = New SonOfFoo() 
    'works 
    fooInstance.DoSomething("I'm really a SonOfFoo") 
    'compiler error, Foo.DoSomething has no overload for an integer 
    fooInstance.DoSomething(123) 

    Dim barInstance As Bar = New SonOfBar() 
    'works 
    barInstance.DoSomething("I'm really a SonOfBar") 
    'compiler error, Bar.DoSomething has no overload for an integer 
    barInstance.DoSomething(123) 

    Dim sonOfFooInstance As New SonOfFoo() 
    'compiler error, the base implementation of DoSomething is hidden and cannot be called 
    sonOfFooInstance.DoSomething("I'm really a SonOfFoo") 
    'works 
    sonOfFooInstance.DoSomething(123) 

    Dim sonOfBarInstance As New SonOfBar() 
    'works -- because we used the Overloads keyword 
    sonOfBarInstance.DoSomething("I'm really a SonOfBar") 
    'works 
    sonOfBarInstance.DoSomething(123) 
End Sub 

Aquí es some information sobre cómo se compila de manera diferente en la CLI.