Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
Cuando se gestiona la visibilidad de clases, métodos y propiedades de formularios dentro de un programa principal estático void, los modificadores de acceso son esenciales en el lenguaje de programación de desarrollo basado en componentes C#. Cuando se construyen interfaces gráficas de usuario modulares y aplicaciones mantenibles, uno de esos modificadores de acceso que es bastante relevante es el interno. La idea de C# interno en este artículo, junto con varias aplicaciones útiles para IronPDF, un marco flexible en C# para gestionar documentos PDF.
La palabra clave interna/modificador de acceso en C# limita la visibilidad de un tipo o miembro a la de otros miembros dentro del mismo ensamblado. Esto implica que cualquier clase, ya sea clase derivada, método o propiedad etiquetada como interna, puede ser accedida por otros tipos dentro del mismo ensamblaje, pero no está disponible para tipos fuera del ensamblaje. Este grado de control de acceso es esencial para la encapsulación, ya que le permite especificar los detalles de implementación que deben ser utilizados exclusivamente dentro de la misma asamblea de una manera privada.
En C#, puede utilizar el modificador interno de las siguientes maneras:
Declarar una clase que sólo está disponible dentro del mismo ensamblado utilizando internal.
// Assembly1
internal class InternalClass
{
// Members of InternalClass
}
// Assembly1
internal class InternalClass
{
// Members of InternalClass
}
' Assembly1
Friend Class InternalClass
' Members of InternalClass
End Class
Limitar la visibilidad de los miembros de la clase, como campos, propiedades y métodos, al mismo conjunto aplicando 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
Declarar una interfaz a la que sólo se puede acceder dentro del mismo ensamblaje utilizando el modificador de acceso interno.
// Assembly1
internal interface IInternalInterface
{
// Interface members
}
// Assembly1
internal interface IInternalInterface
{
// Interface members
}
' Assembly1
Friend Interface IInternalInterface
' Interface members
End Interface
Declarar una clase anidada a la que sólo se puede acceder dentro del mismo ensamblado utilizando 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
Limitación del acceso a todo el conjunto desde conjuntos externos mediante la aplicación de internos a nivel de conjunto.
[assembly: InternalsVisibleTo("ExternalAssembly")]
[assembly: InternalsVisibleTo("ExternalAssembly")]
<Assembly: InternalsVisibleTo("ExternalAssembly")>
Durante el desarrollo y las pruebas, los modificadores de acceso internos pueden hacerse accesibles a un conjunto externo designado utilizando la propiedad InternalsVisibleTo
.
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
}
}
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
}
}
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
Como MiMétodoInterno
se designa como miembro interno en este ejemplo, sólo se puede acceder a él dentro del Ensamblado A. Se producirá un error de compilación si intenta acceder a esta función desde el ensamblado B.
La combinación de los modificadores de acceso protegido e interno da como resultado el modificador de acceso interno protegido. Un miembro (método, propiedad o campo) o un tipo (clase, interfaz o delegado) puede ser accedido tanto dentro como fuera de su ensamblaje por tipos derivados gracias a un modificador de acceso compuesto interno protegido. El nivel de acceso interno protegido proporciona un equilibrio entre la visibilidad que dan por separado los niveles de acceso protegido e interno.
Utilización del lenguaje de programación C#, IronPDF es una biblioteca .NET que permite a los desarrolladores generar, editar y modificar documentos PDF. Ofrece toda una serie de herramientas y funciones para interactuar con archivos PDF de muchas maneras, como crear PDF a partir de HTML, convertir HTML en PDF, combinar o dividir documentos PDF y añadir anotaciones, texto y fotos a PDF ya existentes.
Obtenga la biblioteca IronPDF; es necesario para el futuro parche. Para ello, introduzca el siguiente código en el gestor de paquetes:
Install-Package IronPdf
Otra opción es utilizar el gestor de paquetes NuGet para buscar el paquete "IronPDF". Podemos elegir y descargar el paquete necesario de esta lista de todos los paquetes NuGet asociados con IronPDF.
IronPDF ofrece una amplia gama de funciones para generar, modificar y procesar documentos PDF. Los detalles de implementación pueden mantenerse ocultos tras los límites del ensamblado encerrando el código de procesamiento de PDF dentro de clases o métodos internos. Para más información sobre IronPDF aquí.
Examine la siguiente situación:
// 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
return mergedPdfDocument;
}
}
// Assembly B (MainApplication)
public class MainClass
{
void ProcessPdfDocuments()
{
var Renderer = new IronPdf.HtmlToPdf();
var pdfProcessor = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");;
// Accessing internal methods within the same assembly is allowed
pdfProcessor.ApplyWatermark("<h4>Confidential</h4>")
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
return mergedPdfDocument;
}
}
// Assembly B (MainApplication)
public class MainClass
{
void ProcessPdfDocuments()
{
var Renderer = new IronPdf.HtmlToPdf();
var pdfProcessor = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>");;
// Accessing internal methods within the same assembly is allowed
pdfProcessor.ApplyWatermark("<h4>Confidential</h4>")
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
Return mergedPdfDocument
End Function
End Class
' Assembly B (MainApplication)
Public Class MainClass
Private Sub ProcessPdfDocuments()
Dim Renderer = New IronPdf.HtmlToPdf()
Dim pdfProcessor = Renderer.RenderHtmlAsPdf("<h1>Hello, IronPDF</h1>")
' Accessing internal methods within the same assembly is allowed
pdfProcessor.ApplyWatermark("<h4>Confidential</h4>") IronPdf.PdfDocument mergedPdf = pdfProcessor.MergePdfDocuments(pdfDocumentList)
End Sub
End Class
En este ejemplo, la clase PdfProcessor del ensamblado A utiliza IronPDF para encapsular el código de procesamiento de PDF. Dado que los métodos se designan como internos, sólo los miembros internos del mismo ensamblaje pueden acceder a ellos. La MainClass del ensamblador B puede utilizar fácilmente estas funciones internas. Para saber más sobre el código IronPDF, consulte aquí.
Finalmente, el modificador interno de C# proporciona un fuerte control sobre qué tipos y miembros son visibles dentro de un ensamblado. Ayuda a crear aplicaciones seguras, modulares y fáciles de mantener cuando se utiliza junto con IronPDF. Puede alcanzar un compromiso entre abstracción, seguridad y usabilidad encerrando el código relacionado con IronPDF dentro de clases o métodos internos. Cuando se trabaja con bibliotecas como IronPDF que gestionan funciones esenciales como el procesamiento de documentos PDF, es especialmente importante adoptar los conceptos de encapsulación y acceso limitado para promover una arquitectura estable y escalable en sus aplicaciones C#.
El paquete ligero $749 de IronPDF incluye una licencia muy robusta, opciones de rediseño y una mayor duración del soporte de programación. Los clientes pueden probar el artículo en entornos de aplicación reales durante el periodo de prueba con marca de agua. Haga clic en el botón enlace para obtener más información sobre las ventajas, el proceso de aprobación y el formulario de borrador de IronPDF. Mira esto sitio web para obtener más información sobre Iron Software.
9 productos API .NET para sus documentos de oficina