Help with this sample

[Praveen]

trying to learn plymorphism.
My sample is

public class Class1
{
public static void Main(string[] args)
{
Cls1 x = new Cls1();
Cls2 y = new Cls2();
Cls3 y = new Cls3();

Object[] coll = new Object[] {x,y,z};

foreach (Object obj in coll)
{
Console.WriteLi ne(obj.Rtn());
// here is the issue.
//How to get the return value of Rtn();
//I want to use the loop and the concept of polymorphism

}
}
}
public class Cls1
{
public string Rtn()
{
return "From Cls1";
}
}
public class Cls2
{
public string Rtn()
{
return "From Cls2";
}
}

public class Cls3
{
public string Rtn()
{
return "From Cls3";
}
}

[nick.fletcher]

In order to exhibit polymorphism, your classes Cls1, Cls2, Cls3 need to
all derive from a base class with your common method defined.

Declare an abstract base class with one method called Rtn(). Derive
your classes from this class and then during your foreach loop, call
the method on the base class rather than the concrete classes

eg

public abstract MyBaseClass
{
public abstract string Rtn();
}

public class Cls1 : MyBaseClass
{
public override string Rtn()
{
return "From class 1";
}
}
//repeat this for your other classes

when calling the method use

foreach (MyBaseClass c in coll)
{
Console.Writeln ( c.Rtn() );
}

Hope this helps.

ps if you dont want to use an abstract class then you can just create a
concrete base class and mark the method as protected virtual

On Nov 26, 8:23 pm, "Praveen" <prav...@newsgr oup.nospamwrote :

trying to learn plymorphism.
My sample is

public class Class1
{
public static void Main(string[] args)
{
Cls1 x = new Cls1();
Cls2 y = new Cls2();
Cls3 y = new Cls3();

Object[] coll = new Object[] {x,y,z};

foreach (Object obj in coll)
{
Console.WriteLi ne(obj.Rtn());
// here is the issue.
//How to get the return value of Rtn();
//I want to use the loop and the concept of polymorphism

}
}
}

public class Cls1
{
public string Rtn()
{
return "From Cls1";
}
}

public class Cls2
{
public string Rtn()
{
return "From Cls2";
}
}

public class Cls3
{
public string Rtn()
{
return "From Cls3";
}
}

[Dave Sexton]

Hi,

Polymorphism exists in .NET via inheritance and interfaces. You haven't
illustrated the use of interfaces in your example, and you've barely
scratched the surface of inheritance. Here's a simple article that you may
want to read:

"Polymorphi sm in object-oriented programming"
http://en.wikipedia.org/wiki/Polymor...ed_programming

Cls3 y = new Cls3();

Your code won't compile because the line above attempts to redefine "y".

foreach (Object obj in coll)
{
Console.WriteLi ne(obj.Rtn());

You can't call obj.Rtn() because obj is of the Type, "System.Object" , which
doesn't provide a method named, "Rtn". You must cast "obj" to a Type that
has a method named, "Rtn":

foreach (object obj in coll)
{
if (obj is Cls1)
Console.WriteLi ne(((Cls1) obj).Rtn());
else if (obj is Cls2)
Console.WriteLi ne(((Cls2) obj).Rtn());
else if (obj is Cls3)
Console.WriteLi ne(((Cls3) obj).Rtn());
}

Obviously, this isn't very dynamic at all.

Since you'd like to late-bind to an instance of Cls1, Cls2 and Cls3 to call
"Rtn", a method which each of these classes has in common with the same
signature, you could use an interface:

interface IReturn
{
string Rtn();
}

class Cls1 : IReturn
{
public string Rtn() { return "From Cls1"; }
}

class Cls2 : IReturn
{
public string Rtn() { return "From Cls2"; }
}

....

And you can use the interface as such:

IReturn[] returningColl = new IReturn[] {
new Cls1(), new Cls2()
};

foreach (IReturn returningObject in returningColl)
Console.WriteLi ne(returningObj ect.Rtn());

--
Dave Sexton

"Praveen" <pr*****@newsgr oup.nospamwrote in message
news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

trying to learn plymorphism.
My sample is

public class Class1
{
public static void Main(string[] args)
{
Cls1 x = new Cls1();
Cls2 y = new Cls2();
Cls3 y = new Cls3();

Object[] coll = new Object[] {x,y,z};

foreach (Object obj in coll)
{
Console.WriteLi ne(obj.Rtn());
// here is the issue.
//How to get the return value of Rtn();
//I want to use the loop and the concept of polymorphism

}
}
}
public class Cls1
{
public string Rtn()
{
return "From Cls1";
}
}
public class Cls2
{
public string Rtn()
{
return "From Cls2";
}
}

public class Cls3
{
public string Rtn()
{
return "From Cls3";
}
}

[Hameer Saleem]

Hi Praveen,

You cannot invoke the Rtn method from the variable of type object without
casting it to the appropriate class type.
But since you want to use polymorphism, you dont want to cast it.

polymorphism can be applied in this case, can be accomplished in the
following ways

--Derive Cls1, Cls2 and Cls3 from a common base type.
The base type should have a virtual method Rtn which you should override
in each of the classes Cls1, Cls2 amd Cls3.

Example:
class BaseType
{
protected virtual string Rtn()
{
return String.Empty;
}

}
class Cls1 : BaseType
{
protected override string Rtn()
{
return "From Cls1";;
}
}
Use BaseType[] instead of object[]

OR

--Create a particular Interface which defines the method Rtn.
Implement the Rtn method in each of the classes Cls1, Cls2 amd Cls3.
interface IBaseType
{
string Rtn();
}
class Cls1 : IBaseType
{
public string Rtn()
{
return "From Cls1";;
}
}
Use IBaseType[] instead of object[]

Regards,
Hameer Saleem
"Praveen" wrote:

trying to learn plymorphism.
My sample is

public class Class1
{
public static void Main(string[] args)
{
Cls1 x = new Cls1();
Cls2 y = new Cls2();
Cls3 y = new Cls3();

Object[] coll = new Object[] {x,y,z};

foreach (Object obj in coll)
{
Console.WriteLi ne(obj.Rtn());
// here is the issue.
//How to get the return value of Rtn();
//I want to use the loop and the concept of polymorphism

}
}
}
public class Cls1
{
public string Rtn()
{
return "From Cls1";
}
}
public class Cls2
{
public string Rtn()
{
return "From Cls2";
}
}

public class Cls3
{
public string Rtn()
{
return "From Cls3";
}
}

[Jeff Louie]

Praveen... Polymorphism, having more than one form, can be implemented
using
interfaces, abstract classes or events. Whenever I see a long switch in
code, I
start thinking about a polymorphic solution. This tutorial may help:

http://www.geocities.com/jeff_louie/oop.htm

Regards,
Jeff

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

[Dave Sexton]

Hi Jeff,

I don't think that "events" have anything to do with "implementi ng"
polymorphism.

--
Dave Sexton

"Jeff Louie" <an*******@devd ex.comwrote in message
news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

Praveen... Polymorphism, having more than one form, can be implemented
using
interfaces, abstract classes or events. Whenever I see a long switch in
code, I
start thinking about a polymorphic solution. This tutorial may help:

http://www.geocities.com/jeff_louie/oop.htm

Regards,
Jeff

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

[Jeff Louie]

Hi Dave... IMHO, events/delegates can be looked at as type safe pointers
to
polymorphic methods.

http://www.geocities.com/jeff_louie/oop31.htm
http://msdn2.microsoft.com/en-us/library/ms173173.aspx

It took me a while to understand this, so that is why I am sticking my
neck out
here to so state this.

Regards,
Jeff

>I don't think that "events" have anything to do with "implementi ng"

polymorphism.<

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

[Dave Sexton]

Hi Jeff,

I'll agree with you that delegates implement polymorphism since they can be
late-bound to their targets, but not events. Events must be part of an
interface, which is already polymorphic in nature. It's the delegates
registered with the events that are polymorphic, not the event itself.

--
Dave Sexton

"Jeff Louie" <an*******@devd ex.comwrote in message
news:OZ******** ******@TK2MSFTN GP02.phx.gbl...

Hi Dave... IMHO, events/delegates can be looked at as type safe pointers
to
polymorphic methods.

http://www.geocities.com/jeff_louie/oop31.htm
http://msdn2.microsoft.com/en-us/library/ms173173.aspx

It took me a while to understand this, so that is why I am sticking my
neck out
here to so state this.

Regards,
Jeff

>>I don't think that "events" have anything to do with "implementi ng"

polymorphism.<

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

[Jeff Louie]

Hi Dave.. This is how I see it. Events and Delegates are intertwined in
NET. In
general they are often used in tandom. Delegates are type safe pointers
to a
polymorphic method. Events are used to simplify the use of Delegates.
When
you fire an event you are calling one or more polymorphic methods. This
type of
semantic debate is important but clouds the concept that polymorphism is
not
limited to interfaces and abstract classes in .NET.

I am trying to say that you can implement polymorphic behaviour in .NET
using
events _and delegates_. To some, this idea is new and may be an "aha"
moment.
I apologize if I was not clear in my original post.

Regards,
Jeff

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

[Dave Sexton]

Hi Jeff,

When
you fire an event you are calling one or more polymorphic methods. This
type of
semantic debate is important but clouds the concept that polymorphism is
not
limited to interfaces and abstract classes in .NET.

I disagree.

My point is that delegates are providing the polymorphism, not the events.
Events are just a construct that aggregates delegates for private
invocation.

When you write, "you can implement polymorphic behaviour in .NET using
events _and delegates_.", I disagree that "events" have anything to do with
it. Delegates being added to an "event" are polymorphic regardless. Adding
delegates to an event does not provide any further polymorphic aspects to
the already late-bound delegates. An event itself, being part of a class
definition or interface, may be polymorphic in the sense that it's
implemented or inherited, just like a public property. Public properties
alone are not polymorphic and neither are events.

I think the key here is that Typed delegates derive from System.Delegate ,
which is why delegates are polymorphic - inheritance. Events are not
objects, so they cannot be polymorphic.

To say that you can use events to implement polymorphism is like saying you
can use public properties to implement polymorphism, when in fact it's
actually inheritance and interfaces that are required for polymorphism, not
the class members.

--
Dave Sexton

"Jeff Louie" <an*******@devd ex.comwrote in message
news:uQ******** ******@TK2MSFTN GP03.phx.gbl...

Hi Dave.. This is how I see it. Events and Delegates are intertwined in
NET. In
general they are often used in tandom. Delegates are type safe pointers
to a
polymorphic method. Events are used to simplify the use of Delegates.
When
you fire an event you are calling one or more polymorphic methods. This
type of
semantic debate is important but clouds the concept that polymorphism is
not
limited to interfaces and abstract classes in .NET.

I am trying to say that you can implement polymorphic behaviour in .NET
using
events _and delegates_. To some, this idea is new and may be an "aha"
moment.
I apologize if I was not clear in my original post.

Regards,
Jeff

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