你能解释一下c#中internal关键字的实际用法吗?

我知道内部修饰符限制了对当前程序集的访问,但何时以及在何种情况下应该使用它?


当前回答

我发现内部被过度使用了。您真的不应该只向某些类公开某些功能,而不向其他使用者公开。

在我看来,这打破了界面,打破了抽象。这并不是说永远不应该使用它,而是更好的解决方案是重构到不同的类,或者在可能的情况下以不同的方式使用。然而,这并不总是可能的。

The reasons it can cause issues is that another developer may be charged with building another class in the same assembly that yours is. Having internals lessens the clarity of the abstraction, and can cause problems if being misused. It would be the same issue as if you made it public. The other class that is being built by the other developer is still a consumer, just like any external class. Class abstraction and encapsulation isnt just for protection for/from external classes, but for any and all classes.

另一个问题是,许多开发人员会认为他们可能需要在程序集中的其他地方使用它,并将其标记为内部,即使他们当时并不需要它。另一个开发商可能会认为它就在那里。通常,在有明确的需要之前,您希望将其标记为私有。

但其中有些可能是主观的,我并不是说永远不应该使用它。只在需要的时候使用。

其他回答

在“使用尽可能严格的修饰符”规则的驱动下,我在需要访问的任何地方都使用internal,比如,从另一个类中访问方法,直到我显式地需要从另一个程序集访问它。

由于程序集接口通常比类接口的总和更窄,所以我在很多地方使用它。

这个怎么样:通常建议不要向程序集的外部用户公开List对象,而是公开IEnumerable对象。但是在程序集中使用List对象要容易得多,因为您可以获得数组语法和所有其他List方法。因此,我通常有一个内部属性,公开要在程序集中使用的List。

欢迎对这种方法提出意见。

这个例子包含两个文件:Assembly1.cs和Assembly2.cs。第一个文件包含一个内部基类BaseClass。在第二个文件中,尝试实例化BaseClass将产生一个错误。

// Assembly1.cs
// compile with: /target:library
internal class BaseClass 
{
   public static int intM = 0;
}

// Assembly1_a.cs
// compile with: /reference:Assembly1.dll
class TestAccess 
{
   static void Main()
   {  
      BaseClass myBase = new BaseClass();   // CS0122
   }
}

在本例中,使用示例1中使用的相同文件,并将BaseClass的可访问性级别更改为public。还要将成员IntM的可访问性级别更改为internal。在这种情况下,可以实例化类,但不能访问内部成员。

// Assembly2.cs
// compile with: /target:library
public class BaseClass 
{
   internal static int intM = 0;
}

// Assembly2_a.cs
// compile with: /reference:Assembly1.dll
public class TestAccess 
{
   static void Main() 
   {      
      BaseClass myBase = new BaseClass();   // Ok.
      BaseClass.intM = 444;    // CS0117
   }
}

来源:http://msdn.microsoft.com/en-us/library/7c5ka91b (VS.80) . aspx

前几天,也许是一个星期,在一个我不记得的博客上看到了一个有趣的东西。基本上这不是我的功劳,但我认为它可能有一些有用的应用。

假设您想让另一个程序集看到一个抽象类,但不希望有人能够继承它。Sealed不能工作,因为它是抽象的,这个程序集中的其他类确实从它继承。Private将不起作用,因为您可能希望在另一个程序集中声明一个Parent类。

namespace Base.Assembly
{
  public abstract class Parent
  {
    internal abstract void SomeMethod();
  }

  //This works just fine since it's in the same assembly.
  public class ChildWithin : Parent
  {
    internal override void SomeMethod()
    {
    }
  }
}

namespace Another.Assembly
{
  //Kaboom, because you can't override an internal method
  public class ChildOutside : Parent
  {
  }

  public class Test 
  { 

    //Just fine
    private Parent _parent;

    public Test()
    {
      //Still fine
      _parent = new ChildWithin();
    }
  }
}

如您所见,它有效地允许某人使用父类而不能够继承。

如果Bob需要BigImportantClass,那么Bob需要让拥有项目A的人注册,以保证BigImportantClass将被编写以满足他的需求,测试以确保它满足他的需求,被记录为满足他的需求,并且将设置一个过程以确保它永远不会被更改,从而不再满足他的需求。

如果一个类是内部的,那么它就不需要经过这个过程,这为项目a节省了预算,他们可以把这些钱花在其他事情上。

内在的意义并不在于它让鲍勃的生活变得困难。而是它允许您控制Project A在特性、生命周期、兼容性等方面做出的昂贵承诺。