Entwickler-Ecke :: Thema anzeigen - ArrayList mit vordefinnierten Item objekten

Master_BB - Sa 22.10.05 14:50
Titel: ArrayList mit vordefinnierten Item objekten

Hallo,
weiß jemand wie ich eine Liste erstellte
die von ArrayList abgeleitet ist wo jedoch
die Items der ArrayList einen vordefinierten Typ haben?

sprich

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

  TMyList = class(System.Collections.ArrayList)
  public
  end;
  TMyItem = class
  public
  end;

//jetzt soll sowas möglich sein
var
  AMyList : TMyList;
  AMyItem : TMyItem;
begin
  AMyItem := AMyList.Item[0];  //normaler weise bräuche man hier ja einen Typcast
end;

greetz
Master_BB

Moderiert von Christian S.: Topic aus .NET verschoben am Sa 22.10.2005 um 14:51

Robert_G - Sa 22.10.05 17:13

Dzu willst eigentlich gar nicht von ArrayList ableiten, right?
Du willst eigentlich nur eine typisierte Implementierung von IList. ;)

Mit .Net2 ist das ein no-brainer:
C#:

C#-Quelltext

1:
2:
3:
4:

List<MyItem> list = new List<MyItem>();
list.Add(new MyItem());
      
MyItem myItem = list[0];

Chrome:

Delphi-Quelltext

1:
2:
3:
4:

var list = new List<MyItem>();
list.Add(new MyItem());
      
var myItem = list[0];

Wenn du es in 1.1 haben willst (Kunststück mit D.Net :mrgreen: ), wäre hier der typed Collection Wizzard aus #d eine Hilfe.
Willst du es in D.Net machen wirst du bemerken, dass du dort Interfaces nicht mehr explizit implementieren kannst.[meta]trotz der Abwärtskompat., die dir ständig das Bein stellt ist es hier inkompatibel[/meta]

In C# implmentiert man ein Interface explizit[meta]somit werden die Interface member nur zugänglich, wenn man die Instanz darauf castet[/meta], indem man den Interface Namen varanstellt und keinen Access modifier angibt.
Am Beispiel IList.Add würde das so aussehen:

typisiertes Add:

C#-Quelltext

1:
2:
3:
4:

public int Add(MyItem value)
{
  return InnerList.Add(value);
}

Ilist.Add, welches dein Add aufruft.

C#-Quelltext

1:
2:
3:
4:

int IList.Add(object value)
{
  return Add(value as MyItem);
}

Mit der guten alten implements-Clause würde es so aussehen[meta]ist nicht direkt Delphi, aber Chrome Code, der möglichst "urtümlich" aussieht[/meta]:

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

MyItemCollection = public class(IList)
private
  fInnerList: ArrayList; readonly;
  
  method set_Item(index : Integer; value: MyItem);
  method get_Item(index : Integer): MyItem;
protected
  property InnerList : IList read fInnerList; implements IList;
public
  constructor;
  constructor(capacity : Integer);
  
  property Count : Integer read fInnerList.Count;
  
  property IsFixedSize    : Boolean read fInnerList.IsFixedSize;
  property IsReadonly     : Boolean read fInnerList.IsReadonly;
  property IsSynchronized : Boolean read fInnerList.IsSynchronized;
  
  property Item[index : Integer] : MyItem
    read get_Item write set_Item; default; virtual;

  method Add(value : MyItem) : Integer; virtual;
  method Remove(value : MyItem); virtual;
  method Contains(value : MyItem) : Boolean; virtual;
  method IndexOf(value : MyItem) : Integer; virtual;
  method Insert(index : Integer; value : MyItem); virtual;
end;

Unter D.Net wird es dir wohl nicht erspart bleiben alles zu Fuss zu machen.
Alle Methoden und den Indexer musst du außerdem mit reintroduce; versehen, damit sie nicht mehr in der Code completion auftauchen[meta]falls du *wirklich* von ArrayList ableiten willst...[/meta].

btw, Danke: beim Tippen des Beitrages sind mir 3 Ideen gekommen, mit denen ich die Jungs von RemObjects nerven kann. :mrgreen:

Master_BB - Sa 22.10.05 19:02

hm schade,
ich hatte mir schon fast gedacht das ich über die IList
implementation gehen muss.

ich hatte gehofft da gibts in .NET1.1 sowas
schönes wie man bei dem XML unter .NET1.1 machen kann.

und zwar setzt man dort ja vor eine Liste das Attribut

Delphi-Quelltext

1:
2:
3:

[XMLInclude(TypeOf(MyItem))]
TMyList = class(ArrayList)
....

und schupp weiß der Serializer von welchem Typ die Items
sind. Und ich dachte es gibt davon vieleicht noch eine allgemeinere
Form die mir alle Items der ArrayList schon beim Implementieren
usw in diesen Typ gibt.
Naja schade. Bis Delphi .NEt2.0 fähig wird
wirds noch dauern ergo bleib ich beim Typecasten

Moderiert von Christian S.: Delphi-Tags hinzugefügt.

Robert_G - Sa 22.10.05 19:16

Master_BB hat folgendes geschrieben:

hm schade,
ich hatte mir schon fast gedacht das ich über die IList
implementation gehen muss.

IList bring IEnumerable mit und damit hast du schon einmal simples DataBinding für Listen-Controls und foreach/for-in frei Haus.

Zitat:

Naja schade. Bis Delphi .NEt2.0 fähig wird
wirds noch dauern ergo bleib ich beim Typecasten

Oder einfach der typed collection Wizzard aus #d. Was bringt einem das "Verständnis" zwischen .Net-Sprachen, wenn man es nicht benutzt? Eine C# Assembly mit der typed Collection aus #d und die einfach in deinem D.Net-Programm verwenden. ;)
Kommst du später zu .Net2.0 würdest du einfach so deinen Code zum laufen bringen[meta]um die ganzen unnötigen Typecasts wegzukriegen[/meta]:

Delphi-Quelltext

1:
2:
3:

type 
  MyItemCollection = public class(List<MyItem>)
  end;

btw: Gibt es eigentlich einen Grund für D.Net[meta]außer Portierung über VCL.Net...[/meta]? Also nicht nur weil "Delphi" draufsteht. ;)

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2024 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!