Item.add vonList of T überschreiben

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 8 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

    Item.add vonList of T überschreiben

    Nabend
    ich möchte in einer List of T das Befüllen dieser kontrollieren und ggf Daten nachbessern
    Dafür habe ich eine Klasse welche von der List of T erbt. Diese wird nach bedarf an anderen Stellen eingebaut.

    Das funktioniert zum Teil.

    VB.NET-Quellcode

    1. Public Class myList(Of T) : Inherits List(Of T)
    3. Private _Items As New List(Of T)
    5. Public Overloads Property Item As List(Of T)
    6. Get
    7. Return _Items
    8. End Get
    10. Set(value As List(Of T))
    11. _Items = value
    13. For Each i In value
    14. 'prüfung/anpassung
    16. Next
    18. RaisePropertyChanged()
    19. End Set
    20. End Property
    22. Public Overloads Function Add(i As T)
    23. 'prüfung/anpassung/hinzufügen
    24. Return True
    25. End Function


    ein paar Test

    VB.NET-Quellcode

    1. Dim m As New myList(Of myObj)
    2. m.Add(beliebigesItem1) //funktioniert da .add überschrieben
    3. m.Item = <andereListe> //funktioniert hier. läuft durch SET
    4. m.Item.Add(beliebigesItem2) //hier nicht


    Mir ist nicht klar wie ich an Item.Add rankomme.
    Zur not den Aufruf auch verhindere und da ich das "andere" Add noch da ist.
    "Item" auf Protect setzten fällt aus da ich sonst zu xaml nicht mehr binden kann.


    Ich habe die Vermutung das ich das Konstrukt der List of T mit dem Item Property nicht ganz überrissen habe bzw etwas vorhabe was nicht so gedacht ist.

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

    "//hier nicht" ist eine super Fehlerbeschreibung, wie lautet denn die Fehlermeldung?
    Nebenbei, was versuchst du da mit der "Item" Property zu bauen, du hast doch schon eine Liste?
    Warum soll deine Liste eine weitere Liste über die Item Property anbieten?

    es wird kein Fehler geworfen. Die Liste wird ganz normal befüllt. Also alle 3 Syntaxmöglichkeiten befüllen auch die gleiche Liste.
    Ich habe nur beim letzten keine Möglichkeit gefunden noch dazwischen zugehen um zb Daten zu prüfen und/oder addhandler zu setzen (das ist ggf nicht state of the art).
    Eine weitere Liste sollte eigendlich nihct existieren. Ich überschreibe hier das Item Property. So war ich jedenfalls vorhin noch der Meinung.
    Habe jetzt mit der IList angefangen und mir von VS die benötigten zu überschreibenen Methoden bauen lassen... nunja es ist hinter den Kulissen wohl doch komplizierter:

    VB.NET-Quellcode

    1. Default Public Property Item(index As Integer) As T Implements IList(Of T).Item
    2. Get
    3. Return Item(index)
    4. End Get
    5. Set(value As T)
    6. Item(index) = value
    7. End Set
    8. End Property


    Steig ich noch nicht durch.
    Muss ggf mal kleines Testprojekt basteln. Ist grad zuviel drumherum. ;)

    Ach, den teil mit "Overloads" habe ich übersehen, sorry.
    Trotzdem ist mir nicht ganz klar warum das nötig sein soll und im Framework ist "_items" ein T[], also ein Array.

    Wenn ich die Add-Methode überschreiben wollte, würde ich das wie folgt machen:

    C#-Quellcode

    1. public class MyList2<T> :List<T>
    2. {
    3. public new void Add(T item)
    4. {
    5. // nur ein Beispiel
    6. if (!this.Contains(item))
    7. {
    8. base.Add(item);
    9. }
    10. }
    11. }


    Auch habe ich m.Item = <andereListe> und m.Item.Add(beliebigesItem2) noch nie gesehen, plus das ergibt für mich keinen Sinn.
    Für m.Item = <andereListe> wäre eigentlich m = <andereListe> und bei m.Item.Add(beliebigesItem2) nur m.Add(beliebigesItem2) die Schreibweise.

    Kannst dir das hier mal anschauen: system/collections/generic/list

    ähm das IList(Of T)-Interface zu implementieren macht überhaupt keinen Spass - davon würd ich sehr abraten.
    Da hast du glaub bis zu 20 Interface-Member am Hals, und einiges ist doppelt gemoppelt, und ganz schön schrullig.

    Ich täte 2 Sachen vorschlagen:
    Entweder du beerbst Collection(Of T) - darin ist Add und Clear und Insert und so Sachen sind da Overridable, und es gibt eine InnerList(Of T), auf die alles Projeziert wird.
    Also das Ding ist dafür vorgesehen, beerbt zu werden, um Auflistungen mit eigener Intelligenz zu entwickeln.

    Oder du nimmst einfach ObservableCollection(Of T).
    Die gibt dir mit den Events CollectionChanging und CollectionChanged alles in die Hand, um derlei Vorgänge zu kontrollieren.
    (ObservableCollection(Of T) erbt übrigens von Collection(Of T) - man sieht also, wie im Framework auch nur mit Wasser gekocht wird)

    ---

    Ich nochma.
    ich möchte in einer List of T das Befüllen dieser kontrollieren und ggf Daten nachbessern
    Dafür habe ich eine Klasse welche von der List of T erbt. Diese wird nach bedarf an anderen Stellen eingebaut.
    Dafür ist ObservableCollection(Of T) da und Schluss.

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

    Die IList einbauen scheint wirklich eine kleine Hölle zu sein. Also für mich. :D

    Die ObservableCollection habe ich meist gemieden da ich im Kopf habe ...falls doch mal wieder WinForms nimmst....ja hab ich schon lange nicht mehr und ich nehm ja WPF weils doch einiges vereinfacht. :D

    Als Quartalshobbybastler brauch erstmal paar Tage um das alles durchzuprobieren. Aber ich denke ich komme zum Ziel und das Thema ist erledigt

    Danke Gruß Marc

    ObservableCollection(Of T) ist nicht auf Wpf beschränkt.
    Ist in Winforms ebensogut verfügbar.

    Für dein Vorhaben brauchst du auch nix zu beerben, sondern die OC ist dafür geeignet, so wie sie ist.
    Verarbeite ihre Events und tu da, was zu tun ist.

    Nochmal zum Beerben: Da gibts nix neues zu erfinden, weil was du brauchst ist bereits erfunden, und das Rad, was du nochmal erfindest, wird sicherlich nicht so rund wie das, wasses schon gibt.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

Facebook
Telefonspende