Inner Class Extends Outer Class

[Martijn Mulder]

A construction like this:

class Outer
{
class Inner:Outer
{
}
}

compiles without problem but does it introduce infinity?

[JohnGoogle]

I've never thought of doing this! However, it seems to work OK.

public class Outer
{
public class Inner : Outer
{
public override string ToString()
{
return "I'm an inner";
}
}

public override string ToString()
{
return "I'm an outer";
}
}
To test it:

static void Main(string[] args)
{
Outer o = new Outer();
Console.WriteLine(o);

Outer.Inner i = new Outer.Inner();
Console.WriteLine(i);

Console.WriteLine("\nPress ENTER to continue");
Console.ReadLine();
}
Without using 'using' statements you have to refer to it as Outer.Inner
so it's a bit long winded! I'd prefer to declare them sequentially for
ease of readability but it seems that the compiler can cope with it OK.
Martijn Mulder wrote:

A construction like this:

class Outer
{
class Inner:Outer
{
}
}

compiles without problem but does it introduce infinity?

[Dave Sexton]

Hi Martjin,

Why would you think that it might "introduce infinity"?

After all, it's not like you are asking about something recursive, like this:

class Outer : Inner { }
class Inner : Outer { }

BTW, the above fails during compilation with an interesting message:

Error 2 Circular base class dependency involving 'Inner' and 'Outer'

--
Dave Sexton

"Martijn Mulder" <i@mwrote in message
news:45***********************@news.wanadoo.nl...

>A construction like this:

class Outer
{
class Inner:Outer
{
}
}

compiles without problem but does it introduce infinity?

[Martijn Mulder]

Why would you think that it might "introduce infinity"?

>
After all, it's not like you are asking about something recursive, like
this:

class Outer : Inner { }
class Inner : Outer { }

BTW, the above fails during compilation with an interesting message:

Error 2 Circular base class dependency involving 'Inner' and 'Outer'

I can compile and run this program without problems. But I don't see any use
for it (yet):

//class Outer
public class Outer
{

//ToString
public override string ToString(){return "Outer class";}
//nested class Inner
public class Inner:Outer
{

//ToString
public override string ToString(){return "Inner class";}
}
//Main
static void Main()
{
System.Console.WriteLine(new Outer());
System.Console.WriteLine(new Outer.Inner());
System.Console.WriteLine(new Outer.Inner.Inner());
System.Console.WriteLine(new Outer.Inner.Inner.Inner());
}
}

_____________________
output:

Outer class
Inner class
Inner class
Inner class

[Dave Sexton]

Hi Martjin,

Yes, I suspect that it would work - I don't see why anyone would think that it
wouldn't. I don't know of any good use for it either ;)

--
Dave Sexton

"Martijn Mulder" <i@mwrote in message
news:45***********************@news.wanadoo.nl...

>Why would you think that it might "introduce infinity"?

After all, it's not like you are asking about something recursive, like
this:

class Outer : Inner { }
class Inner : Outer { }

BTW, the above fails during compilation with an interesting message:

Error 2 Circular base class dependency involving 'Inner' and 'Outer'

I can compile and run this program without problems. But I don't see any use
for it (yet):

//class Outer
public class Outer
{

//ToString
public override string ToString(){return "Outer class";}
//nested class Inner
public class Inner:Outer
{

//ToString
public override string ToString(){return "Inner class";}
}
//Main
static void Main()
{
System.Console.WriteLine(new Outer());
System.Console.WriteLine(new Outer.Inner());
System.Console.WriteLine(new Outer.Inner.Inner());
System.Console.WriteLine(new Outer.Inner.Inner.Inner());
}
}

_____________________
output:

Outer class
Inner class
Inner class
Inner class

[Jon Skeet [C# MVP]]

Martijn Mulder <i@mwrote:

<snip>

I can compile and run this program without problems. But I don't see any use
for it (yet):

I may well use them when looking at "class enums". If you have a
private constructor in the outer class, it can be used from the nested
class, which means you can have a fixed, well-known set of derived
types. See the comments in
http://msmvps.com/blogs/jon.skeet/ar...classenum.aspx
for an example.

--
Jon Skeet - <sk***@pobox.com>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too