Inheritance - issue with Constructors

[Doug]

I have a public abstract class that I want to inherit from in two other
classes. My public abstract one has a constructor with several
parameters. For some reason I cannot get to that constructor unless I
create a constructor in my two other classes like this:

public ClassName(strin g szParameter1, string szParameter2, string
szParameter3) : base(szParamete r1, szParameter2, szParameter3)
{
}

This doesn't make sense to me. The reason I did this was to save on
code and now I've essentially got my parameters listed 2 times more
than I thought I'd need for each class that inherits from the abstract
one.

Is there a better way to do this?

[Mattias Sjögren]

This doesn't make sense to me.
Yes it does, constructors aren't inherited.

Is there a better way to do this?

No you're doing it the right way.

Mattias

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

[Mattias Sjögren]

This doesn't make sense to me.
Yes it does, constructors aren't inherited.

Is there a better way to do this?

No you're doing it the right way.

Mattias

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

[Peter van der Goes]

"Doug" <dn******@dtgne t.com> wrote in message
news:11******** *************@l 41g2000cwc.goog legroups.com...

I have a public abstract class that I want to inherit from in two other
classes. My public abstract one has a constructor with several
parameters. For some reason I cannot get to that constructor unless I
create a constructor in my two other classes like this:

public ClassName(strin g szParameter1, string szParameter2, string
szParameter3) : base(szParamete r1, szParameter2, szParameter3)
{
}

This doesn't make sense to me. The reason I did this was to save on
code and now I've essentially got my parameters listed 2 times more
than I thought I'd need for each class that inherits from the abstract
one.

Is there a better way to do this?

First, read Mattias' answer. Similarly, destructors are not inherited.
Second, if by "better" you mean simpler, you can consider defining and using
a default constructor in the base class, thus avoiding the:

: base(szParamete r1, szParameter2, szParameter3)

But, if the derived class constructor's parameters are needed as arguments
to the base class constructor, that won't work for you.

--
Peter [MVP Visual Developer]
Jack of all trades, master of none.

[Peter van der Goes]

"Doug" <dn******@dtgne t.com> wrote in message
news:11******** *************@l 41g2000cwc.goog legroups.com...

I have a public abstract class that I want to inherit from in two other
classes. My public abstract one has a constructor with several
parameters. For some reason I cannot get to that constructor unless I
create a constructor in my two other classes like this:

public ClassName(strin g szParameter1, string szParameter2, string
szParameter3) : base(szParamete r1, szParameter2, szParameter3)
{
}

This doesn't make sense to me. The reason I did this was to save on
code and now I've essentially got my parameters listed 2 times more
than I thought I'd need for each class that inherits from the abstract
one.

Is there a better way to do this?

First, read Mattias' answer. Similarly, destructors are not inherited.
Second, if by "better" you mean simpler, you can consider defining and using
a default constructor in the base class, thus avoiding the:

: base(szParamete r1, szParameter2, szParameter3)

But, if the derived class constructor's parameters are needed as arguments
to the base class constructor, that won't work for you.

--
Peter [MVP Visual Developer]
Jack of all trades, master of none.

[Nick Malik [Microsoft]]

Normally, when folks say "This doesn't make sense to me", that tells me that
you expected one thing, but the framework gave you another thing. Can you
tell us what you expected would happen?

--
--- Nick Malik [Microsoft]
MCSD, CFPS, Certified Scrummaster
http://blogs.msdn.com/nickmalik

Disclaimer: Opinions expressed in this forum are my own, and not
representative of my employer.
I do not answer questions on behalf of my employer. I'm just a
programmer helping programmers.
--

[Doug]

Thanks for both of your responses. Unfortunately, I do need a
constructor with parameters in the base class because both of my
inherited ones need that same constructor. So I'll have to go with
what I'm doing. Thanks again.

[Nick Malik [Microsoft]]

Normally, when folks say "This doesn't make sense to me", that tells me that
you expected one thing, but the framework gave you another thing. Can you
tell us what you expected would happen?

--
--- Nick Malik [Microsoft]
MCSD, CFPS, Certified Scrummaster
http://blogs.msdn.com/nickmalik

Disclaimer: Opinions expressed in this forum are my own, and not
representative of my employer.
I do not answer questions on behalf of my employer. I'm just a
programmer helping programmers.
--

[Doug]

Thanks for both of your responses. Unfortunately, I do need a
constructor with parameters in the base class because both of my
inherited ones need that same constructor. So I'll have to go with
what I'm doing. Thanks again.

[Doug]

I didn't realize Constructors were not inherited. I thought that by
having an abstract class that two other classes inherited from that I
could essentially have this:

public abstract class AbstractClass
{
decimal m_m1;
decimal m_m2;
decimal m_m3;

public AbstractClass(d ecimal m1, decimal m2, decimal m3)
{
m_m1 = m1;
m_m2 = m2;
m_m3 = m3;
}
}

public class InheritedClass1 : AbstractClass
{
}

public class InheritedClass2 : AbstractClass
{
}

And then I could call one of the Inherited Classes like this:

InheritedClass1 oNewClass = new InheritedClass1 (m1, m2, m3);

and that by doing this, that this line would go to the Constructor in
AbstractClass. This saves a lot of code for me. Instead I have to do
this for my inherited classes:

public class InheritedClass1 : AbstractClass
{
public InheritedClass1 (decimal m1, decimal m2, decimal m3) :
base (m1, m2, m3)
{
}
}
public class InheritedClass2 : AbstractClass
{
public InheritedClass2 (decimal m1, decimal m2, decimal m3) :
base (m1, m2, m3)
{
}
}

It still saves some code, but it seems like some excess to me that I
have to have a constructor in my Inherited classes and that I have to
repeate the parameters in the base entry as well. But I think I know
why now.