CODEWITHSUNDEEP
dojoscript#
Matt Tsōnto
Matt Tsōnto

Reputation: 1701

Multiple inheritance in Script#

I'm trying to make a Script# import library to wrap (parts of) the dojo toolkit--especially the dijit widgets. Unfortunately, dojo uses multiple inheritance, and C# doesn't support that (except for interfaces, which Script# doesn't handle properly--see below).

I'm trying to accomplish something like this:

[Imported]
public class A
{
   public void Foo() {}
}
[Imported]
public class B
{
   public void Bar() {}
}
[Imported]
public class C : A, B
{
   public void Sproing() {}
}

but obviously that's not valid C#, and therefore isn't valid Script#.

Is there a way in Script# to accommodate multiple inheritance of [Imported] classes? I tried using interfaces, since C# supports multiple inheritance of them and I'm not providing implementations anyway: [Imported] public interface A { void Foo(); } [Imported] public interface B { void Bar(); } [Imported] public interface C : A, B { void Sproing(); } however, when I try to use the library from another Script# project, code such as C c = null; c.Foo(); I just get a "Check that your C# source compiles and that you are not using an unsupported feature. Common things to check for include use of fully-qualified names (use a using statement to import namespaces instead) or accessing private members of a type from a static member of the same type." error on the c.Foo() call.

Any other ideas? The [Mixin] attribute doesn't appear to do what I need either.

The only other option I see at the moment (aside from fixing the interfaces problem in Script#, which I'm not prepared to do) is to ditch inheritance altogether and put all the "inherited" members in each leaf class. That would look something like this:

[Imported]
public class A
{
   public void Foo() {}
}
[Imported]
public class B
{
   public void Bar() {}
}
[Imported]
public class C
{
   public void Foo() {}
   public void Bar() {}
   public void Sproing() {}
}

Obviously that would get ugly fast, but I could automate it. Since JavaScript's type system is pretty fast-and-loose anyway, this might even work OK there. And in Script# land, consumers of the import library would simply need to do more explicit casts than they should need to do. Are there other disadvantages that I'm overlooking?

Upvotes: 0

Views: 156

Answers (1)

Nikhil Kothari
Nikhil Kothari

Reputation: 5225

Interface inheritance isn't currently supported. It will be fixed in a future rev.

You could define:

interface A {
}
interface B {
}
class C : A, B {
}

It does mean you'll end up having to define all members, even if stubs in C.

I haven't looked at Dojo in any depth, but potentially a better strategy will be to have a base class with methods shared across many of the widgets, and then derived widget types for each individual widget type. That would be something similar to the jQueryUI stuff that is in the script# repository.

Upvotes: 1

Related Questions