What is the best way to match a specific member implementation (on a class) with the corresponding member of an interface?

[e-manual-goldstein]

This isn't an issue for assemblies created from C# because the class member names must match the names of the interface members. However, in Visual Basic, the names of the members can be different to the names of the interface members that they implement. For example, I have an interface defined in VB like so:

Public Interface ISimpleInterface 
    Property BasicProperty as String
End Interface

I can implement this interface on my VB class like so:

Public Class SimpleVBClass Implements ISimpleInterface
    Public Property AlternativeNamedProperty As String Implements ISimpleInterface.BasicProperty
        Get
            Return ""
        End Get
        Set(value as String)
        
        End Set
    End Property
End Class

When the code is compiled, this causes a mismatch between the Name of the PropertyDefinition found on the SimpleVBClass ("AlternativeNamedProperty") and the Name of the PropertyDefinition found on the ISimpleInterface. My aim is to be able to unequivocally match a member implementation with the "contract" that it fulfills.

[ltrzesniewski]

Look at the generated IL:

.method public final specialname newslot strict virtual 
    instance string get_AlternativeNamedProperty () cil managed 
{
    .override method instance string ISimpleInterface::get_BasicProperty()

    // ...
}

The property getter and setter are methods with an explicit .override clause. You'll find those in the MethodDefinition.Overrides collection.

Note that no .override clause needs to be present when the method signatures match (implicit implementation).

By the way:

This isn't an issue for assemblies created from C# because the class member names must match the names of the interface members.

C# has explicit interface implementations, which produce similar IL.

[e-manual-goldstein]

Thanks for the quick response! I had actually already been looking at using the Overrides feature but for some reason, on certain other examples, my approach wasn't working as expected. The other examples come from much more complicated object models with a good deal of inheritance and overriding of virtual/abstract methods etc. so I think that might have something to do with it (the more complex are proprietary code so I can't post here unfortunately).

[e-manual-goldstein]

That SharpLab website is amazing, thanks for sharing. I used it to quickly test a similar scenario to the one that I'm currently looking at:

Public Class ChildClass 
Inherits SimpleVBClass

    Public Overrides Property AlternativeNamedProperty As String
        Get
            Return MyBase.AlternativeNamedProperty
        End Get
        Set(value As String)
            MyBase.AlternativeNamedProperty = value
        End Set
    End Property

End Class 

The IL Code generated for my ChildClass has no mention of the interface that it implements, which is what I'm looking for. But I suppose the correct approach is for the overridden member on the base class to be matched to the interface member and then the member on the subclass will be "matched" to the overridden member.

[ltrzesniewski]

If you're looking after the precise semantics, ECMA-335 has you covered. Look at section II.12.2.