级联多个接口的扩展方法？

Question

I have multiple interfaces that my objects can implement. I am wondering if there is a way to "cascade" one extension method into another while using the same method name. I may be looking at this all wrong, but here is an example:

public interface IBaseDto
{
     int Id {get;set;}
     string CreatedByFullName {get;set;}
}

public interface IDocumentDto
{
     List<ContactDto> Subscriptions {get;set;}
}

public class ContactDto: IBaseDto
{
     public int Id {get;set;}
     public string CreatedByFullName {get;set;}
     public string FirstName {get; set}
     public string LastName {get;set;}
}

public class MeetingDto: IDocumentDto
{
     public int Id {get;set;}
     public string CreatedByFullName {get;set;}
     public List<ContactDto> Subscriptions {get;set;}
}

So, let's say I want to convert the DTOs into entities using an extension method. An example would be MeetingDto.ToEntity() ;

I am trying to think if I can write part of the extension method for an IBaseDto , another for the IDocumentDto and then for each concrete implementations for just their own properties. When I call MeetingDto.ToEntity() it would first hit the meeting extension method and call the IDocumentDto version, fill in what it needed, and then the IDocumentDto would call the IBaseDto . I hope this makes sense.

UPDATE:

I came up with this and it works pretty well:

public static TBaseDto ToEntity<TBridgeDto>(this TBaseDto dto) where TBaseDto: IBaseDto
        {
...            
return dto;
        }


        public static TDocumentDto ToEntity<TDocumentDto>(this TDocumentDto dto, IDocumentDto currentDto) where TDocumentDto : IDocumentDto
        {
...            
return dto.ToEntity();
        }

        public static MeetingDto ToEntity(this RfiDto dto)
        {
...            
return dto.ToEntity(dto)

        }

Answer 1

Yes you can..... just cast to the interface you want...

eg

 interface I1
    {
        int Id { get; set; }
    }

    public interface I2
    {
        string Name { get; set; }
    }

    public class Blah : I1, I2
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    static class ExtendIt
    {
        public static void ToEntity(this I1 x)
        {
            x.Id = 1;
        }

        public static void ToEntity(this I2 x)
        {
            x.Name = "hello";
        }

        public static void ToEntity(this Blah x)
        {
            (x as I1).ToEntity();
            (x as I2).ToEntity();
        }


    }

Answer 2

Like this?

public static class Helper
{
    public static void ToEntity(this MeetingDto source)
    {
        Console.WriteLine ("MeetingDto.ToEntity");
        //Do Stuff
        (source as IDocumentDto).ToEntity();
    }

    public static void ToEntity(this ContactDto source)
    {
        Console.WriteLine ("ContactDto.ToEntity");
        //Do Stuff
        (source as IBaseDto).ToEntity();
    }

    public static void ToEntity(this IDocumentDto source)
    {
        Console.WriteLine ("IDocumentDto.ToEntity");
        //Do Stuff
        foreach (var element in source.Subscriptions)
        {
            element.ToEntity();
        }
    }

    public static void ToEntity(this IBaseDto source)
    {
        Console.WriteLine ("IBaseDto.ToEntity");
        //Do Stuff        
    }
}

Answer 3

Extension methods are static, and as such they cannot be overridden using inheritance.

If you want it to apply to every element, why not just have both interfaces implement a 3rd interface with your ToEntity method?

If you can't modify those classes, then consider something akin to the IConverer interface. Have an interface with a method that takes...something, and returns an entity. (It could be generic.) This way you are separating out the code to convert each of those types to entities, much as you would with extension methods.