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]; }
}
}
}