Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. csharp-internal
.NET AIDE

C# Internal (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Lors de la gestion de la visibilité des classes de formulaire, des méthodes et des propriétés dans un programme principal void statique, les modificateurs d'accès sont essentiels dans le langage de programmation de développement basé sur les composants C#. Lors de la création d'interfaces utilisateur graphiques modulaires et maintenables, un modificateur d'accès pertinent est internal. L'idée de C# internal sera discutée dans cet article, ainsi que plusieurs applications utiles pour IronPDF, un framework C# flexible pour la gestion des documents PDF.

Comment utiliser les membres internes dans le développement basé sur les composants C

  1. Créez un projet C#.
  2. Comprenez le modificateur d'accès internal.
  3. Appliquez 'internal' aux membres.
  4. Organisez le code au niveau de l'assembly.
  5. Utilisez les membres internes au sein du même assembly.
  6. Compilez le code.

Comprendre le modificateur d'accès internal

En C#, le mot-clé/modificateur d'accès internal limite la visibilité d'un type ou d'un membre à celle des autres membres au sein du même assembly. Cela implique que toute classe, qu'il s'agisse d'une classe dérivée, d'une méthode ou d'une propriété étiquetée comme internal, peut être accessible par d'autres types au sein du même assembly mais est inaccessible aux types en dehors de l'assembly. Ce degré de contrôle d'accès est essentiel pour l'encapsulation car il vous permet de spécifier des détails d'implémentation qui doivent être utilisés exclusivement à l'intérieur du même assembly de manière privée.

En C#, vous pouvez utiliser le modificateur internal de manière suivante :

Classe Interne

Déclarer une classe qui n'est disponible qu'à l'intérieur du même assembly en utilisant internal.

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

Classe Interne Members

Limiter la visibilité des membres de la classe, tels que les champs, les propriétés et les méthodes, au même assembly en appliquant 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

Interface Interne

Déclarer une interface qui ne peut être accédée qu'au sein du même assembly en utilisant le modificateur d'accès internal.

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

Classe Imbriquée Interne

Déclarer une classe imbriquée qui ne peut être accédée qu'à l'intérieur du même assembly en utilisant internal.

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

Assembly Interne

Limiter l'accès à l'ensemble de l'assembly depuis les assemblies externes en appliquant internal au niveau de l'assembly.

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

Pendant le développement et les tests, les modificateurs d'accès internal peuvent être rendus accessibles à un assembly externe désigné en utilisant l'attribut InternalsVisibleTo.

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

Étant donné que MyInternalMethod est désigné comme un membre interne dans cet exemple, il ne peut être accédé qu'au sein de l'Assembly A. Une erreur de compilation se produira si vous tentez d'accéder à cette fonction depuis l'Assembly B.

La combinaison des modificateurs d'accès protected et internal donne le modificateur d'accès protected internal. Un membre (méthode, propriété ou champ) ou un type (classe, interface ou délégué) peut être accédé à la fois à l'intérieur et à l'extérieur de son assembly par des types dérivés grâce à un modificateur d'accès composé protected internal. Un équilibre entre la visibilité que les niveaux d'accès protected et internal donnent séparément est fourni par le niveau d'accès protected internal.

IronPDF

En utilisant le langage de programmation C#, le site officiel IronPDF est une bibliothèque .NET qui permet aux développeurs de générer, éditer et modifier des documents PDF. Il propose une gamme d'outils et de fonctionnalités pour interagir avec les fichiers PDF de différentes manières, y compris la création de PDF à partir de HTML, la conversion de HTML en PDF, la combinaison ou la division de documents PDF, et l'ajout d'annotations, de texte et de photos à des PDF déjà existants.

Installer IronPDF

Obtenez la bibliothèque IronPDF ; elle est nécessaire pour le prochain correctif. Entrez la commande suivante dans la console du gestionnaire de package pour y parvenir :

Install-Package IronPdf

C# Internal (Comment cela fonctionne pour les développeurs) : Figure 1 - Installer IronPDF

Utiliser le gestionnaire de packages NuGet pour rechercher le package "IronPDF" est une option supplémentaire. Nous pouvons choisir et télécharger le package nécessaire à partir de cette liste de tous les packages NuGet associés à IronPDF.

C# Internal (Comment cela fonctionne pour les développeurs) : Figure 2 - Package IronPDF

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

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

Caractéristiques de IronPDF

  • Convertir HTML en PDF : Avec IronPDF, vous pouvez créer des documents PDF à partir de tout type d'informations HTML, y compris des fichiers, des URL et des chaînes de code HTML.
  • Génération PDF : En utilisant le langage de programmation C#, vous pouvez ajouter du texte, des graphiques et d'autres composants aux documents PDF de manière programmatique.
  • Manipulation PDF : IronPDF offre des capacités pour diviser un fichier PDF en plusieurs fichiers, combiner plusieurs documents PDF en un seul fichier, et modifier des PDF déjà existants.
  • Formulaires PDF : La bibliothèque est utile dans des situations où des données de formulaire doivent être recueillies et traitées puisqu'elle permet aux utilisateurs de créer et remplir des formulaires PDF.
  • Fonctionnalités de Sécurité : Les documents PDF peuvent être protégés par un mot de passe et des permissions et être encryptés en utilisant IronPDF.
  • Extraction de Texte : IronPDF peut être utilisé pour extraire du texte à partir de fichiers PDF.

Encapsulation de la Gestion des PDF avec IronPDF

Une vaste gamme de fonctionnalités pour la génération, la modification et le traitement des documents PDF est offerte par IronPDF. Les détails d'implémentation peuvent être cachés derrière les frontières de l'assembly en enveloppant le code de traitement des PDF à l'intérieur de classes ou méthodes internes. Pour en savoir plus sur IronPDF, référez-vous à la Documentation IronPDF.

Examinez la situation suivante :

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

Dans cet exemple, la classe PdfProcessor de l'assembly A utilise IronPDF pour encapsuler le code de traitement des PDF. Parce que les méthodes sont désignées comme internes, elles ne peuvent être accédées que par d'autres membres internes du même assembly. La MainClass de l'assembly B peut facilement utiliser ces fonctions internes. Pour en savoir plus sur le code IronPDF, référez-vous à l'Exemple IronPDF HTML vers PDF.

C# Internal (Comment cela fonctionne pour les développeurs) : Figure 3 - Sortie

Conclusion

Enfin, le modificateur C# internal offre un contrôle fort sur quels types et membres sont visibles à l'intérieur d'un assembly. Il aide à créer des applications sûres, modulaires et maintenables lorsqu'il est utilisé en conjonction avec IronPDF. Vous pouvez trouver un compromis entre l'abstraction, la sécurité et la facilité d'utilisation en encapsulant le code lié à IronPDF à l'intérieur de classes ou méthodes internes. Lorsque vous travaillez avec des bibliothèques comme IronPDF qui gèrent des fonctions essentielles telles que le traitement des documents PDF, il est particulièrement important d'adopter les concepts d'encapsulation et d'accès limité pour promouvoir une architecture stable et évolutive dans vos applications C#.

Une licence très robuste, des options de personnalisation et une plus longue durée de support de programmation sont tous inclus dans le light bundle $799 d'IronPDF. Les clients peuvent tester l'élément dans des contextes d'application réels pendant la période d'essai marquée d'un filigrane. En savoir plus sur Licences IronPDF pour comprendre les avantages, le processus d'approbation et le formulaire de brouillon. Consultez le Site Web Iron Software pour en savoir plus.

Questions Fréquemment Posées

Comment le mot-clé interne en C# améliore-t-il l'encapsulation ?

Le mot-clé interne en C# améliore l'encapsulation en restreignant la visibilité des types ou membres à l'intérieur de la même assemblée, empêchant ainsi les assemblées externes d'accéder aux détails internes de l'implémentation. Cela favorise une architecture plus propre et la maintenabilité de la base de code.

Quel est le rôle de l'attribut InternalsVisibleTo en C# ?

L'attribut InternalsVisibleTo en C# vous permet d'accorder l'accès aux membres internes d'une assemblée à une assemblée externe spécifiée. Ceci est particulièrement utile pour les tests, car il permet aux assemblées de test d'accéder aux membres internes pour la validation tout en maintenant l'encapsulation lors du déploiement.

Le modificateur d'accès interne peut-il être utilisé pour le traitement des PDF en C# ?

Oui, le modificateur d'accès interne peut être utilisé en conjonction avec des bibliothèques comme IronPDF pour encapsuler la logique de traitement des PDF au sein d'une assemblée. Cela garantit que les fonctions sensibles de manipulation de PDF ne sont pas exposées à l'extérieur, renforçant la sécurité et la maintenabilité.

Quels sont les cas d'utilisation courants pour le mot-clé interne en C# ?

Les cas d'utilisation courants pour le mot-clé interne en C# incluent la restriction d'accès aux classes internes, aux méthodes et aux propriétés, en particulier lors de la création de composants modulaires tels que les interfaces utilisateur graphiques ou lors de l'encapsulation de la logique métier au sein de bibliothèques comme IronPDF pour la gestion des documents PDF.

Comment convertir HTML en PDF en utilisant C# ?

Vous pouvez convertir HTML en PDF en utilisant C# avec IronPDF. La bibliothèque offre des méthodes telles que RenderHtmlAsPdf pour convertir des chaînes HTML en documents PDF, ainsi que RenderHtmlFileAsPdf pour convertir directement des fichiers HTML.

Quels avantages le modificateur d'accès interne offre-t-il pour le développement de bibliothèques ?

L'utilisation du modificateur d'accès interne dans le développement de bibliothèques offre des avantages tels qu'une sécurité améliorée, en gardant les détails d'implémentation sensible cachés des assemblées externes, et une meilleure maintenabilité, en encapsulant la logique complexe au sein de la bibliothèque et en exposant seulement les interfaces nécessaires.

Comment IronPDF peut-il être utilisé pour la sécurité des documents lors du traitement des PDF ?

IronPDF peut être utilisé pour la sécurité des documents lors du traitement des PDF en appliquant des fonctionnalités telles que la protection par mot de passe, le cryptage et le contrôle d'accès, garantissant que seuls les utilisateurs autorisés peuvent voir ou modifier les documents PDF générés ou manipulés dans un environnement sécurisé.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit