Ändern der Eigenschaft Typ in der Klasse implementiert das interface, mit dem Objekt-Typ Eigenschaft

Schreibe ich eine TemplateEngine, die mir erlauben, meine eigenen markup in text-basierten Dateien. Ich bin zu wollen fügen Sie Steuerelemente wie plugins wie die Anwendung reift. Ich habe aktuell eine Struktur wie die folgende:

interface IControl
    string Id
    object Value

class Label : IControl
    string Id
    string Value

class Repeater : IControl
    string Id
    List<IControl> Value

Nun sehen Sie das seltsame Teil sofort in die Repeater-Klasse mit der Value-Eigenschaft. Ich hatte gehofft, dass mit dem Wert geben Sie als Objekt in die Schnittstelle würde mir erlauben, die Flexibilität zu erweitern, die Kontrollen, als ich entlang gehen. Der compiler hat das nicht gerne, und das aus gutem Grund, denke ich.

Bottom line: ich bin zu versuchen, um alle control-Klassen implementieren das gleiche interface haben, aber unterschiedliche Typen für die Value-Eigenschaft.

Hat jemand irgendwelche Vorschläge, wie dies zu erreichen?

Hinweis: Bitte gehen Sie nicht in die darauf hindeutet, Dinge, die wie verwenden, Spark View Engine für templates. Es gibt einen Grund, warum ich bin, was zusätzliche Arbeit für mich.

Was Fragen Sie?
LOL Sorry, ich könnte brauchen, um eine video-clip erklärt es ein wenig besser. versuchen, zu mehr details führen könnten, in einem Roman
Ich bin versuchen, um alle control-Klassen implementieren das gleiche interface haben, aber unterschiedliche Typen für die Value-Eigenschaft.
aktualisiert meine Antwort wieder mit einem neuen Beispiel :->

InformationsquelleAutor used2could | 2010-04-18

c#interface

Normalerweise die Repeater umsetzen würden, etwas anderes, wie ein IItemsControl zum Beispiel.

BEARBEITEN 1

(aus Gründen der Kürze entfernt)

EDIT 2

Ah okay, Sie können verwenden Sie immer explizite interface-Implementierung natürlich:

interface IControl
{
    string Id { get; set; }
    object Value { get; set; }
}

class Label : IControl
{
    public string Id { get; set; }
    public string Value { get; set; }

    object IControl.Value
    {
        get { return this.Value; }
        set { this.Value = (string)value; }
    }
}

class Repeater : IControl
{
    public string Id { get; set; }
    public IList<IControl> Value { get; set; }

    object IControl.Value
    {
        get { return this.Value; }
        set { this.Value = (IList<IControl>)value; }
    }
}

ja, das ist die einzige andere Weg, den ich denken konnte
+1, um herauszufinden, was der Mist ich war sogar im Gespräch über
lolz ... nur training meine Hellsicht Fähigkeiten :-> ... ich aktualisierte meine Antwort mit einem Beispiel.
Gutes Beispiel Herzm!!
Dies funktioniert möglicherweise nicht immer. Die explizite definition von Eigenschaften, falls abweichend von der lokalen Eigenschaften, dann wäre gefährlich. Siehe mein Beispiel.

InformationsquelleAutor herzmeister

3

können Sie auch Generika:
```
interface IControl<T> 
{
    string ID{get;set;}
    T Value{get;set;}
}

class SomeControl : IControl<string>
{
    public string ID{get;set}
    public string Value{get;set;}
}

class SomeOtherControl : IControl<int>
{
    public string ID{get;set}
    public int Value{get;set;}
}
```
Ich mag dieses besser als die explizite interface-Idee, wenn es nur einen return-Wert, der geändert werden muss. Aber ich denke, wenn Sie hatte mehrere Eigenschaften, die jeder zurückkehren würde, eine andere Art, würden Sie nicht haben wollen IControl. Zumindest würde ich Sie nicht. In diesem Fall würde ich empfehlen, die expliziten Schnittstellen.

Natürlich, dies würde nicht funktionieren, wenn Sie nicht über Zugriff auf den Quellcode des IControl.

Edit: hatte einen Tippfehler. Feste
- ja, den könnten wir Generika zu, ich habe darüber nicht nachgedacht, weil ich bin einer Gehirnwäsche unterzogen, die vom UI-design tools, die meist nicht auf, wie Steuerelemente mit generischen Typ-Parameter. 😉
- Ich dachte über Generika und es wurde abgelehnt, die von management. Etwas über es nicht einfach für Entwickler, die nicht so vertraut mit der Bibliothek die details... (ich sammeln Sie nur ein check)
- Im Rückblick auf diese Jahre später... Generika war die bessere Lösung. Danke @Joel.
InformationsquelleAutor Joel

Nein, der compiler nicht erlauben, denselben Namen Felder verschiedene Datentypen anders als das, was in der Schnittstelle definiert in abgeleiteten Klassen.

Den Eigenschaften (da keine Felder sind erlaubt im interface) sollte durchgeführt werden, in der Ableitung von Klassen und Sie müssen denselben Datentyp haben. So, können Sie wahrscheinlich tun es mit Eigenschaften ohne explizite Deklaration.

Allerdings, wenn Sie machen, Wert von einer Funktion zurückgegeben wird, dann funktioniert es, aber Sie müssen überprüfen Sie die zurück geben weil die return-Typen sollten passen für die Funktion, sonst erhalten Sie eine Fehlermeldung, dass die Schnittstelle die Funktion wurde nicht implementiert.

    interface IControl
    {
        object Value();
    }
    class A : IControl
    {
        string m_value = string.Empty;
        public object Value() { return m_value; }
    };
    class B : IControl
    {
        List<IControl> m_value = new List<IControl>();
        public object Value() { return m_value; }
    };
    ....
    object o = new B().Value();
    if (o is List<IControl>)
        MessageBox.Show("List");

[Update]

Sie müssen vorsichtig sein, wenn ausdrücklich die Definition der Körper, der Eigenschaften. Nachdem ein name für zwei Eigenschaften wäre gefährlich, wenn die Implementierung nicht sorgfältig durchgeführt.

Diese beiden Eigenschaften, wenn die verschiedene definition, wäre es erklärbar, die für die endgültige Verwendung des interface-und Klassen.

        public IList<IControl> Value
        object IControl.Value

Diesem Beispiel sehen:

    ...
    class Repeater : IControl
    {
        List<IControl> m_Value = new List<IControl>();
        public IList<IControl> Value
        {
            get { return this.m_Value; }
            set { this.m_Value = (IList<IControl>)value; }
        }
        object IControl.Value
        {
            get
            {
                return this.m_Value;
            }
            set
            {
                this.m_Value = new List<IControl>();
                this.m_Value.Add(new Label());
                this.m_Value.AddRange((List<IControl>)value);
            }
        }
    }
    ...
    Repeater b = new Repeater();
    IControl i = b;
    List<IControl> list = new List<IControl>();
    list.Add(new Repeater());
    i.Value = list;

Können Sie beobachten, dass in der Liste container-Repeater haben unterschiedliche Werte, wenn Daten Hinzugefügt, die über IControl (wegen der expliziten definition der IContainer.Wert).

+1 vielen Dank für den Hinweis auf das Anliegen explizit definieren einer Eigenschaft.

InformationsquelleAutor Nayan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.