How to properly define and call a method on a derived class in C# with an unknown type parameter -

i trying define "transformation" class responsible returning simplified array object based on complex type. class accomplish via "transform" method accepts complex type. based on fractal (http://fractal.thephpleague.com/transformers/), trying implement similar in c#.

so far, have defined abstract base transformerabstract class contains properties , methods common every derived transformer class:

public abstract class transformerabstract {     public abstract object transform(object entity); } 

i struggling how implement transform method, because need know complex type can create transformation, different every derived transformation class (for example: cycletransformer, etc.)

 public class cycletransformer : transformerabstract  {     public override object transform(object entity)     {         throw new notimplementedexception();     } } 

i have several other places in applicationwhere want able transform data - example, take following snippet:

    protected object[] firetransformer(transformerabstract transformer, object data)     {         var includeddata = new object();          var transformeddata = transformer.transform(data);          if (transformerhasincludes(transformer))         {             includeddata = fireincludedtransformers(transformer, data);             //serialize & merge includes         }          object[] returndata = new object[1];         returndata[0] = transformeddata;         returndata[1] = includeddata;          return returndata;     } 

i appear have 2 problems:

1. i can't mark method abstract because need know entity type.
2. if mark method virtual code calls base class instead of derived one, though can see @ run time via debugging correct instance of class generated.

i tried using generics on (e.g. transformerabstract<t> : itransformer<t>) forced me supply type constraint on class uses transformerabstract, thought overly restrictive.

i'd stop using object , instead use interfaces.

interface itransformresult<t> {  }  interface itransformable<t> {  }  interface itransforminclude<t> {  }  interface itransformer<t> {     itransformresult<t> transform(itransformable<t> data);     bool hasincludes { get; }      ienumerable<itransforminclude<t>> fireincludes(itransformable<t> data); }  class transformeddata<t> {     public itransformresult<t> result { get; set; }     public ienumerable<itransforminclude<t>> includes { get; set; } } 

now have typed structure function simple as:

protected transformeddata<t> firetransformer<t>(itransformer<t> transformer,                                                 itransformable<t> data) {     return new transformeddata<t>     {         result = transformer.transform(data),         includes = transformer.hasincludes                     ? transformer.fireincludes(data)                     : null     }; }