Есть такой тип object. С ним можно вытварять очень много. Есть так же рефлексия с помощью которой хочть черта лысого можно динамически вызвать. Но C# — это статически типизированный язык. Если хотити динамики, то их есть у меня. Есть VB.NET с той самой "утиной типизацией", кстати в 9.0 с ней даже по круче будет. Там придумали "утиные интерфесы" — т.е. описываешь интерфейс как "утиный" и приводишь в рантайме к нему любой объект... если у объектоа методы совпадают, то можно вызвать методы через утиный интерфейс. Что это дает? А тот самый комплит ворд и подсказки среды, плюс еще возможность обнаружить ошибку при инициализации ссылки на интерфейс, а не при вызове 101-вого метода. Далее создали динамические переменные. Когда можно намисать та:

a = "SomeMethodName"
...
b.a(x, y)

за синтаксис не ручвюсь, но смысл думаю понятен.
Но это все из другой оперы. Это все для скриптов. А в нормальных ОО-программах типизация должна быть типзацией, а не утиными историями.

Java/C# не являются ни развитием, ни "осознанием ошибок" C++. Они взяли наихудшую парадигму из языка и возвели ее в степень догмы. А именно — идею наследования. Наследование — это самая большая провокация в индустрии. Ни в каком моделировании наследования не существует и в реальной жизни тоже — ни в электронике, ни в бухгалтерии, ни где бы то ни было еще. Есть одно — генеология. Но это не имеет ни малешего отношения к тому, что называется наследованием в программировании. Все эти многоэтажные иерархии классов только усложняют жизнь, вместо того, чтобы упрощать. И служат они одной единственной цели — раздувать и дальше этот мыльный пузырь и продолжать кормить миллиарды индусов. В результате этой идеи возникла дутая индустрия, не обеспеченная никакими реальными активами. А вся мировая практика говорит о том, что рано или поздно этот пузырь лопнет.

def load_header_and_data( stream )
    h = load_header( stream )
    if stream.respond_to( "seek" )
        stream.seek( h.get_length() )
    else
        stream.read( h.get_length() )
    end
    load_data( stream )
end

template <class T, T val>
struct member_wrapper{};

template <class T>
char test_for_seek(const T&, member_wrapper<void (T::*)(size_t), &T::seek>* p = 0);

template <class T>
double test_for_seek(const T&, ...);

template <class T>
struct has_member_seek
{
    static T t;
    static const bool value = (1 == sizeof(test_for_seek(t)));
};

template<bool b>
struct seeker
{
    template <class T>
    static void seek( T & stream, size_t off )
        {
            std::vector< char > buf( off );
            stream.read( &buf[ 0 ], off );
        }
};

template<>
struct seeker<true>
{
    template <class T>
    static void seek( T & stream, size_t off )
        {
            stream.seek( off );
        }
};

template <class T>
void seek( T & stream, size_t off )
{
    seeker< has_member_seek< T >::value >::seek( stream, off );
}

template< class T >
void load_header_and_data( T & stream )
{
    Header h = load_header( stream );
    seek( stream, h.get_length() );
    load_data( stream );
}

FR>Так вроде Duck typing обобщенное программирование в чистом виде, а это довольно старая парадигма

In computer science, generics is a technique that allows one value to take different datatypes (so-called polymorphism) as long as certain contracts such as subtypes and signature are kept. The programming style emphasizing use of this technique is called generic programming.

void LoadHeaderAndData( T stream )
{
    Header h = LoadHeader( stream );
    if( stream.HasMethod( "Seek" ) )
        stream.Seek( h.GetLength() );
    else
        stream.Load( h.GetLength() );
    LoadData( stream );
}

class SmartType<T>
where T: ICountable
{
  public static int q(T param) { return t.Count;}
}

void LoadHeaderAndData( T stream )
{
    Header h = LoadHeader( stream );
    if( has_method(stream, Seek) )
        stream.Seek( h.GetLength() );
    else
        stream.Load( h.GetLength() );
    LoadData( stream );
}

public void LoadHeaderAndData(Stream stream)
{
  Header h = LoadHeader(stream);
  if(stream.CanSeek())
    stream.Seek(h.GetSkipLength());
  else
  {
    byte[] buffer = new byte[h.GetSkipLength()];
    stream.Read(buffer, 0, h.GetSkipLength());
  }
  LoadData(stream);
}

E>def load_header_and_data( stream )
E>    h = load_header( stream )
E>    if stream.respond_to( "seek" )
E>        stream.seek( h.get_length() )
E>    else
E>        stream.read( h.get_length() )
E>    end
E>    load_data( stream )
E>end
E>

E>template< class T >
E>void load_header_and_data( T & stream )
E>{
E>    Header h = load_header( stream );
E>    seek( stream, h.get_length() );
E>    load_data( stream );
E>}
E>

template<typename T> seek(T,int);
template<> seek<File>(File _f, int _bytes);
template<> seek<Soket>(Soket _s, int _bytes);

class File
{
...
void skip(int _bytes){seek(_bytes);}
...
}
class Socket
{
...
void skip(int _bytes){read(_bytes);}
...
}

def load_header_and_data( stream )
    h = load_header( stream )
    if stream.respond_to( "seek" )
        stream.seek( h.get_length() )
    else if stream.respond_to( "move" ) //и такие хаки - еще в 18 местах...
        stream.move( h.get_length() )
    else
        stream.read( h.get_length() )
    end
    load_data( stream )
end