"hufaun***@yahoo.com" wrote:

> SITUATION:
> I have a class "MainClass" that has an indexer "SubClass1Indexer".
> This indexer returns an instance that implements a particular
> interface "ISubClass1". This interface defines another indexer
> "SubClass2Indexer". Bellow is some code with comments. It should
> compile.
>
> PROBLEM:
> I would like to write something like this:
>
>       MainClass cm = new MainClass();
>       cm.SubClass1Values[0].SubClass2Values[0].ToString();
>
> Note that "SubClass2Indexer" needs access to an internal field of
> "SubClass1". This only seems to be possible if a field is allowed in
> an interface, i.e. ISubClass1. That is not the case, though.
>
> NONE IDEAL SOLUTIONS:
> 1) Make "this[]" in SubClass2Indexer aware of all the current and
> future implementations of "ISubClass1".
> 2) Do a casting after "cm.SubClass1Values[0]" but then I have to write
> separate indexers "SubClass2Indexer" for each implementation of
> "ISubClass1".
>
> QUESTION:
> How can I solve the shortcomings in the above solutions? Or in general
> how is this best handled?
>
> CODE:
> using System;
> using System.Collections.Generic;
> using System.Text;
>
> namespace testProj
> {
>     class Program
>     {
>         static void Main(string[] args)
>         {
>             MainClass cm = new MainClass();
>             cm.SubClass1Values[0].SubClass2Values[0].ToString();
>         }
>     }
>
>     //CLASSES
>     public class MainClass
>     {
>         private SubClass1Indexer m_subClass1Indexer;
>         protected internal List<ISubClass1> m_subClass1List; //
> SubClass1Indexer needs access to this.
>
>         public SubClass1Indexer SubClass1Values
>         {
>             get { return m_subClass1Indexer; }
>         }
>     }
>
>     public class SubClass1 : ISubClass1
>     {
>         private SubClass2Indexer m_subClass2Indexer;
>         protected internal List<ISubClass2> m_subClass2List; //
> SubClass2Indexer needs access to this.
>
>         public SubClass2Indexer SubClass2Values
>         {
>             get { return m_subClass2Indexer; }
>         }
>     }
>
>     //INTERFACES
>     public interface ISubClass1
>     {
>         //!!! If the following would be possible then in
> SubClass2Indexer
>         // I would not have to make the function 'this[]' be aware of
> all
>         // the ISubClass1 implementations.
>         //protected internal List<ISubClass> m_subClass2List;
>
>         SubClass2Indexer SubClass2Values { get; }
>     }
>
>     public interface ISubClass2
>     {
>     }
>
>     //INDEXERS
>     public class SubClass1Indexer
>     {
>         private readonly MainClass m_subClass1Owner;
>
>         public SubClass1Indexer(MainClass seriesOwner)
>         {
>             m_subClass1Owner = seriesOwner;
>         }
>
>         public ISubClass1 this[Int32 index]
>         {
>             get {
>                 return m_subClass1Owner.m_subClass1List[index];
>             }
>         }
>     }
>
>     public class SubClass2Indexer
>     {
>         private readonly ISubClass1 m_subClass2Owner;
>
>         public SubClass2Indexer(ISubClass1 subClass2Owner)
>         {
>             m_subClass2Owner = subClass2Owner;
>         }
>
>         public ISubClass2 this[Int32 index]
>         {
>             //The command commented out would be possible if one could
>             // define a field in an interface. Now I'll need a switch
>             // to handle all the IClass1 implementations. So I can't
> just
>             // add a new implementation without adjusting this
> function.
>             //get { return m_subClass2Owner.m_subClass2List[index]; }
>             get { return
> ((SubClass1)m_subClass2Owner).m_subClass2List[index]; }
>         }
>     }
> }
>
>