如何使受保护的成员在“孙子”类中不可访问

Question

我在抽象类 AbstractModule 中有受保护的变量

var1

我创建

abstract class AbstractActivity : AbstractModule

 并使用父类 AbstractModule 中的 

var1

现在我创建

class MyActivity : AbstractActivity

 并且我想让 

var1

 在 MyActivity 类中不可访问。

我该怎么做？

（我可以创建受保护的属性，但是我遇到了同样的问题）

Answer 1

C# 不允许这样做。但是您可以通过创建一个具有相同名称的字段来隐藏类中的字段

AbstractActivity

。然后，您的类 

MyActivity

 将可以访问阴影字段及其值，但不能访问 

AbstractModule

 中定义的字段。

  public class A
  {
     protected bool seeMe;
  }

  public class B : A
  {
     public B()
     {
        base.seeMe = false; // this is A.seeMe
     }

     protected bool seeMe;
  }

  public class C : B
  {
     public C()
     {
        seeMe = true; // this is B.seeMe
     }
  }

上面的示例不会阻止编写使用影子字段的代码。如果程序员意识到

A.seeMe

 并认为它正在被设置，这可能会引起混乱。当使用 

B.seeMe

 时，您可以通过用 Obsolete 属性修饰它来强制编译错误：

  public class B : A
  {
     public B()
     {
        base.seeMe = false; // this is A.seeMe
     }

     [Obsolete("cannot use seeMe", error:true)]
     protected bool seeMe;
  }

  public class C : B
  {
     public C()
     {
        seeMe = true; // this will give a compile error
     }
  }

Answer 2

与上述具有 int 值的解决方案相同的示例。

我试图限制子类中同名的祖父母字段。

  public class MyClass
  {
        protected int myValue = 10;
  }
  public class MyClass1 : MyClass
  {
        protected int myValue = 15;
        public MyClass1()
        {
            base.myValue = 25;
            this.myValue = 11;
        }
  }
  public class MyClass2 : MyClass1
  {
        public void print()
        {
            Console.WriteLine("My Value : " + myValue);//this will print 11                
        }
  }
  class Program
  {
        static void Main(string[] args)
        {
            MyClass2 myClass2 = new MyClass2();
            myClass2.print();
        }
  }

//使用sealed关键字限制子类中的祖父方法

public class MyClass
{
    protected virtual void MyMethod()
    {
    }
}
public class MyClass1 : MyClass
{
    // because of sealed method this method will not going to override in derived class.
    sealed override protected void MyMethod() 
    {
    }
}
public class MyClass2 : MyClass1
{
    protected override void MyMethod()//this will give compiler error
    {
    }  
}

Answer 3

这已经成为一个老问题了。正确的答案是使用

private protected

 访问修饰符，它将封装孙子成员的成员，同时对类的子成员仍然可见。