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¡¡¡