конечно, ограниченным только сборкой, в которой он объявлен - получает "друг» функциональность в некоторой степени из этого. Друг друг - это то, что видно только определенным другим сборкам за пределами сборки, в которой он объявлен. C # не имеет встроенной поддержки для друга, однако CLR делает.

Ты можешь использоватьInternalsVisibleToAttribute чтобы объявить сборку друга, и все ссылки в сборке друга будут рассматривать внутренние элементы вашей декларируемой сборки как общедоступные в рамках сборки друга. Проблема в том, что все внутренние элементы видны; вы не можете выбирать.

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

и над неуправляемым кодом.

Когда у вас есть библиотека на основе C / C ++, для которой вы хотите использовать DllImport, вы можете импортировать эти функции как статические функции класса и сделать их внутренними, чтобы у вашего пользователя был доступ только к вашей оболочке, а не к исходному API, чтобы он мог 'не связывайтесь ни с чем. Статические функции, которые вы можете использовать везде в сборке, для нескольких нужных вам классов-оболочек.

Вы можете взглянуть на Моно. Каир, этоs обертка вокруг библиотеки Каира, которая использует этот подход.

ет свои преимущества, например, упрощает понимание вашего API.

Кроме того, если в вашей сборке существует ошибка, вероятность исправления, вносящего критические изменения, меньше. Без внутренних классов вы должны были бы предположить, что изменение любого классаПубличные участники были бы серьезным изменением. Что касается внутренних классов, вы можете предположить, что изменение их открытых элементов нарушает только внутренний API сборки (и любые сборки, на которые есть ссылка в атрибуте InternalsVisibleTo).

Мне нравится иметь инкапсуляцию на уровне класса и на уровне сборки. Есть те, кто не согласен с этим, но этоПриятно знать, что функциональность доступна.

который использует LINQ-to-SQL для данных конца. У меня есть два основных пространства имен: Biz и Data. Модель данных LINQ находится в Data и помеченавнутренний»; пространство имен Biz содержит открытые классы, которые обертывают классы данных LINQ.

Так что естьData.Client, а такжеBiz.Client; последний предоставляет все соответствующие свойства объекта данных, например:

private Data.Client _client;
public int Id { get { return _client.Id; } set { _client.Id = value; } }

У объектов Biz есть закрытый конструктор (для принудительного использования фабричных методов) и внутренний конструктор, который выглядит следующим образом:

internal Client(Data.Client client) {
    this._client = client;
}

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

Это первый раз, когда ямы действительно использовалиinternal много, и этоДоказательство довольно полезно.

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

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

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();
    }
  }
}

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

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

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

Дело не в том, что это усложняет жизнь Бобу. Это'Это означает, что он позволяет вам контролировать, какие дорогостоящие обещания дает Project A в отношении функций, срока службы, совместимости и так далее.

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 наобщественности, Также измените уровень доступности члена IntM навнутренний, В этом случае вы можете создать экземпляр класса, но не можете получить доступ к внутреннему члену.

// 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

обычно рекомендуется не предоставлять объект List внешним пользователям сборки, а предоставлять IEnumerable. Но намного проще использовать объект List внутри сборки, потому что вы получаете синтаксис массива и все другие методы List. Итак, у меня обычно есть внутреннее свойство, открывающее список для использования внутри сборки.

Приветствуются комментарии об этом подходе.

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

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

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

Это, на мой взгляд, нарушает интерфейс, нарушает абстракцию. Это не значит, что его никогда не следует использовать, но лучшим решением является рефакторинг в другой класс или использование по-другому, если это возможно. Однако это не всегда возможно.

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

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

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

internal, Одним из примеров может быть, если вы хотите контролировать, как создаются экземпляры классов; позволять'скажем, вы предоставляете какую-то фабрику для создания экземпляров класса. Вы можете сделать конструкторinternal, так что фабрика (которая находится в той же сборке) может создавать экземпляры класса, но код вне этой сборки может:т.

Тем не менее, я могуне вижу смысла в создании классов или членовinternal без особых причин, так же мало, как это имеет смысл сделать ихpublic, или жеprivate без особых причин.

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

public class DangerousClass {
    public void SafeMethod() { }
    internal void UpdateGlobalStateInSomeBizarreWay() { }
}

оступа к конкретным реализациям со стороны пользователя вашей сборки.

Если у вас есть фабрика или другое центральное место для конструирования объектов, пользователю вашей сборки нужно иметь дело только с открытым интерфейсом или абстрактным базовым классом.

Кроме того, внутренние конструкторы позволяют вам контролировать, где и когда создается экземпляр общедоступного класса.

классы и т. Д., Которые должны быть доступны в рамках текущей сборки и никогда за ее пределами.

Например, DAL может иметь ORM, но объекты не должны подвергаться бизнес-уровню, все взаимодействие должно осуществляться с помощью статических методов и передачи необходимых параметров.

что при проектировании библиотеки только те классы, которые предназначены для использования извне (клиентами вашей библиотеки), должны быть общедоступными. Таким образом, вы можете скрыть классы, которые

и т.п.

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

public будет автоматически отображаться в intellisense, когда кто-то смотрит на пространство имен вашего проекта. С точки зрения API важно показывать пользователям вашего проекта только те классы, которые они могут использовать. Использоватьinternal ключевое слово, чтобы скрыть то, что они не должныне вижу.

Если твойBig_Important_Class для проекта А предназначен для использования вне вашего проекта, то вы не должны отмечать его.internal

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

что я когда-либо использовал ключевое слово internal - это код проверки лицензии в моем продукте ;-)

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

Сокрытие сложности (например, инкапсуляция) является главной концепцией качественной разработки программного обеспечения.

чем меньше типов вы выставляете, тем проще ваша библиотека. Защита от несанкционированного вскрытия / безопасность - другое (хотя Reflection может победить это).

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