CODEWITHSUNDEEP
vb.net
Vimal CK
Vimal CK

Reputation: 3563

Interface behavior is dfferent in VB.Net

Interface behaves differently in Vb.Net. Below is a sample code snippet where IStudent interface has a method SayHello which is implemented by a class Student. The Access modifier for SayHello should be Public by default. By changing Access modifier to Private is not breaking the existing code and still i can access this private method using below code

Dim stdnt As IStudent = New Student
stdnt.SayHello()

Access modifier determines the scope of the members in a class, more over private members are accessible only from the class which exists. But here the theory of Access Modifier, Encapsulation are broken.

Thanks in advance

Module Module1

   Sub Main()
        Dim stdnt As IStudent = New Student
        stdnt.Name = "vimal"
        stdnt.SayHello()
   End Sub

End Module

Public Interface IStudent

   Property Name As String

   Sub SayHello()

End Interface

Public Class Student
   Implements IStudent

   Private Property Name As String Implements IStudent.Name

   Private Sub SayHello() Implements IStudent.SayHello
       Console.WriteLine("Say Hello!")
   End Sub

End Class

Upvotes: 6

Views: 1386

Answers (5)

MichaelM
MichaelM

Reputation: 21

When your variable stdnt is declared as IStudent, the interface methods and properties are then made Public, so the derived class' (Student) implementation is executed. If, on the other hand, if stdnt was declared as Student, the private members (Name and SayHello) would not be implemented, and an error would be thrown.

I'm guessing that the Interface members stubs (Name & SayHello) are by default Public, and the access modifier definitions of the derived class' implementation are ignored.

IMHO.

Upvotes: 2

Eric Lippert
Eric Lippert

Reputation: 660128

The original poster submitted this question to me via [email protected]; my answer is here:

https://communities.coverity.com/blogs/development-testing-blog/2013/10/09/oct-9-posting-interface-behaves-differently-in-visual-basic

To briefly summarize:

Why was .NET designed in this way?

That question is impossibly vague.

Is encapsulation broken by explicit implementation in C# and VB?

No. The privacy of the method restricts the accessibility domain of the methods name, not who can call the method. If the author of the class chooses to make a private method callable by some mechanism other than looking it up by name, that is their choice. A third party cannot make the choice for them except via techniques such as private reflection, which do break encapsulation.

How is this feature implemented in .NET?

There is a special metadata table for explicit interface implementations. The CLR consults it first when attempting to figure out which class (or struct) method is associated with which interface method.

Upvotes: 4

Hans Passant
Hans Passant

Reputation: 941555

There is no fundamental difference between C# and VB.NET, they just chose different ways to solve ambiguity. Best demonstrated with a C# snippet:

interface ICowboy {
    void Draw();
}
interface IPainter {
    void Draw();
}

class CowboyPainter : ICowboy, IPainter {
    void ICowboy.Draw() { useGun(); }
    void IPainter.Draw() { useBrush(); }
    // etc...
}

VB.NET just chose consistent interface implementation syntax so the programmer doesn't have to weigh the differences between implicit and explicit implementation syntax. Simply always explicit in VB.NET.

Only the accessibility of the interface method matters. Always public.

Upvotes: 3

Dave Doknjas
Dave Doknjas

Reputation: 6542

The exact equivalent in C# is the following - the method available to objects of the interface type and the private method available otherwise:

   void IStudent.SayHello()
   {
       this.SayHello();
   }
   private void SayHello()
   {
       Console.WriteLine("Say Hello!");
   }

Upvotes: 1

JLe
JLe

Reputation: 2904

From MSDN:

You can use a private member to implement an interface member. When a private member implements a member of an interface, that member becomes available by way of the interface even though it is not available directly on object variables for the class.

In C#, this behaviour is achieved by implementing the interface explicitly, like this:

public interface IStudent {
    string Name { get; set; }
    void SayHello();
}

public class Student : IStudent {
    string IStudent.Name { get; set; }

    void IStudent.SayHello() {
        Console.WriteLine("Say Hello!");
    }
}

So, if you were to omit the IStudent. in front of the method names, it would break. I see that in the VB syntax the interface name is included. I don't know whether this has any implications altough. But interface members aren't private, since the interface isn't. They're kinda public...

Upvotes: 4

Related Questions