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 {
    //  Constructor sin parámetros
    public ExampleClass() {
        //  Código de inicialización
    }
}

public class ExampleClass {
    //  Constructor sin parámetros
    public ExampleClass() {
        //  Código de inicialización
    }
}

Public Class ExampleClass
	'  Constructor sin parámetros
	Public Sub New()
		'  Código de inicialización
	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.

//  Matriz unidimensional
int [] numbers = new int [5]; //  Inicializa un array de 5 enteros
//  Matriz multidimensional
int [,] matrix = new int [3, 2]; //  Una matriz 3x2
//  Jagged array (una matriz de matrices)
int [][] jaggedArray = new int [3][];
jaggedArray [0] = new int [4]; //  La primera fila tiene 4 columnas
jaggedArray [1] = new int [5]; //  La segunda fila tiene 5 columnas
jaggedArray [2] = new int [3]; //  La tercera fila tiene 3 columnas

//  Matriz unidimensional
int [] numbers = new int [5]; //  Inicializa un array de 5 enteros
//  Matriz multidimensional
int [,] matrix = new int [3, 2]; //  Una matriz 3x2
//  Jagged array (una matriz de matrices)
int [][] jaggedArray = new int [3][];
jaggedArray [0] = new int [4]; //  La primera fila tiene 4 columnas
jaggedArray [1] = new int [5]; //  La segunda fila tiene 5 columnas
jaggedArray [2] = new int [3]; //  La tercera fila tiene 3 columnas

'  Matriz unidimensional
Dim numbers(4) As Integer '  Inicializa un array de 5 enteros
'  Matriz multidimensional
Dim matrix(2, 1) As Integer '  Una matriz 3x2
'  Jagged array (una matriz de matrices)
Dim jaggedArray(2)() As Integer
jaggedArray (0) = New Integer (3){} '  La primera fila tiene 4 columnas
jaggedArray (1) = New Integer (4){} '  La segunda fila tiene 5 columnas
jaggedArray (2) = New Integer (2){} '  La tercera fila tiene 3 columnas

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}");
//  En 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}");
//  En 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}")
'  En 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)); //  Salida: 25
}

public void PerformOperation() {
    int LocalFunction(int x) {
        return x * x;
    }
    Console.WriteLine(LocalFunction(5)); //  Salida: 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)) '  Salida: 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)); //  Salida: 25

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

Dim square As Func(Of Integer, Integer) = Function(x) x * x
Console.WriteLine(square(5)) '  Salida: 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(); //nuevo T
    }
}

public class Container<T> where T : new() {
    public T CreateItem() {
        return new T(); //nuevo 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 HTML archivos 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";
            //  Crear un nuevo documento PDF a partir de contenido HTML
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");
            //  Guardar el PDF en un archivo
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);
            //  Mensaje de confirmación
            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";
            //  Crear un nuevo documento PDF a partir de contenido HTML
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>");
            //  Guardar el PDF en un archivo
            string filePath = "HelloWorld.pdf";
            pdf.SaveAs(filePath);
            //  Mensaje de confirmación
            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"
			'  Crear un nuevo documento PDF a partir de contenido HTML
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1><p>This is a PDF generated from HTML using IronPDF.</p>")
			'  Guardar el PDF en un archivo
			Dim filePath As String = "HelloWorld.pdf"
			pdf.SaveAs(filePath)
			'  Mensaje de confirmación
			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.