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.
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 :
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
Friend Class InternalClass
' Members of InternalClass
End ClassLimiter 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
Friend Class [MyClass]
Friend Shared InternalField As Integer
Friend Sub InternalMethod()
End Sub
End ClassDé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
Friend Interface IInternalInterface
' Interface members
End InterfaceDé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
Friend Class InternalNestedClass
' Members of InternalNestedClass
End Class
End ClassLimiter 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")]Imports System.Runtime.CompilerServices
' Allowing "ExternalAssembly" to access internal members of this assembly
<Assembly: InternalsVisibleTo("ExternalAssembly")>Pendant le développement et les tests, les modificateurs d'accès internes 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
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Étant donné que MyInternalMethod est désigné comme un membre interne dans cet exemple, il ne peut être accessible qu'au sein de l'Assemblée 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.
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.
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 :
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.
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");
}
}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 ClassUne 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)
Friend Class PdfProcessor
Friend Sub AddWatermark(pdfDocument As IronPdf.PdfDocument, watermarkText As String)
' Implementation details for adding a watermark using IronPDF
End Sub
Friend Function MergePdfDocuments(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 ClassDans cet exemple, la classe PdfProcessor de l'assembly A utilise IronPDF pour encapsuler le code de traitement 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. Le 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.
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 redéfinition et une durée de support de programmation plus longue sont toutes incluses dans le paquet light $999 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.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
