Container-Klassen in C#

[Luckie]

Ich verstehe nur noch Bahnhof. :gruebel:

Jedenfalls habe ich es jetzt mal so gemacht:

Code:

namespace Container_Klasse
{
    public partial class Form1 : Form
    {
        List<Person> PersonenListe = new List<Person>();

        private void UpdateControls()
        {
            toolStripStatusLabel1.Text = PersonenListe.Count.ToString();

            lbEntries.Items.Clear();
            foreach (Person person in PersonenListe)
            {
                lbEntries.Items.Add(person.Name + ", " + person.Vorname);
            }

            tbName.Text = string.Empty;
            tbVorname.Text = string.Empty;

            btnDel.Enabled = (PersonenListe.Count > 0) && (lbEntries.SelectedIndex > -1);
        }

        public Form1()
        {
            InitializeComponent();
            UpdateControls();
        }

        private void btnAdd_Click(object sender, EventArgs e)
        {
            Person p = new Person(tbName.Text, tbVorname.Text);
            PersonenListe.Add(p);
            tbName.Focus();
            UpdateControls();           
        }

        private void lbEntries_SelectedIndexChanged(object sender, EventArgs e)
        {
            btnDel.Enabled = lbEntries.SelectedIndex > -1;
            if (lbEntries.SelectedIndex > -1)
            {
                tbName.Text = PersonenListe[lbEntries.SelectedIndex].Name;
                tbVorname.Text = PersonenListe[lbEntries.SelectedIndex].Vorname;
            }
        }

        private void btnDel_Click(object sender, EventArgs e)
        {
            if (lbEntries.SelectedIndex > -1)
            {
                PersonenListe.RemoveAt(lbEntries.SelectedIndex);
                UpdateControls();
            }
        }
    }
}

Ist da irgendein schwerwiegender Fehler drin?

Wie könnte ich das ganze jetzt noch nach Name und Vorname sortieren?

Habs:

Code:

        private static int ComparePerson(Person p1, Person p2)
        {
            if (p1.Name == p2.Name)
                return p1.Vorname.CompareTo(p2.Vorname);
            else
                return p1.Name.CompareTo(p2.Name);
        }

        private void UpdateControls()
        {
            toolStripStatusLabel1.Text = PersonenListe.Count.ToString();

            PersonenListe.Sort(ComparePerson);


            lbEntries.Items.Clear();
            foreach (Person person in PersonenListe)
            {
                lbEntries.Items.Add(person.Name + ", " + person.Vorname);
            }

            tbName.Text = string.Empty;
            tbVorname.Text = string.Empty;

            btnDel.Enabled = (PersonenListe.Count > 0) && (lbEntries.SelectedIndex > -1);
        }

[Elvis]

Zitat:

Zitat von Luckie

Ist da irgendein schwerwiegender Fehler drin?

Ja, eine Menge unnötigen Code.
Kompilere einmal dein Projekt, gehe jetzt mal in den Form designer und oben im Menü klickst du auf du Data\Show data sources.
Nun legst du in dem neuen Toolwindow eine neue Data source an, im Dialog wählst du Object aus und im nächsten Schritt kannst du deine Klasse "Person" auswählen -> Finish.
Jetzt kannst du einfach die Eigenschaften Name und Vorname auf dein Formular.
Die Textboxes sind jetzt an diese beiden Eigenschaften in der PersonBindingSource gebunden, die ebenfalls auf dem Form liegt.
Willst du den Navigator nicht haben, kannst du ihn einfach löschen.
Jetzt noch eine ListBox auf dein Form ziehen, und ihr als DataSource die personBindingSource verpassen.


Mehr muss im Form nicht stehen, um all das zu können, was dein Code gemacht hat:

Code:

public partial class Form1 : Form
{
  readonly BindingList<Person> persons = new BindingList<Person>();

  public Form1()
  {
    InitializeComponent();
    personBindingSource.DataSource = persons;
  }

  private void personBindingSource_ListChanged(object sender, ListChangedEventArgs e)
  {
    deleteButton.Enabled  = personBindingSource.Position != -1;
    nameTextBox.Enabled    = deleteButton.Enabled;
    vornameTextBox.Enabled = deleteButton.Enabled;
  }

  private void addButton_Click(object sender, EventArgs e)
  {
    personBindingSource.AddNew();
  }

  private void deleteButton_Click(object sender, EventArgs e)
  {
    personBindingSource.RemoveCurrent();
  }
}

In der Klasse würd ich halt INotifyPropertyChange implementieren, um die UI (oder andere) über Änderungen informieren zu können.
Außerdem habe ich noch ToString überschrieben, da das der Defaultwert ist, den eine ListBox darstellt.

Code:

public class Person : INotifyPropertyChanged
{
  string name;
  string vorname;

  public override string ToString()
  {
    return name + ", " + vorname;
  }

  public string Name
  {
    get { return name; }
    set
    {
      if (name == value) return;

      name = value;
      RaisePropertyChanged("Name");
    }
  }

  public string Vorname
  {
    get { return vorname; }
    set
    {
      if (vorname == value) return;

      vorname = value;
      RaisePropertyChanged("Name");
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;
  protected void RaisePropertyChanged(string propertyName)
  {
    PropertyChangedEventHandler h = PropertyChanged;

    if (h != null)
      h(this, new PropertyChangedEventArgs(propertyName));

  }
}

[Mephisto81]

Hallo,

Zitat:

Zitat von OregonGhost

Edit: Der Name trügt übrigens. List ist keine verkettete Liste. Allgemein kannst du dich auch mal in "Collection" einlesen, und in die in diesem Zusammenhang interessanten Interfaces IEnumerable, das u.a. von List<T> und auch normalen Arrays implementiert wird.

da würde mich mal interessieren, wie du darauf kommst das List<T> keine "verkettete Liste" ist? Nur weil Array ebenfalls das Interface IEnumerable implementiert, sagt das noch lange nicht aus das beide dasselbe sind, sondern vielmehr, dass beide Konstrukte mit einer foreach-Anweisung iteriert werden können. :wink:

Grüße
Mephisto

[Elvis]

Zitat:

Zitat von Mephisto81

da würde mich mal interessieren, wie du darauf kommst das List<T> keine "verkettete Liste" ist?

Weil es allgemein bekannt ein arraybasierter Container ist.
Es ist die generische Vorsetzung der Arraylist.

LinkedList<T> ist eine verkette Liste.

[OregonGhost]

Zitat:

Zitat von Mephisto81

Hallo,

Zitat:

Zitat von OregonGhost

Edit: Der Name trügt übrigens. List ist keine verkettete Liste. Allgemein kannst du dich auch mal in "Collection" einlesen, und in die in diesem Zusammenhang interessanten Interfaces IEnumerable, das u.a. von List<T> und auch normalen Arrays implementiert wird.

da würde mich mal interessieren, wie du darauf kommst das List<T> keine "verkettete Liste" ist? Nur weil Array ebenfalls das Interface IEnumerable implementiert, sagt das noch lange nicht aus das beide dasselbe sind, sondern vielmehr, dass beide Konstrukte mit einer foreach-Anweisung iteriert werden können. :wink:

Grüße
Mephisto

Zitat:

Zitat von Windows SDK

The List class is the generic equivalent of the ArrayList class. It implements the IList generic interface using an array whose size is dynamically increased as required.

[Dax]

Zitat:

Zitat von OregonGhost

Zitat:

Zitat von Windows SDK

The List class is the generic equivalent of the ArrayList class. It implements the IList generic interface using an array whose size is dynamically increased as required.

Zitat:

Zitat von Windows SDK

Die List-Klasse ist die generische Entsprechung der ArrayList-Klasse. Sie implementiert das generische IList-Interface und benutzt ein Array, dessen Größe dynamisch vergrößert und verkleinert wird.

Frei übersetzt, und nix mit verlinkter Liste..

[Luckie]

@elvis: Das ist sicher auch eine Möglichkeit, aber ich wollte ja wissen, wie es von Hand geht, um es zu verstehen. Letztendlich will ich mich etwas in C# einarbeiten, um zu sehen, wie es funktioniert usw.

Zum Vergleichen habe ich jetzt mal eine Klasse implementiert:

Code:

    class PersonComparer: IComparer<Person>
    {
        public enum SortType {Descending = -1, Ascending = 1};
        protected SortType sortType;

        public PersonComparer()
        {
            this.sortType = SortType.Ascending;
        }

        public PersonComparer(SortType st)
        {
            this.sortType = st;
        }

        public SortType HowToSort
        {            
            set{this.sortType = value;}
        }

        public int Compare(Person p1, Person p2)
        {
            if (p1.Name == p2.Name)
                return (int)sortType * p1.Vorname.CompareTo(p2.Vorname);
            else
                return (int)sortType * p1.Name.CompareTo(p2.Name);
        }
    }

[Mephisto81]

Hallo,

Zitat:

Zitat von Dax

Zitat:

Zitat von OregonGhost

Zitat:

Zitat von Windows SDK

The List class is the generic equivalent of the ArrayList class. It implements the IList generic interface using an array whose size is dynamically increased as required.

Zitat:

Zitat von Windows SDK

Die List-Klasse ist die generische Entsprechung der ArrayList-Klasse. Sie implementiert das generische IList-Interface und benutzt ein Array, dessen Größe dynamisch vergrößert und verkleinert wird.

Frei übersetzt, und nix mit verlinkter Liste..

stimmt, hab's gerade (nachdem Oregon geantwortet hatte) mal im MSIL-Code und mittels Reflector überprüft. Danke für eure Infos :thumb:

Grüße
Mep

[Elvis]

Zitat:

Zitat von Luckie

@elvis: Das ist sicher auch eine Möglichkeit, aber ich wollte ja wissen, wie es von Hand geht, um es zu verstehen. Letztendlich will ich mich etwas in C# einarbeiten, um zu sehen, wie es funktioniert usw.

Ist ja auch ok, in .Net synchronisiert man halt UI und Daten nicht zu Fuss, dass läuft eigentlich nur per DataBinding.
Wie diese Bindung dann aussieht, kannst du mit einigen Interfaces selbst bestimmen.

Zitat:

Zum Vergleichen habe ich jetzt mal eine Klasse implementiert.

Ginge auch so:

Code:

var sortType = SortType.Blabla;

personenListe.Sort((left, right) -> (int)sortType * (left.Name != right.Name)
                     ? String.Compare(left.Name, right.Name)
                     : String.Compare(left.Vorname, right.Vorname));