Inheritence problem in C#

Question

3.00/5 (1 vote)

See more:

As a test for the forum and also because I don't know a good solution.

I've got a low down base class with a protected method that is overridden on implimentations, something like:

class Foo 
{
  protected Bar()
  {
    // base work
  }
}

class Tang : Foo
 {
  protected override Bar()
  {
    // my bits
    base.Bar();
  }
}

Now I want to have a wrapper class that can take ANY derived Foo (say a Tang) and do its wrapper work then call out to the wrapped Foo.

Class Outside : Foo
{
  private Foo wrapped;

  Outside (Foo wrapped)
      : base()
  {
    this.wrapped = wrapped;
  }

  protected override Bar()
  {
    // my bits
    // then call the wrapped one:
    this.wrapped.Bar();
  }
}

Now because Bar is protected and Outside is in a different namespace to Foo so I can't call wrapped. Any idea of a what or how [-700 for suggesting any change to Foo, it is off limits]

[Additional Information]

I'm still fiddling, we did a nasty to get things working but it wasn't ideal; this was based on the WrappedFoo solution.

The big problem is that Foo's namespace is off-limits, it's in the core infrastructure, and we need a solution in the Tang namespace.

Posted 10-Sep-09 3:07am

Nagy Vilmos

Updated 22-Nov-09 22:13pm

v7

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

0x3c0 · Accepted Answer · 2009-09-10T06:35:00

This isn't my strong point, but perhaps you could cast wrapped before calling Bar? If that doesn't work, then you could use Reflection, in some method like this:

C#

Type tp = this.wrapped.GetType();
Type baseType = tp.BaseType;
MethodInfo baseMethod = baseType.GetMethod("Bar", BindingFlags.DeclaredOnly | BindingFlags.IgnoreCase);

baseMethod.Invoke(this.wrapped, arguments);

If DeclaredOnly doesn't work, then you could try FlattenHierarchy. I haven't tested that, but it might work

I updated your post to fix a spelling error in the title by the way.

J4amieC · Accepted Answer · 2009-09-10T23:39:00

How about a wrappable foo class:

C#

class WrappableFoo : Foo
{  
      public void CallBar()
      { 
             base.Bar(); 
      } 
}

Tang must then inherit WrappableFoo

C#

class Tang : WrappableFoo
 {
  protected override Bar()
  {
    // my bits
    base.Bar();
  }
}

And Outside must always take a WrappableFoo

C#

Class Outside : Foo
{
  private WrappableFoo wrapped;

  Outside (WrappableFoo wrapped)
      : base()
  {
    this.wrapped = wrapped;
  }

  protected override Bar()
  {
    // my bits
    // then call the wrapped one:
    this.wrapped.CallBar();
  }
}

Inheritence problem in C#

2 solutions

Solution 1

Solution 2

Add your solution here

Preview 0