How Interfaces are calling Object class methods?

Question

3.50/5 (2 votes)

See more:

We all know Interfaces are not classes and so interfaces do not inherit any class and even do not inherit object class.

But when we Implement a interface in a class and override the object class method in that class, then we can call that object class method overridden in our child class from the interface(by interface reference variable).

How can interface call personal methods of child class?

Answer Please..........

C#

IMyInterface
{
   void ShowMe();
}
 
ClassA : IMyInterface
{
  void ShowMe()
  {
    MessageBox.Show("ClassA");
  }
  void Display()
  {
    MessageBox.Show("Display");
  }
 
  string ToString()
  {
    MessageBox.Show("ToString Class");
    return "";
  }
  
}
 
//Now, if the call is made like:

 
IMyInterface objClass = new ClassA();
 

objClass.ShowMe();
 
//ShowMe() method can be called because it is overridden method of the interface.

objClass.Display();
 
// Display() method can't be called because it is a personal method of ClassA.

objClass.ToString()
 
//when we call ToString() method, it runs.
//How toString() Method runs while it is not overridden method of interface.How can interface call personal methods of ClassA.

//I found some answer while googling that ToString is a method of object class that's why it founds in every class and interfaces.

//while more searching i found that interfaces do not inherit any class even interfaces can't inherit any class(it's a rule,interfaces are not classes and they don't inherit any class).

//Then how ToString runs???????????

Posted 18-Jul-12 18:56pm

Mahesh Kumar Badgujar

Add a Solution

Comments

Sergey Alexandrovich Kryukov 19-Jul-12 0:58am

What do you call a "personal method"? :-)
--SA

Prasad_Kulkarni 19-Jul-12 0:59am

You've already ask'd this question:
How Interfaces are calling Object class methods?[^]
How Interfaces are calling Object class methods?[^]
Don't re-post your questions, If you want to modify or update your question then use 'Improve question' widget. But don't re-post it.

Sergey Alexandrovich Kryukov 19-Jul-12 1:35am

Thank you for pointing it out, I did not know.
The question is incorrect, but not so trivial. I provided my answer, please see -- this is interesting enough.
--SA

Prasad_Kulkarni 19-Jul-12 4:46am

You're welcome SA!

Sebastian T Xavier 19-Jul-12 1:15am

Don't re-post

2 solutions

Solution 2

I think your example is very bad: because what you should do in your class is override the ToString method it inherited from System.Object , not replace it (what you did, and you did it wrong - look at the compiler warning (you should use the new keyword on the method declaration)).
So implicit your ClassA is defined like this

C#

class ClassA : System.Object, IMyInterface

.
There for it has a ToString method you can call (btw. it won't call yours!!!!)
Try for yourself:

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CallInterface
{
    interface IMyInterface
    {
        void ShowMe();
    }

    class ClassA : IMyInterface
    {
        public void ShowMe()
        {
            Console.WriteLine("ClassA");
        }
        public void Display()
        {
            Console.WriteLine("Display");
        }

        public string ToString() // compiler warning here (use new keyword, but in reality you wouldn't provide a new ToString method you would use an override)
        {
            Console.WriteLine("ToString Class");
            return "";
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            IMyInterface objClass = new ClassA();
            objClass.ShowMe();
            //objClass.Display(); // wrong, interface does not know about a Display method

            objClass.ToString();
            Console.ReadKey();
        }
    }
}

Conclusion: Your question is "bad" because your understanding of what an interface is and how inheritance works is wrong.

* you don't override interface methods - you implement them
* if you know the type of an object (or can test for a concrete type like ClassA)
you can recast your interface typed object to the concrete type and call your method:

C#

ClassA classA = objClass as ClassA;
if(classA != null)
classA.Display();

* your example code won't compile (a lot of errors) - so maybe implement a real example (like I did above) play with it, will give you a better understanding.
* What SA told you is why a ToString method is found on any Interface type, but I don't think you even thought about that.

So:
* play with an example
* read (again) about inheritance, interfaces, and override vs. new in C#
* Try to understand when to use each of these patterns
* Use interfaces the right way and you won't ask questions like this (because if you wonder "why can't I call this method" most likely your architecture is wrong.

Posted 19-Jul-12 1:33am

johannesnestler

Comments

Mahesh Kumar Badgujar 20-Jul-12 1:02am

Thanks for the answer my intelligent friend.
well, there are many errors in my example because i didn't write it here to compile but to make somebody understand my question.

and What SA told me is actually what i was searching for.

ok

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2012-07-18T19:20:00

The question is based on some misunderstanding. All types inherit from System.Object, but this inheritance is with a twist. When you call a method of System.Object, such as System.Object.ToString, and the target object is of the value type, the object is boxed, and the boxed representation of it does inherit from System.Object. Would you be surprised of the code shown below?

C#

int value = 3;
string stringValue = value.ToString(); //where ToString is System.Object

Here is what happens here: a compiler interprets the method call as boxing, followed by the call:

C#

//pseudo-code:
class ValueType : System.Object {/*...*/}
class Int32 : System.ValueType {/*...*/}
string stringValue = ((System.Int32)value).ToString();

That was just a warm-up exercise, to feel more comfortable with types and realize that things are not so trivial.

Now, let's come back to interfaces. You should remember that is some variable is declared as an interface type, it can only be a compile-time type, because interfaces cannot be instantiated. When this variable is instantiated, its run-time type is always some class or structure (structures also can implement interfaces).

Compiler "knows" that this run-time type is some class or some structure, but it "does not know" what exactly. But as this unknown type is always derived from System.Object, the compiler "knows" that the variable is assignment compatible with is, so its methods can be called with this variable, which is passed to the method as hidden "this" parameter.

To say it shorter: even though an interface is not inherited from System.Object, the initialized variables of an interface type always have some run-time type which does.

—SA