Imagenes

Codigo para binarizar una imagen y pasarla a escala de grises utilizando la clase Marshall, para esto, importamos el siguiente Namespace:

using System.Runtime.InteropServices;

codigo Marshall para escala de grises:

private void grayMarshall()
{

Bitmap n = (new Bitmap(pctbxImagPrincipal.Image));
Rectangle rec = new Rectangle(0, 0, n.Width, n.Height);
BitmapData bmpD = n.LockBits(rec, ImageLockMode.ReadWrite, n.PixelFormat);
IntPtr ptr = bmpD.Scan0;
int bytes = bmpD.Stride * n.Height;
byte[] rgbValues = new byte[bytes];
Marshal.Copy(ptr, rgbValues, 0, bytes);
for (int i = 3; i < rgbValues.Length; i += 4)
{
byte NewValue = (byte)((int)((rgbValues[i - 3]) * .11) + (int)((rgbValues[i - 2]) * .59) + (int)((rgbValues[i - 1]) * .3));
rgbValues[i - 1] = rgbValues[i - 2] = rgbValues[i - 3] = NewValue;
}
Marshal.Copy(rgbValues, 0, ptr, bytes);
n.UnlockBits(bmpD);
pctbxImagResult.Image = n;
}

codigo Marshall para binarizar imagen:
private void binmarshall()
{
Bitmap n = (new Bitmap(pctbxImagPrincipal.Image));
Rectangle rec = new Rectangle(0, 0, n.Width, n.Height);
BitmapData bmpD = n.LockBits(rec, ImageLockMode.ReadWrite, n.PixelFormat);
IntPtr ptr = bmpD.Scan0;
int bytes = bmpD.Stride * n.Height;
byte[] rgbValues = new byte[bytes];
Marshal.Copy(ptr, rgbValues, 0, bytes);
//DateTime start = DateTime.Now;
for (int i = 3; i < rgbValues.Length; i += 4)
{
byte NewValue = (byte)((int)((rgbValues[i - 3]) * .11) + (int)((rgbValues[i - 2]) * .59) + (int)((rgbValues[i - 1]) * .3) / 3);
if (NewValue <= 100)
{
rgbValues[i - 1] = rgbValues[i - 2] = rgbValues[i - 3] = 0;
}
else
{
rgbValues[i - 1] = rgbValues[i - 2] = rgbValues[i - 3] = 255;
}
}
Marshal.Copy(rgbValues, 0, ptr, bytes);
n.UnlockBits(bmpD);
pctbxImagResult.Image = n;
}

Ahora utilizando punteros para eficientar el proceso al pasar a escala de grises:
unsafe
{
Bitmap n = (new Bitmap(pctbxImagPrincipal.Image));
Rectangle rec = new Rectangle(0, 0, n.Width, n.Height);
BitmapData bmpD = n.LockBits(rec, ImageLockMode.ReadWrite, n.PixelFormat);
IntPtr ptr = bmpD.Scan0;
byte* RealPointer = (byte*)ptr.ToPointer();
int bytes = bmpD.Stride * n.Height;
for (int i = 3; i < bytes; i += 4)
{
byte NewValue = (byte)((int)((*(RealPointer + i - 3)) * .11) + (int)((*(RealPointer + i - 2)) * .59) + (int)((*(RealPointer + i - 1)) * .3));
RealPointer[i - 1] = RealPointer[i - 2] = RealPointer[i - 3] = NewValue;
}
n.UnlockBits(bmpD);
pctbxImagResult.Image = n;
}

otra forma muy conocida para tratar imagenes es utilizando los ciclos anidados:

escala de grises:

Bitmap n = (new Bitmap(pictureBox1.Image));
for (int i = 0; i < n.Width; i++)
{
for (int j = 0; j < n.Height; j++)
{
Color l = (n.GetPixel(i, j));
int k = l.ToArgb();
int rojo = (int)((k & 0x0000FF) * 0.3);
int Verde =(int)(((k & 0x00FF00) >> 8)*.59);
int blue = (int)(((k & 0xFF0000) >> 16)*.11);
int NColor = rojo + Verde + blue;
n.SetPixel(i, j, Color.FromArgb(NColor| NColor<<8| NColor<<16 | 255<<24 ));
}

}
pictureBox1.Image = n;

binarizacion :

Bitmap imagen = (new Bitmap(pictureBox1.Image));
for (int i = 0; i < n.Width; i++)
{
for (int j = 0; j < n.Height; j++)
{
Color l = (imagen.GetPixel(j, i));
int gris = (int)((l.R + l.B + l.G) / 3);
if (gris <= 100)
{
imagen.SetPixel(j, i, Color.Black);
}
else
{
imagen.SetPixel(j, i, Color.White);
}
}
}
pictureBox1.Image = n;

Serialización de clases derivadas

Al referirme a clases derivadas me refiero a clases que heredan ya sea de interfaces, clases abstractas o clases concretas, al serializar este tipo de clases muy amplias utilizando la herencia es un poco complejo el estar "marcando" por clase que es un atributo o que es una clase raíz y cosas así para después su serialización, entonces existe una forma que nos permite hacer este trabajo muy cómodamente y sin tener que estar marcando cada clase con atributos y demás. Esta forma consiste en personalizar la serializacion de objetos, utilizando:

XmlAttributes

XmlElementAttribute

XmlAttributeOverrides

XmlSerializer

Supongamos que tenemos esta jerarquia de clases:

public class Name
{

public Name() { }

public Name(string Name, string _1erApellido, string _2doApellido)
{
nombre = Name;

primerApellido = _1erApellido;

segundoApellido = _2doApellido;

}

public stringnombre { set;get;}

public string primerApellido {

set; get; }

public
string segundoApellido { set; get; }

public
override
string ToString()

{

return nombre + " " + primerApellido + " " + segundoApellido;

}

}

public class Persona {

public Persona() { }

public Persona(Name Nombre, string fechaNacimiento)

{

this.Nombre = Nombre;

this.FechaNacimiento = fechaNacimiento;

}

public
Name Nombre { get; set; }

public
string FechaNacimiento { get; set; }

}

public
class
PersonaFisica:Persona

{

public
string RazonSocial { set; get; }

public
string homoClave { set; get; }

public PersonaFisica() { }

public PersonaFisica(Name _nombre, string _fechaNacimiento, string homoclave)

: base(_nombre, _fechaNacimiento)

{

this.homoClave = homoclave; this.RazonSocial = Nombre.ToString();

 

}

}

public class Interprete

{

public
string Nombre { set; get; }

}

public
class
Disco

{

public Disco() { }

public
string Titulo { set; get; }

public
Interprete Interprete { set; get; }

public
string Clasificacion { set; get; }

public
string TipoDisco { set; get; }

}

[XmlRootAttribute("prestamo")]
public class Prestamo{

public Prestamo(){}

public Prestamo(PersonaFisica Cliente,Disco Articulo)

{

DatosCliente = Cliente;

ArticuloAPrestar = Articulo;

fechaInicio = DateTime.Now.ToString(); ;

}

public
PersonaFisica DatosCliente { set; get; }

public
Disco ArticuloAPrestar { set; get; }

public
string fechaInicio { set; get; }

}

Ahora bien, como se puede dar uno cuenta,estas clases estan bastantes creciditas,donde una implementa a todas,la serializacion se vuelve un tanto ruda porque se estan utilizando clases sobre clases y asi sucesivamente, ahora bien para serializar todas estas a la vez,nos ayudamos de nuestros amigos mencionados anteriormente, primero, necesitamos instanciar Un objeto XmlAttributes y un XmlElementAttribute:

XmlAttributes atribXml = new
XmlAttributes();

XmlElementAttribute elemntAtrib = new
XmlElementAttribute();

A la propiedad Type de "elemntAtrib"(XmlElementAttribute) se le asigna el tipo de dato que queremos serizalizar, en este caso seria de tipo Prestamo.

elemntAtrib.Type = typeof(Prestamo);

Despues al objeto" atribXml " de tipo XmlAttributes le agregamos un elemento XmlElementAttribute:

atribXml.XmlElements.Add(elemntAtrib);

Ahora bien, despues de esto vamos a necesitar reemplazar el modo predeterminado de serializar los objetos, y esto lo hacemos instanciando un objeto de tipo "XmlAttributeOverrides",que es lo que necesitamos para nuestros fines.

XmlAttributeOverrides atribSobreEscrito = new
XmlAttributeOverrides();

Mediante el metodo Add agregamos un objeto XmlAttributes.

atribSobreEscrito.Add(typeof(List<Prestamo>), atribXml);

NOTA: al agregar un XmlAttributes necesitamos especificar el tipo de dato del cual queremos serializar, en este caso es una lista generica que guarda objetos de tipo Prestamo,seguido del objeto XmlAttributes que hemos creado.

Ahora bien, ya que tenemos todas las piezas del puzzle solo tenemos que llamar a la clase magica que hace el trabajo y para eso instanciamos un objetito de esta:

XmlSerializer serializer = new
XmlSerializer(typeof(List<Prestamo>), atribSobreEscrito);

Y por ultimo vamos a escribir sobre el archivo.

 

TextWriter writer = new
StreamWriter(@"C:\\Prestamos.xml");

Y serializar:

serializer.Serialize(writer, Prestamos);

writer.Close();

codigo Serializar:

XmlAttributes atribXml = new XmlAttributes();
XmlElementAttribute elemntAtrib = new
XmlElementAttribute();

elemntAtrib.Type = typeof(Prestamo);

atribXml.XmlElements.Add(elemntAtrib);

XmlAttributeOverrides atribSobreEscrito = new
XmlAttributeOverrides();

atribSobreEscrito.Add(typeof(List<Prestamo>), atribXml);

XmlSerializer serializer =new
XmlSerializer(typeof(List<Prestamo>), atribSobreEscrito);

TextWriter writer = new
StreamWriter(@"C:\\Prestamos.xml");

serializer.Serialize(writer, Prestamos);

writer.Close();

Por ultimo para deserializar el objeto es similar:

Codigo Deserializar:

     ///, se instancia un objeto XmlAttributeOverrides, XmlAttributes, XmlElementAttribute

XmlAttributeOverrides atribSobreEscrito = new
XmlAttributeOverrides();

XmlAttributes atribXml = new
XmlAttributes();

XmlElementAttribute elemntAtrib = new
XmlElementAttribute();

elemntAtrib.Type = typeof(Prestamo);

atribXml.XmlElements.Add(elemntAtrib);

atribSobreEscrito.Add(typeof(List<Prestamo>), atribXml);

XmlSerializer serializer = new
XmlSerializer(typeof(List<Prestamo>), atribSobreEscrito);

FileStream fsFile = new
FileStream(path, FileMode.Open);//se abre el archivo en el path especificado para leerlo

Prestamos = (List<Prestamo>) serializer.Deserialize(fsFile);//Prestamos es una lista de prestamos(List<Prestamo>)), a esta se le asignan los elementos que se deserealizan del archivo.

Y bueno espero que se entienda la explicacion a grandes rasgos.

Saludos.

Acceder a una bd Access

Vamos a acceder a una base de datos de access y el pekeño ejemplo abarca la insercion, eliminacion y show de datos, esto con solo dos campitos, ID y Nombre en una tabla llamada "tabla1".

codigo:
using System;
using System.Data.OleDb;
using System.Data;
using System.Windows.Forms;

namespace example_bd
{
public partial class Form1 : Form
{ //Se declara un string que indica el provedor, el path y la protección del acceso al origen de datos.
string namedb = @"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Example.accdb;Persist Security Info=False";
string SentTbTabla = "SELECT * FROM Tabla1 ORDER BY ID";//query
OleDbConnection conexion;//se declara la conexion que utilizaremos
OleDbDataAdapter daComplemnt;//se declara un adaptador de datos
OleDbCommandBuilder creation;//se declara un commanbuilder para agregar comportamientos como insertar,eliminar actualizar etc, al dataAdapter.
DataTable dtTabla1;//se declara una tabla
public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{
//conexion con la bd access
conexion= new OleDbConnection(namedb);
//se crea el adaptador
daComplemnt = new OleDbDataAdapter(SentTbTabla, conexion);
//se crea el commandbuilder para asignar los comandos update,delete,insert al dataAdapter
creation = new OleDbCommandBuilder(daComplemnt);
//se crean las tablas
dtTabla1 = new DataTable();
//se le agregan los siguientes comportamientos al dataAdapter, aunque se supone que se realiza automaticamente luego surgen problemas internos y no lo hace..:]
daComplemnt.UpdateCommand = creation.GetUpdateCommand();
daComplemnt.DeleteCommand = creation.GetDeleteCommand();
daComplemnt.Fill(dtTabla1 );

}
private void btnMostrar_Click(object sender, EventArgs e)
{
if(txtID.Text !="")//valida que no este vacio el textbox.
{
//se realiza la extraccion de los campos de la bd
DataRow[] foundRows;
//busca la columna que tenga un determinado ID dado por el usuario en el txtID
foundRows = dtTabla1.Select("ID=" + "'" + txtID .Text + "'");
//se muestra en txtName el valor del nombre con el ID dado por el usuario
txtName.Text = foundRows[0].ItemArray[1] + "";
}
}
private void btnDelate_Click(object sender, EventArgs e)
{
DataRow[] foundRows;
//Se busca una fila atravez de un valor de columna ID
foundRows = dtTabla1.Select("ID=" + "'" + txtID.Text + "'");
//se elimina
foundRows[0].Delete();
//se realiza la actualizacion a la bd
daComplemnt.Update(dtTabla1);
//aceptar cambios para que surta efecto directo en la bd
dtTabla1.AcceptChanges();
MessageBox.Show("hecho");
txtID.Text = "";
txtName.Text = "";
}
private void btnInsertar_Click(object sender, EventArgs e)
{
//se crea una nueva DataRow
DataRow drComplemnt = dtTabla1.NewRow();
//se agregan en cada campito los valores de los textbox
drComplemnt["ID"] = txtID.Text;
drComplemnt["Nombre"] = txtName.Text;
//se agrega a la tabla la columna llenada anteriormente
dtTabla1.Rows.Add(drComplemnt);
//update a la bd
daComplemnt.Update(dtTabla1);
// aceptar cambios para que surta efecto directo en la bd
dtTabla1.AcceptChanges();
MessageBox.Show("hecho");
txtID.Text = "";
txtName.Text = "";
}
}
}

descargate el proyecto con la bd de ejemplo:
http://www.megaupload.com/?d=14QIN1KS

La palabra Static

Para empezar, que es un miembro?

Los miembros nos van a representar datos y comportamientos, esto tanto en clases como en estructuras. En las clases todo lo declarado dentro de ella y por herencia son miembros.

Los tipos de miembros que puede contener una clase o estructura:

Miembro	Descripción
Campos	Los campos son variables declaradas dentro de la clase. Un campo puede ser un o una instancia de otra clase.
Constantes	Las constantes son campos o propiedades cuyo valor se establece en tiempo de compilación y no se puede cambiar.
Propiedades	Las propiedades son métodos de una clase a los que se obtiene acceso como si fueran campos de esa clase. Una propiedad puede proporcionar protección a un campo de clase con el fin de evitar que se cambie sin el conocimiento del objeto.
Métodos	Los métodos definen las acciones que una clase puede realizar. Los métodos pueden aceptar parámetros que proporcionan datos de entrada y devolver datos de salida a través de parámetros.
Eventos	Los eventos proporcionan a otros objetos notificaciones sobre lo que ocurre, como clics en botones o la realización correcta de un método. Los eventos se definen y desencadenan mediante delegados.
Operadores	Un operador es un término o un símbolo que acepta como entrada una o más expresiones, u operandos, y devuelve un valor. Los operadores que requieren un operando, como el operador de incremento (++) o new, se conocen como operadores unarios. Los operadores que requieren dos operandos, como los operadores aritméticos (+,-,*,/) se conocen como operadores binarios. Un operador, el operador condicional (?:), utiliza tres operandos y es el único operador terciario.
Indizadores	Los indizadores permiten indizar un objeto de manera similar a como se hace con las matrices.
Constructores	Los constructores son métodos a los que se llama cuando el objeto se crea por primera vez. Se utilizan a menudo para inicializar los datos de un objeto.
Destructores	Son métodos a los que llama el motor de ejecución cuando el objeto está a punto de quitarse de la memoria. Generalmente se utilizan para asegurarse de que los recursos que se deben liberar se controlan apropiadamente.

Ahora bien, ya que sabemos que es un miembro, podemos decir que el modificador static se utiliza para declarar un miembro estático, y este indica que un miembro, en lugar de pertenecer a un objeto, pertenece a la propia clase.

De este modo conseguimos que en cada instanciación de un objeto sólo haya una copia del miembro static (sin importar el número de instanciaciones).

Para acceder a los valores de un miembro static es necesario hacer la referencia a través del nombre de la clase y no con algún objeto, esto es:

Class Animal {

Public static int corre(){…}

}

Animal.corre();

De esta forma se accede a los miembros statics de las clases.

¿En dónde podemos utilizar dicho modificador?

Se puede utilizar con clases, campos, métodos, propiedades, operadores, eventos y constructores, pero no puede utilizarse con indizadores, destructores o tipos que no sean clases (por ejemplo: interfaces). Además no puede combinarse con ninguno de los modificadores de herencia (abstract y final) ni de versión segura (hide y override).

Miembros estáticos

Algunas particularidades:

 

• Los métodos estáticos también se pueden sobrecargar.
  
• Aunque un campo no se puede declarar como static const, const es esencialmente estático en su comportamiento.
  
• C# no admite las variables locales estáticas (variables que se declaran dentro del método).
  
• Los miembros estáticos se inicializan antes de obtener acceso al miembro estático por primera vez y antes de llamar al constructor estático, si éste existe.
  

 

Clases estáticas

Una clase estática, comúnmente se utiliza para agrupar métodos que solo hacen procesos con datos de entrada por medio de los parámetros.

El crear una clase estática es similar a construir una clase no estática con miembros estáticos y un constructor privado, este último evitara que se creen instancias de esta. Aunque podamos hacer esto último, el crear una clase estática tiene la ventaja de que el compilador comprueba que no se agregue algún miembro de instancia (miembro no estático) y nos garantice de que no se puedan hacer instancias de esta. Además de que toda clase estática es de tipo " sealed "(sellada) y por lo tanto no pueden heredarse y esta a su vez no puede heredar de alguna otra clase excepto la clase object.

Las clases estáticas pueden contar con constructores, obviamente que no serán constructores de instancia sino que serán estáticos, y su uso se limita a inicializar variables estáticas, esto también se puede aplicar a las clases no estáticas que cuenten con miembros estáticos y se necesiten inicializar.

Constructores estáticos
Un constructor estático se utiliza para inicializar cualquier dato estático o realizar una determinada acción.

Por ejemplo:

class Time{
static readonly long time;

static Time()

{
time = DateTime.Now.Ticks;

}

} .

Compilar sin Visual studio

Podemos compilar codigo fuente escrito para programas de tipo consola o de winform, sin necesidad de compilar desde visual studio utilizando el command prompt del sdk, para realizar dicha accion sigue la siguiente ruta:

Inicio->>todos los programas->Microsoft Visual Studio->Visual Studio Tools->Visual Studio Command Prompt.

al abrir la consola te ubicas en el directorio donde se encuentra tu archivo de texto plano (txt.cs), despues para crear el .exe de tu archivo escribe esto en la consola:

csc nombreArchivo.cs

Con esto obtenemos el exe de tu source code.

Programacion Orientada a Objetos en C#

Visual C#.NET
Es creado especialmente para .NET,100% Orientado a Objetos y Componentes,este tiene su sintaxis derivada de C, C++, Delphi y Java.

Clases.
Las clases son declaradas mediante la palabra reservada class:
class CuentaBancaria
{
//Definición de miembros
}
Métodos.
Los métodos se conforman de la siguiente forma:
modificador_acceso tipo_retorno nombre_método(tipo_dato firma1,tipo_dato2 firma2, tipo_daton firma_n){}

public void HacerDeposito(int importe){} //No devuelve valor
public int ObtenerInventario(int codArticulo,int articulo2){} //Devuelve un entero

Sobrecarga de Métodos.
Varios métodos con el mismo nombre pero diferente firma.
public void HacerDeposito(int importe) {}
public void HacerDeposito(int importe, bool acreditar){}

Métodos de clase.
Miembros que no requieren de una instancia para ser invocados.

public static void HacerDeposito(int importe) {}

Propiedades.

Las propiedades son miembros que ofrecen un mecanismo flexible para leer, escribir o calcular los valores de campos privados. Se pueden utilizar las propiedades como si fuesen miembros de datos públicos, aunque en realidad son métodos especiales denominados descriptores de acceso. De este modo, se puede tener acceso a los datos con facilidad, a la vez que proporciona la seguridad y flexibilidad de los métodos.

class CtaCte
{ int balance;
public int Balance
{ get{return balance;}
set {balance = value;}
}
}
class Cliente
{
public string Nombre { get; set; }
public int Edad { get; set; }
public int Cuenta { get; set; }
}

Herencia.
class Cuenta {} //Clase Base
class CtaCte : Cuenta { } //Clase Derivada
Dos palabras clave que afectan la “habilidad” de heredar desde una clase base:
public sealed class Cuenta{
//No se puede heredar de esta clase “sellada”
}
public abstract class Cuenta{
//No se pueden crear instancias de esta clase, sólo
//de sus derivadas ya que es una clase abstracta.
}
NOTA: Los miembros privados de clases base se heredan en las clases derivadas pero éstas no pueden tener acceso a ellos.

Constructores.

Son métodos dentro de la clase que son llamados automáticamente cuando se crea una instancia de dicha clase.

class CtaCte
{ public CtaCte(){...} //Const. por default
public CtaCte(int i){...} //Const. con un parametro
}


Modificadores de Acceso (Alcance de miembros).


Los modificadores de acceso definen el acceso(visibilidad) de los miembros(atributos,metodos) de una clase.
-En C# todo miembro es declarado como PRIVATE por default.-
Tanto para los atributos como para los métodos de una clase puede configurarse el nivel de visibilidad o acceso que estos tendrán hacia el mundo exterior.

Públic: un miembro público puede ser accedido desde cualquier otra clase.
Private: un miembro privado solamente puede ser accedido desde la clase en la que está declarado.
internal:Los tipos o miembros internos sólo son accesibles dentro de los archivos del mismo ensamblado.
Proteted: un miembro protegido solamente puede ser accedido desde la clase en la que está declarado y desde las clases que hereden de ella.
Proteted internal:Sólo los tipos derivados o tipos dentro del mismo ensamblado pueden tener acceso a ese miembro.


Enumeraciones.
Es un tipo distinto que consiste en un conjunto de constantes con nombre denominado lista de enumeradores. Cada tipo de enumeración tiene un tipo subyacente, que puede ser cualquier tipo integral excepto char. El tipo predeterminado subyacente de los elementos de la enumeración es int. De forma predeterminada, el primer enumerador tiene el valor 0 y el valor de cada enumerador sucesivo se incrementa en 1.

enum Days {Sat, Sun, Mon, Tue, Wed, Thu, Fri};

Atributos de clase.
Los atributos de clase tienen la siguiente estructura:
modificadr_acceso static tipo_dato nombre_atributo;

public static string color="red";

Metodos virtuales(sobreescritura).
Los metodos virtuales se utilizan para definir a un metodo en una superclase como un metodo que se puede sobreescribir.
Los metodos virtuales heredados por alguna superclase se pueden sobreescribir utilizando la palabra clave override.

public virtual double Area()
{ return x * y;}

Sobreescribiendo metodos virtuales

public override double Area()
{ return PI * x * x;}

Interfaces.
Las interfaces pueden estar compuestas de métodos, propiedades, eventos, indizadores o cualquier combinación de estos cuatro tipos de miembros. Una interfaz no puede contener atributos. Los miembros de interfaz son automáticamente públicos.

interface ICtaCve
{
void metodo1();
void metodo2(string cuenta);
}

Implementando metodos de una interfaz(implicito).

class myClass:ICtaCve
{
public void metodo1(){}
public void metodo2(string a){}
}

Conceptos sobre el paradigma orientado a objetos.

¿Que es un objeto?
Según las definiciones formales de James Rumbaugh y Grady Booch, un objeto es una abstracción de la realidad que tiene un significado concreto y claro para el problema que se está modelando.
Todos los objetos tienen 3 características principales:
Estado,Comportamiento e Identidad.
Estado: -Todo objeto posee un estado, el cual normalmente cambia en el transcurso del tiempo.
-Es una de muchas posibles condiciones en las que puede existir el objeto.
Comportamiento: El comportamiento de un objeto va a definirr las acciones (u operaciones)que este puede realizar ante diversos contextos en el que se desarrolle.
Identidad: La identidad de un objeto es la que va a definir a este como único,aunque su estado sea igual al de otro objeto(o idéntico inclusive).
¿Qué es una Clase?
Una clase es una plantilla general para un grupo de objetos con ciertas características en común,por ejemplo propiedades,comportamientos,semantica etc.

¿Que elementos contienen las clases?
Las clases se definen con atributos y métodos:
atributos:Los atributos definen las características que tienen los objetos,estos suelen tener nombre,alcance y tipo de dato.
métodos:Los métodos definen la acción que llevara a cabo el objeto.

Dada la definición de clase y objeto podemos decir que:
Un objeto es una instancia de una clase.

Ahora bien, ya que sabemos los conceptos principales, existen otros que son necesarios y útiles, dentro de la estructuración de una clase, y estos son: propiedades y métodos de clase(estáticos).
Los atributos estáticos sirven para que al instanciar un objeto, ese tipo de dato se instancie una sola vez,y los cambios que se hagan a ese atributo, se vean afectados en todas las instancias de esa clase.
Los métodos de clase son miembros que no necesitan de una instancia para ser invocados.

Pilares de la Orientación a Objetos.




Abstracción.
El proceso de abstracción permite seleccionar las características relevantes dentro de un conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real. La abstracción es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases que permitan modelar la realidad o el problema que se quiere atacar.

Encapsulamiento.
Principio que establece que los atributos propios de un objeto no deben ser visibles desde otros objetos.Permite exponer el estado(atributos) del objeto sólo a través de sus comportamientos(métodos) del mismo.Esto nos ayuda a una mejor respuesta ante los cambios.

Herencia.
Es una relación entre clases en la cual una clase comparte la estructura y comportamiento definido en otra clase.Cada clase que hereda de otra posee:
Los atributos de la clase base además de los propios,soporta todos o algunos de los métodos de la clase base(superclase).
NOTA: Los miembros privados de clases base se heredan en las clases derivadas pero éstas no pueden tener acceso a ellos.
Cabe destacar que existen 2 tipos de herencia.
Herencia Simple: una clase derivada puede heredar sólo de una clase base.
Herencia Múltiple: una clase derivada puede heredar de una o más clases base.


Conceptos del Diseño Orientado a Objetos.
Interfaces.

Es un recurso de diseño que permite definir comportamientos(métodos), y que clases que no están estrechamente relacionadas entre sí deban tener el mismo comportamiento.
La implementación de una interfaz es un contrato que obliga a la clase a implementar todos los métodos definidos en la interfaz.
Por ultimo, una pequeña pero muy significativa característica es que no se pueden declarar atributos dentro de una interfaz.

Polimorfismo.

Es la propiedad que tienen los objetos de permitir invocar genéricamente un comportamiento (método).
El polimorfismo se puede obtener a partir de 2 formas, estas son: por sobrecarga y por sobre escritura.
Un polimorfismo por sobrecarga significa que podemos utilizar el mismo nombre del método cuantas veces sea necesario pero con la diferencia de que sus parámetros(firmas del método)difieran una de las otras.
El polimorfismo por sobreescritura se da mas en el ambito de la herencia, ya que cuando una clase hereda de una clase base(superclase),esta(clase hija) puede redefinir el comportamiento de algun metodo que esté definido en la superclase.

Manejo de claves del editor de registro de windows en C#

Como primer entrada mostrare un ejemplo de como manipular las claves de registro del regedit,como sabemos existen 5 nombres de claves dentro del registro, estas son: HKEY_CLASSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
HKEY_CURRENT_CONFIG
las cuales para un mejor manejo de informacion las llamaremos claves root.
Para manipular los valores contenidos dentro de las claves .net nos provee clases para esto,un par de estas muy importantes son "Registry" y "RegistryKey".
La clase Registry provee objetos RegistryKey que representan los nombres de las claves root y métodos estáticos para acceder al valor de alguna clave.
Ahora bien, antes de empezar con el código necesitamos importar un namespace:
using Microsoft.Win32;
el cual contiene las clases a utilizar.
La clase registry también contiene métodos estáticos gets y sets para los valores de las claves,estas abren y cierran claves de registro cada vez que son usadas,estas no tienen un buen desempeño como sus métodos análogos descritos en la clase RegistryKey.
Métodos de la clase RegistryKey:
Nota: solo se mencionan los mas útiles para el ejemplo.
Para mayor información visita:
http://msdn.microsoft.com/es-es/library/microsoft.win32.registrykey_members(v=VS.80).aspx
CreateSubKey: Crea una nueva subclave o abre una subclave existente.
DeleteSubKey: Elimina la subclave especificada.
DeleteValue: Elimina el valor especificado de esta clave.
GetValue: Recupera el valor asociado al nombre especificado.
OpenSubKey: Recupera la subclave especificada.
SetValue: Establece el valor de un par nombre/valor de la clave del Registro.
Ahora bien, después de conocer algunos método necesitamos instanciar objetos de acuerdo a nuestras necesidades, para manejar claves root debemos instanciar un objeto indicando el tipo de clave root que utilizaremos:
RegistryKey key = Registry.ClassesRoot;
RegistryKey key = Registry.CurrentUser;
RegistryKey key = Registry.LocalMachine;
RegistryKey key = Registry.Users;
RegistryKey key = Registry.CurrentConfig;

Después de tener nuestro objeto instanciado pasamos a ejemplificar sus métodos.
Crear Subclaves:
key.CreateSubKey("Psched");
Eliminar Subclaves:
key.DeleteSubKey("Explorer");
Eliminar valores:
key.DeleteValue("Explorer");
Obtener valores:
key.GetValue("NonBestEffortLimit");
Abrir Subclaves:
key.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced");
Se abre una clave de solo lectura.
key.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",true );
2° parametro indica el tipo de acceso al valor de las subclaves.true:permite el acceso para escribir.
Escribir valores:
keyReg.SetValue("NonBestEffortLimit", 0);
Pongo un ejemplo en el cual se modifica un valor de registro para acelerar el apagado del pc.

RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\\Desktop", true);
string value = Convert.ToString(key.GetValue("WaitToKillAppTimeout"));
if (value == "20000") //Hecho
{
key.SetValue("WaitToKillAppTimeout",4000);
try
{
RegistryKey key2 = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Control", true);
key2.SetValue("WaitToKillServiceTimeout", 4000);
//se crea un objeto proceso para matar el proceso del explorer y asi poder hacer una actualizacion del sistema sin reiniciar el pc.
Process[] proceso = Process.GetProcessesByName("Explorer");
proceso[0].Kill();//se mata proceso
proceso[0].Close();
}
catch (Exception exp){
key.SetValue("WaitToKillAppTimeout", 20000);
MessageBox.Show("Error de proceso: /r" + exp.Message);
}
}
else // ya hecho
{
MessageBox.Show("Ya esta modificada la entrada del registro");
}

Matta neeee¡¡¡