Interface and enums

[Bob]

Hi,
Can someone explain why you can't declare enums in an interface?
The compiler says "interfaces can't declare types"
Ignoring the syntax implications it seems to me that you should be able to
declare that an enum exists. i.e. It is within the 'spirit' of an interface
to state that it exists. The implementing class will provide the members.

e.g. I have a code library that performs a function.
It exposes two interfaces which allow for two different ways of asking for
the function.
One way involves a public enum, i.e. Some of the method calls accept the
enum as a parameter, the other does not.
It seems to me that I should be able to declare the enum in one interface
and leave it out of the other.
Currently the enum is available to declared objects of either interface.
e.g.
ImyFirstInterfa ce FirstInterface = new MyLib.myImpleme ntingclass();
ImySecondInterf ace SecondInterface = new MyLib.myImpleme ntingclass();

Both FirstInterface and SecondInterface can see MyLib.myPublicE num
thanks
Bob

[Mattias Sjögren]

>Ignoring the syntax implications it seems to me that you should be able to
declare that an enum exists. i.e. It is within the 'spirit' of an interface
to state that it exists. The implementing class will provide the members.

How would your client code consume the enum if you don't know its
members?
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Bob]

Hi Mattias,
I see it happening in much the same way as any other interface
implementation.
i.e.

****Interface code *****
public Interface IMyInterface
{
enum MyJamChoice{};
bool JamInStock(MyJa mChoice whichone);
}
****End Interface Code

*****Implementa tion code*****
In MyImplementatio nClass we have
enum ImyInterface.My JamChoice
{
Strawberry,
Apricot
}
bool ImyInterface.Ja mInStock(ImyInt erface.MyJamCho ice whichone)
{
//Jam checking code return true if in stock
}
**********End of Implementation code *******

****Client Code***
ImyInterface = new MyImplementatio nClass()
//at this point Intellisense knows the enum contents
if (ImyInterface.J amInStock(ImyIn terface.MyJamCh oice.StrawBerry )
{//Lets have breakfast}
**** End of Client code****
regards
Bob
"Mattias Sjögren" <ma************ ********@mvps.o rgwrote in message
news:e6******** ******@TK2MSFTN GP02.phx.gbl...

>

Ignoring the syntax implications it seems to me that you should be able

to

declare that an enum exists. i.e. It is within the 'spirit' of an

interface

to state that it exists. The implementing class will provide the members.

How would your client code consume the enum if you don't know its
members?
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Mattias Sjögren]

>****Client Code***

>ImyInterface = new MyImplementatio nClass()

Should I assume that ImyInterface is a variable of type IMyInterface
or what?

>//at this point Intellisense knows the enum contents
if (ImyInterface.J amInStock(ImyIn terface.MyJamCh oice.StrawBerry )

It does? If ImyInterface is indeed a variable of type IMyInterface,
the compiler knows nothing about the concrete implementation
(MyImplementati onClass) you're using. That's kind of the point of
using interfaces - to be able to write the same code regardless of
implementation.
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[=?ISO-8859-2?Q?Marcin_Grz=EAbski?=]

Hi Bob,

Bob napisa³(a):

Hi Mattias,
I see it happening in much the same way as any other interface
implementation.
i.e.

****Interface code *****
public Interface IMyInterface
{
enum MyJamChoice{};
bool JamInStock(MyJa mChoice whichone);
}
****End Interface Code

*****Implementa tion code*****
In MyImplementatio nClass we have
enum ImyInterface.My JamChoice
{
Strawberry,
Apricot
}
bool ImyInterface.Ja mInStock(ImyInt erface.MyJamCho ice whichone)
{
//Jam checking code return true if in stock
}
**********End of Implementation code *******

You can not just define the interface of (any) type!
Interface is the contract wich gives all needed functionality.
If you declare the empty interface then the only thing
you can provide is the "empty" implementation of it.
The value types can implement interfaces but the enums can not,
because they have only values as a members.

It is important that if you want to provide the interface
with enums (as a arguments), you'll have to define these
enums, because you need to define the contract.

With regards
Marcin

[bob]

Hi Marcin and Mattias,
I know that I can't do this.
This is more a philisophical discussion on why not.
I see nothing wrong with defining an empty enum in the interface and
providing the members in the implementation.
I have yet to be convinced that it should not be achievable.
my pseudo code was meant to convey this.
Harking back to my Jam stocktake.
What is wrong with the concept?
I would implement the interface and fill the enum with Strawberry and
apricot.
You could implement the interface and fill the enum with
Plum and blackberry.
My client code could choose one of my jams
Your client code could choose one of your jams.
regards
Bob
"Marcin Grzêbski" <mg************ ***@taxussi.com .plwrote in message
news:eq******** **@news.superme dia.pl...

Hi Bob,

Bob napisa³(a):

Hi Mattias,
I see it happening in much the same way as any other interface
implementation.
i.e.

****Interface code *****
public Interface IMyInterface
{
enum MyJamChoice{};
bool JamInStock(MyJa mChoice whichone);
}
****End Interface Code

*****Implementa tion code*****
In MyImplementatio nClass we have
enum ImyInterface.My JamChoice
{
Strawberry,
Apricot
}
bool ImyInterface.Ja mInStock(ImyInt erface.MyJamCho ice whichone)
{
//Jam checking code return true if in stock
}
**********End of Implementation code *******

You can not just define the interface of (any) type!
Interface is the contract wich gives all needed functionality.
If you declare the empty interface then the only thing
you can provide is the "empty" implementation of it.
The value types can implement interfaces but the enums can not,
because they have only values as a members.

It is important that if you want to provide the interface
with enums (as a arguments), you'll have to define these
enums, because you need to define the contract.

With regards
Marcin

[PS]

"Bob" <bo*@nowhere.co mwrote in message
news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

Hi Mattias,
I see it happening in much the same way as any other interface
implementation.
i.e.

****Interface code *****
public Interface IMyInterface
{
enum MyJamChoice{};
bool JamInStock(MyJa mChoice whichone);
}
****End Interface Code

*****Implementa tion code*****
In MyImplementatio nClass we have
enum ImyInterface.My JamChoice
{
Strawberry,
Apricot
}
bool ImyInterface.Ja mInStock(ImyInt erface.MyJamCho ice whichone)
{
//Jam checking code return true if in stock
}
**********End of Implementation code *******

****Client Code***
ImyInterface = new MyImplementatio nClass()
//at this point Intellisense knows the enum contents
if (ImyInterface.J amInStock(ImyIn terface.MyJamCh oice.StrawBerry )
{//Lets have breakfast}
**** End of Client code****

Enums are not "dynamic" like that.

Here is an example to see if this is the problem you are trying to avoid.

interface ICarFactory
{
Car MakeCar(ModelsE num model);
}

ICarFactory factory = new FordFactory();
factory.MakeCar (ModelsEnum.Toy otaRav4);

PS

regards
Bob
"Mattias Sjögren" <ma************ ********@mvps.o rgwrote in message
news:e6******** ******@TK2MSFTN GP02.phx.gbl...

>>

>Ignoring the syntax implications it seems to me that you should be able

to

>declare that an enum exists. i.e. It is within the 'spirit' of an

interface

>to state that it exists. The implementing class will provide the
members.

How would your client code consume the enum if you don't know its
members?
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Chris Dunaway]

On Feb 8, 3:20 am, "bob" <b...@nowhere.c omwrote:

Hi Marcin and Mattias,
I know that I can't do this.
This is more a philisophical discussion on why not.
I see nothing wrong with defining an empty enum in the interface and
providing the members in the implementation.

What it two classes that implement your interface have two different
implementations for the enum? What if they then need to communicate
the enum variable to a third class? How is the third class to know
which implementation of the enum to use? What if they conflict?

[bob]

Hi,
Your example is much more succint than mine.
Excellent.
In my brave new world your ICarFactory interface would also declare
ModelEnum{}
Your FordFactory implemenation would be forced to fill it. Hopefully with
'starlet','esco rt' etc

In the client code
Once the ; is typed in
ICarFactory factory = new FordFactory();
Intellisense knows the contents of ModelEnum from its inspection of the
FordFactory implementation
When you type in
factory.MakeCar (ModelsEnum.
You are presented with the contents of Fordfactory.Mod elsEnum
Rav4 would not be in the list and would force a type checking error if you
insisted on typing it in.
regards
Bob

Enums are not "dynamic" like that.

Here is an example to see if this is the problem you are trying to avoid.

interface ICarFactory
{
Car MakeCar(ModelsE num model);
}

ICarFactory factory = new FordFactory();
factory.MakeCar (ModelsEnum.Toy otaRav4);

PS

regards
Bob
"Mattias Sjögren" <ma************ ********@mvps.o rgwrote in message
news:e6******** ******@TK2MSFTN GP02.phx.gbl...

>
Ignoring the syntax implications it seems to me that you should be

able

to

declare that an enum exists. i.e. It is within the 'spirit' of an

interface

to state that it exists. The implementing class will provide the
members.

How would your client code consume the enum if you don't know its
members?
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[bob]

Hi Chris,
Please see my reply to PS. His example is much better than mine.
There can be no confusion because at some point you must instantiate your
interface declaration in the client code. Once you type in
IMyInterface m = new SomeImplementat ion();
You have locked down the enum to what ever is in the SomeImplementat ion.
regards
Bob
"Chris Dunaway" <du******@gmail .comwrote in message
news:11******** *************@q 2g2000cwa.googl egroups.com...

On Feb 8, 3:20 am, "bob" <b...@nowhere.c omwrote:

Hi Marcin and Mattias,
I know that I can't do this.
This is more a philisophical discussion on why not.
I see nothing wrong with defining an empty enum in the interface and
providing the members in the implementation.

What it two classes that implement your interface have two different
implementations for the enum? What if they then need to communicate
the enum variable to a third class? How is the third class to know
which implementation of the enum to use? What if they conflict?