2

I have recently came to this dilemma: let's say I want to use two libraries each of them defines a interface for a consumer and a consumable:

#region Library A 
// This region represents a library (A) defining some interfaces

/// <summary>
/// Interface to be implemented by any processor of type A
/// </summary>
interface AProcessor
{
    void Process(AProcessable a);
}

/// <summary>
/// Interface to be implemented by any object processable by a processor of type A
/// </summary>
interface AProcessable
{
    int MyPropertyA { get; set; }
}
#endregion


#region Library B
// This region represents a library (B) defining some other interfaces

/// <summary>
/// Interface to be implemented by any processor of type B
/// </summary>
interface BProcessor
{
    void Process(BProcessable a);
}

/// <summary>
/// Interface to be implemented by any object processable by a processor of type B
/// </summary>
interface BProcessable
{
    int MyPropertyB { get; set; }
}
#endregion

Then, on my application, I implement a consumable type that implements both consumable interfaces from each library:

/// <summary>
/// A type processable by processors of type A and processors of type B.
/// </summary>
class Processable :
    AProcessable,
    BProcessable
{
    // Implements interface AProcessable
    public int MyPropertyA { get; set; }

    // Implements interface BProcessable
    public int MyPropertyB { get; set; }
}

And I implement a consumer type capable of consume objects of type Processable, which implements AProcessable and BProcessable:

/// <summary>
/// A processor that implements an A-type processor and a B-type processor.
/// </summary>
class Processor : 
    AProcessor, 
    BProcessor
{
    // I thought that Process method would implement AProcessor.Process() and
    // BProcessor.Process() as it expects a Processable object as parameter which
    // implements AProcessable and BProcessable, but it doesn't.
    // Compiler rises an error telling that Processor doesn't implement neither
    // AProcessor.Process() nor BProcessor.Process()
    /*
    public void Process(Processable a)
    {
        throw new NotImplementedException();
    }
    */


    // Implementing both methods does not work because it creates ambiguity: when
    // we call Processor.Process(p) being "p" a Processable object the compiler 
    // doesn't know if it has to call Processor.Process(AProcessable) or
    // Processor.Process(BProcessable).
    /*
    public void Process(AProcessable a)
    {
        throw new NotImplementedException();
    }

    public void Process(BProcessable a)
    {
        throw new NotImplementedException();
    }
    */
}

¿What's my design error and what would be the correct approach?

Thanks in advance.

Improve this question

5 Answers 5

Reset to default
4

You are looking for Explicit Interface implementations. This link has a tutorial:

http://msdn.microsoft.com/en-us/library/aa288461(v=vs.71).aspx

Basically, the method signature shows the interface type:

void BProcessor.Process(BProcessable b)
{

}

And can only be accessed with a direct reference to BProcessor:

BProcessor b;
b.Process(null);

An inferred reference to BProcessor will not work with explicit implementations:

Processor p;
p.Process(new BProcessable()); // This won't compile.

This allows you to implement interfaces that have conflicting member names. If they have conflicting type names, you then need to start looking into namespace conflicts.

You'll notice an explicit implementation because when you get Intellisense for Processor it will be missing Process(BProcessable b).

If your code for handling process happens to be shared, you can do the following:

public void Process(Processable p)
{

}

void AProcess.Process(AProcessable a)
{
    Process((Processable)a);
}

void BProcess.Process(BProcessable b)
{
    Process((Processable)b);
}

However, personally I'd avoid this type of forward casting as you aren't guaranteed (other than you being in full control of the code) to get given a Processable type.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Yeah! That makes sense. Anyway, as AProcess.Process(AProcessable a) and BProcess.Process(BProcessable b) are private the compiler still complaints about interfaces not being implemented. Below Francesco points to a similar solution making those methods public and avoiding explicit interface implementation that wroks fine. I would love to keep them private but I understand it's not possible. Thank you very much.
@David ah I see, good spot by him. To be honest I hadn't looked too deeply into the type structure you were using. Interface members are required to be public, as the interface is designed to be used by other code. A private interface member makes no sense.
2

Use explicit interface implementations:

void AProcessor.Process(AProcessable a)
{
    throw new NotImplementedException();
}

void BProcessor.Process(BProcessable a)
{
    throw new NotImplementedException();
}

Using explicit interface implementations disable automatic lookup of what method to call. When you call those methods you need to cast the object to an interface:

Processor p;
Processable pa;
((AProcess)p).Process(pa);

Except for handling this situation with conflicting names/method signatures explicit implementations can also be used to hide (or at least make it harder to use) methods that are required by an interface, but isn't making sense for a specific class.

Improve this answer

1 Comment

I didn't know about explicit implementation. Thank you very much for your help.
1

I don't think that explicit interface implementation is needed here, since there is no collision between the signatures of the two processing methods (the type of the argument is AProcessable for AProcessor and BProcessable for the second). Since I immagine that for Processable instances you want both the processing to be executed, I would implement it this way:

public class Processor : AProcessor, BProcessor
{
    #region AProcessor Members

    public void Process(AProcessable a)
    {
        throw new Exception("The method or operation is not implemented.");
    }

    #endregion

    #region BProcessor Members

    public void Process(BProcessable a)
    {
        throw new Exception("The method or operation is not implemented.");
    }

    #endregion

    public void Process(Processable a)
    {
        Process((AProcessable)a);
        Process((BProcessable)a);
    }
}
Improve this answer

2 Comments

Yeah dude, it made the trick. It would be perfect if I could keep Process(AProcessable) and Process(BProcessable) private, but I think it's not going to be possible. Thank you very much.
It's not possible to have them private because, as Adam wrote, everything belonging to an interface has to be public
0

In your first attempt, with one method, you are not implementing the precise definition form the interface, which does not want a Processable object as a parameter, but an AProcessable and BProcessable, depending on which one you want.

The second, as others have pointed out, needs to use explicit implementations, so that you can clearly define which of the two you want to call.

If you want to call both of them, then you need to make two separate calls - you could implement a method Process wihtin the class, and call AProcessable.Process and BProcessable.Process. But it has to be done explicitly, not just through inheritance and interfaces.

Improve this answer

1 Comment

Your solution is in the line of the other solutions. They helped me a lot. Thank you.
0

Everyone has provided fine explainations for the technical reasons why the code isn't working, however I assume you understand these as your question asked what the design issue is and how to solve it.... so I'll add my 2c into the mix.

Basically you are trying to two mix two otherwise completely distinct concepts into one logical controlling piece of code (the Processor class).

By defining two different things that can be processed and two means by which processors of those things must behave you are setting about defining a system that processes two distinct things in completely different ways... therefore they are not the same and can't be combined.

As for another solution on how to "fix" the problem (I use the word fix lightly as it's hard to suggest an alternate solution without knowing the context of the problem you solving) you really need to find a way to represent the two processable types and processors in a common way.... or just not mix the two concepts in the concrete Processor implementation.

Knowing more about the actual context of the problem would help us give a more accurate suggestion! :)

Good luck!

Improve this answer

1 Comment

Yeah, you're right. I unterstood why it didnt' work and I suspected of a bad design problem. I understand that what I'm trying to do is a little tricky. It makes sense in the context I'm working in, but I also understand that it's not a common scenario. Your abstractions made me clarify some ideas. Thank you.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.