Interface und Extensions



  • Hallo Community,

    könnte ich mit folgendem Konzept auf Probleme stoßen?

    public interface IDataDriven { }
    
    public static class DataDrivenExtensions
    {
        public static void SetProperty<T>(this IDataDriven dataDriven, string propertyName, object value)
        {
            Type type = dataDriven.GetType();
            PropertyInfo propertyInfo = type.GetProperty(propertyName);
            if (propertyInfo != null)
            {
                propertyInfo.SetValue(dataDriven, value);
            }
        }
        public static T GetProperty<T>(this IDataDriven dataDriven, string propertyName)
        {
            Type type = dataDriven.GetType();
            PropertyInfo propertyInfo = type.GetProperty(propertyName);
            if (propertyInfo == null)
                return default(T);
    
            object value = propertyInfo.GetValue(dataDriven);
            return (T)value;
        }
    }
    

    Das benutze ich um Klassen, die bereits eine Basisklasse haben, dennoch weitere Funktionen visuell erben zu lassen.

    interface IDataDriven { }
    
    class A { }
    
    class B : A, IDataDriven { }
    
    b.GetProperty<int>("...");
    

    Ich habe sowas noch nicht in Verwendung gesehen, vielleicht weil es schlechter Stil ist oder nicht gebraucht wird. Ich denke es ist in Ordnung, was sagt ihr?

    Mit freundlichen Grüßen



  • Hi,

    kannst du bitte nochmal den konkreten Anwendungszweck erklären? Was soll "Funktionen visuell erben" lassen genau bedeuten? Willst du darüber in irgendeinerweise Mehrfachvererbung abbilden?

    MfG
    KaPtainCugel



  • Was machst du dann bei sowas?

    class Foo : IDataDriven
    {
        public int Bar
        {
            get;
            set;
        }
    }
    

    Aufruf:

    Foo foo = new Foo();
    foo.SetProperty<string>("Bar", "Peng");
    

    Mich interessiert auch der Anwendungsfall, vielleicht kann man das dann auch typsicher gestalten.



  • Danke für den Tipp. Ich hätte den Code wohl mehr reduzieren sollen, denn es geht weniger um die beiden Methoden, als das Konstrukt eines leeren Interfaces für welches ich Erweiterungsmethoden erstelle.
    Wie schon erwähnt, soll es eine Art Mehrfachvererbung sein.



  • Was bringt dir die "Mehrfachvererbung", wenn das Interface leer ist? Du weißt ja gar nicht, was hinter dem Objekt steht, das deine Erweiterungsmethoden bekommen. Das wird ja auch der Grund sein, weshalb du mit Reflection arbeitest. Typsicher wirst du es auf die Art und Weise nicht hinbekommen.



  • Hallo,

    einziges wo ich es mir vielleicht noch mit viel Biegen und Brechen sinnoll vorstellen könnte wäre für Xml-Serialisierung. Also etwas in Richtung:

    public interface IXmlSerializable
    {
    }
    
    public class MyDataObject : IXmlSerializable
    {
        public string Name { get; set; }
        public List<string> Entries { get; set; }
    }
    
    public static class IXmlSerializableExtensions
    {
        public static void Serialize(this IXmlSerializable dataObject, string path)
        {
           // .. run serialization
        }
    
        public static IXmlSerializable Deserialize(this IXmlSerializable dataObject, string path)
        {
           // ... run deserialization
        }
    }
    

Log in to reply