Praktische Verwendung für das Schlüsselwort "intern" in C #

Könnten Sie bitte erklären, was die praktische Verwendung für die ist internal Schlüsselwort in C # ?

Ich weiß, dass der internalModifikator den Zugriff auf die aktuelle Assembly beschränkt, aber wann und unter welchen Umständen sollte ich ihn verwenden?

Dienstprogramm- oder Hilfsklassen / -methoden, auf die Sie von vielen anderen Klassen innerhalb derselben Assembly aus zugreifen möchten, auf die Sie jedoch sicherstellen möchten, dass Code in anderen Assemblys nicht zugreifen kann.

Von MSDN (über archive.org):

Der interne Zugriff wird häufig in der komponentenbasierten Entwicklung verwendet, da eine Gruppe von Komponenten auf private Weise zusammenarbeiten kann, ohne dem Rest des Anwendungscodes ausgesetzt zu sein. Beispielsweise könnte ein Framework zum Erstellen grafischer Benutzeroberflächen Steuerungs- und Formularklassen bereitstellen, die mithilfe von Mitgliedern mit internem Zugriff zusammenarbeiten. Da diese Mitglieder intern sind, sind sie keinem Code ausgesetzt, der das Framework verwendet.

Sie können den internen Modifikator auch zusammen mit dem verwenden InternalsVisibleTo Attribut auf Assembly-Ebene verwenden, um "Friend" -Baugruppen zu erstellen, denen ein spezieller Zugriff auf die internen Klassen der Zielassembly gewährt wird.

Dies kann nützlich sein, um Unit-Test-Assemblys zu erstellen, die dann interne Mitglieder der zu testenden Assembly aufrufen dürfen. Natürlich erhalten keine anderen Assemblys diese Zugriffsebene. Wenn Sie also Ihr System freigeben, bleibt die Kapselung erhalten.

Wenn Bob BigImportantClass benötigt, muss Bob die Personen, die Projekt A besitzen, dazu bringen, sich anzumelden, um sicherzustellen, dass BigImportantClass so geschrieben wird, dass es seinen Anforderungen entspricht, getestet wird, um sicherzustellen, dass es seinen Anforderungen entspricht, dokumentiert wird, dass es seinen Anforderungen entspricht, und dass ein Prozess wird eingerichtet, um sicherzustellen, dass es niemals geändert wird, um seine Bedürfnisse nicht mehr zu erfüllen.

Wenn eine Klasse intern ist, muss sie diesen Prozess nicht durchlaufen, wodurch Budget für Projekt A gespart wird, das sie für andere Dinge ausgeben kann.

Der interne Punkt ist nicht, dass es Bob das Leben schwer macht. Auf diese Weise können Sie steuern, welche teuren Versprechen Projekt A in Bezug auf Funktionen, Lebensdauer, Kompatibilität usw. macht.

Ein weiterer Grund für die Verwendung von intern ist, wenn Sie Ihre Binärdateien verschleiern. Der Obfuscator weiß, dass es sicher ist, den Klassennamen interner Klassen zu verschlüsseln, während der Name öffentlicher Klassen nicht verschlüsselt werden kann, da dadurch vorhandene Referenzen beschädigt werden könnten.

Wenn Sie eine DLL schreiben, die eine Menge komplexer Funktionen in einer einfachen öffentlichen API zusammenfasst, wird "intern" für die Klassenmitglieder verwendet, die nicht öffentlich verfügbar gemacht werden sollen.

Das Verbergen von Komplexität (auch als Kapselung bezeichnet) ist das Hauptkonzept des Qualitätssoftware-Engineerings.

Das interne Schlüsselwort wird häufig verwendet, wenn Sie einen Wrapper für nicht verwalteten Code erstellen.

Wenn Sie über eine C / C ++ - basierte Bibliothek verfügen, die Sie für DllImport verwenden möchten, können Sie diese Funktionen als statische Funktionen einer Klasse importieren und intern gestalten, sodass Ihr Benutzer nur auf Ihren Wrapper und nicht auf die ursprüngliche API zugreifen kann Leg dich mit irgendetwas an. Da die Funktionen statisch sind, können Sie sie überall in der Assembly für die mehreren benötigten Wrapper-Klassen verwenden.

Sie können sich Mono.Cairo ansehen, es ist ein Wrapper um die Cairo-Bibliothek, der diesen Ansatz verwendet.

Aufgrund der Regel "Verwenden Sie so strenge Modifikatoren wie möglich" verwende ich intern überall dort, wo ich beispielsweise auf Methoden einer anderen Klasse zugreifen muss, bis ich explizit von einer anderen Assembly aus darauf zugreifen muss.

Da die Assembly-Schnittstelle normalerweise schmaler ist als die Summe der Klassenschnittstellen, gibt es ziemlich viele Stellen, an denen ich sie verwende.

Ich finde intern weit überstrapaziert. Sie sollten bestimmte Funktionen wirklich nicht nur bestimmten Klassen aussetzen, die Sie anderen Verbrauchern nicht anbieten würden.

Dies bricht meiner Meinung nach die Schnittstelle, bricht die Abstraktion. Dies bedeutet nicht, dass es niemals verwendet werden sollte, aber eine bessere Lösung besteht darin, auf eine andere Klasse umzugestalten oder wenn möglich auf eine andere Weise verwendet zu werden. Dies ist jedoch möglicherweise nicht immer möglich.

Der Grund dafür kann sein, dass ein anderer Entwickler möglicherweise eine andere Klasse in derselben Assembly wie Ihre erstellt. Interna verringern die Klarheit der Abstraktion und können bei Missbrauch zu Problemen führen. Es wäre das gleiche Problem, als ob Sie es öffentlich gemacht hätten. Die andere Klasse, die vom anderen Entwickler erstellt wird, ist wie jede externe Klasse immer noch ein Verbraucher. Klassenabstraktion und Kapselung dienen nicht nur dem Schutz für / vor externen Klassen, sondern für alle Klassen.

Ein weiteres Problem ist, dass viele Entwickler denken werden sie müssten es möglicherweise an anderer Stelle in der Baugruppe verwenden und es trotzdem als intern markieren, obwohl sie es zu diesem Zeitpunkt nicht benötigen. Ein anderer Entwickler könnte dann denken, dass es für die Aufnahme da ist. Normalerweise möchten Sie privat markieren, bis Sie einen endgültigen Bedarf haben.

Aber einiges davon kann subjektiv sein, und ich sage nicht, dass es niemals verwendet werden sollte. Einfach bei Bedarf verwenden.

Ich habe neulich, vielleicht eine Woche, einen interessanten auf einem Blog gesehen, an den ich mich nicht erinnern kann. Grundsätzlich kann ich das nicht gutschreiben, aber ich dachte, es könnte eine nützliche Anwendung haben.

Angenommen, Sie möchten, dass eine abstrakte Klasse von einer anderen Assembly gesehen wird, aber Sie möchten nicht, dass jemand davon erben kann. Sealed funktioniert nicht, weil es aus einem bestimmten Grund abstrakt ist. Andere Klassen in dieser Assembly erben davon. Private funktioniert nicht, da Sie möglicherweise eine übergeordnete Klasse irgendwo in der anderen Assembly deklarieren möchten.

Namespace Base.Assembly
{
  öffentliche abstrakte Klasse Eltern
  {
    interne abstrakte Leere SomeMethod ();
  }}

  // Dies funktioniert einwandfrei, da es sich in derselben Assembly befindet.
  öffentliche Klasse ChildWithin: Parent
  {
    interne Überschreibung void SomeMethod ()
    {
    }}
  }}
}}

Namespace Another.Assembly
{
  // Kaboom, weil Sie eine interne Methode nicht überschreiben können
  öffentliche Klasse ChildOutside: Parent
  {
  }}

  öffentlicher Klassentest 
  { 

    //Alles gut
    private Eltern _parent;

    öffentlicher Test ()
    {
      //Immer noch gut
      _parent = new ChildWithin ();
    }}
  }}
}}

Wie Sie sehen können, kann jemand die Parent-Klasse effektiv verwenden, ohne von ihr erben zu können.

Dieses Beispiel enthält zwei Dateien: Assembly1.cs und Assembly2.cs. Die erste Datei enthält eine interne Basisklasse, BaseClass. In der zweiten Datei führt ein Versuch, BaseClass zu instanziieren, zu einem Fehler.

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

Verwenden Sie in diesem Beispiel dieselben Dateien wie in Beispiel 1 und ändern Sie die Zugriffsstufe von BaseClass in public . Ändern Sie auch die Barrierefreiheitsstufe des Mitglieds IntM in intern . In diesem Fall können Sie die Klasse instanziieren, aber nicht auf das interne Mitglied zugreifen.

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

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

Wenn Sie Methoden, Klassen usw. haben, auf die im Rahmen der aktuellen Assembly und niemals außerhalb dieser zugegriffen werden muss.

Beispielsweise kann eine DAL über ein ORM verfügen, die Objekte sollten jedoch nicht der Geschäftsschicht ausgesetzt sein. Die gesamte Interaktion sollte über statische Methoden erfolgen und die erforderlichen Parameter übergeben werden.

Eine sehr interessante Verwendung von intern - wobei das interne Mitglied natürlich nur auf die Assembly beschränkt ist, in der es deklariert ist - besteht darin, bis zu einem gewissen Grad "Freund" -Funktionalität daraus zu ziehen. Ein Freundmitglied ist etwas, das nur für bestimmte andere Versammlungen außerhalb der Versammlung sichtbar ist, in der es deklariert ist. C # hat keine integrierte Unterstützung für Freunde, die CLR jedoch.

Sie können InternalsVisibleToAttribute verwenden , um eine Friend-Assembly zu deklarieren. Alle Verweise innerhalb der Friend-Assembly behandeln die internen Mitglieder Ihrer deklarierenden Assembly im Rahmen der Friend-Assembly als öffentlich. Ein Problem dabei ist, dass alle internen Mitglieder sichtbar sind; Sie können nicht auswählen.

Eine gute Verwendung für InternalsVisibleTo besteht darin, verschiedene interne Elemente einer Einheitentestbaugruppe auszusetzen, wodurch die Notwendigkeit komplexer Reflexionsumgehungen zum Testen dieser Elemente entfällt. Alle internen Mitglieder, die sichtbar sind, sind nicht so problematisch. Wenn Sie jedoch diesen Ansatz wählen, werden Ihre Klassenschnittstellen ziemlich stark durcheinander gebracht und können möglicherweise die Kapselung innerhalb der deklarierenden Assembly ruinieren.

Als Faustregel gibt es zwei Arten von Mitgliedern:

• öffentliche Oberfläche : sichtbar von einer externen Assembly (öffentlich, geschützt und intern geschützt): Der Aufrufer ist nicht vertrauenswürdig, daher sind Parameterüberprüfung, Methodendokumentation usw. erforderlich.
• Private Oberfläche : Von einer externen Assembly aus nicht sichtbar (private und interne oder interne Klassen): Der Aufrufer ist im Allgemeinen vertrauenswürdig, sodass die Parameterüberprüfung, Methodendokumentation usw. möglicherweise weggelassen wird.

Je weniger Typen Sie verfügbar machen, desto einfacher ist Ihre Bibliothek. Manipulationssicherheit / Sicherheit ist eine andere (obwohl Reflection dagegen gewinnen kann).

Mit internen Klassen können Sie die API Ihrer Assembly einschränken. Dies hat Vorteile wie die Vereinfachung des Verständnisses Ihrer API.

Wenn in Ihrer Assembly ein Fehler vorliegt, ist die Wahrscheinlichkeit geringer, dass das Update eine wichtige Änderung einführt. Ohne interne Klassen müssten Sie davon ausgehen, dass das Ändern der öffentlichen Mitglieder einer Klasse eine bahnbrechende Änderung darstellt. Bei internen Klassen können Sie davon ausgehen, dass das Ändern ihrer öffentlichen Mitglieder nur die interne API der Assembly (und aller Assemblys, auf die im InternalsVisibleTo-Attribut verwiesen wird) beschädigt.

Ich mag die Kapselung auf Klassen- und Versammlungsebene. Es gibt einige, die damit nicht einverstanden sind, aber es ist schön zu wissen, dass die Funktionalität verfügbar ist.

Ich habe ein Projekt, das LINQ-to-SQL für das Daten-Backend verwendet. Ich habe zwei Hauptnamespaces: Biz und Data. Das LINQ-Datenmodell befindet sich in Data und ist als "intern" gekennzeichnet. Der Biz-Namespace verfügt über öffentliche Klassen, die die LINQ-Datenklassen umschließen.

Also gibt es Data.Clientund Biz.Client; Letzteres legt alle relevanten Eigenschaften des Datenobjekts offen, z.

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

Die Biz-Objekte haben einen privaten Konstruktor (um die Verwendung von Factory-Methoden zu erzwingen) und einen internen Konstruktor, der folgendermaßen aussieht:

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

Dies kann von jeder Geschäftsklasse in der Bibliothek verwendet werden, aber das Front-End (UI) hat keine Möglichkeit, direkt auf das Datenmodell zuzugreifen, wodurch sichergestellt wird, dass die Geschäftsschicht immer als Vermittler fungiert.

Dies ist das erste Mal, dass ich wirklich internalviel benutzt habe, und es erweist sich als sehr nützlich.

Es gibt Fälle, in denen es sinnvoll ist, Mitglieder von Klassen zu machen internal. Ein Beispiel könnte sein, wenn Sie steuern möchten, wie die Klassen instanziiert werden. Angenommen, Sie stellen eine Art Factory zum Erstellen von Instanzen der Klasse bereit. Sie können den Konstruktor internalso erstellen, dass die Factory (die sich in derselben Assembly befindet) Instanzen der Klasse erstellen kann, Code außerhalb dieser Assembly jedoch nicht.

Ich kann jedoch keinen Sinn darin sehen, Klassen oder Mitglieder internalohne bestimmte Gründe zu bilden, genauso wenig wie es sinnvoll ist, sie zu machen public, oder privateohne bestimmte Gründe.

Das einzige, für das ich jemals das interne Schlüsselwort verwendet habe, ist der Lizenzprüfcode in meinem Produkt ;-)

Eine Verwendung des internen Schlüsselworts besteht darin, den Zugriff des Benutzers Ihrer Assembly auf konkrete Implementierungen zu beschränken.

Wenn Sie über eine Factory oder einen anderen zentralen Ort zum Erstellen von Objekten verfügen, muss sich der Benutzer Ihrer Assembly nur mit der öffentlichen Schnittstelle oder der abstrakten Basisklasse befassen.

Mit internen Konstruktoren können Sie außerdem steuern, wo und wann eine ansonsten öffentliche Klasse instanziiert wird.

Wie wäre es mit diesem: In der Regel wird empfohlen, ein List-Objekt nicht externen Benutzern einer Assembly zur Verfügung zu stellen, sondern eine IEnumerable verfügbar zu machen. Es ist jedoch viel einfacher, ein List-Objekt in der Assembly zu verwenden, da Sie die Array-Syntax und alle anderen List-Methoden erhalten. Daher habe ich normalerweise eine interne Eigenschaft, die eine Liste zur Verwendung in der Assembly verfügbar macht.

Kommentare zu diesem Ansatz sind willkommen.

publicBeachten Sie, dass jede Klasse, die als definiert ist, automatisch im Intellisense angezeigt wird, wenn jemand Ihren Projektnamespace betrachtet. Aus API-Sicht ist es wichtig, nur Benutzern Ihres Projekts die Klassen anzuzeigen, die sie verwenden können. Verwenden Sie das internalSchlüsselwort, um Dinge auszublenden, die sie nicht sehen sollten.

Wenn Ihr Big_Important_Classfor Project A für die Verwendung außerhalb Ihres Projekts vorgesehen ist, sollten Sie es nicht markieren internal.

In vielen Projekten gibt es jedoch häufig Klassen, die eigentlich nur für die Verwendung in einem Projekt vorgesehen sind. Beispielsweise haben Sie möglicherweise eine Klasse, die die Argumente für einen parametrisierten Thread-Aufruf enthält. In diesen Fällen sollten Sie sie als internalaus keinem anderen Grund markieren, als um sich vor einer unbeabsichtigten API-Änderung zu schützen.

Die Idee ist, dass beim Entwerfen einer Bibliothek nur die Klassen öffentlich sein sollten, die für die Verwendung von außen (von Clients Ihrer Bibliothek) vorgesehen sind. Auf diese Weise können Sie Klassen ausblenden, die

1. Werden sich wahrscheinlich in zukünftigen Versionen ändern (wenn sie öffentlich wären, würden Sie den Client-Code beschädigen)
2. Sind für den Kunden nutzlos und können Verwirrung stiften
3. Sind nicht sicher (daher kann eine unsachgemäße Verwendung Ihre Bibliothek ziemlich stark beschädigen)

usw.

Wenn Sie interne Lösungen entwickeln, ist die Verwendung interner Elemente meiner Meinung nach nicht so wichtig, da die Kunden normalerweise ständigen Kontakt zu Ihnen und / oder Zugriff auf den Code haben. Sie sind jedoch für Bibliotheksentwickler ziemlich kritisch.

Wenn Sie Klassen oder Methoden haben, die nicht sauber in das objektorientierte Paradigma passen, die gefährliche Dinge tun, die von anderen Klassen und Methoden unter Ihrer Kontrolle aufgerufen werden müssen und die Sie keinem anderen erlauben möchten .

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