Get property by Name

  • VB.NET

Es gibt 11 Antworten in diesem Thema. Der letzte Beitrag () ist von Kagurame.

    Get property by Name

    Hallo,

    ich versuche gerade eine generische Validierung von Werten zu realisieren.

    In einem Konkreten Fall soll eine List(Of T) nach einem mitgegebenen String-Value suchen, der Name dieser Property ist aber vorher unklar (Es handelt sich hierbei um eine beliebige Property in einem Beliebigen mitgegebenen Typ).
    Der Name der zu überprüfenden Property soll per String mitgegeben werden können.

    Ich hatte schon öfters gelesen, das es irgendwo eine Methode GetPropertyByName gibt. Habe auch so etwas gefunden (IStereoType-Interface), aber msdn gibt so wenige Informationen darüber, das ich weder weis was es ist noch was es genau macht, es heißt nur, das es unter gewissen Umständen (unklar welche) nicht angewendet werden kann.

    Ich vermute, es gibt irgendwelche Wege über Reflection, wisst ihr da was?
    Oder würdet ihr gar sagen, das ich den Such-Algorythmus jeweils mit übergeben soll und dies einfacher wäre? (Stichwort Delegates / Lambdas)

    Naja, Danke im Voraus für Feedback / Tipps / Lösungsansätze.

    Visual Basic-Quellcode

    1. Public Class UniqueNameRule(Of T)
    2. Implements IRule(Of String) 'Interface, welches Validate und SoftRule bereitstellt
    4. Public Property SoftRule As Boolean Implements IRule(Of String).SoftRule
    6. Public Property List As List(Of T)
    7. Public Property PropertyName As String
    9. Public Sub New(list As List(Of T), propertyName As String)
    10. Me.List = list
    11. Me.PropertyName = propertyName
    12. End Sub
    14. Public Function Validate(valueToValidate As String) As RuleResult Implements IRule(Of String).Validate
    16. '#################################################
    17. ' Hier müsste es irgendwie rein
    18. Dim elements = From element As T In List Where {MeineProperty} = valueToValidate
    19. '#################################################
    21. Return New RuleResult(elements.Count < 0, SoftRule, "Message")
    22. End Function
    23. End Class

    Was viel einfachers:
    Gib Deinem Validierer eine Funktion mit, die eine Instanz vom angegebenen Typ entgegennimmt und einen String zurückgibt.

    VB.NET-Quellcode

    1. Private Sub Button1_Click() Handles Button1.Click
    2. Dim Instance1 As New DatClass With {.YourStringProperty = "Get:foo.bar"}
    3. Dim Instance2 As New DatClass With {.YourStringProperty = "Get:foo"}
    4. Dim MyChecker1 As New Checker(Of DatClass)(AddressOf Converter, Instance1, Instance2)
    5. MyChecker1.Check()
    6. 'Oder mit anonymer Funktion:
    7. Dim MyChecker2 As New Checker(Of DatClass)(Function(Target As DatClass) Target.YourStringProperty, Instance1, Instance2)
    8. MyChecker2.Check()
    9. End Sub
    11. Public Function Converter(ByVal Target As DatClass) As String
    12. Return Target.YourStringProperty
    13. End Function
    15. Class DatClass
    17. Public Property YourStringProperty As String
    19. End Class
    21. Class Checker(Of T)
    23. Dim Entries As New List(Of T)
    24. Dim Converter As Func(Of T, String)
    26. Public Sub New(ByVal NewConverter As Func(Of T, String), ByVal ParamArray NewEntries() As T)
    27. Converter = NewConverter
    28. Entries.AddRange(NewEntries)
    29. End Sub
    31. Public Sub Check()
    32. For Each i As T In Entries
    33. If Converter(i).Contains("Foo.Bar") Then
    35. End If
    36. Next
    37. End Sub
    39. End Class


    Würde ich da bevorzugen.
    Ob es schneller als Reflection ist habe ich nicht getestet, aber es wäre denkbar.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    @picoflop:
    Gut, dann geht's natürlich nicht.

    Aber

    Es handelt sich hierbei um eine beliebige Property in einem Beliebigen mitgegebenen Typ

    hat für mich jetzt nicht bedeutet, dass der Typ zur Entwurfszeit noch nicht bekannt ist.

    Alternativ könnte man nur Typen annehmen, die ein Interface implementieren.

    VB.NET-Quellcode

    1. Private Sub Button1_Click() Handles Button1.Click
    2. Dim Instance1 As New DatClass With {.YourStringProperty = "Get:foo.bar"}
    3. Dim Instance2 As New DatClass With {.YourStringProperty = "Get:foo"}
    4. Dim MyChecker As New Checker(Of DatClass)(Instance1, Instance2)
    5. MyChecker.Check()
    6. End Sub
    8. Interface IHasAProperty
    10. Function GetProperty() As String
    12. End Interface
    14. Class DatClass
    15. Implements IHasAProperty
    17. Public Property YourStringProperty As String
    19. Public Function GetProperty() As String Implements IHasAProperty.GetProperty
    20. Return YourStringProperty
    21. End Function
    23. End Class
    25. Class Checker(Of T As IHasAProperty)
    27. Dim Entries As New List(Of T)
    29. Public Sub New(ByVal ParamArray NewEntries() As T)
    30. Entries.AddRange(NewEntries)
    31. End Sub
    33. Public Sub Check()
    34. For Each i As T In Entries
    35. If i.GetProperty.Contains("Foo.Bar") Then
    37. End If
    38. Next
    39. End Sub
    41. End Class


    Das hat natürlich den Nachteil, dass man keine bereits vorgegebenen Klassen verwenden kann. Es sei denn man erstellt eine abgeleitete Klasse und lässt diese das Interface implementieren.


    Aber mir fällt jetzt wirklich kein Beispiel ein, wo es nicht möglich ist einen Konverter anzugeben.
    Ich könnte mir denken, dass das nötig ist, wenn man mit Reflection irgendeinen Typ ausliest. Aber dann kann man ja sowieso Reflection verwenden.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Hallo,

    bin erst heute dazu gekommen, mir das ganze mal genauer anzuschauen.

    @Niko Ortner: Wenn ich es so machen würde (was sicherlich möglich wäre), müsste ich - Nur um hier Validieren zu können, in einer anderen Assembly rumpfuschen(Welche Shared für dieses und daraus abgeleitete Projekte ist). Vielleicht verständlich, das ich das daher nicht unbedingt möchte.

    Das mit dem Erben wäre vielleicht möglich, hier bin ich in einem Vergleichbaren Fall wie du erwähnst, das ich keine Vorgefertigten Klassen nutzen könnte... Daher Erben evtl.

    @picoflop:

    Habe mir das Beispiel angesehen, aber nicht jede Klasse hat ein Invoke, oder irre ich mich da? Habe mit Reflection zu wenig Erfahrung, und verstanden habe ich das Beispiel auch nicht ganz...
    Habe es mir mal im Naming angepasst, damit ich es besser lesen kann (eben so wie ich es gewohnt bin, Casing und Namensgebung, was ich raus lesen konnte...), aber wirklich was gebracht hat es leider nicht.

    Ich habe bspw. einen Typ Member (selbst erstellt) oder Group (selbst erstellt), aber wie würde es da funktionieren, wenn ich bei Group den GroupName bräuchte oder bei Member die RoomNumber (beides String-Properties)?
    Kannst du da vielleicht einen Denkanstoß geben oder ein kleines Beispiel, das ich es vielleicht verstehe?


    Ich denke ich werde es mal mit Interface und Vererbung versuchen, bis ich den Weg über Reflection verstanden habe... ^^

    Kagurame schrieb:

    ich versuche gerade eine generische Validierung von Werten zu realisieren.

    In einem Konkreten Fall soll eine List(Of T) nach einem mitgegebenen String-Value suchen, der Name dieser Property ist aber vorher unklar (Es handelt sich hierbei um eine beliebige Property in einem Beliebigen mitgegebenen Typ).
    Der Name der zu überprüfenden Property soll per String mitgegeben werden können.
    ich glaub das wird nix.

    Aber ich versteh auch nicht, was "Validieren" mit "Suchen in einer List(Of T)" zu tun hat.
    Und nach einer Property suchen, deren Name unbekannt ist stößt sich iwie ein bischen mit meinen Vorstellungen von streng typisierter Programmiersprache und Zeugs.

    Was man allerdings generisch machen kann, dass man eine kleine ganze Methode mitgibt, mit der die Suche entscheidet, ob ein Item matcht oder nicht.
    Aber das ist dir vmtl. bereits bekannt, odr?

    ErfinderDesRades schrieb:

    Aber ich versteh auch nicht, was "Validieren" mit "Suchen in einer List(Of T)" zu tun hat.

    Indirekt.

    Ich habe verschiedene Regeln (Rule(Of T)), und jede Regel bekommt einen zu überprüfenden Wert mit. Um eine solche geht es hier konkret.
    Ein Validator stellt sicher (er validiert), das bei einem festgelegten Wert ein Satz von Regeln eingehalten wird (er kann eine beliebige Anzahl an Regeln, welche den selben Typ haben (Of T) Validieren und gibt ein Gesamtergebnis zurück).

    Beispielhafter Pseudocode

    GruppenName = "Obergeschoss"

    StringNotEmptyRegel(GruppenName) ' Typ String
    StringNotLongerThanRegel(GruppenName) ' Typ String, entsprechendes Feld in der DB hat nur 25 Characters Platz, ich überprüfe direkt bei der Eingabe, ohne zur DB rennen zu müssen
    StringNotExistRegel(GruppenName) ' Gruppenname darf nur einmal existieren, Liste von Gruppen wird überprüft

    Validator.ValidiereAlleRegeln(Regel, Regel, Regel) ' => Mitgegebener Wert zulässig => True / False


    Wie in dem (vielleicht nicht so guten) Beispiel ersichtlich, möchte ich bspw. wissen, ob eine Gruppe schon existiert. Ich habe eine Liste von Gruppen, die entsprechende Eigenschaft heißt GroupName.
    Bei einem Member (anderer Typ, andere List mit Member´s drinne) möchte ich vielleicht den LogOnName überprüfen, in einem anderen Fall vielleicht die PhoneNumber-Eigenschaft.

    Klar, das ich nicht für jede mögliche Eigenschaft, die irgendwo nicht doppelt existieren soll, eine eigene Regel schreiben möchte, sondern eine Intelligente Regel, der ich sage, wie die zu überprüfende Eigenschaft heißt.


    ErfinderDesRades schrieb:

    Was man allerdings generisch machen kann, dass man eine kleine ganze Methode mitgibt, mit der die Suche entscheidet, ob ein Item matcht oder nicht.

    Ein Member, oder eine Group, die nichts anderes soll, als Daten zu halten (nämlich Informationen über diese), hat aber nichts damit zu tun, ob sie irgendwo schonmal Ähnlichkeiten zu jemand anders hat.
    Damit fällt dieses Argument weg (oder ich verstehe dich falsch)

    Was ich nun gemacht habe, ist ein Interface, welches dem Typ die Möglichkeit bietet, jemand anderes die entsprechende Eigenschaft zu sagen.

    Zum Vergleich: Du weißt nicht, ob es irgendwo jemanden gibt, der genauso heißt wie du, dafür haben wir Ämter, die das vielleicht irgendwo wissen. Aber du kannst uns deinen Namen nennen, und jeder andere auch und wir können das selbst überprüfen. Dafür hätten wir ein Computer-Programm, aber dir fällt diese Aufgabe nicht zu, du hast andere Aufgaben (Computer-Technisch gesehen)

    Konnte ich so das Problem vielleicht verdeutlichen?

    mir ist dieser Regel-Kram im wesentlichen schon bekannt, und eine dieser fabelhaften Regeln heißt auch "DelegateRule", und der gibt man einen Delegaten, anhand dessen validiert wird.
    Verwendet man häufig für kompliziertere Regelungen.

    Wie gesagt: Da alle möglichen Properties anzugeben, zusammen mit ihren Match-Werten passt nicht in den Kontext einer strengtypisierten Sprache.

    Hingegen eine Berechnung anzugeben, die aussagt: valide oder nicht - dazu sind Delegaten erfunden worden.

    Ich versuchma im Ämter-Beispiel zu formulieren:
    propertymäßig würde ich hingehen und sagen: Sucht mal: Alter: 150, Name: "Rumpelstilzchen"

    Und dann finden die vlt. alle 150jährigen Rumpelstilzchen

    Delegate-mäßig binnich viel mächtiger, ich kann zb auch angeben, dass die RS älter als 150 sein sollen - also suchtma: Alter > 150 Andalso Name = "Rumpelstilzchen"
    (Keine Ahnung, warum ich dafür nicht zuständig sein sollte.)

    Da kriegst du propertymäßig schnell einen Vogel, weil es gibt ja einige mehr Vergleichsmöglichkeiten: >, >=, =, <, <=, Like, .StartsWith, .Contains, ...
    Das wird lustig, wenn du da 4 Properties mitnander verknüpfen willst - da wirst du einen Haufen Regel-Klassen coden müssen.

    Guck - hier habichmich mal mit so Zeugs auseinandergesetzt: IDataErrorInfo

    ErfinderDesRades schrieb:

    (Keine Ahnung, warum ich dafür nicht zuständig sein sollte.)

    Weil ein Member hier nicht wissen muss, ob er schonmal existiert oder ob es einen mit selben Namen gibt. Wenn das überprüft werden soll, dann sollte dies der tun, der ihn anlegt. Und wenn es heißt, einfach in den Raum "Hans" zu rufen und Hans fühlt sich angesprochen.
    Du solltest Hans aber nicht fragen können, wie viele Hans es gibt, er würde dir wahrscheinlich mit 'wes ich doch net' oder so antworten... aber du kannst nach Hans ausrufen und mehrere Hans fühlen sich angesprochen...

    Eine Klasse tut immer nur das, wofür sie da ist. Und wenn ein Member zum Member-Daten halten da ist, dann ist er nicht zum Redundazen suchen da... dafür gibt es irgendwo Listen oder Vergleichbares wo das drinne steht...
    Solltest du aber wissen... ^^

    OK, habs nu mit den Delegaten gemacht... bin vorher nicht auf die Idee oder ähnliche gekommen, funktioniert nun alles bestens...

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Class DelegateWithListRule(Of T)
    2. Implements IRule(Of T)
    4. Public Property SoftRule As Boolean Implements IRule(Of T).SoftRule
    5. Public Delegate Function ArePropertiesEqual(element As T, elementToCompare As T) As Boolean
    7. Public Property [Delegate] As ArePropertiesEqual
    8. Public Elements As List(Of T)
    10. Sub New([delegate] As ArePropertiesEqual, elements As List(Of T))
    11. Me.Delegate = [delegate]
    12. Me.Elements = elements
    13. End Sub
    15. Public Function Validate(valueToValidate As T) As RuleResult Implements IRule(Of T).Validate
    17. Dim matchingElements = From element As T In Elements Where [Delegate].Invoke(element, valueToValidate)
    19. Return New RuleResult(matchingElements.Count = 0, SoftRule, "Wert darf nicht mehrfach gewählt werden.")
    20. End Function
    22. End Class
    24. '...
    28. Private _memberList As List(Of Member)
    29. Private _groupList As List(Of Group)
    31. <TestInitialize()>
    32. Public Sub Initialize()
    33. Dim memA As New Member With {.LogOnName = "MHans", .PhoneNumber = "12345"}
    34. Dim memB As New Member With {.LogOnName = "PBernd", .PhoneNumber = "12342"}
    35. Dim memC As New Member With {.LogOnName = "MMeier", .PhoneNumber = "12343"}
    36. _memberList = New List(Of Member)
    37. _memberList.AddRange({memA, memB, memC})
    39. Dim grpA As New Group With {.Name = "GrpA"}
    40. Dim grpB As New Group With {.Name = "GrpB"}
    41. Dim grpC As New Group With {.Name = "GrpC"}
    42. _groupList = New List(Of Group)
    43. _groupList.AddRange({grpA, grpB, grpC})
    44. End Sub
    46. Private Function CompareGroup(grp As Group, otherGrp As Group) As Boolean
    47. Return grp.Name.Equals(otherGrp.name)
    48. End Function
    50. Private Function CompareMember(mem As Member, otherMem As Member) As Boolean
    51. Return mem.LogOnName.Equals(otherMem.LogOnName) OrElse mem.PhoneNumber.Equals(otherMem.PhoneNumber)
    52. End Function
    54. <TestMethod()>
    55. Public Sub Validate_Succeeds_UniqueStringPropertyValueRule_CheckGroupName_NoWarning()
    56. Dim grp As New Group With {.Name = "grp"}
    58. Dim validatorResult As ValidatorResult = Validator.Validate(Of Group)(grp, {New DelegateWithListRule(Of Group)(AddressOf CompareGroup, _groupList) With {.SoftRule = False}})
    60. Assert.IsTrue(validatorResult.IsSuccessFull)
    61. Assert.AreEqual(0, validatorResult.MessageList.Count)
    62. End Sub
    64. '...
    68. <TestMethod()>
    69. Public Sub Validate_Succeeds_UniqueStringPropertyValueRule_CheckMemberProperties_Warning()
    70. Dim mem As New Member With {.LogOnName = "MHans", .PhoneNumber = "0"}
    72. Dim validatorResult As ValidatorResult = Validator.Validate(Of Member)(mem, {New DelegateWithListRule(Of Member)(AddressOf CompareMember, _memberList) With {.SoftRule = True}})
    74. Assert.IsTrue(validatorResult.IsSuccessFull)
    75. Assert.AreEqual(1, validatorResult.MessageList.Count)
    76. Assert.IsTrue(validatorResult.MessageList(0).StartsWith("Warnung: "))
    77. End Sub
    79. <TestMethod()>
    80. Public Sub Validate_Fails_UniqueStringPropertyValueRule_CheckMemberProperties()
    81. Dim mem As New Member With {.LogOnName = "KBoese", .PhoneNumber = "12345"}
    83. Dim validatorResult As ValidatorResult = Validator.Validate(Of Member)(mem, {New DelegateWithListRule(Of Member)(AddressOf CompareMember, _memberList) With {.SoftRule = False}})
    85. Assert.IsFalse(validatorResult.IsSuccessFull)
    86. Assert.AreEqual(1, validatorResult.MessageList.Count)
    87. Assert.IsTrue(validatorResult.MessageList(0).StartsWith("Fehler: "))
    88. End Sub
    90. '...

    Kagurame schrieb:

    Eine Klasse tut immer nur das, wofür sie da ist. Und wenn ein Member zum Member-Daten halten da ist, dann ist er nicht zum Redundazen suchen da... dafür gibt es irgendwo Listen oder Vergleichbares wo das drinne steht...

    Redundanzen suchen tun die Delegaten ja auch nicht. Sie bestimmen nur, ob ein anneres Objekt eine Redundanz wäre. Also ähnlich der Equals-Methode, und das darf ein Objekt schon aussagen, ob es findet, dasses einem anneren gleicht oder nicht.
    Und in diesem Fall ist der Delegat ja nichtmal im Objekt angesiedelt, sondern in einer Regel bezüglich dieses Objekt-Typen.

    ErfinderDesRades schrieb:

    dasses einem anneren gleicht oder nicht

    Das schon, aber sie weiß nicht, ob es irgendwo noch einen "Bruder" gibt...

    Naja, is ja jetzt auch Wurscht, ansonsten können wir das gerne per PN klären, wenn du magst (Hat ja nicht mehr wirklich was mim Thema zu tun, geht ja schon mehr wieder Richtung Grundsätze...)

    Redundanzen suchen: Konkreter Fall eben genannt... ^^

    Edit:

    Hab das ganze nochmal überarbeitet. Funktioniert immer noch, erfüllt nun aber eher seinen eigentlichen zweck und kann nicht mehr - wie davor - als Unsauberer Ersatz für alle Regeln der Validierung genutzt werden.
    Neuer Code

    VB.NET-Quellcode

    1. Option Infer On
    2. Option Explicit On
    3. Option Compare Binary
    4. Option Strict On
    6. Imports System.Reflection
    7. Imports <Namespace>.Validation
    8. Imports System.Collections.Generic
    9. Imports System.Linq
    11. Namespace <Namespace>.Client
    13. ''' <summary>
    14. ''' Diese Klasse gleicht anhand eines mitgegebenen Delegaten eine Instanz vom Typ TElement mit einer List(Of TElement) ab und stellt sicher,
    15. ''' das in dieser eine Property nicht schon mit dem mitgegebenen Wert (valueToValidate As TMember) enthalten ist.
    16. ''' </summary>
    17. ''' <typeparam name="TElement"></typeparam>
    18. ''' <remarks></remarks>
    19. Public Class UniqueMemberRule(Of TElement, TMember)
    20. Implements IRule(Of TMember)
    22. Public Property SoftRule As Boolean Implements IRule(Of TMember).SoftRule
    23. Public Property InstanceList As List(Of TElement)
    25. ''' <summary>
    26. ''' Gibt den entsprechenden Member zurück
    27. ''' </summary>
    28. ''' <value>Element, welches den member enthält</value>
    29. ''' <returns>Member aus dem Element</returns>
    30. ''' <remarks></remarks>
    31. Public Property Member As Func(Of TElement, TMember)
    33. Sub New(instances As List(Of TElement), member As Func(Of TElement, TMember))
    34. Me.Member = member
    35. Me.InstanceList = instances
    36. End Sub
    38. Public Function Validate(valueToValidate As TMember) As RuleResult Implements IRule(Of TMember).Validate
    39. ' Liste der entsprechenden Properties zusammen bauen
    40. Dim propertyList = From e In InstanceList Select Member.Invoke(e)
    42. Return New RuleResult(Not propertyList.Contains(valueToValidate), SoftRule, "Wert darf nicht mehrfach gewählt werden.")
    43. End Function
    45. End Class
    47. End Namespace
    49. '...
    51. <TestInitialize()>
    52. Public Sub Initialize()
    53. Dim memA As New Member With {.LogOnName = "MHans", .PhoneNumber = "12345"}
    54. Dim memB As New Member With {.LogOnName = "PBernd", .PhoneNumber = "12342"}
    55. Dim memC As New Member With {.LogOnName = "MMeier", .PhoneNumber = "12343"}
    56. _memberList = New List(Of Member)
    57. _memberList.AddRange({memA, memB, memC})
    59. Dim grpA As New Group With {.Name = "GrpA"}
    60. Dim grpB As New Group With {.Name = "GrpB"}
    61. Dim grpC As New Group With {.Name = "GrpC"}
    62. _groupList = New List(Of Group)
    63. _groupList.AddRange({grpA, grpB, grpC})
    64. End Sub
    66. <TestMethod()>
    67. Public Sub Validate_Succeeds_UniqueMemberRule_CheckGroupName_NoWarning()
    69. Dim grpName As String = "grp"
    71. Dim rule As New UniqueMemberRule(Of Group, String)(_groupList, Function(givenGrp As Group) givenGrp.Name) With {.SoftRule = False}
    72. Dim validatorResult As ValidatorResult = Validator.Validate(grpName, {rule})
    74. Assert.IsTrue(validatorResult.IsSuccessFull)
    75. Assert.AreEqual(0, validatorResult.MessageList.Count)
    76. End Sub

    Ich sage ihm nun praktisch, wie er an die Eigenschaft rankommt, so überprüft er (Validiert) er nun auch selbst und lässt dies nicht dritte übernehmen.
    Ist im Endeffekt auch angenehmer zu verwenden...

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Kagurame“ ()

Facebook
Telefonspende