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

419

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?

Alexander Prokofyev
quelle

Antworten:

379

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.

Asche
quelle
8
Das InternalsVisibleTo-Attribut ist eine große Hilfe. Vielen Dank.
Erict
33
Mein Gefühl ist, dass von dem Moment an, in dem Sie internes benötigen, irgendwo etwas mit dem Design nicht stimmt. IMHO sollte man in der Lage sein, reines OO zu verwenden, um alle Probleme zu lösen. In diesem Moment starre ich auf die einmillionste Verwendung von intern in der .NET Framework-Quelle, die es mir unmöglich macht, die von ihnen selbst verwendeten Inhalte zu nutzen. Durch die Verwendung von intern haben sie einen Monolithen geschaffen, der oberflächlich modular ist, aber zusammenbricht, wenn Sie versuchen, Dinge zu isolieren. Sicherheit ist auch kein Argument, da die Rettung reflektiert wird.
Grimasse der Verzweiflung
26
@GrimaceofDespair: Lassen Sie mich hier einen diagreeing Kommentar hinzufügen. Ich persönlich sehe intern als eine sehr nützliche Version des Modifikators "public" in großen Multiprojektlösungen. Das Hinzufügen dieses Modifikators zu einer Klasse in meinem Teilprojekt verhindert die "zufällige Verwendung" dieser Klasse durch andere Teilprojekte in der Lösung und ermöglicht es mir, die ordnungsgemäße Verwendung meiner Bibliothek zu erzwingen. Wenn ich später etwas umgestalten muss, muss ich mich nicht fragen: "Warten Sie, aber warum hat dieser Typ eine Instanz der Point-Klasse erstellt, die ich nur für meine eigenen Zwecke innerhalb dieser speziellen Berechnung benötigt habe?"
KT.
3
Anders ausgedrückt, wenn sich alle auf die Interna des SmtpClient verlassen würden und in einem Moment dort ein Fehler entdeckt würde, hätte .NET ernsthafte Probleme, diesen Fehler zu beheben, und würde ihn möglicherweise sogar lange aufrechterhalten. Ich erinnere mich, dass ich einmal einen amüsanten Artikel gelesen habe, in dem die Länge beschrieben wurde, bis zu der Windows-Entwickler gehen mussten, um die "Bugwards-Kompatibilität" mit allen älteren Programmen zu gewährleisten, die verschiedene interne Funktionen und Fehler verwendeten. Das Wiederholen dieses Fehlers mit .NET ist nicht sinnvoll.
KT.
13
Ich denke, intern ist viel nützlicher als öffentlich. Sie verwenden public nur dann, wenn Sie explizit sagen: "Hier, Benutzer - ich biete eine nützliche Funktion, die Sie verwenden können." Wenn Sie eher eine Anwendung als eine Benutzerbibliothek schreiben, sollte alles intern sein, da Sie nicht versuchen, den Benutzern Funktionen zum externen Aufrufen zu geben. Wenn Sie eine Benutzerbibliothek schreiben, sollten nur die nützlichen Funktionen öffentlich sein, die Sie dem Benutzer geben, warten, unterstützen und bis zum Ende der Zeit beibehalten möchten. Andernfalls machen Sie es intern.
Darrell Plank
85

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.

Eric Lippert
quelle
5
Macht perfekt Sinn. Ich wünschte nur, wir hätten die Möglichkeit, interne Mitglieder zu überschreiben, weil wir hier alle Erwachsenen zustimmen.
Cwallenpoole
6
@ EricLippert Nicht ganz das, was ich meinte. Wenn ich kompilierten Code erbe, der "intern" enthält, stecke ich fest, oder? Es gibt keine Möglichkeit, dem Compiler einfach zu sagen: "Nein, dieser andere Entwickler hat Sie angelogen. Sie sollten mir stattdessen vertrauen", es sei denn, ich verwende Reflection.
Cwallenpoole
11
@cwallenpoole: Wenn Sie Code verwenden, der von Lügnern geschrieben wurde, die Code schreiben, den Sie nicht mögen, hören Sie auf, ihren Code zu verwenden, und schreiben Sie Ihren eigenen Code, den Sie besser mögen.
Eric Lippert
2
@EricLippert Das sollte Zunge in die Wange sein, ich wollte nicht beleidigen. (Ich habe meistens nur versucht zu bestätigen, dass ich in solchen Fällen SOL bin).
Cwallenpoole
5
@cwallenpoole: Ich bin nicht im geringsten beleidigt. Ich biete gute Ratschläge an, falls Sie sich in dieser unglücklichen Situation befinden.
Eric Lippert
60

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.

Joel Mueller
quelle
4
Pff. Wenn Sie den Bytecode mit einem Disassembler betrachten, wird immer noch ziemlich klar, was der Code sowieso tut. Obfuscators sind kaum eine milde Abschreckung für jemanden, der wirklich versucht, in die Interna zu gelangen. Ich habe noch nie von einem Hacker gehört, der aufgehört hat, nur weil er keine nützlichen Funktionsnamen erhalten hat.
Nyerguds
28
Sie schließen Ihre Tür also nicht ab, wenn Sie schlafen, weil Sie noch nie von einem Dieb gehört haben, der durch ein Schloss gestoppt wurde?
Sergio
4
Deshalb verschlüssele ich Klassen- und Variablennamen im Quellcode. Sie können vielleicht herausfinden, was ein PumpStateComparator ist, aber können Sie erraten, was ein LpWj4mWE ist? #jobsecurity (Ich mache das nicht und bitte mach das auch nicht, Internet-Leute.)
Slothario
32

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.

Jeffrey L Whitledge
quelle
20

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.

Edwin Jarvis
quelle
12

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.

Ilya Komakhin
quelle
3
Wenn Sie "so streng wie möglich modifizieren", warum dann nicht privat?
R. Martinho Fernandes
6
Da privat zu streng ist, wenn auf Klasseneigenschaften / -methoden außerhalb der Klasse zugegriffen werden muss, und Fälle, in denen von einer anderen Seite aus auf sie zugegriffen werden muss, sind bly nicht so häufig.
Ilya Komakhin
11

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.

mattlant
quelle
Ich erstelle häufig Domänenobjekte, für die sie Mitglieder haben, die für andere Domänenobjekte innerhalb derselben Assembly öffentlich sein sollten. Dieselben Mitglieder sollten jedoch NICHT für Clientcode verfügbar sein, der sich außerhalb der Assembly befindet. Für Situationen wie diese ist "intern" sehr angemessen.
Rock Anthony Johnson
8

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.

Programmierwerkzeug
quelle
7

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

Murad Mohd Zain
quelle
6

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.

Aaron Powell
quelle
6

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.

cfeduke
quelle
5

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.
Michael Damatov
quelle
4

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

Streit
quelle
4

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.

xofz
quelle
2

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.

Keith Williams
quelle
2

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.

Fredrik Mörk
quelle
1

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

Steven A. Lowe
quelle
1

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.

Andrew Kennan
quelle
1

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.

Samik R.
quelle
@Samik - Könnten Sie bitte näher erläutern: "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." Warum wird unzählige bevorzugt?
Howiecamp
1
@Howiecamp: Meistens, weil IEnumerable einen schreibgeschützten Zugriff auf die Liste bietet. Wenn Sie die Liste direkt verfügbar machen, kann sie von Clients geändert werden (z. B. Elemente löschen usw.), was möglicherweise unbeabsichtigt ist.
Samik R
Wenn Sie eine Liste oder IList verfügbar machen, wird ein Vertrag erstellt, mit dem Sie beispielsweise (z. B.) immer schnell auf die Daten zugreifen können. Wenn Sie eines Tages entscheiden, Ihre Methode zu ändern, um eine andere Sammlung oder gar keine Sammlung zu verwenden (Ertragsrendite), müssen Sie entweder eine Liste erstellen, um nur einen Wert zurückzugeben, oder den Vertrag durch Ändern des Rückgabetyps der Methode brechen. Die Verwendung eines weniger spezifischen Rückgabetyps bietet Ihnen Flexibilität.
1

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.

Matt Davis
quelle
Warum also nicht stattdessen privat verwenden?
Gefangener
1
Das privateSchlüsselwort kann nur für Klassen oder Strukturen verwendet werden, die in einer anderen Klasse oder Struktur definiert sind. Eine in einem Namespace definierte Klasse kann nur deklariert werden publicoder internal.
Matt Davis
1

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.

Grzenio
quelle
-7

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() { }
}
Yfeldblum
quelle
Was versuchst du zu sagen? Es ist nicht sehr klar. Zumindest nicht für mich.
pqsk
Einverstanden mit @pqsk
Anynomous Khan