Interface vs. Virtual methods

  • Thread starter Thread starter Just D
  • Start date Start date
J

Just D

All,

What are advantages and disadvantages of these two different approaches?

1 . I create a base class with a few virtual methods, then I derive my
classes from this class, override these methods and use this class.

2. I work with the interface, same for each class, just define it for every
class

What is faster in .NET? I supposed that deriving from the base classes.

The main purpose was to create a few classes of the second level having the
same method names like Initialize(), Update(), Get(), Sage(). Add() etc.

Thanks,
Dmitri
 
What are advantages and disadvantages of these two different approaches?
1 . I create a base class with a few virtual methods, then I derive my
classes from this class, override these methods and use this class.

2. I work with the interface, same for each class, just define it for every
class

What is faster in .NET? I supposed that deriving from the base classes.

The main purpose was to create a few classes of the second level having the
same method names like Initialize(), Update(), Get(), Sage(). Add() etc.
Click to expand...


There should be no performance differences between interfaces and virtual
methods since interface methods are internally just abstract methods.
You should consider that in .NET classes can oly have one base-class but
multiple interfaces, also if your classes will have common functionality you
best go with base-class but using interfaces you can still use composition
or delegation to provide this functionality in each class without
copy/paste-programming.

Also bear in mind that if you later add methods to an interface you also
have to add it to all its implementing classes, with a base-class you don't
have this problem (unless the added method is abstract).
 
Hi Cody,
You should consider that in .NET classes can only have one base-class but
multiple interfaces, also if your classes will have common functionality
you
best go with base-class but using interfaces you can still use composition
or delegation to provide this functionality in each class without
copy/paste-programming.
Click to expand...

Interesting, but just one question. I haven't heard that I can use a parts
of code from different files to compose some code file. Are you meaning this
way? Sometimes I want to include a part of the code repeating in different
places, the inheritance is not always acceptable and I need just to insert a
reference to some external file to use the code from this file. I couldn't
find any official way for that in C#. In C++ we can do that. I even asked in
this group or in CSHARP a few months ago. No answer.If you know anything
about these combining of the code from external files, then please tell a
little bit more, ok?

Thanks,
Dmitri
 
You should consider that in .NET classes can only have one base-class
but
Interesting, but just one question. I haven't heard that I can use a parts
of code from different files to compose some code file. Are you meaning this
way? Sometimes I want to include a part of the code repeating in different
places, the inheritance is not always acceptable and I need just to insert a
reference to some external file to use the code from this file. I couldn't
find any official way for that in C#. In C++ we can do that. I even asked in
this group or in CSHARP a few months ago. No answer.If you know anything
about these combining of the code from external files, then please tell a
little bit more, ok?
Click to expand...


In the next version of C# you will be able to split classes in several
source files, but I didn't meant that.
Composition is someting like that:

class Car
{
Engine engine;
}

instead of

class Car : Engine
{
}

so if you need common functionality and do not want to put it in a
base-class, make it an own class and put and object of it in your class. Got
the idea?
 
Have a look at
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/fastmanagedcode.asp.
Performance issues of method calls are explained in VERY HIGH detail there.
In a nutshell: an interface call takes a little longer than a virtual method
call, but we're talking about nano-seconds here, so this is really only
relevant if all your methods are empty...

From a design perspective: classes describe "kinds" of things (like cat,
human or car) while interfaces describe "ways to interact" with things, or
"roles" of things (like waiter, president, transportation utility). It's not
always 100% clear how to classify things, but the methods you describe
(Init, Update, Get, Add) sound like "a way to interact with things",
although these "things" may be of unrelated kind.

Typical interfaces are IComparable or IList; You can write algorithms that
operate on these and provide e.g. sorting or searching services without
knowledge of the underlying implementation;

The basic idea is: instead of tying classes together, you loosely couple
them through well-defined interfaces, so you can at any time decide to split
a certain class into two if it gets too complex, to fuse two classes
together if they don't make sense separete from each other or to exchange a
certain class by another. Other classes won't be affected by such decisions,
as they only see the interfaces that don't change (of course this only works
if your interfaces *are* well defined...)

Hope this helps,

Niki
 
Have a look at
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/ht
ml/fastmanagedcode.asp.
Performance issues of method calls are explained in VERY HIGH detail there.
In a nutshell: an interface call takes a little longer than a virtual method
call, but we're talking about nano-seconds here, so this is really only
relevant if all your methods are empty...
Click to expand...

They should perform the same speed, you cannot tell the one is faster than
the other only because of small deviations in the results. The results
highly depend on the hardware, the .NET runtime version and on the
application (does the code fit in the cache/cache misses on so on).
What you surely can tell that inlined methods are the fastest, and the speed
decreases with the count and sizes of the method parameters (including
this-pointer) and return type, which means that a static void foo() is the
fastest and a virtual method should perform much slower.

I do not believe some results of the test it says for example that a "this
itf instance call" takes 0.2ns whereas a "this itf virtual call" took 5.4ns.
Iam sure, the first one was certainly inlined.
 
It really depends on the nature of your methods. Interfaces are best when
you deal with functionality that spans multiple families of classes. For
example, you want to add print capabilities to both the Employee class and
an Invoice class. Other than object, these two classes have nothing in
common, so you would unlikely create a virtual class to derive from, as this
is not good OO design.

--
Gregory A. Beamer
MVP; MCP: +I, SE, SD, DBA

************************************************
Think Outside the Box!
************************************************
 
Assuming a spherical cow ...

A lot of assumptions here to derive the idea that virtual methods are
faster. I will agree, however, that the span is very small, if it is faster.
When compiled, you end up with code that is identical, or nearly so.

--
Gregory A. Beamer
MVP; MCP: +I, SE, SD, DBA

************************************************
Think Outside the Box!
************************************************
 
cody said:
...
They should perform the same speed, you cannot tell the one is faster than
the other only because of small deviations in the results. The results
highly depend on the hardware, the .NET runtime version and on the
application (does the code fit in the cache/cache misses on so on).
Click to expand...

Did you read that article? He actually shows the assembler sequency produced
JIT compiler, and they are different for virtual calls/interface calls. Why
should they take the same amout of time? I'm not an assembler crack, but it
seems pretty obvious that 5 instructions may take more time than 3
instructions...
I do not believe some results of the test it says for example that a "this
itf instance call" takes 0.2ns whereas a "this itf virtual call" took 5.4ns.
Iam sure, the first one was certainly inlined.
Click to expand...

virtual calls need one extra memory lookup; Memory lookups are about the
most expensive operation in this kind of benchmark.
BTW: "I do not believe this" is no argument: if you want to say something,
do your own benchmarks and show us your results. Include JIT results if time
measurements aren't sufficient (as you say)

Niki
 
Cowboy (Gregory A. Beamer) said:
Assuming a spherical cow ...

A lot of assumptions here to derive the idea that virtual methods are
faster. I will agree, however, that the span is very small, if it is
Click to expand...
faster.


Of course, on a P3 or higher processor, benchmarking
5-instruction-assembler-sequences doesn't make much sense. I didn't say "use
virtual calls because they are faster". I only said "look, there's almost no
difference - use the kind of call that fits your design better". And I do
think the article does show that.
5-6 ns *are* fast.
When compiled, you end up with code that is identical, or nearly so.
Click to expand...

virtual method: pointer lookup (virtual method table -> method pointer)
interface method: pointer to pointer to pointer lookup (interface method ->
method table -> interface map)
Different code.
Read the article.

Niki
 
Did you read that article? He actually shows the assembler sequency produced
JIT compiler, and they are different for virtual calls/interface calls. Why
should they take the same amout of time? I'm not an assembler crack, but it
seems pretty obvious that 5 instructions may take more time than 3
instructions...
Click to expand...

OK I now read it again and it seems that for interface calls there is an
additional lookup for the interface.
It seems interface tables are using not the vtable of the class but of the
interface, so the result is now logical to me.

All method calls in the table took from 5.4-6.8ns, the two inlined ones took
0.2ns. So it is very unlikely that "this itf virtual call" takes 0.2ns.
Iam certain the method was inlined.
virtual calls need one extra memory lookup; Memory lookups are about the
most expensive operation in this kind of benchmark.
Click to expand...

Here is the question why a "static call" took 6.1ns and a "virtual call"
took 5.4ns.
 
Back
Top