CÓMO USAR VISUAL STUDIO, OPTIMIZAR CÓDIGO

Cómo usar Visual Studio

La optimización de código es el conjunto de fases de un compilador que transforman un fragmento de código en otro fragmento con un comportamiento equivalente y que se ajusta de forma más eficiente. Constituye un elemento importante en el desarrollo de una aplicación que aunque no asegure su éxito total, proporciona mejoras considerables que permiten un mayor acercamiento a este. Su objetivo principal radica en maximar la eficiencia temporal y espacial de los programas permitiendo reorganizar el código de manera limpia, correcta y eficiente.

Para entender mejor la optimización veremos unos ejemplos claros, a continuación, un código escrito de la forma tradicional, sin aplicar código limpio y mucho menos la optimización, cabe mencionar que, ésta forma tradicional de escribir códigos no está mal pero existe redundancia de código, el cual afecta al rendimiento del sistema.

public class D_Clientes
{
	private int _IdClientes;
	private string _CIORUC;
	private string _RazonSocial;
	private string _Direccion;
	private string _Telefono;
	private string _TextoBuscar;

	public int IdClientes { get => _IdClientes; set => _IdClientes = value; }
	public string CIORUC { get => _CIORUC; set => _CIORUC = value; }
	public string RazonSocial { get => _RazonSocial; set => _RazonSocial = value; }
	public string Direccion { get => _Direccion; set => _Direccion = value; }
	public string Telefono { get => _Telefono; set => _Telefono = value; }
	public string TextoBuscar { get => _TextoBuscar; set => _TextoBuscar = value; }
}

en este ejemplo de código vemos que hay redundancia de código, entonces, una vez aplicada la optimización, nos quedaría de la siguiente manera


public class D_Clientes
{
	public int IdClientes { get; set; }
	public string CIORUC { get; set; }
	public string RazonSocial { get; set; }
	public string Direccion { get; set; }
	public string Telefono { get; set; }
	public string TextoBuscar { get; set; }
}

de este modo se ha optimizado el código quedando mucho más limpio y ordenado que la anterior, cumplimiendo las mismas funciones


Ahora, otro ejemplo de un método que en ella se observa que se puede optimizar y simplificar el código

//METODO MOSTRAR REGISTROS DE LA TABLA CLIENTES
public DataTable MostrarRegistros()
{
	DataTable DtResultado = new DataTable("clientes");
	SqlConnection SqlCon = new SqlConnection();
	try
	{
		SqlCon.ConnectionString = CD_Conexion.conexion;
		SqlCommand SqlCmd = new SqlCommand();
		SqlCmd.Connection = SqlCon;
		SqlCmd.CommandText = "spmostrar_clientes";
		SqlCmd.CommandType = CommandType.StoredProcedure;

		//Declarar un SqlDataAdapter para Ejecutar los Comandos y llenar el DataTable
		SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
		SqlDat.Fill(DtResultado);
	}
	catch (Exception)
	{
		DtResultado = null;
	}
	return DtResultado;
}

//METODO BUSCAR REGISTROS DE LA TABLA CLIENTES
public DataTable BuscarRegistros(CD_Clientes Clientes)
{
	DataTable DtResultado = new DataTable("clientes");
	SqlConnection SqlCon = new SqlConnection();
	try
	{
		SqlCon.ConnectionString = CD_Conexion.conexion;
		SqlCommand SqlCmd = new SqlCommand();
		SqlCmd.Connection = SqlCon;
		SqlCmd.CommandText = "spbuscar_clientes";
		SqlCmd.CommandType = CommandType.StoredProcedure;

		SqlParameter ParTextoBuscar = new SqlParameter();
		ParTextoBuscar.ParameterName = "@textobuscar";
		ParTextoBuscar.SqlDbType = SqlDbType.VarChar;
		ParTextoBuscar.Size = 50;
		ParTextoBuscar.Value = Clientes.TextoBuscar;
		SqlCmd.Parameters.Add(ParTextoBuscar);

		SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
		SqlDat.Fill(DtResultado);
	}
	catch (Exception)
	{
		DtResultado = null;
	}
	return DtResultado;
}

aquí, nuevamente contamos con redundancia de código, ahora, si aplicamos la optimización y simplificamos el código, quedaría de esta manera.


//METODO MOSTRAR REGISTROS DE LA TABLA CLIENTES
public DataTable MostrarRegistros()
{
	DataTable DtResultado = new DataTable();
	SqlConnection SqlCon = new SqlConnection();
	try
	{
		SqlCon.ConnectionString = CD_Conexion.conexion;
		SqlCommand SqlCmd = new SqlCommand
		{
			Connection = SqlCon,
			CommandText = "spmostrar_clientes",
			CommandType = CommandType.StoredProcedure
		};

		//Declarar un SqlDataAdapter para Ejecutar los Comandos y llenar el DataTable
		SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
		SqlDat.Fill(DtResultado);
	}
	catch (Exception) { DtResultado = null; }
	return DtResultado;
}

//METODO BUSCAR REGISTROS DE LA TABLA CLIENTES
public DataTable BuscarRegistros(CD_Clientes Clientes)
{
	DataTable DtResultado = new DataTable();
	SqlConnection SqlCon = new SqlConnection();
	try
	{
		SqlCon.ConnectionString = CD_Conexion.conexion;
		SqlCommand SqlCmd = new SqlCommand
		{
			Connection = SqlCon,
			CommandText = "spbuscar_clientes",
			CommandType = CommandType.StoredProcedure
		};

		SqlParameter ParTextoBuscar = new SqlParameter
		{
			ParameterName = "@textobuscar",
			SqlDbType = SqlDbType.VarChar,
			Size = 50,
			Value = Clientes.TextoBuscar
		};
		SqlCmd.Parameters.Add(ParTextoBuscar);

		SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
		SqlDat.Fill(DtResultado);
	}
	catch (Exception) { DtResultado = null; }
	return DtResultado;
}

de esta manera hemos aplicado la simplificación de código y hemos optimizado. Es importante eliminar los códigos muertos, esto tiende a favorecer el tiempo de ejecución y el espacio de memoria utilizada. Además, hay que reducir la declaración de variables innecesarias dentro del código.


Los ejemplos presentados contribuyen a guiar el proceso de optimización de código a los programadores menos experimentados. Brindando un pequeño compendio de técnicas basadas fundamentalmente en la reducción tiempo de ejecución y espacio de memoria utilizado en la implementación de algoritmos y/o programas.


Ver video tutorial


Comparte este artículo con tus amigos:

Post Relacionados


Comentarios

Me encantaría saber tu opinión sobre el contenido.