Как получить доступ к внутреннему методу объекта-потомка в C#

Question

Я пытаюсь получить доступ к методу, который помечен как внутренний в родительском классе (в его собственной сборке) в объекте, который наследуется от одного и того же родителя.

Позвольте мне объяснить, что я пытаюсь сделать ...

Я хочу, чтобы создавать классы службы, которые возвращают IEnumberable с основной список для классов неслужебную (например, UI) и необязательно возвращать IEnumerable с базовый IQueryable для других сервисов.

Я написал несколько примеров кода, чтобы продемонстрировать, что я пытаюсь выполнить, как показано ниже. Пример не в реальной жизни, поэтому, пожалуйста, помните, что при комментировании.

Все услуги будут наследовать от чего-то вроде этого (только соответствующий код показан):

public class ServiceBase<T> 
{ 
    protected readonly ObjectContext _context; 
    protected string _setName = String.Empty; 

    public ServiceBase(ObjectContext context) 
    { 
     _context = context; 
    } 

    public IEnumerable<T> GetAll() 
    { 
     return GetAll(false); 
    } 

    //These are not the correct access modifiers.. I want something 
    //that is accessible to children classes AND between descendant classes 
    internal protected IEnumerable<T> GetAll(bool returnQueryable) 
    { 
     var query = _context.CreateQuery<T>(GetSetName()); 
     if(returnQueryable) 
     { 
      return query; 
     } 
     else 
     { 
      return query.ToList(); 
     } 
    } 

    private string GetSetName() 
    { 
     //Some code... 
     return _setName; 
    } 



} 

Наследственные услуги будут выглядеть следующим образом:

public class EmployeeService : ServiceBase<Employees> 
{ 
    public EmployeeService(ObjectContext context) 
     : base(context) 
    { 

    } 

} 

public class DepartmentService : ServiceBase<Departments> 
{ 
    private readonly EmployeeService _employeeService; 

    public DepartmentService(ObjectContext context, EmployeeService employeeService) : base(context) 
    { 
     _employeeService = employeeService; 
    } 

    public IList<Departments> DoSomethingWithEmployees(string lastName) 
    { 
     //won't work because method with this signature is not visible to this class 
     var emps = _employeeService.GetAll(true); 

     //more code... 
    } 
} 

Поскольку родительский класс живет является многоразовым, он бы живут в другой сборке, чем детские услуги. Если GetAll (bool returnQueryable) будет помечен как внутреннее, дети не смогут увидеть метод GetAll (bool) друг друга, а только общедоступный метод GetAll().

Я знаю, что я могу добавить новый внутренний метод GetAll для каждой службы (или, возможно, промежуточного родительского класса в рамках одной и той же сборки), чтобы каждый дочерний сервис внутри сборки мог видеть метод друг друга; но это кажется ненужным, поскольку функциональность уже доступна в родительском классе.

Например:

internal IEnumerable<Employees> GetAll(bool returnIQueryable) 
    { 
     return base.GetAll(returnIQueryable); 
    } 

По сути то, что я хочу, чтобы услуги, чтобы иметь возможность получить доступ к другим методам обслуживания, как IQueryable, так что они могут дополнительно уточнить неподтвержденные результаты, в то время как все остальные получают простые старые списки.

Любые идеи?

EDIT

Вы знаете, что у меня было немного весело играть немного кода в гольф с этим ... но в конечном счете, я не смог бы использовать эту схему в любом случае, потому что я прохожу интерфейсы вокруг, а не классы ,

Так что в моем примере GetAll (bool returnIQueryable) не будет в интерфейсе, то есть мне придется делать кастинг, что противоречит тому, что я пытаюсь выполнить.

Я не уверен, что у меня был мозговой пердит, или если я был просто слишком возбужден, пытаясь получить то, что, как я думал, было аккуратно работать. В любом случае, спасибо за ответы.

Answer 1

Что не так с очевидным ответом на то, чтобы сделать этот метод общедоступным?

Доступность в любом случае небезопасна, поэтому «злые люди» могут использовать отражение, чтобы обойти любой модификатор, который вы надели. И так как вы хотите называть эти методы из несвязанных «родственных» классов, они должны быть общедоступными, так как нет модификатора доступности «родного брата».

Альтернативное предложение: примените атрибут [assembly:InternalsVisibleTo("SomeOtherAssembly")], чтобы предоставить другим узлам бизнес-домена доступ к внутренним членам.

Обратите внимание, что это добавляет нагрузку на обслуживание (если вы переименовываете или добавляете сборки), использует «магические строки» и отрицает исходное значение внутреннего (так как теперь все внутренние члены будут видны и для этих других сборок).

Answer 2

Когда ваши классы потомков будут жить в одной и той же сборке, это было бы проще. Тем не менее, следующий «трюк» также работает, когда ваши классы живут в отдельных сборках (изменение ключевого слова интерфейса internal до public), но это только мешает вызывать метод, когда объект не выполняется. Например, листинг объекта InheritedClass на IBaseInterface позволит любому вызвать метод GetValue. Это то, что вы действительно не можете предотвратить, потому что даже если там какая-то комбинация ключевых слов, которые могли бы делать то, что вы хотите, кто-то еще мог бы вызвать методы через отражение.

internal interface IBaseInterface { 
    string GetValue(); 
} 

public abstract class MyBase : IBaseInterface { 
    string IBaseInterface.GetValue() 
    { return "MyBase"; } 
} 

public class InheritedClass : MyBase { 
    public void PrintValue(IBaseInterface someclass) 
    { Console.WriteLine(someclass.GetValue()); } 
} 

Answer 3

Может быть, я что-то отсутствует, но вы должны быть в состоянии пометить его как protected internal и достичь своих целей.

namespace Foo 
{ 
    class A 
    { 
     protected internal void D() { Console.WriteLine(this.ToString() + " says 'Blah'"); } 
    } 
} 

namespace Bar 
{ 
    class B : Foo.A 
    { 
     public B() 
     { 
     } 
    } 
} 

namespace Baz 
{ 
    class C : Foo.A 
    { 
     public C() 
     { 
      D(); 
      Bar.B b = new Bar.B(); 
      b.D(); 

      Foo.A a = new Foo.A(); 
      a.D(); 
     } 
    } 
} 

Чтобы увидеть выход

Baz.C c = new Baz.C(); 

Это все законно код. Foo.A является базой, Bar.B и Baz.C наследуется от Foo.A. void D является защищенным внутренним членом A. Baz.C может вызывать D(), как и ожидалось, а также создавать экземпляры Bar.B и Foo.A и вызывать их методы D().

protected internal элементы видны для всех классов потомков в любой сборке и всех классах внутри той же сборки, что и база. Доступность заканчивается за пределами этих границ. Не-потоковые классы в тех же сборках, что и дети, не смогут увидеть участника.