1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

private List<int> mListe;
public List<int> MyIntListe
        {
            get
            {
                return mListe;
            }
            set{
                if (value != null)
                {
                    mListe= value;
                }
                else
                {
                    throw new Exception("You must make at least one selection\n in the 'Dividend' option box");
                }
            }
        }                    

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

class Program
    {
        static void Main(string[] args)
        {
            Class1 c = new Class1();
            c.MyIntListe.Add(1);
            c.MyIntListe.Add(2);

            foreach (int tmpElm in c.MyIntListe)
                Console.WriteLine(tmpElm);    

        }
    }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

 if (value != null)
                {
                    if (value[0] < 0) // kurz gefasst man müsste sich jetzt noch um den index kümmern.
                    mListe = value;
                }
                else
                {
                    throw new Exception("You must make at least one selection\n in the 'Dividend' option box");
                }                    

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

 
public List<int> MyIntListe
        {
            get
            {
                if (mListe.Count > 0)
                {
                    if (mListe[0] < 0)
                        mListe.RemoveAt(0);
                }
                return mListe;
            }                    

1:
2:

List<int> tmp = c.MyIntListe;
tmp.Add(1);                    

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

class TolleIntCollection : ICollection<int>
{
    // ...
}

// ---------------

var obj = new TolleIntCollection()
{
    1,
    2,
    3
};                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

class Class1
    {
 private List<int> mListe;
        public Class1()
        {
            mListe = new List<int>();
        }

  public void SetMyListInt(int i)
        {
            mListe.Add(i); 
        }

        public List<int> GetMyListInt(int index)
        {
            return mListe(index); 
        }
 }                    

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:

class Class1
{
    private MyCheckedIntegerList mListe = new MyCheckedIntegerList();
    public IList<int> MyIntListe
    {
        get
        {
            return mListe;
        }            
    }

    public class MyCheckedIntegerList : Collection<int>
    {
        public MyCheckedIntegerList() { }
        public MyCheckedIntegerList(IList<int> list) : base(list) { }

        protected override void InsertItem(int index, int item)
        {
            // irgendeine Prüfung
            if (item <= 0)
                throw new ArgumentOutOfRangeException("Value must be greater than 0.", "item");

            base.InsertItem(index, item);
        }
    }
}                    

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:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

public class ValidatingList<T> : IList<T>
{
    private readonly IList<T> _list;
    private readonly Predicate<T> _validate;

    public int Count
    {
        get { return _list.Count; }
    }
    public bool IsReadOnly
    {
        get { return _list.IsReadOnly; }
    }
    public T this[int index]
    {
        get { return _list[index]; }
        set
        {
            ValidateWithException(value);
            _list[index] = value;
        }
    }

    public ValidatingList(Predicate<T> validate)
        : this(new List<T>(), validate)
    {
    }
    public ValidatingList(IList<T> list, Predicate<T> validate)
    {
        if (validate == null)
            throw new ArgumentNullException("validate");

        _validate = validate;
        _list = list ?? new List<T>();
    }

    public virtual bool Validate(T item)
    {
        return _validate(item);
    }
    private void ValidateWithException(T item)
    {
        if (!Validate(item))
            throw new ArgumentException("invalid item");
    }

    public void Insert(int index, T item)
    {
        ValidateWithException(item);
        _list.Insert(index, item);
    }
    public void Add(T item)
    {
        ValidateWithException(item);
        _list.Add(item);
    }

    // IList<T>-Implementierungen ...
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

var list = new ValidatingList<string>(x => x != null);

list.Add("a");
list.Add("b");
list.Add(null); // -> Exception

var item = "asdf";
if (list.Validate(item))
    list.Add(item);
// ...                    

1:
2:
3:
4:
5:

 public void Add(T item)
        {
            ValidateWithException(item);
            _list.Add(item);
        }                    

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

public class ValidatingList<T> : IList<T>
{
    private  IList<T> _list;

    public ValidatingList()
    {
        _list = new List<T>(); // hier
    }

    //obligacions of this Interface
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

 class DeineKlasse
    {
        public ObservableCollection<int> IntListe { get; private set; }

        public DeineKlasse()
        {
            IntListe = new ObservableCollection<int>();
            IntListe.CollectionChanged += IntListeOnCollectionChanged;
        }

        //Hier wird ein neuer WERT zu der Liste hinzugefügt. Das Listen-Objekt bleibt aber das gleiche!!!

        private void IntListeOnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            // Wenn neue Werte hinzugefügt wurden, einfach alle Werte mit 0 aus der Liste löschen
            // (falls welche vorhanden sind)

            if (e.Action == NotifyCollectionChangedAction.Add) IntListe.Remove(0);
        }
    }                    

1:
2:
3:

DeineKlasse klasse1 = new DeineKlasse();
klasse1.IntListe.Add(2);
klasse1.IntListe.Add(0);