C#

List<Student> students = new List<Student>();

students.Add(student1);
students.Add(student2);
students.Add(student3);

Public class Course
{
    private string courseName;
 
    public string CourseName
    {
        get { return courseName; }
        set { courseName = value; }
    }

    // this would be ok, because it's a "declaration" like "private string courseName;" above
    Student[] studentarray = new Student[3]; 

    // this isn't a declaration and can't exist directly in the class scope:
    studentarray[0] = student1;

    // instead theoretically something like this (within a methods scope):
    public void SomeMethod()
    {
        studentarray[0] = student1;
        // "theoretically" because "student1" isn't known here
    }
    
    // makes a tiny bit more sense:
    public void SetStudent0(Student student)
    {
        studentarray[0] = student;
        // only a tiny bit because this method would have the fixed purpose
        // of assigning to array index 0
    }
    // you would call it outside of this class like so: someCourse.SetStudent0(student1);

    // some more sense:
    public void SetStudent(Student student, int index)
    {
        studentarray[index] = student;
        // only some more sense because from outside this class you don't know which
        // array indices would be valid
    }
    // you would call it outside of this class like so: someCourse.SetStudent(student1, 0);

    // even more sense:
    private int ArrayCursor = 0;
    public void AddStudent(Student student)
    {
        studentarray[ArrayCursor] = student;
        ArrayCursor++;
        // will only work as long as there's enough space in the array
    }
    // you would call it outside of this class like so: someCourse.AddStudent(student1);

    // best with a generic list:
    private List<Student> Students = new List<Student>();
    public void AddStudent(Student student)
    {
        Students.Add(student);
    }
}

public class ClsContacts
{
    public List Properties { get; private set; }

    public ClsContacts()
    {
         Properties = new List<Property>();
    }
}

Doncal wrote:

Thanks a lot Sascha, That works.

Doncal wrote:

I'll keep your suggestions in mind when I start knowing what Im doing. ;o)

Sascha Lefévre wrote:

but instead as an interface that only allows reading (e.g. IEnumerable or ReadOnlyCollection) and have the allowed manipulations as methods of ClsContacts.

class ListEncapsulation
{
    // pre .NET 4.5
    public ReadOnlyCollection<int> Example1 { get { return EncapsulatedList.AsReadOnly(); } }
    public IEnumerable<int> Example2 { get { return EncapsulatedList.AsReadOnly(); } }

    // .NET 4.5
    public IReadOnlyList<int> Example3 { get { return EncapsulatedList.AsReadOnly(); } }

    private List<int> EncapsulatedList = new List<int>();

    // + methods that expose the allowed manipulations on the list
}