Очевидный способ для кастинга к объекты фактический тип

Разрешение таймеров в Windows ограничено примерно 10 миллисекундами, поэтому вы никогда не сможете получить значения времени с точностью до микросекунд.

Если ваши значения времени поступают из другого места, которое способно к такому разрешению, тогда возьмите эти значения за микросекунды. Умножение на 1000 или деление int на 1000 не даст вам лучшего разрешения, это просто изменит масштаб вашего сравнения.

Я думаю, что лучшим решением было бы сделать метод A виртуальным, а не иметь B-повторную реализацию, к которой присоединен интерфейс A (это может потребовать больше работы, чем просто переопределение одной функции), что вы можете сделать так (пример должен быть полным, кроме определения загрузочного интерфейса):

#include <glib-object.h>
#include "fooable.h"

typedef struct {GObject parent;} A;
typedef struct {
    GObjectClass parent;
    gint (*foo) (Fooable *self, gdouble quux);
} AClass;

#define TYPE_A           (a_get_type())
#define A_CLASS(cls)     (G_TYPE_CHECK_CLASS_CAST((cls), TYPE_A, AClass))
#define A_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_A, AClass))

gint a_foo_real (Fooable *self, gdouble quux) {
    g_print("a_foo_real(%g)\n", quux);
    return 5;
}

gint a_foo (Fooable *self, gdouble quux) {
    return A_GET_CLASS(self)->foo(self, quux);
}

void implement_fooable (FooableIface *iface) {iface->foo = a_foo;}
void a_class_init      (AClass *cls)         {cls->foo = a_foo_real;}
void a_init            (A *self)             {}

G_DEFINE_TYPE_WITH_CODE(A, a, G_TYPE_OBJECT,
    G_IMPLEMENT_INTERFACE(TYPE_FOOABLE, implement_fooable));

/* derive class B from A  */
typedef struct {A parent;} B;
typedef struct {AClass parent;} BClass;

#define TYPE_B (b_get_type())

gint b_foo_real (Fooable *self, gdouble quux) {
    g_print("b_foo_real(%g)\n", quux);
    return 55;
}

void b_class_init (BClass *cls) {A_CLASS(cls)->foo = b_foo_real;}
void b_init       (B *self)     {}

G_DEFINE_TYPE(B, b, TYPE_A);

int main () {
    g_type_init();
    A *a = g_object_new(TYPE_A, NULL);
    B *b = g_object_new(TYPE_B, NULL);
    fooable_foo(FOOABLE(a), 87.0); // a_foo_real(87.0) and returns 5
    fooable_foo(FOOABLE(b), 32.0); // b_foo_real(32.0) and returns 55
    return 0;
}

Это не менее краткий пример, чем я могу сделать это. При вызове fooable _ foo () функция просматривает свою таблицу vtable для функции, определенной при реализации интерфейса a _ foo () , которая просматривает таблицу vtable класса A, чтобы определить, какую функцию следует фактически вызвать. Определение класса B переопределяет класс A a _ foo _ real () своим собственным. Если для цепочки требуется b _ foo _ real класса B, это достаточно просто (используйте A _ CLASS (b_parent_class) - > foo () , который определен для вас в макросе G_DEFINE_TYPE)

Если все, что вы делаете, это вызываете ToString , из-за полиморфного характера C # ToString вызовет правильную реализацию, даже если все, что у вас есть, является ссылкой на Object.

Например:

var d=DateTime.Now;
object od=d;
Console.WriteLine(od.ToString());
Console.WriteLine(d.ToString());   //same as previous line