Question

Is there a way to define a field as private but still modifiable within a method using the generic of the containing class?

(Apologies for the length of the question; I am struggling to nail down exactly what I am asking)

Specifically, I currently have three classes A, B, C with the following requirements:

1. B and C have a field called name, but A does not
2. A and C have a method Load(), but B does not
3. Collections of B and C use name in a custom Add() method, but A does not use this method

This is my current solution:

public class BaseClass
{
    public SomeType Load() { ... }
}

public interface IClass {
    string Name {get; set;}
}

public class MyList : SomeCollection<IClass>
{
    // Depends on x.Name, and may modify Name before adding x to the collection
    public new void Add(IClass x) { ... }
}

public class A : BaseClass { ... }

public class B : IClass { ... }

public class C : BaseClass, IClass { ... }

This solution works for me if Name has a public set. But is there some way to properly encapsulate x.Name so that Add can modify x.Name, but x.Name cannot be modified in instances of B and C?

Answer 1

The short answer is no. You cannot selectively expose members to specific classes, and MyList has no inheritance relationship with IClass.
What you can do, however, is create an additional internal interface (or possibly make IClass internal) that exposes the Name property and implement it explicitly. This means that in order to read/write the Name property, you would need to cast an instance to the internal interface, which would be possible only within the assembly it is defined.

internal interface IClassName { string Name { get; set; } }

public class MyList : Collection<IClass>
{
    protected override void InsertItem(int index, IClass item)
    {
        var className = item as IClassName;
        if (className != null)
        {
            // do something with className.Name ...
        }
        base.InsertItem(index, item);
    }
}

public class B : IClassName { string IClassName.Name { get; set; } }

Note I’m not using the new keyword to bypass the base class’ Add method since this would override the polymorphism (e.g. if you’d cast an instance of MyList to IList<IClass> the original implementation of Add would be called – and that’s bad.) Instead I’m overriding the appropriate method from the Collection<T> class, which is designed for collection inheritance.