Beginner interface question

[^MisterJingo^]

I've been reading up on interfaces, one example I came across showed
that you can hide a method implemented from an interface from the class
which implements it. To use it, you must cast to the interface type
e.g.:

interface IFoo
{
void display();
}

class Blah : IFoo
{
void IFoo.display()
{
System.Console. WriteLine("hell o");
}
}

class MainApp
{
public static void Main()
{
Blah myBlah = new Blah();

myBlah.display( ); //error
((IFoo)myBlah). display(); //works
}
}

In what circumstances would you ever want to do this? The place I found
this didn't explain why this would ever be done.
Sorry if these questions are missing the obvious :).

Chris

[Jeff Louie]

MJ... If each object has special features then you might want to
implement a
persistance interface and each object would provide a custom behavior at
Save.
If most objects can be persisted using generic logic then you can rely
on generic
persistance. So most object persist using [Serializable] just fine, a
few do not
and need to also implement ISerializable such as Singleton classes,
providing a
custom behavior.

Regards,
Jeff

If I had a number of objects which were not derived from the same base

class. Each of these objects had a load and save method, which were
called on every instanced object when the user selected a save event.
Would it be best to create a load/save interface, and then use a method
such as above. Or would it be best to use a function which calls every
object in turn, decides what form the object is and then load/save. Or
even factoring all objects which need load and save functionality into
a common base class? (the load or save could be something like
drawToScreen etc).<

*** Sent via Developersdex http://www.developersdex.com ***

[Jeff Louie]

_Internal_ to a project, you may come to the day that you define the
contract
first for almost everything and then start building concrete classes. So
you
program to a contract, contract first, using Interfaces. Internal to a
project, you
will be amazed at how this helps. Say you need to add a new method to an
Interface. Just do it and the compiler flags every concrete class that
needs to be
updated.

Regards,
Jeff

I'm trying to get my head around when best to use interfaces etc.<

*** Sent via Developersdex http://www.developersdex.com ***

[Dave Johnson]

hello josh, first of all thanks for your reply, thank you all guys it
has been great to witness all these action and try to learn from it.
the following code works for me, i only have access to the properties
and methods that i want, but i am not quite sure that i doing this
right, i mean it could have been done without interfaces in the
following code and it would have worked, so appearntly i didnt quite get
it and as this newsgroups are my only source of learning so far i would
appreciate feedbacks and comments as much as possilbe, whatz the trick
??!!

interface IData
{
int ClientInfo { get;set;}
int OrderInfo { get;set;}
}
interface IClient
{
int ClientInfo { get;}
}
interface IAdministrator
{
int ClientInfo { get;set;}
int OrderInfo { get;set;}
}

class Data : IData
{
private int clientInfo = 0;
private int orderInfo = 0;
public Data()
{
this.clientInfo = clientInfo;
this.orderInfo= orderInfo;
}
public int ClientInfo
{
get { return this.clientInfo ; }
set { this.clientInfo = value; }
}
public int OrderInfo
{
get { return this.orderInfo; }
set { this.orderInfo = value; }
}
}

class Client : IClient
{
Data data = new Data();

public Client()
{
this.data = data;
}
public int ClientInfo
{
get { return data.ClientInfo ; }
}
}

namespace WebApplication1 2
{

class Administrator : IAdministrator
{
private IData data = null;
public Administrator()
{

this.data = data;
}
public int ClientInfo
{
get
{
return data.ClientInfo ;
}
set
{
this.data.Clien tInfo = value;
}
}
public int OrderInfo
{
get { return this.data.Order Info; }
set { this.data.Order Info = value; }
}
}
Sharing makes All the Difference

--
Sent via .NET Newsgroups
http://www.dotnetnewsgroups.com

[Jeff Louie]

Dave... You are right. Except for IData you could have solved this
problem
without an interface. The key concepts are
1) using containment by reference to adapt the readwrite IData interface
to a
limited IClient interface and
2) understanding that multiple objects can hold a reference to a single
object
without the need for reference counting.

Since Client and Administrator take IData as a parameter, you can pass a
different Data class in the future and the code will still work. In fact
you can
pass any class that implements IData to the constructors and it will
work in
the future.

If you don't find the ability to look at the public contract as:

interface IData
{
int ClientInfo { get;set;}
int OrderInfo { get;set;}
}
interface IClient
{
int ClientInfo { get;}
}
interface IAdministrator
{
int ClientInfo { get;set;}
int OrderInfo { get;set;}
}

helpful, then there is no need to abstract out all of the interfaces. At
least
until you write a gazillion concrete classes and then decide to modify a
single
contract. If you used interfaces, the compiler will find all of the
concrete
classes that need to be updated!

There are at least four times when interfaces or abstract base classes
are
useful:

Polymorphic behavior
Defering the final behavior to a more knowledgable class
Encapsulating or hiding the implementation
Marking a class

So try to write some code that uses these four idioms and you will see
the
light. If you need hints:

IDrawable
IComparable
IPlugIn
IRequiresSessio nState

Regards,
Jeff

*** Sent via Developersdex http://www.developersdex.com ***