C# Nuevo (Cómo funciona para los desarrolladores)

La palabra clave del operador new en C# es versátil y cumple múltiples funciones esenciales en el lenguaje. Desde la instanciación de objetos hasta la ocultación de miembros heredados, la comprensión de sus aplicaciones es crucial para un desarrollo eficaz de C#. Esta guía explora el nuevo con ejemplos claros que ilustran su potencia y flexibilidad. También exploraremos la IronPDF más adelante en esta guía.

Introducción a la instanciación de objetos

La instanciación de objetos es el proceso en el que el operador new crea una instancia de una clase o estructura. En C#, esto se consigue principalmente utilizando la palabra clave new, que llama al constructor del tipo especificado y asigna memoria para el nuevo objeto.

Creación de instancias con el nuevo

Para crear una instancia de un objeto, el operador new va seguido del nombre de la clase y de un par de paréntesis. Si la clase tiene un constructor que toma parámetros, los argumentos deben ser suministrados dentro de estos paréntesis.

public class Book {
    public string Title { get; set; }
    public Book(string title) {
        Title = title;
    }
}
Book book = new Book("The C# Programming Language");

public class Book {
    public string Title { get; set; }
    public Book(string title) {
        Title = title;
    }
}
Book book = new Book("The C# Programming Language");

Public Class Book
	Public Property Title() As String
	Public Sub New(ByVal title As String)
		Me.Title = title
	End Sub
End Class
Private book As New Book("The C# Programming Language")

Constructores por defecto y sin parámetros

C# proporciona un constructor por defecto si no hay constructores definidos explícitamente en una clase. Sin embargo, una vez definido un constructor con parámetros, debe declararse explícitamente un constructor sin parámetros si es necesario.

public class ExampleClass {
    // Parameterless constructor
    public ExampleClass() {
        // Initialization code here
    }
}

public class ExampleClass {
    // Parameterless constructor
    public ExampleClass() {
        // Initialization code here
    }
}

Public Class ExampleClass
	' Parameterless constructor
	Public Sub New()
		' Initialization code here
	End Sub
End Class

Técnicas avanzadas de creación de objetos

En C#, la creación de objetos no consiste sólo en instanciar clases; es una puerta de entrada para aprovechar las potentes características del lenguaje y conseguir un código más eficaz, legible y conciso. Aquí exploraremos técnicas avanzadas como el trabajo con matrices, la utilización de tipos y el empleo de inicializadores de objetos para agilizar sus esfuerzos de codificación.

Matrices y colecciones

Crear matrices de un tipo específico en C# es una habilidad fundamental, pero son los matices los que elevan tus capacidades de codificación. Utilizando la palabra clave new, puedes instanciar matrices, especificando su tipo y el número de elementos que deben contener. Esto es crucial para gestionar colecciones de variables de forma estructurada. Más allá de las matrices básicas, new facilita la creación de matrices multidimensionales y dentadas, dando cabida a estructuras de datos complejas.

// Single-dimensional array
int [] numbers = new int [5]; // Initializes an array for 5 integers
// Multidimensional array
int [,] matrix = new int [3, 2]; // A 3x2 matrix
// Jagged array (an array of arrays)
int [][] jaggedArray = new int [3][];
jaggedArray [0] = new int [4]; // First row has 4 columns
jaggedArray [1] = new int [5]; // Second row has 5 columns
jaggedArray [2] = new int [3]; // Third row has 3 columns

// Single-dimensional array
int [] numbers = new int [5]; // Initializes an array for 5 integers
// Multidimensional array
int [,] matrix = new int [3, 2]; // A 3x2 matrix
// Jagged array (an array of arrays)
int [][] jaggedArray = new int [3][];
jaggedArray [0] = new int [4]; // First row has 4 columns
jaggedArray [1] = new int [5]; // Second row has 5 columns
jaggedArray [2] = new int [3]; // Third row has 3 columns

' Single-dimensional array
Dim numbers(4) As Integer ' Initializes an array for 5 integers
' Multidimensional array
Dim matrix(2, 1) As Integer ' A 3x2 matrix
' Jagged array (an array of arrays)
Dim jaggedArray(2)() As Integer
jaggedArray (0) = New Integer (3){} ' First row has 4 columns
jaggedArray (1) = New Integer (4){} ' Second row has 5 columns
jaggedArray (2) = New Integer (2){} ' Third row has 3 columns

Tipos anónimos

Los tipos anónimos brillan en escenarios que requieren estructuras de datos temporales sin la sobrecarga de declarar una clase formal. Utilizando new con una sintaxis de inicializador de propiedades, puedes crear objetos sobre la marcha. Esta función es increíblemente útil para las consultas LINQ en las que es necesario seleccionar un subconjunto de propiedades de un objeto más grande o para agrupar datos rápidamente sin crear un tipo específico.

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

var person = new { Name = "Alice", Age = 30 };
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
// In LINQ
var results = from p in people
              select new { p.Name, p.Age };

Dim person = New With {
	Key .Name = "Alice",
	Key .Age = 30
}
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")
' In LINQ
Dim results = From p In people
	Select New With {
		Key p.Name,
		Key p.Age
	}

Inicializadores de objetos

Un inicializador de objetos representa una comodidad sintáctica, que permite crear una instancia de una clase y establecer inmediatamente sus propiedades sin llamar a un constructor con parámetros. Esto no sólo hace que el código sea más legible, sino que también reduce la probabilidad de errores al eliminar la necesidad de múltiples constructores para diferentes escenarios. Los inicializadores de objetos son especialmente útiles cuando se trabaja con objetos complejos, ya que permiten establecer sólo las propiedades que se necesitan.

public class Rectangle {
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}
Rectangle rect = new Rectangle {
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

public class Rectangle {
    public int Width { get; set; }
    public int Height { get; set; }
    public Point Location { get; set; }
}
Rectangle rect = new Rectangle {
    Width = 100,
    Height = 50,
    Location = new Point { X = 0, Y = 0 }
};

Public Class Rectangle
	Public Property Width() As Integer
	Public Property Height() As Integer
	Public Property Location() As Point
End Class
Private rect As New Rectangle With {
	.Width = 100,
	.Height = 50,
	.Location = New Point With {
		.X = 0,
		.Y = 0
	}
}

Funciones locales y expresiones lambda

C# admite funciones locales y expresiones lambda, lo que aumenta la flexibilidad y concisión del código.

Función local

Una función local es un método definido dentro del ámbito de otro método, que sirve como una poderosa herramienta para organizar el código y encapsular la funcionalidad.

public void PerformOperation() {
    int LocalFunction(int x) {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

public void PerformOperation() {
    int LocalFunction(int x) {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); // Output: 25
}

Public Sub PerformOperation()
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	int LocalFunction(int x)
'	{
'		Return x * x;
'	}
	Console.WriteLine(LocalFunction(5)) ' Output: 25
End Sub

Expresiones lambda

La expresión lambda proporciona una forma concisa de escribir expresiones o métodos en línea sin necesidad de tipos delegados explícitos.

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Func<int, int> square = x => x * x;
Console.WriteLine(square(5)); // Output: 25

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) ' Output: 25

Uso de "new" en la herencia

En la herencia de clases, new puede ocultar los miembros heredados, lo que permite a las clases derivadas introducir un miembro con el mismo nombre que los de sus clases base.

Ocultar miembros heredados

El uso de new para ocultar un miembro en una clase derivada no anula el mismo miembro; en su lugar, introduce un nuevo miembro que es distinto de la versión de la clase base.

public class BaseClass {
    public void Display() {
        Console.WriteLine("Base display");
    }
}
public class DerivedClass : BaseClass {
    public new void Display() {
        Console.WriteLine("Derived display");
    }
}

public class BaseClass {
    public void Display() {
        Console.WriteLine("Base display");
    }
}
public class DerivedClass : BaseClass {
    public new void Display() {
        Console.WriteLine("Derived display");
    }
}

Public Class BaseClass
	Public Sub Display()
		Console.WriteLine("Base display")
	End Sub
End Class
Public Class DerivedClass
	Inherits BaseClass

	Public Shadows Sub Display()
		Console.WriteLine("Derived display")
	End Sub
End Class

Entender lo nuevo con genéricos

Los genéricos introducen un nivel de abstracción en la programación en C#, permitiendo a los desarrolladores diseñar clases, métodos e interfaces que operan sobre tipos genéricos. Cuando se combinan con la palabra clave new, los genéricos permiten instanciar tipos dinámicamente, lo que mejora aún más la reutilización del código y reduce la redundancia.

La restricción new() en Generic Type

El nuevo()La restricción es una piedra angular del uso de new con genéricos, especificando que un argumento de tipo en una clase o método genérico debe tener un constructor público sin parámetros. Esta restricción le permite crear instancias de su tipo genérico dentro de la clase o método, haciendo que sus clases y métodos genéricos sean más flexibles y potentes.

public class Container<T> where T : new() {
    public T CreateItem() {
        return new T(); //new T
    }
}

public class Container<T> where T : new() {
    public T CreateItem() {
        return new T(); //new T
    }
}

public class Container(Of T) where T : New() {
	public T CreateItem() { Return New T(); }
}

En este ejemplo, Contenedorpuede crear instancias de T, siempre que T tenga un constructor sin parámetros. Esta capacidad es inestimable cuando se desarrollan bibliotecas o frameworks que requieren la creación de objetos pero no se conocen los tipos específicos de antemano.

Introducción a IronPDF

IronPDF destaca como una potente herramienta que utiliza las capacidades de C# para trabajar con archivos PDF. Al incorporar IronPDF, los desarrolladores pueden crear mediante programación nuevos Documentos PDF a partir de cadenas HTMLarchivos o URL, manipular PDF existentes y extraer contenido, todo ello mediante la conocida sintaxis de C# y aprovechando la palabra clave new para la instanciación de objetos.

Ejemplo de código

using IronPdf;
using System;
namespace IronPdfExample
{
    class Program
    {
//static void main
        static void Main(string [] args)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");
            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);
            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

using IronPdf;
using System;
namespace IronPdfExample
{
    class Program
    {
//static void main
        static void Main(string [] args)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Create a new PDF document from HTML content
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");
            // Save the PDF to a file
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);
            // Confirmation message
            Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\\{filePath}");
        }
    }
}

Imports IronPdf
Imports System
Namespace IronPdfExample
	Friend Class Program
'static void main
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"
			' Create a new PDF document from HTML content
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")
			' Save the PDF to a file
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)
			' Confirmation message
			Console.WriteLine($"PDF file has been generated at: {Environment.CurrentDirectory}\{filePath}")
		End Sub
	End Class
End Namespace

En este fragmento de programa de clase, new IronPdf.ChromePdfRenderer() demuestra la instanciación de un objeto renderizador IronPDF. A continuación, este objeto se utiliza para crear un nuevo PDF a partir de una cadena HTML, mostrando la perfecta integración de bibliotecas de terceros con los patrones de creación de objetos de C#. IronPDF requiere el uso de la palabra clave new para iniciar sus clases, lo que lo convierte en un ejemplo relevante para los desarrolladores que aprenden sobre la instanciación de objetos y exploran las características avanzadas de C#.

Salida

Cuando ejecutes el programa, verás el siguiente mensaje en la consola:

Y una vez que abras el archivo PDF, verás esto:

Conclusión

La palabra clave new en C# es una piedra angular de la programación orientada a objetos, que permite a los desarrolladores instanciar objetos, gestionar la herencia y utilizar genéricos con precisión y facilidad. A través de ejemplos prácticos, desde la creación de instancias de clases sencillas hasta el aprovechamiento de funciones avanzadas como los tipos anónimos y los inicializadores de objetos, esta guía demuestra la versatilidad y la potencia de new.

La integración de IronPDF muestra cómo C# puede extender su alcance más allá de las aplicaciones tradicionales, permitiendo la generación y manipulación de archivos PDF mediante código. IronPDF ofrece un prueba gratuita para que los desarrolladores exploren sus características, con licencias a partir de $749.