Desencriptar cadena de texto con C#

Podemos desencriptar cualquier cadena de texto con C# en base a una key de encriptación. El siguiente código espera un parámetro texto del que queremos desencriptar, la key secreta de encriptación, y el CyphMode).

Podemos desencriptar cualquier cadena de texto con C# en base a una key de encriptación. El siguiente código espera un parámetro texto del que queremos desencriptar, la key secreta de encriptación, y el CyphMode).

La función devolverá el valor desencriptado. Nos puede venir bien si queremos desencriptar id's de valores, por ejemplo...


public static string Decrypt(string p_InputString, string p_SecretKey, CipherMode p_CyphMode)

{

 if (String.IsNullOrEmpty(p_InputString)) {

  return String.Empty;

 } else {

  StringBuilder ret = new StringBuilder();

  byte[] InputbyteArray = new byte[Convert.ToInt32(p_InputString.Length) / 2];

  TripleDESCryptoServiceProvider Des = new TripleDESCryptoServiceProvider();

  MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();


  try {

   Des.Key = hashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(p_SecretKey));

   Des.Mode = p_CyphMode;

   for (int X = 0; X <;= InputbyteArray.Length - 1; X++) {

    Int32 IJ = (Convert.ToInt32(p_InputString.Substring(X * 2, 2), 16));

    ByteConverter BT = new ByteConverter();

    InputbyteArray[X] = new byte();

    InputbyteArray[X] = Convert.ToByte(BT.ConvertTo(IJ, typeof(byte)));

   }


   MemoryStream ms = new MemoryStream();

   CryptoStream cs = new CryptoStream(ms, Des.CreateDecryptor(), CryptoStreamMode.Write);


   //Flush the data through the crypto stream into the memory stream

   cs.Write(InputbyteArray, 0, InputbyteArray.Length);

   cs.FlushFinalBlock();


   //Get the decrypted data back from the memory stream

   byte[] B = ms.ToArray();

   ms.Close();

   for (int I = 0; I <;= B.GetUpperBound(0); I++) {

    ret.Append(Convert.ToChar(B[I]));

   }

  } catch (Exception ex) {

   //   ME.Publish("SF.Utils.Utils", "DecryptString", ex, ManageException_Enumerators.ErrorLevel.FatalError);

   return String.Empty;

  }


  return ret.ToString();

 }

}


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Declaración de métodos en C#


Cuando uno plantea una clase en lugar de especificar todo el algoritmo en un único método es dividir todas las responsabilidades de las clase en un conjunto de métodos.
Un método hemos visto que tiene la siguiente sintaxis:
public void [nombre del método]() 
{
    [algoritmo]
}
Veremos que hay varios tipos de métodos:

Métodos con parámetros.

Un método puede tener parámetros:
public void [nombre del método]([parámetros]) 
{
    [algoritmo]
}
Los parámetros los podemos imaginar como variables locales al método, pero su valor se inicializa con datos que llegan cuando lo llamamos.

Problema 1:

Confeccionar una clase que permita ingresar valores enteros por teclado y nos muestre la tabla de multiplicar de dicho valor. Finalizar el programa al ingresar el -1.

Programa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tabla
{
    class TablaMultiplicar
    {
        public void CargarValor()
        {
            int valor;
            string linea;
            do
            {
                Console.Write("Ingrese un valor (-1 para finalizar):");
                linea = Console.ReadLine();
                valor = int.Parse(linea);
                if (valor != -1)
                {
                    Calcular(valor);
                }
            } while (valor != -1);
        }

        public void Calcular(int v)
        {
            for(int f=v;f<=v*10;f=f+v) 
            {
                Console.Write(f+"-");
            }
            Console.WriteLine();
        }

        static void Main(string[] args)
        {
            TablaMultiplicar tm = new TablaMultiplicar();
            tm.CargarValor();
        }
    }
}

En esta clase no hemos definido ningún atributo.
El método Calcular recibe un parámetro de tipo entero, luego lo utilizamos dentro del método para mostrar la tabla de multiplicar de dicho valor, para esto inicializamos la variable f con el valor que llega en el parámetro. Luego de cada ejecución del for incrementamos el contador f con el valor de v.
        public void Calcular(int v)
        {
            for(int f=v;f<=v*10;f=f+v) 
            {
                Console.Write(f+"-");
            }
            Console.WriteLine();
        }
Un método puede no tener parámetros como hemos visto en problemas anteriores o puede tener uno o más parámetros (en caso de tener más de un parámetro los mismos se separan por coma)
El método CargarValores no tiene parámetros y tiene por objetivo cargar un valor entero por teclado y llamar al método Calcular para que muestre la tabla de multiplicar del valor que le pasamos por teclado:
        public void CargarValor()
        {
            int valor;
            string linea;
            do
            {
                Console.Write("Ingrese un valor (-1 para finalizar):");
                linea = Console.ReadLine();
                valor = int.Parse(linea);
                if (valor != -1)
                {
                    Calcular(valor);
                }
            } while (valor != -1);
        }
Como vemos al método Calcular lo llamamos por su nombre y entre paréntesis le pasamos el dato a enviar (debe ser un valor o variable entera)
En este problema en la Main solo llamamos al método CargarValor, ya que el método Calcular luego es llamado por el método CargarValor:
        static void Main(string[] args)
        {
            TablaMultiplicar tm = new TablaMultiplicar();
            tm.CargarValor();
        }

Métodos que retornan un dato.

Un método puede retornar un dato:
public [tipo de dato] [nombre del método]([parámetros]) 
{
  [algoritmo]
  return [tipo de dato]
}
Cuando un método retorna un dato en vez de indicar la palabra clave void previo al nombre del método indicamos el tipo de dato que retorna. Luego dentro del algoritmo en el momento que queremos que finalice el mismo y retorne el dato empleamos la palabra clave return con el valor respectivo.

Problema 2:

Confeccionar una clase que permita ingresar tres valores por teclado. Luego mostrar el mayor y el menor.

Programa:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EspacioMayorMenor
{
    class MayorMenor
    {

        public void cargarValores()
        {
            string linea;
            Console.Write("Ingrese primer valor:");
            linea = Console.ReadLine();
            int valor1 = int.Parse(linea);
            Console.Write("Ingrese segundo valor:");
            linea = Console.ReadLine();
            int valor2 = int.Parse(linea);
            Console.Write("Ingrese tercer valor:");
            linea = Console.ReadLine();
            int valor3 = int.Parse(linea);
            int mayor, menor;
            mayor = CalcularMayor(valor1, valor2, valor3);
            menor = CalcularMenor(valor1, valor2, valor3);
            Console.WriteLine("El valor mayor de los tres es:" + mayor);
            Console.WriteLine("El valor menor de los tres es:" + menor);
        }

        public int CalcularMayor(int v1, int v2, int v3)
        {
            int m;
            if (v1 > v2 && v1 > v3)
            {
                m = v1;
            }
            else
            {
                if (v2 > v3)
                {
                    m = v2;
                }
                else
                {
                    m = v3;
                }
            }
            return m;
        }

        public int CalcularMenor(int v1, int v2, int v3)
        {
            int m;
            if (v1 < v2 && v1 < v3)
            {
                m = v1;
            }
            else
            {
                if (v2 < v3)
                {
                    m = v2;
                }
                else
                {
                    m = v3;
                }
            }
            return m;
        }

        static void Main(string[] args)
        {
            MayorMenor mm = new MayorMenor();
            mm.cargarValores();
            Console.ReadKey();
        }
    }
}
Si vemos la sintaxis que calcula el mayor de tres valores enteros es similar al algoritmo visto en conceptos anteriores:

Lo primero que podemos observar que el método retorna un entero y recibe tres parámetros:
        public int CalcularMayor(int v1, int v2, int v3) 

Dentro del método verificamos cual de los tres parámetros almacena un valor mayor, a este valor lo almacenamos en una variable local llamada "m", al valor almacenado en esta variable lo retornamos al final con un return.
La llamada al método calcularMayor lo hacemos desde dentro del método CargarCalores:
        mayor=CalcularMayor(valor1,valor2,valor3);

Debemos asignar a una variable el valor devuelto por el método CalcularMayor. Luego el contenido de la variable mayor lo mostramos:
            Console.WriteLine("El valor mayor de los tres es:"+mayor);
            Console.WriteLine("El valor menor de los tres es:"+menor);

La lógica es similar para el cálculo del menor.
Leer más...

Hacer una peticion Ajax con Jquery



Una vez mas les traemos un post acerca de las bondades de AJAX el cual hemos hablado en posts anteriores...
Hemos hablado de como hacer peticiones AJAX con JQUERY que es algo que nos facilita mucho la vida al momento de actualizar solo una parte de la web, ya que esto lo podemos realizar Asyncronamente.
 jQuery, como framework de JavaScript nos permite realizar esta tarea de forma sencilla, evitando codificar directamente la petición AJAX en JavaScript.

Hoy vamos a realizar una petición a una página para devolver el contenido, que incluiremos en una capa de nuestra página.

Lo primero será montar nuestra página HTML. Con un button y un div.

  
    <div id="mensaje"></div>
     
    <button id="cargar">Cargar</button>


Lo siguiente será inicializar jQuery y empezar a generar el código.
Cargamos la librería jQuery mediante la etiqueta SCRIPT.
 
 <script type="text/javascript" src="jquery.js"></script>

 O llamamos a un CDN que pueden encontrar mas información Aqui.

<script src="http://code.jquery.com/jquery-latest.min.js" type="text/javascript"></script>


Una vez configurado todo...  Lo siguiente será capturar el evento click del botón con Jquery. Para ello, sobre el ID cargar llamamos el evento Click de ese objeto.

  

<script type="text/javascript">
    $(document).ready(function(){
           $("#cargar").click(function(){
               // Petición AJAX
            });     
    });
  </script>


Para hacer la petición AJAX nos apoyaremos en la función .get(url,[data],[callback],[type]). Esta función es muy sencilla y sus parámetros son:
  • url, es la URL que contendrá el fichero que nos devuelva los datos.
  • data, son los datos a enviar a la URl de petición
  • callback, es el método que se ejecutará cuando se realice la petición
  • type, tipo de datos que se devolverán desde el servidor: text, xml, html, json,...
 La peticion AJAX seria:

$.get("http://csharpalextremo.tk//ejemplos/datos.aspx", function(data){
          $("#mensaje").html(data); 
});

En el metodo se puede apreciar varias cosas. La primera que datos.aspx es el fichero que devuelve los datos (no entraremos en detalle de como se compone, pero básicamente devuelve código HTML). La segunda es que la función de callback recibe como parámetro los datos devueltos por el servidor... dentro de esta función lo que estamos haciendo es añadir estos datos a la capa mediante el método .html().

Ahora solo nos queda el explotar las posibilidades del método .get() para dar potencia a nuestra web mediante peticiones AJAX con jQuery.

Pueden DESCARGAR el código de ejemplo desde Aqui. 

Espero que lo disfruten, compartan y comenten. ;)

Visita: http://rubitcorp.co/

"Si se puede imaginar... se puede programar."
Leer más...

Imagen: Editar, Recortar, Redimencionar y Guardar en Carpeta



 En C #, puede ser agotador para hacer ciertas funciones de edición de imagen utilizando GDI +. Este blog tiene algunos métodos de edición divertidas que pueden ser útiles a veces. También he incluido un bonito y pequeño programa en C # para mostrar toda la funcionalidad de los siguientes métodos.
Guardar un Jpeg dentro de una carpeta.

Lo primero a hacer es configurar la firma del método con los parámetros de entrada. Se trata de la ruta de archivo de salvar (cadena), la imagen de guardar (System.Drawing.Bitmap), y un ajuste de calidad (largo).
private void saveJpeg(string path, Bitamp img, long quality)

Lo proximo a hacer es configurar la información del codificador para guardar el archivo. Esto incluye establecer un EncoderParameter para la calidad de la imagen JPEG. El siguiente paso es obtener la información codec de su equipo para jpegs. Hago esto con una función para recorrer las disponibles en el equipo y asegurarse que el codec jpeg está ahí. La línea de bajo se asegura de que el codec JPEG se encuentra en el equipo. Si no simplemente devuelve fuera del método.

La última cosa a hacer es guardar el mapa de bits utilizando el codec y el infomation encoder.

private void saveJpeg(string path, Bitmap img, long quality)
{
   // Encoder parameter for image quality
   EncoderParameter qualityParam = new EncoderParameter(Encoder.Quality, quality);

   // Jpeg image codec
   ImageCodecInfo jpegCodec = this.getEncoderInfo("image/jpeg");

   if(jpegCodec == null)
      return;

   EncoderParameters encoderParams = new EncoderParameters(1);
   encoderParams.Param[0] = qualityParam;

   img.Save(path, jpegCodec, encoderParams);
}

private ImageCodecInfo getEncoderInfo(string mimeType)
{
   // Get image codecs for all image formats
   ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();

   // Find the correct image codec
   for (int i = 0; i < codecs.Length; i++)
      if (codecs[i].MimeType == mimeType)
         return codecs[i];
   return null;
}

Recorte

El método toma dos objetos - la imagen que desea recortar (System.Drawing.Image) y el rectángulo para recortar (System.Drawing.Rectangle). La siguiente cosa a hacer es crear un mapa de bits (System.Drawing.Bitmap) de la imagen. Lo único que queda por hacer es recortar la imagen. Esto se hace mediante la clonación de la imagen original, pero sólo teniendo un rectángulo de la original.

private static Image cropImage(Image img, Rectangle cropArea)
{
   Bitmap bmpImage = new Bitmap(img);
   Bitmap bmpCrop = bmpImage.Clone(cropArea,
   bmpImage.PixelFormat);
   return (Image)(bmpCrop);
}

Cambiar el tamaño

El siguiente grupo de código es un poco más largo y más complejo. La razón principal que este código es más largo es porque esta función al cambio de tamaño se mantendrá la altura y la anchura proporcional.
Para empezar, vemos que los parámetros de entrada son la imagen para cambiar el tamaño (System.Drawing.Image) y el tamaño (System.Drawing.Size). También en este conjunto de código hay  algunas variables que utilizamos. Los dos primeros son la altura y anchura original que se utiliza más adelante. Y hay 3 otras variables para calcular la información de proporción.

private static Image resizeImage(Image imgToResize, Size size)
{
   int sourceWidth = imgToResize.Width;
   int sourceHeight = imgToResize.Height;

   float nPercent = 0;
   float nPercentW = 0;
   float nPercentH = 0;
}

El siguiente paso es determinar en realidad el tamaño que debe tener la iamgen. El primer paso es el cálculo de los porcentajes del nuevo tamaño en comparación con el original. A continuación tenemos que decidir qué porcentaje es menor porque este es el porcentaje de la imagen original que utilizaremos en altura y en anchura. Y ahora se calcula el número de píxeles de altura y anchura de la imagen de destino.

nPercentW = ((float)size.Width / (float)sourceWidth);
nPercentH = ((float)size.Height / (float)sourceHeight);

if (nPercentH < nPercentW)
   nPercent = nPercentH;
else
   nPercent = nPercentW;

int destWidth = (int)(sourceWidth * nPercent);
int destHeight = (int)(sourceHeight * nPercent);

La última cosa a hacer es crear el mapa de bits (System.Drawing.Bitmap) que vamos a dibujar. La imagen cambia de tamaño en el uso de un objeto Graphics (System.Drawing.Graphics) del objeto. Asimismo, establecer el modo de interpolación, que es el algoritmo usado para cambiar el tamaño de la imagen. Prefiero HighQualityBicubic, que desde mi prueba parece devolver los resultados más altos de calidad. Y sólo para limpiar un poco que disponer del objeto Graphics.

Bitmap b = new Bitmap(destWidth, destHeight);
Graphics g = Graphics.FromImage((Image)b);
g.InterpolationMode = InterpolationMode.HighQualityBicubic;

g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
g.Dispose();

Y esto nos da el código final.

private static Image resizeImage(Image imgToResize, Size size)
{
   int sourceWidth = imgToResize.Width;
   int sourceHeight = imgToResize.Height;

   float nPercent = 0;
   float nPercentW = 0;
   float nPercentH = 0;

   nPercentW = ((float)size.Width / (float)sourceWidth);
   nPercentH = ((float)size.Height / (float)sourceHeight);

   if (nPercentH < nPercentW)
      nPercent = nPercentH;
   else
      nPercent = nPercentW;

   int destWidth = (int)(sourceWidth * nPercent);
   int destHeight = (int)(sourceHeight * nPercent);

   Bitmap b = new Bitmap(destWidth, destHeight);
   Graphics g = Graphics.FromImage((Image)b);
   g.InterpolationMode = InterpolationMode.HighQualityBicubic;

   g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
   g.Dispose();

   return (Image)b;
}



Espero que lo disfruten, compartan y comenten. ;)
Visita: http://rubitcorp.co/
"Si se puede imaginar... se puede programar."
Leer más...

Eventos de una Página Web (WebForm ASP.NET)

Este pequeño post es para aclarar algunos conceptos sobre el ciclo de vida de una página web ASP.NET (WebForm).
Nota: A este post le iré agregando mas contenido poco a poco, con los propios comentarios de los lectores y mis experiencias diarias sobre el ciclo de vida y los distintos estados de una pagina.
Eventos más importantes de la pagina en orden de ejecución:

    PreInit
    Init
    Load
    PreRender

PreInit

El evento PreInit ocurre antes de la inicialización de los controles de la pagina.

Normalmente es usado para añadir dinámicamente controles a la pagina, porque añadiéndolos aquí garantizamos que a dichos controles se les apliquen adecuadamente los Skins del Theme definido (si no hemos definido ningún Theme daría un poco igual añadirlos aquí o en Init, por ejemplo).

Además puede usarse para definir dinámicamente (programáticamente) la MasterPage y el Theme de la pagina.




Init

Este evento ocurre después de que todos los controles de la pagina ya tienen definidos sus Theme . Este evento es usado normalmente para leer o definir propiedades de los controles.


Load

El load de la pagina ocurre antes que el load de los controles.


PreRender

Este evento ocurre justo antes de que los controles de la pagina sean rendereados y pintados en el navegador web. Normalmente es usado para modificar el contenido de la pagina o sus controles. Primero ocurre el PreRender de la pagina y después el de cada uno de controles.


Nota: Existen muchos mas eventos y muchos artículos que hablan sobre el tema, pero yo iré poniendo aquí los que me parecen que son los mas importantes y más usados.



Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Entendiendo los extensores en c sharp

Los métodos extensores son un recurso de C# a partir de la versión 3.0 y permite añadir métodos a tipos ya definidos sin tener que crear un tipo heredero, recompilar o modificar al tipo original de una forma muy sencilla y con una sintaxis casi idéntica a la forma tradicional de declarar un método. En otras palabras, si queremos añadirle una funcionalidad a una clase o tipo ya definido anteriormente, no tendremos que modificarla, al no ser que vayamos a usar variables privadas de la clase o cosas por el estilo.

Se definen como métodos estáticos pertenecientes a una clase estática y no genérica; pero se llaman de la forma tradicional, como métodos de una instancia de una clase.

Se les pasa como primer parámetro this seguido del tipo de la clase a la cual se va a añadir el método; aquí tenemos un ejemplo de añadirle un método a la clase String de .Net:
public static class MyExtensions
{
     public static int WordCount(this String str)
     {
         //Split separa la cadena en un array de string utiizando los separadores especificados
         return str.Split(new char[] { ' ', '.', '?', ';' , ':' }, StringSplitOptions.RemoveEmptyEntries).Length;
     }
}

Utilizando este ejemplo:

 string s = "hello extension methods!";
  int count = s.WordCount();
  //Este código imprime: 3

Este método podrá ser usado en todas las variables de tipo string, IntelliSense también los reconoce ya que no violan los principios de encapsulación, pues en realidad no modifican a la clase ni acceden a sus variables privadas.

Los métodos extensores se usan para extender una clase o interface; pero no para sobreescribirla. Un método extensor con el mismo nombre y signatura (parámetros) que un método de la clase o la interface, nunca será llamado: en tiempo de compilación, los métodos extensores tienen menor prioridad que los métodos definidos en el propio tipo y están definidos en el ámbito del namespace.

Veamos otro ejemplo un poco más complejo usando interfaces y genericidad:

//Este método devuelve el mayor de una colección que sea 
//IEnumerable(List, array, LinkedList, etc)
public static T Mayor(this IEnumerable items) where T : IComparable
    {
      T max = default(T);
      bool empty = true;
      foreach (T x in items)
      {
        max = x; empty = false;  break;
      }
      if (empty) throw new Exception("The source cannot be empty");
      foreach (T x in items)
      {
        if (x.CompareTo(max) > 0)
          max = x;
      }
      return max;
    }

Como en el caso anterior, ahora en todas las clases que implementen la interfaz IEnumerable donde sus elementos se puedan comparar, tendremos un método Mayor, que devuelve el mayor elemento de la colección de objetos de tipo T genérico. Veamos algunos ejemplos de como usar este método:

int[] numeros = { 10, -60, 20, -50, 30, -40 };
Console.WriteLine(numeros.Mayor()=;
//se va a imprimir 30

Otro ejemplo podría ser:

List colores = new List { "rojo", "verde", "azul", "blanco", "negro"};
Console.WriteLine(colores.Mayor());
//se va a imprimir verde, que es el mayor en orden alfabético

 Bueno, si quieren ver más ejemplos aquí les dejo unos cuantos métodos extensores en C# para descargar con sus probadores y todo, para que practiques y le saques el mayor partido a esta nueva característica de C#. Si tienes alguna duda, propuesta o no entiendes algo por favor escribe en los comentarios. Proximamente estaremos hablando de LINQ, otra de las nuevas características de C# y .Net.

Descargar Aqui:


Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Método Parse() o los métodos de la clase Convert




Vamos arrojar un poco de luz sobre las diferencias entre utilizar el método Parse() de las estructuras de tipos de .NET o utilizar los métodos de la clase System.Convert. En realidad parece que hacen lo mismo pero existe una gran diferencia.Supongamos que dejamos que un usuario introduzca un valor numérico por pantalla y queremos realizar cálculos con ese valor. Por lo tanto, el valor introducido por el usuario será del tipo System.String y deberemos convertirlo a un tipo de valor numérico, por ejemplo System.Int32.
En definitiva queremos saber que diferencia hay entre ejecutar estas dos lineas de código:
int valorA Convert.ToInt32(valorUsuario);
int valorB Int32.Parse(valorUsuario);
Cuando utilizamos la segunda opción, el método Parse(), si el usuario no ha introducido ningún valor (null) recibiremos una excepción del tipo System.FormatException. Lo que indica que el formato del argumento no cumple las especificaciones del parámetro del método invocado.
En cambio, cuando utilizamos la primera opción, los métodos de la clase System.Convert, si el valor pasado al método es null, el método ConovertToInt32() devolverá un valor numérico, devolverá cero en todos los casos que el valor de entrada sea null.
Utilizando la herramienta Reflector podemos ver las diferencias de código que hay entre estas dos formas de convertir los tipos de .NET.

     
    Convert.ToInt32();

public static int ToInt32(string value)
{
     if (value == null)
     {
          return 0;
     }
     return int.Parse(value, CultureInfo.CurrentCulture);
}
 

    Int32.Parse();

public static int Parse(string s)
{
     return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

String Cuidado con ese tipo!


El tipo System.String, que como todos sabemos representa una cadena, es un tipo algo especial con el que hay que tener un poco de cuidado a la hora de menejarlo. Veamos en primer lugar una definición más o menos formal del tipo System.String:
"El tipo System.String es un tipo por referencia e inmutable (de solo lectura) que representa una cadena de texto como una colección secuencial de caracteres Unicode (objetos System.Char)".
 Para este artículo nos centraremos en la primera parte de la definición, es decir, en "El tipo System.String es un tipo por referencia e inmutable (de solo lectura) ...".

¿Que quiere decir que es inmutable?
Un objeto inmutable es un objeto que no se puede modificar. Cuando creas, o cargas en menoria un objeto de este tipo, permanece con el mismo valor durente toda la vida del objeto. Veamos el siguiente fragmento de código:
            string miCadena "Un saludo";
            
miCadena +" para el lector";
Quizás pueda parecer que en la segunda linea de este fragmento estamos modificando el literal "Un saludo" pero esto no es así. Como ya dijimos antes, el objeto "Un saludo" es inmutable, por lo tanto, despúes de la concatenación, lo que se devuelve es un nuevo objeto de tipo System.String que contiene la modificación: "Un saludo para el lector".
Por lo tanto, cuando concatenamos cadenas de esta forma, tenemos en la memoria dos objetos, uno con el valor original y otro con la modificación. Es evidente, que sí esta operación la realizamos miles de veces, por ejemplo leyendo de una base de datos, el rendimiento de la aplicación se verá gravemente afectado. Por otro lado, si la operación solo se realiza una o dos veces (incluso tres o cuatro) no tiene tanta importancia.
Supongamos que tenemos una base de datos con todos los nombre de los lectores de este blog, y supongamos que son miles los nombres guardados (¡ojalá!...jeje). Ahora queremos leer de la base de datos todos los nombres y saludarles por pantalla. Creamos un método al que le pasamos cada nombre leido en un bucle.
        static void Saludar(string Nombre)
        {
            StringBuilder sb 
= new StringBuilder("Hola para ");
            
sb.Append(Nombre);
            
Console.WriteLine(sb.ToString());
        
}
Esta es la manera correcta de proceder, creando un objeto System.Text.StringBuilder y añadiendo cada nueva cadena por medio de su método Append(). Si queréis podéis descargaros un pequeño programilla que calcula el tiempo que se tarda en realizar concatenaciones con System.String y System.Text.StringBuilder en función de un número de iteraciones introducidas por el usuario.
String_vs_StringBuilder.rar (21,95 kb)

Más cosas a tener en cuenta.
¿Más cosas a tener en cuenta?. Ya dijimos que eran...¡unos tipos de cuidado!.
Cuando inicializamos variables de tipo Sytem.String y queremos darles un valor por defecto de cadena vacia es muy frecuente hacerlo con las comillas "".
    class Lector
    {
        
public string Nombre;
        public string 
Apellidos;
        public string 
Direccion;
        public string 
Telefono;
        public string 
Comentario;
        public string 
FechaComentario;

        public 
Lector()
        {
            Nombre 
"";
            
Apellidos "";
            
Direccion "";
            
Telefono "";
            
Comentario "";
            
FechaComentario "";
        
}

        
//...............

        //Aquí el resto de mienbros de la clase.

        //...............
    
}
No es recomendable hacerlo de esta forma. En este caso hemos creado (cargado en la menoria) 6 objetos diferentes de tipo cadena. Y seguramente luego "intentaremos" modificarlos al asignarles un valor determinado. Lo correcto, o por lo menos más recomendable, es hacerlo así:

        public Lector()
        {
            Nombre 
String.Empty;
            
Apellidos String.Empty;
            
Direccion String.Empty;
            
Telefono String.Empty;
            
Comentario String.Empty;
            
FechaComentario String.Empty;
        
}
Al utilizar el campo String.Empty que representa una cadena vacía, estamos apuntando todas las variables a un mismo objeto. De esta forma solo reservamos memoria para un único objeto gracias a que los tipos System.String son tipos por refencia.
Bueno...ya saben...¡cuidado con estos "tipos"!.



Espero que lo disfruten, compartan y comenten. ;)

Visita: http://rubitcorp.co/

"Si se puede imaginar... se puede programar."
Leer más...
Google