阴影（VB.NET）和新（C＃）之间的区别

Question

Simple question from a simple-minded: What are the differences between the Shadows keyword in VB.NET and the New keyword in C#? (regarding method signatures of course).

Answer 1

They are identical. Shadows is the VB.NET equivalent for C#'s new keyword . They mean the same thing semantically and they compile down to the same IL.

In some versions of Visual Studio (I'm not sure if this is still the case), using the Shadows keyword in a VB.NET project had the effect of hiding all functions with the same name from Intellisense. But that's not actually a language feature; it's not even clear if it's by design or a bug in the implementation of Intellisense. If you use the same VB.NET library from a C# application, you'll see all of the methods as if they were declared with new .

Answer 2

They are not identical.

The Shadowing concept does not exist in C #

Consider a vb.net base class with some overloads:

Public Class BaseClass
    Public Function SomeMethod() As String
        Return String.Empty
    End Function
    Public Function SomeMethod(SomeParam As String) As String
        Return "Base from String"
    End Function

    Public Function SomeMethod(SomeParam As Integer) As String
        Return "Base from Integer"
    End Function
    Public Function SomeMethod(SomeParamB As Boolean) As String
        Return "Base from Boolean"
    End Function
End Class

And this derived class:

Public Class DerivedClass
    Inherits BaseClass

    Public Shadows Function SomeMethod(SomeParam As String) As String
        Return "Derived from String"
    End Function
End Class

Now consider the implementation:

Dim DerivedInstance = New DerivedClass()

DerivedInstance have just one version of SomeMethod, and all other base versions have been shadowed .

if you compile and reference the assembly in a C# project you can see what happens:

DerivedInstance shadows method

To perform hiding in VB.Net, you still have to use the overloads (or overrides if base method is marked as overridable ) keyword:

Public Class DerivedClass
    Inherits BaseClass

    Public Overloads Function SomeMethod(SomeParam As String) As String
        Return "Derived from String"
    End Function
End Class

And this is what happens after compiling:

DerivedInstance hide method

So, in VB.Net, if you use overloads keyword, on a signature that matches one on base class, you're hiding that base version of method, just like you would in c #:

public class DerivedClass : BaseClass
{
    public new string SomeMethod(string someParam)
    {
        return "Derived from String";
    }
}

Edit: This is the IL code:

From C#:

.method public hidebysig specialname rtspecialname instance void .ctor () cil managed 
{
    IL_0000: ldarg.0
    IL_0001: call instance void Shadowing_CS.BaseClass::.ctor()
    IL_0006: ret
}

.method public hidebysig instance string SomeMethod (
        string s
    ) cil managed 
{
    IL_0000: ldstr "Derived from string"
    IL_0005: ret
}

From VB:

.method public specialname rtspecialname instance void .ctor () cil managed 
{
    IL_0000: ldarg.0
    IL_0001: call instance void Shadowing_VB.BaseClass::.ctor()
    IL_0006: ret
}

.method public instance string SomeMethod (
        string s
    ) cil managed 
{
    IL_0000: ldstr "Derived from string"
    IL_0005: ret
}

So.... they are not identical.

Note: Before downvote... please.... just try.

Answer 3

它们是相同的，它只是实现相同OOP概念的语言特定关键字。