如何实现泛型类装饰器的复制方法？

Question

Imagine you have a generic interface that defines a generic value and a copy constructor like this (replacing ICloneable):

// T: type of value to hold, TU: type of the class itself
interface ICopyable<T,TU> where TU: ICopyable<T,TU> {
    T Value { get; set; }
    TU Copy();
}

This could be implemented by a boolean value holder like this:

class BooleanHolder : ICopyable<Boolean, BooleanHolder> {
    public BooleanHolder Copy() { 
        return new BooleanHolder(){ Value = Value }; 
    }
}

Now comes the question: How would you define a decorator class that holds another ICopyable? My not working idea was:

class DecoratingHolder<T,TU> : ICopyable<ICopyable<T,TU>, DecoratingHolder<T,TU>> {
    public DecoratingHolder<T,TU> Copy {
        // won't compile as Value is of type T and not of type ICopyable<T,TU> 
        // as I expected - why is that?
        return new DecoratingHolder<T,TU>(){ Value = Value.Copy };
    }
}

Note that I called Copy to also have the value of type ICopyable<T,TU> copied, this is on purpose to ensure deep copies.

So what do I have to change to make this structure work?

Answer 1

You might just need to add a constraint. You define that ICopyable<T, TU> where TU : ICopyable<T, TU> but in your DecoratingHolder , you never explicitly constraint TU as such on DecoratingHolder .

More specifically, I think it's this part of the line:

class DecoratingHolder<T,TU> : ***ICopyable<ICopyable<T,TU>***

That's causing the issue. You're defining a ICopyable<T,TU> type, but TU has not been constrained to be ICopyable<T, TU> . (one might be able to infer that from the rest of the class declaration/inheritance, but the compiler doesn't) Once you add the constraint, then the compiler knows that Value is a compatible ICopyable<T,TU> type.

This compiles fine for me (had to fix some other minor things with the pseudocode you provided):

class DecoratingHolder<T,TU> : ICopyable<ICopyable<T,TU>, DecoratingHolder<T,TU>> 
    where TU : ICopyable<T,TU>
{
    public ICopyable<T,TU> Value { get; set; }

    public DecoratingHolder<T,TU> Copy() {
        return new DecoratingHolder<T, TU>(){ Value = Value };
    }
}

EDIT: In retrospect, do you even need that constraint on ICopyable ? Seems to not do much as you already generically define the outgoing type anyway. Unless you have code elsewhere that depends on the fact that it returns ICopyable<T, TU> for some reason (it would inherently anyway as it would return a strongly typed TU or BooleanHolder or DecoratingHolder ) then consider dumping it.

interface ICopyable<T,TU>
{
    T Value { get; set; }
    TU Copy();
}

class BooleanHolder : ICopyable<Boolean, BooleanHolder> 
{
    public bool Value { get; set; }
    public BooleanHolder Copy() { 
        return new BooleanHolder(){ Value = Value }; 
    }
}

class DecoratingHolder<T,TU> : ICopyable<ICopyable<T,TU>, DecoratingHolder<T,TU>> 
{
    public ICopyable<T,TU> Value { get; set; }

    public DecoratingHolder<T,TU> Copy() {
        return new DecoratingHolder<T, TU>(){ Value = Value };
    }
}

EDIT: From your comment requiring a deep copy, keep the constraints then (you'll need them), and invoke Copy on Value (sorry, I must have missed that detail)

class DecoratingHolder<T,TU> : ICopyable<ICopyable<T,TU>, DecoratingHolder<T,TU>> 
    where TU : ICopyable<T,TU>
{
    public ICopyable<T,TU> Value { get; set; }

    public DecoratingHolder<T,TU> Copy() {
        return new DecoratingHolder<T, TU>(){ Value = Value.Copy() };
    }
}

The Copy methods for any given class should then make sure they perform a deep copy. (I would suggest renaming Copy to DeepCopy if your framework needs them to be deep copy and you don't want implementations to do shallows accidentally)

Answer 2

A cast worked for me:

    public DecoratingHolder<T, TU> Copy()
    {
        return new DecoratingHolder<T, TU>() { Value = (ICopyable<T, TU>)Value.Copy() };
    }

I guess in this context the compiler doesn't go as far as to establish that TU and ICopyable<T, TU> is the same thing.