IList的 <IList<T> &gt;到IReadonlyCollection <IReadonlyCollection<T> &gt;

Question

I have a list of string array and I would like to make both collection read-only.

So I have this code:

public XmlPatternTree(IList<string> nodeNames, IList<IList<string>> attributeNames,
        IList<IList<string>> attributeValues) : this()
    {
        NodeNames = new ReadOnlyCollection<string>(nodeNames);
        AttributeNames = new ReadOnlyCollection<ReadOnlyCollection<string>>();
        AttributeValues = attributeValues;
        Depth = NodeNames.Count;
    }

My issue is that AttributeNames and AttributeValues assignments causes a compilation error, it seems that I can create a ReadonlyCollection of ReadonlyCollection from a non-readonly collection of non-readonly objects.

Is there something I can do other than looping over all the values and add them in the list ?

Thanks

Answer 1

If you change your type from IList<string> to just List<string> , then this should work:

attributeNames.Select((x) => x.AsReadOnly()).ToList().AsReadOnly();

If you can't modify your method signature (ie you have to keep IList<string> ), then you can do this:

attributeNames.Select((x) => x.ToList().AsReadOnly()).ToList().AsReadOnly();

Answer 2

If the version of the .net framework is greater then 4.0 the generic version of List<> implements the IReadOnlyCollection<> interface. If it is more convenient for you, you can change your signature from IList<ILIst<>> to List<List<>> and should work fine.

 AttributeNames = attributeNames;
 AttributeValues = attributeValues;

Answer 3

Just a note on the covariance of the IReadOnlyList<out T> type (similar to vasil oreshenski's answer).

If you decide to have:

public XmlPatternTree(IReadOnlyList<string> nodeNames, 
  IReadOnlyList<IReadOnlyList<string>> attributeNames,
  IReadOnlyList<IReadOnlyList<string>> attributeValues) : this()
{
  NodeNames = nodeNames;
  AttributeNames = attributeNames;
  AttributeValues = attributeValues;
}

public IReadOnlyList<string> NodeNames { get; private set; }
public IReadOnlyList<IReadOnlyList<string>> AttributeNames  { get; private set; }
public IReadOnlyList<IReadOnlyList<string>> AttributeValues { get; private set; }
public int Depth => NodeNames.Count;

in your class, then the covariance mentioned means you can use reference conversions, and not any wrapping inside another class , as in:

var nn = new List<string>();
var an = new List<string[]>();
var av = new List<string[]>();
// populate 'nn', 'an', and 'av'

// the following compiles with no wrapper class:
var tree = new XmlPatternTree(nn, an, av);

Of course, people can cast the interfaces back to the actual types, like List<string[]> , and modify the collections without using reflection, if they guess that the type is really that list of arrays. However, that would be quite malignant, so you could assume it is no problem if only "good" people use your class

PS! What I said and coded above with IReadOnlyList<out T> could just as well have been done with IReadOnlyCollection<out T> since it is covariant (" out ") as well. You would just not have the indexer access on the properties (such as var name = tree.AttrbuteNames[idx1][idx2] ). But then you could use HashSet<> and similar which are not IReadOnlyList<> .