Question

I would like to bring access to an internal array with a Property, but controlling the access to array elements.

I have write a simple example that can explain my problem better than myself.

In the example, I provide a ‘Fail’ class and a ‘Controlled’ class. The second one runs as I would like, but the approach is a bit different and it is usefull only with one array.

My question is the next:
What about if I must to have two different arrays and therefore two differenct properties.

How to do it ?

Thanks.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("The Fail Class:");

            MyFailClass MyFailTestClass = new MyFailClass(5);
            MyFailTestClass.MyList[2] = 11;
            if (MyFailTestClass.Modified) {
                Console.WriteLine("Right");
            } else {
                Console.WriteLine("Error");
            }



            Console.WriteLine("The Controlled Class:");

            MyControlledClass MyControlledTestClass = new MyControlledClass(5);
            MyControlledTestClass[2] = 11;
            if (MyControlledTestClass.Modified) {
                Console.WriteLine("Right");
            } else {
                Console.WriteLine("Error");
            }

            Console.ReadKey();
        }
    }

    public class MyFailClass
    {
        // Property 
        public byte[] MyList
        {
            get
            {
                return myList;
            }
            set  // <--------- Never enters here if I set a concrete array element
            {
                Modified = !myList.Equals(value);
                myList = value;
            }
        }
        public bool Modified { get; set; }

        // Constructor
        public MyFailClass(int elements)
        {
            myList = new byte[elements];
        }

        private byte[] myList;
    }

    public class MyControlledClass
    {
        // Property 
        public byte this[int index]
        {
            get
            {
                return myList[index];
            }
            set
            {
                Modified = !myList[index].Equals(value);
                myList[index] = value;
            }
        }
        public bool Modified { get; set; }

        // Constructor
        public MyControlledClass(int elements)
        {
            myList = new byte[elements];
        }

        private byte[] myList;
    }
}

Answer 1

If you want two arrays, it stands to reason that you might later want three, or four (I don’t know for sure, but that seems to be how things go).

In this case, I would consider making a class that’s an aggregate of your “MyControlledClass”

public class IndexedClass
{
    // Property 
    public byte this[int index]
    {
        get
        {
            return myList[index];
        }
        set
        {
            Modified = !myList[index].Equals(value);
            myList[index] = value;
        }
    }

}

public class IndexedClassGroup
{
    // Property 
    public IndexedClass this[int index]
    {
        get
        {
            return myList[index];
        }
        set
        {
            Modified = !myList[index].Equals(value);
            myList[index] = value;
        }
    }

}

Then, you could access these things like a two dimensional array.

Personally, I’m a little leery of exposing an array as a gettable/settable concept, in theory, so I don’t know a whole lot about the ins and outs of doing that. Whether a classes uses an array or a list or whatever seems like a private implementation detail rather than a public property. If you’re going to expose something, expose an ICollection<> or IEnumerable<> and resolve it internally to an array. My two cents, anyway.