Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. csharp-internal
.NET HILFE

C# intern (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Beim Verwalten der Sichtbarkeit von Formularen, Methoden und Eigenschaften in einem statischen void-Main-Programm sind Zugriffsmodifikatoren in der C#-komponentenbasierten Entwicklungsprogrammiersprache unerlässlich. Beim Erstellen modularer und wartbarer grafischer Benutzeroberflächen ist einer dieser Zugriffsmodifikatoren, der sehr relevant ist, internal. Die Idee von C# internal wird in diesem Artikel diskutiert, zusammen mit mehreren nützlichen Anwendungen für IronPDF, ein flexibles C#-Framework zur Verwaltung von PDF-Dokumenten.

Verwendung von internal-Mitgliedern in der komponentenbasierten Entwicklung in C

  1. Erstellen Sie ein C#-Projekt.
  2. Verstehen Sie den internal-Zugriffsmodifikator.
  3. Wenden Sie internal auf Mitglieder an.
  4. Organisieren Sie den Code auf Assembly-Ebene.
  5. Verwenden Sie internal-Mitglieder innerhalb derselben Assembly.
  6. Kompilieren Sie den Code.

Verständnis des internal-Zugriffsmodifikators

Das internal-Schlüsselwort/Zugriffsmodifikator in C# beschränkt die Sichtbarkeit eines Typs oder Mitglieds auf die anderen Mitglieder innerhalb derselben Assembly. Dies impliziert, dass jede Klasse, sei es eine abgeleitete Klasse, Methode oder Eigenschaft, die als internal gekennzeichnet ist, von anderen Typen innerhalb derselben Assembly zugänglich sein kann, aber für Typen außerhalb der Assembly nicht verfügbar ist. Dieser Grad der Zugriffskontrolle ist für die Kapselung unerlässlich, da er es Ihnen ermöglicht, Implementierungsdetails festzulegen, die ausschließlich innerhalb derselben Assembly auf private Weise verwendet werden sollen.

In C# können Sie den internal-Modifikator auf folgende Weise verwenden:

Interne Klasse

Deklarieren einer Klasse, die nur innerhalb derselben Assembly verfügbar ist, indem internal verwendet wird.

// Assembly1
internal class InternalClass
{
    // Members of InternalClass
}
// Assembly1
internal class InternalClass
{
    // Members of InternalClass
}
' Assembly1
Friend Class InternalClass
	' Members of InternalClass
End Class
$vbLabelText   $csharpLabel

Interne Klassenmitglieder

Einschränkung der Sichtbarkeit von Klassenmitgliedern, wie Feldern, Eigenschaften und Methoden, auf dieselbe Assembly durch Anwendung von internal.

// Assembly1
internal class MyClass
{
    internal static int InternalField;
    internal void InternalMethod() { }
}
// Assembly1
internal class MyClass
{
    internal static int InternalField;
    internal void InternalMethod() { }
}
' Assembly1
Friend Class [MyClass]
	Friend Shared InternalField As Integer
	Friend Sub InternalMethod()
	End Sub
End Class
$vbLabelText   $csharpLabel

Interne Schnittstelle

Deklarieren einer Schnittstelle, die nur innerhalb derselben Assembly durch Verwendung des internal-Zugriffsmodifikators zugänglich ist.

// Assembly1
internal interface IInternalInterface
{
    // Interface members
}
// Assembly1
internal interface IInternalInterface
{
    // Interface members
}
' Assembly1
Friend Interface IInternalInterface
	' Interface members
End Interface
$vbLabelText   $csharpLabel

Intern verschachtelte Klasse

Deklarieren einer geschachtelten Klasse, die nur innerhalb derselben Assembly unter Verwendung von internal zugänglich ist.

// Assembly1
public class OuterClass
{
    internal class InternalNestedClass
    {
        // Members of InternalNestedClass
    }
}
// Assembly1
public class OuterClass
{
    internal class InternalNestedClass
    {
        // Members of InternalNestedClass
    }
}
' Assembly1
Public Class OuterClass
	Friend Class InternalNestedClass
		' Members of InternalNestedClass
	End Class
End Class
$vbLabelText   $csharpLabel

Interner Aufbau

Einschränkung des Zugriffs auf die gesamte Assembly von externen Assemblies durch Anwendung von internal auf Assembly-Ebene.

using System.Runtime.CompilerServices;

// Allowing "ExternalAssembly" to access internal members of this assembly
[assembly: InternalsVisibleTo("ExternalAssembly")]
using System.Runtime.CompilerServices;

// Allowing "ExternalAssembly" to access internal members of this assembly
[assembly: InternalsVisibleTo("ExternalAssembly")]
Imports System.Runtime.CompilerServices

' Allowing "ExternalAssembly" to access internal members of this assembly
<Assembly: InternalsVisibleTo("ExternalAssembly")>
$vbLabelText   $csharpLabel

Während der Entwicklung und des Testens können die internal-Zugriffsmodifikatoren einer bestimmten externen Assembly durch Verwendung des Attributs InternalsVisibleTo zugänglich gemacht werden.

// Assembly A
public class MyClassA
{
    internal void MyInternalMethod()
    {
        // Implementation details only accessible within Assembly A
    }
}

// Assembly B
public class MyClassB
{
    void SomeMethod()
    {
        MyClassA myObject = new MyClassA();
        myObject.MyInternalMethod(); // This will result in a compilation error
    }
}
// Assembly A
public class MyClassA
{
    internal void MyInternalMethod()
    {
        // Implementation details only accessible within Assembly A
    }
}

// Assembly B
public class MyClassB
{
    void SomeMethod()
    {
        MyClassA myObject = new MyClassA();
        myObject.MyInternalMethod(); // This will result in a compilation error
    }
}
' Assembly A
Public Class MyClassA
	Friend Sub MyInternalMethod()
		' Implementation details only accessible within Assembly A
	End Sub
End Class

' Assembly B
Public Class MyClassB
	Private Sub SomeMethod()
		Dim myObject As New MyClassA()
		myObject.MyInternalMethod() ' This will result in a compilation error
	End Sub
End Class
$vbLabelText   $csharpLabel

Da MyInternalMethod in diesem Beispiel als internes Element gekennzeichnet ist, kann darauf nur innerhalb der Assembly A zugegriffen werden. Ein Kompilierungsfehler tritt auf, wenn Sie versuchen, auf diese Funktion von Assembly B aus zuzugreifen.

Das Kombinieren der Zugriffsmodifikatoren protected und internal führt zum protected internal-Zugriffsmodifikator. Ein Mitglied (Methode, Eigenschaft oder Feld) oder ein Typ (Klasse, Schnittstelle oder Delegat) kann dank des zusammengesetzten protected internal-Zugriffsmodifikators sowohl innerhalb als auch außerhalb seiner Assembly von abgeleiteten Typen zugegriffen werden. Das protected internal-Zugriffslevel bietet ein Gleichgewicht zwischen den Sichtbarkeiten, die protected und internal getrennt bereitstellen.

IronPDF

Mit der Programmiersprache C# ist die IronPDF-Offizielle Seite eine .NET-Bibliothek, die Entwicklern das Erstellen, Bearbeiten und Modifizieren von PDF-Dokumenten ermöglicht. Es bietet eine Reihe von Werkzeugen und Funktionen, um auf verschiedene Arten mit PDF-Dateien zu interagieren, einschließlich der Erstellung von PDFs aus HTML, der Umwandlung von HTML in PDF, der Kombination oder Teilung von PDF-Dokumenten sowie dem Hinzufügen von Anmerkungen, Texten und Fotos zu bereits existierenden PDFs.

IronPDF installieren

Holen Sie sich die IronPDF-Bibliothek; sie wird für den zukünftigen Patch benötigt. Geben Sie den folgenden Befehl in die Paket-Manager-Konsole ein, um dies zu erreichen:

Install-Package IronPdf

C# Intern (So funktioniert es für Entwickler): Abbildung 1 – IronPDF installieren

Die Verwendung des NuGet-Paket-Managers zur Suche nach dem Paket "IronPDF" ist eine zusätzliche Wahl. Wir können aus dieser Liste aller mit IronPDF verbundenen NuGet-Pakete das benötigte Paket auswählen und herunterladen.

C# Intern (So funktioniert es für Entwickler): Abbildung 2 - IronPDF Paket

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Funktionen von IronPDF

  • HTML in PDF konvertieren: Mit IronPDF können Sie PDF-Dokumente aus beliebigen HTML-Informationen erstellen, einschließlich Dateien, URLs und HTML-Code-Zeichenfolgen.
  • PDF-Erstellung: Mithilfe der Programmiersprache C# können Sie Text, Grafiken und andere Komponenten programmatisch zu PDF-Dokumenten hinzufügen.
  • PDF-Manipulation: IronPDF bietet die Möglichkeit, eine PDF-Datei in zahlreiche Dateien aufzuteilen, mehrere PDF-Dokumente zu einer einzigen Datei zusammenzufügen und bereits vorhandene PDFs zu modifizieren.
  • PDF-Formulare: Die Bibliothek ist hilfreich in Situationen, in denen Formulardaten erfasst und verarbeitet werden müssen, da sie es Benutzern ermöglicht, PDF-Formulare zu erstellen und auszufüllen.
  • Sicherheitsmerkmale: PDF-Dokumente können mit IronPDF passwort- und berechtigungsgeschützt und verschlüsselt werden.
  • Textextraktion: IronPDF kann verwendet werden, um Text aus PDF-Dateien zu extrahieren.

Kapselung der PDF-Verarbeitung mit IronPDF

Eine Vielzahl von Funktionen zum Erstellen, Ändern und Verarbeiten von PDF-Dokumenten wird von IronPDF angeboten. Die Implementierungsdetails können hinter Assembly-Grenzen verborgen bleiben, indem der PDF-Verarbeitungscode in interne Klassen oder Methoden eingeschlossen wird. Um mehr über IronPDF zu erfahren, beziehen Sie sich auf die IronPDF-Dokumentation.

Untersuchen Sie die folgende Situation:

// Assembly A (PDFHandlingLibrary)
internal class PdfProcessor
{
    internal void AddWatermark(IronPdf.PdfDocument pdfDocument, string watermarkText)
    {
        // Implementation details for adding a watermark using IronPDF
    }

    internal IronPdf.PdfDocument MergePdfDocuments(IEnumerable<IronPdf.PdfDocument> pdfDocuments)
    {
        // Implementation details for merging PDF documents using IronPDF
        IronPdf.PdfDocument mergedPdfDocument = new IronPdf.PdfDocument();
        // Logic to merge documents
        return mergedPdfDocument;
    }
}

// Assembly B (MainApplication)
public class MainClass
{
    void ProcessPdfDocuments()
    {
        // Create an instance of the PdfProcessor within the same assembly
        PdfProcessor pdfProcessor = new PdfProcessor();

        // Assuming pdfDocumentList is defined
        IEnumerable<IronPdf.PdfDocument> pdfDocumentList = new List<IronPdf.PdfDocument>();

        // Accessing internal methods within the same assembly is allowed
        pdfProcessor.AddWatermark(new IronPdf.PdfDocument(), "Confidential");
        IronPdf.PdfDocument mergedPdf = pdfProcessor.MergePdfDocuments(pdfDocumentList);
    }
}
// Assembly A (PDFHandlingLibrary)
internal class PdfProcessor
{
    internal void AddWatermark(IronPdf.PdfDocument pdfDocument, string watermarkText)
    {
        // Implementation details for adding a watermark using IronPDF
    }

    internal IronPdf.PdfDocument MergePdfDocuments(IEnumerable<IronPdf.PdfDocument> pdfDocuments)
    {
        // Implementation details for merging PDF documents using IronPDF
        IronPdf.PdfDocument mergedPdfDocument = new IronPdf.PdfDocument();
        // Logic to merge documents
        return mergedPdfDocument;
    }
}

// Assembly B (MainApplication)
public class MainClass
{
    void ProcessPdfDocuments()
    {
        // Create an instance of the PdfProcessor within the same assembly
        PdfProcessor pdfProcessor = new PdfProcessor();

        // Assuming pdfDocumentList is defined
        IEnumerable<IronPdf.PdfDocument> pdfDocumentList = new List<IronPdf.PdfDocument>();

        // Accessing internal methods within the same assembly is allowed
        pdfProcessor.AddWatermark(new IronPdf.PdfDocument(), "Confidential");
        IronPdf.PdfDocument mergedPdf = pdfProcessor.MergePdfDocuments(pdfDocumentList);
    }
}
' Assembly A (PDFHandlingLibrary)
Friend Class PdfProcessor
	Friend Sub AddWatermark(ByVal pdfDocument As IronPdf.PdfDocument, ByVal watermarkText As String)
		' Implementation details for adding a watermark using IronPDF
	End Sub

	Friend Function MergePdfDocuments(ByVal pdfDocuments As IEnumerable(Of IronPdf.PdfDocument)) As IronPdf.PdfDocument
		' Implementation details for merging PDF documents using IronPDF
		Dim mergedPdfDocument As New IronPdf.PdfDocument()
		' Logic to merge documents
		Return mergedPdfDocument
	End Function
End Class

' Assembly B (MainApplication)
Public Class MainClass
	Private Sub ProcessPdfDocuments()
		' Create an instance of the PdfProcessor within the same assembly
		Dim pdfProcessor As New PdfProcessor()

		' Assuming pdfDocumentList is defined
		Dim pdfDocumentList As IEnumerable(Of IronPdf.PdfDocument) = New List(Of IronPdf.PdfDocument)()

		' Accessing internal methods within the same assembly is allowed
		pdfProcessor.AddWatermark(New IronPdf.PdfDocument(), "Confidential")
		Dim mergedPdf As IronPdf.PdfDocument = pdfProcessor.MergePdfDocuments(pdfDocumentList)
	End Sub
End Class
$vbLabelText   $csharpLabel

In diesem Beispiel verwendet die Klasse PdfProcessor der Assembly A IronPDF , um den PDF-Verarbeitungscode zu kapseln. Da die Methoden als internal gekennzeichnet sind, können sie nur von anderen internen Mitgliedern derselben Assembly zugegriffen werden. Assembly B's MainClass kann diese internen Funktionen problemlos nutzen. Um mehr über den IronPDF-Code zu erfahren, beziehen Sie sich auf das IronPDF HTML zu PDF Beispiel.

C# Intern (So funktioniert es für Entwickler): Abbildung 3 - Ausgabe

Abschluss

Schließlich bietet der internal-Modifikator von C# eine starke Kontrolle darüber, welche Typen und Mitglieder innerhalb einer Assembly sichtbar sind. Es hilft, sichere, modulare und wartbare Anwendungen in Kombination mit IronPDF zu erstellen. Sie können einen Kompromiss zwischen Abstraktion, Sicherheit und Benutzerfreundlichkeit finden, indem Sie den mit IronPDF verbundenen Code in interne Klassen oder Methoden einschließen. Beim Arbeiten mit Bibliotheken wie IronPDF, die essentielle Funktionen wie die Verarbeitung von PDF-Dokumenten verwalten, ist es besonders wichtig, die Konzepte der Kapselung und des eingeschränkten Zugriffs zu unterstützen, um eine stabile und skalierbare Architektur in Ihren C#-Anwendungen zu fördern.

Eine sehr robuste Lizenz, Redesign-Optionen und eine längere Dauer des Programmiersupports sind alle im $999 Light-Bundle von IronPDF enthalten. Kunden können den Artikel während der Testphase mit Wasserzeichen in echten Anwendungskontexten testen. Erfahren Sie mehr über IronPDF-Lizenzierung, um die Vorteile, den Genehmigungsprozess und das Entwurfsformular zu verstehen. Besuchen Sie die Iron Software-Website, um mehr zu erfahren.

Häufig gestellte Fragen

Wie verbessert das interne Schlüsselwort in C# die Kapselung?

Das interne Schlüsselwort in C# verbessert die Kapselung, indem es die Sichtbarkeit von Typen oder Mitgliedern auf dieselbe Assembly beschränkt und so verhindert, dass externe Assemblies auf interne Implementierungsdetails zugreifen. Dies fördert eine sauberere Architektur und die Wartbarkeit des Codebestands.

Welche Rolle spielt das Attribut InternalsVisibleTo in C#?

Das Attribut InternalsVisibleTo in C# ermöglicht es, internen Mitgliedern einer Assembly den Zugang zu einer angegebenen externen Assembly zu gewähren. Dies ist besonders nützlich für Tests, da es Test-Assemblies ermöglicht, auf interne Mitglieder zur Validierung zuzugreifen, während die Kapselung während der Bereitstellung aufrechterhalten wird.

Kann der interne Zugriffsmodifikator für die PDF-Verarbeitung in C# verwendet werden?

Ja, der interne Zugriffsmodifikator kann in Verbindung mit Bibliotheken wie IronPDF verwendet werden, um die PDF-Verarbeitungslogik innerhalb einer Assembly zu kapseln. Dadurch wird sichergestellt, dass sensible PDF-Manipulationsfunktionen nicht extern exponiert werden, was die Sicherheit und Wartbarkeit erhöht.

Was sind einige häufige Anwendungsfälle für das interne Schlüsselwort in C#?

Häufige Anwendungsfälle für das interne Schlüsselwort in C# umfassen die Einschränkung des Zugriffs auf interne Klassen, Methoden und Eigenschaften, insbesondere beim Aufbau modularer Komponenten wie grafische Benutzeroberflächen oder beim Kapseln von Geschäftslogik innerhalb von Bibliotheken wie IronPDF zur PDF-Dokumentenverwaltung.

Wie kann man HTML mit C# in PDFs konvertieren?

Sie können HTML mit C# in PDFs konvertieren, indem Sie IronPDF verwenden. Die Bibliothek bietet Methoden wie RenderHtmlAsPdf, um HTML-Strings in PDF-Dokumente zu konvertieren, sowie RenderHtmlFileAsPdf, um HTML-Dateien direkt zu konvertieren.

Welche Vorteile bietet der Einsatz des internen Zugriffsmodifikators für die Bibliotheksentwicklung?

Der Einsatz des internen Zugriffsmodifikators in der Bibliotheksentwicklung bietet Vorteile wie erhöhte Sicherheit, indem sensible Implementierungsdetails vor externen Assemblies verborgen werden, und verbesserte Wartbarkeit durch das Kapseln komplexer Logik innerhalb der Bibliothek und das Freigeben nur notwendiger Schnittstellen.

Wie kann IronPDF für die Dokumentensicherheit bei der PDF-Verarbeitung genutzt werden?

IronPDF kann für die Dokumentensicherheit bei der PDF-Verarbeitung genutzt werden, indem Funktionen wie Passwortschutz, Verschlüsselung und Zugriffskontrolle angewendet werden, um sicherzustellen, dass nur autorisierte Benutzer die generierten oder manipulierten PDF-Dokumente in einer sicheren Umgebung anzeigen oder ändern können.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an