static void Main(string[] args)
{
string rutaDelArchivo = DateTime.Now.ToString("yyyyMMdd-HHmm") + ".txt";
try
{
OtraClase oc = new OtraClase();
oc.MetodoDeInstancia();
}
catch (MiExcepcion ex)
{
ArchivoTexto.Guardar(rutaDelArchivo, ex.Message);
if (ex.InnerException != null)
{
Exception e = ex.InnerException;
do
{
ArchivoTexto.Guardar(rutaDelArchivo, e.Message); //Muestra los msj de las InnerException
e = e.InnerException;
}while (e != null);
}
}
try
{
Console.WriteLine(ArchivoTexto.Leer(rutaDelArchivo));
}
catch (FileNotFoundException ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
OtraClase otraClase = new OtraClase();
otraClase.MetodoInstancia(); //provoco la excepción.
}
catch (MiException miEx) //se produce una excepción del tipo MiExcepcion
{
Console.WriteLine(miEx.Message);
//Console.WriteLine(miEx.InnerException); //SI DEJO ESTO MUESTRA TODO EL PATH DE LOS ERRORES.
Console.WriteLine(miEx.InnerException.Message);
Exception ex = miEx.InnerException;
Console.WriteLine($"MENSAJE: {ex.Message}\nEN: {ex.Source}");//Muestro solo la InnerException.
//SI TENEMOS MUCHAS INNEREXCEPTIONS
//determinamos si pertenecen a la misma instancia
//verifico que no sea null en esta caso...
//if (!Object.ReferenceEquals(miEx,null))
//{
// Exception ex = miEx.InnerException;//guardo la innerException
// do
// {
// Console.WriteLine(ex.Message);
// ex = ex.InnerException;
// } while (!Object.ReferenceEquals(ex,null));//Hasta que no se llamen a todos los Inner, no termina el bucle.
//}
}
Console.ReadKey();
}
public void ProbarConstructorTres()
{
//Act
OtraClase clase = new OtraClase();
clase.OtraClaseInstancia();
}
static void Main(string[] args)
{
try
{
OtraClase n = new OtraClase();
n.OtroMetodoDeInstancia();
}
catch (Exception ex) //(MiExcepcion ex)
{
Console.WriteLine(ex.Message);
while (ex.InnerException != null)
{
ex = ex.InnerException;
Console.WriteLine(ex.Message);
}
/*
* Exception inneer = ex.InnerException;
* Console.WriteLine(ex.Message);
* while (inneer != null)
* {
* Console.WriteLine(inneer.Message);
* inneer = inneer.InnerException;
* }*/
}
Console.ReadKey();
}
public void TestMetodoInstancia()
{
//Arrange
OtraClase otra = new OtraClase();
//Act
otra.MetodoInstancia();
//Assert
}
public void TestConstructorOtraClase()
{
//arrange
OtraClase oc;
//act
oc = new OtraClase();
//assert manejado en el ExcpetedExceptio
}
public static void Main()
{
OtraClase objOtraClase = new OtraClase ();
MiDelegado objMiDelegado = new MiDelegado (objOtraClase.Metodo1);
objMiDelegado += objOtraClase.Metodo2;
objMiDelegado(4);
}
public void Test_MetodoDeInstancia()
{
//ARRANGE
OtraClase otra;
//ACT
otra = new OtraClase();
otra.MetodoDeInstancia();
}
public void TestMetodoDeInstancia()
{
//Arrange
OtraClase oc = new OtraClase();
//Act
oc.MetodoDeInstancia();
//Assert
}
public static void Main()
{
OtraClase objOtraClase = new OtraClase();
Del objDel = objOtraClase.Metodo1;
objDel += objOtraClase.Metodo2;
TratarDelegados.InfoDelegado(objDel);
}
//g.MiException será capturada en el Main, mostrando el mensaje de error que esta almacena
//por pantalla y los mensajes de todas las excepciones almacenadas en sus innerException.
static void Main(string[] args)
{
try
{
MiClase m = new MiClase();
OtraClase o = new OtraClase();
}
catch (MiExcepcion ex)
{
Console.WriteLine(ex.Message, ex.StackTrace);
}
Console.ReadKey();
}
public void Test_04_OtraClase_E1()
{
#region Arrange
OtraClase oc = new OtraClase();
#endregion
#region Act
oc.OtroMetodoInstancia();
#endregion
}
public static void Main()
{
Console.WriteLine ("Se inicia el programa");
// Se crea una instancia de la clase 'OtraClase'
OtraClase objOtraClase = new OtraClase ();
Console.WriteLine ("Se añade al objeto delegado el método estático 'Metodo1DeOtraClase'");
// Añadir a 'objDelegado' un método estático de 'OtraClase'
// Para añadir un primer método a un objeto delegado, se usa el operador '=' .
// Pero esto vale solo para el primer método a añadir, el resto de los métodos se añaden
// con el operador '+=' .
Console.WriteLine ("Se crea una instancia de la clase 'OtraClase'");
MiDelegado objDelegado = new MiDelegado (OtraClase.Metodo1DeOtraClase);
Console.WriteLine ("Se añade al objeto delegado el método no estático 'Metodo2DeOtraClase'");
// Se añade 'Metodo2DeOtraClase' que no es estático. Ahora usamos el operador
//'+=' ya que no es el primer método a añadir.
objDelegado += new MiDelegado (objOtraClase.Metodo2DeOtraClase);
Console.WriteLine ("Se añade al objeto delegado el método estático 'Metodo1DeEstaClase'");
// Se añade un método estático de esta clase. No hay para que referirse al nombre de esta
objDelegado += new MiDelegado (Metodo1DeEstaClase);
Console.WriteLine ("Se crea una instancia de la clase 'EstaClase'");
// Crear una instancia de esta clase 'EstaClase'
EstaClase objEstaClase = new EstaClase ();
Console.WriteLine ("Se añade al objeto delegado el método no estático 'Metodo2DeEstaClase'");
// Se añade un método publico de esta clase
objDelegado += new MiDelegado (objEstaClase.Metodo2DeEstaClase);
Console.WriteLine ("Se llama a objDelegado objDelegado (8, 3);");
// Llamar a un método estático que se almacena en 'objDelegado'
objDelegado (8, 3);
// Ahora, llamamos a los métodos que están relacionados con los métodos de
// 'objEstaClase' y los de 'objOtraClase'. Se vió que a 'objDelegado' al llamarlo no le
// importa si los métodos a añadir son estáticos o públicos.
// Ahora veremos algunos atajos para añadir métodos a un objeto delegado que se añadieron en la
// versión 2.0 del lenguaje C# . Es importante tener en cuenta estos atajos para usarlos y también
// leer código de otros programadores.
objDelegado += objEstaClase.Metodo2DeEstaClase;
objDelegado += OtraClase.Metodo1DeOtraClase;
// Ejecutando el delegado
objDelegado (10, 20);
}
static void Main(string[] args)
{
Console.Title = "Ejercicio Nro 54";
string auxStackTrace = String.Empty;
string path = AppDomain.CurrentDomain.BaseDirectory + DateTime.Now.ToString("yyyyMMdd-HHmm");
try
{
OtraClase auxClase = new OtraClase();
auxClase.MetodoInstancia();
}
catch (Exception e)
{
try
{
while (e != null)
{
//Console.WriteLine(e.Message);
auxStackTrace += e.StackTrace.ToString() + "\n";
e = e.InnerException;
}
if (ArchivoTexto.Guardar(path, auxStackTrace))
{
Console.WriteLine("Archivo guardado correctamente");
}
}
catch (Exception error)
{
Console.WriteLine(error.Message);
}
}
finally
{
Console.WriteLine("Presione una tecla para continuar...");
Console.ReadKey();
Console.Clear();
Console.WriteLine("Lista de stacktrace traida desde archivo: ");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(ArchivoTexto.Leer(path));
Console.ResetColor();
Console.ReadKey();
}
}
public void MetodoInstanciaOtraClase()
{
OtraClase objeto = new OtraClase();
try
{
objeto.MiMetodoInstancia();
Assert.Fail();
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(MiExcepcion));
Assert.IsInstanceOfType(e.InnerException, typeof(UnaExcepcion));
Assert.IsInstanceOfType(e.InnerException.InnerException, typeof(DivideByZeroException));
}
}
static void Main(string[] args)
{
try
{
OtraClase.metodo();
}
catch (UnaEsepcion perro)
{
Console.WriteLine("hola esepcion {0}\n", perro.Message);
Console.WriteLine("hola esepcion {0}\n", perro.StackTrace);
Console.WriteLine("hola esepcion {0}\n", perro.InnerException.Message);
Console.WriteLine("hola esepcion {0}\n\n\n", perro.InnerException.InnerException.Message);
Console.WriteLine("hola esepcion {0}\n", perro.InnerException.InnerException.InnerException.StackTrace);
Console.ReadKey();
}
}
static void Main(string[] args)
{
Console.WriteLine("Ingrese un numero:");
Console.WriteLine("1) guardarlo en el escritorio");
Console.WriteLine("Otro para guardarlo por default");
string path = null;
if (Console.ReadLine() == "1")
{
path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\" + DateTime.Now.ToString("yyyyMMdd-HHmm") + ".txt";
}
else
{
path = DateTime.Now.ToString("yyyyMMdd-HHmm") + ".txt";
}
try
{
OtraClase a = new OtraClase();
a.OtraClaseInstancia();
}
catch (MiExcepcion ex)
{
Exception excep = ex; //Puede contener todas las excepciones
while (excep != null)
{
ArchivoTexto.Guardar(path, excep.Message);
excep = excep.InnerException;
}
}
try
{
ArchivoTexto.Leer(path);
}
catch (FileNotFoundException ex)
{
ArchivoTexto.Guardar(path, ex.ToString());
}
Console.WriteLine(ArchivoTexto.Leer(path));
Console.ReadKey();
}
public static void Main()
{
Console.WriteLine ("Se inicia el programa\n");
OtraClase objOtraClase = new OtraClase ();
// Ya que la palabra clave 'delegate' representa una clase sellada
// 'System.MulticastDelegate', sus intancias pueden ser inicializadas como cualquier
// otra clase.
// Entonces ->
// MiTipoDelegado miObjDelegado1 = new MiTipoDelegado (objOtraClase.Metodo1);
// Es lo mismo que -->
MiTipoDelegado miObjDelegado1 = objOtraClase.Metodo1;
miObjDelegado1 += objOtraClase.Metodo2;
MiTipoDelegado miObjDelegado2 = objOtraClase.Metodo3;
// Este es el objeto delegado que contendra los métodos de 'miObjDelegado1'
// y también los de 'miObjDelegado2'. Es importante asignarle un valor nulo (null)
MiTipoDelegado miObjDelegado3 = null;
// Información sobre los objetos delegados tratados gracias a la clase
// 'TratarDelegados'
Console.WriteLine ("Mostrar información de 'miObjDelegado1'");
TratarDelegados.InformaciónObjDelegado (miObjDelegado1);
Console.WriteLine ("\nMostrar información de 'miObjDelegado2'");
TratarDelegados.InformaciónObjDelegado (miObjDelegado2);
Console.WriteLine ("\nMostrar información de 'miObjDelegado3'");
TratarDelegados.InformaciónObjDelegado (miObjDelegado3);
// Combinar los objetos delegados que contienen métodos, para que los contenga
// un solo objeto delegado. Y mostrar información de los objetos delegados.
Console.WriteLine ("\nLuego de combinar los objetos delegados 'miObjDelegado1'");
Console.WriteLine ("y 'miObjDelegado2' en 'miObjDelegado3'");
miObjDelegado3 += miObjDelegado1 + miObjDelegado2;
Console.WriteLine ("\nMostrar información de 'miObjDelegado3'");
TratarDelegados.InformaciónObjDelegado (miObjDelegado3);
// Llamar a todos los métodos de 'miObjDelegado3'
Console.WriteLine ("\nLlamar a los métodos de 'miObjDelegado3'");
miObjDelegado3 (5);
}
static void Main(string[] args)
{
try
{
OtraClase obj = new OtraClase();
obj.MetodoInstancia();
}catch (MiExcepcion ex)
{
Console.WriteLine(ex.Message);
Exception inners;
inners = ex.InnerException;
while (inners != null)
{
Console.WriteLine(inners.Message);
inners = inners.InnerException;
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
try
{
OtraClase oC = new OtraClase();
oC.MetodoInstancia();
}
catch (MiException e)
{
Console.WriteLine(e.Message);
Exception ex = e.InnerException;
while (ex != null)
{
Console.WriteLine(ex.Message);
ex = ex.InnerException;
}
}
Console.ReadKey();
}
public static void Main()
{
Console.WriteLine ("Se inicia el programa");
// Se crea un objeto de la clase 'OtraClase'
OtraClase objOtraClase = new OtraClase ();
// Se crea un objeto delegado y se le asigna un método, en este ejemplo le
// asignamos solo un método, pero se le pueden asignar más.
// Crear un objeto delegado es muy similar a crear un objeto con una clase, la
// diferencia es que le asignamos un método, en ves de argumentos.
// El método no se esta llamando por eso no se utiliza los paréntesis
// 'objOtraClase.Metodo1'
MiDelegado objDelegado = new MiDelegado (objOtraClase.Metodo1);
// Se crea una variable de tipo int y se le asigna el valor de retorno
// del objeto delegado, que es el mismo retorno de el método anteriormente asignado
int retorno = objDelegado (5); // Se hace la llamada de la misma forma que un método
// Muestra el valor de retorno
Console.WriteLine ("El valor devuelto es {0}", retorno);
}
static void Main(string[] args)
{
try
{
OtraClase a = new OtraClase();
a.OtraClaseInstancia();
Console.WriteLine("hoola");
}
catch (MiExcepcion ex)
{
Exception excep = ex; //Puede contener todas las excepciones
while (excep != null)
{
Console.WriteLine(excep.Message);
excep = excep.InnerException;
}
}
Console.WriteLine("hoola!!!!!!!!!!");
Console.ReadKey();
}
static void Main(string[] args)
{
DateTime fecha = DateTime.Now;
string nombreArchivo = fecha.ToString("yyyyMMdd-hhmm") + ".txt";
try
{
OtraClase obj = new OtraClase();
obj.MetodoInstancia();
}
catch (Exception ex)
{
ArchivoTexto.Guardar(nombreArchivo, ex.Message);
while (ex.InnerException != null)
{
ex = ex.InnerException;
ArchivoTexto.Guardar(nombreArchivo, ex.Message);
}
}
Console.WriteLine(ArchivoTexto.Leer(nombreArchivo));
Console.ReadKey();
}
public static void Main()
{
OtraClase objOtraClase = new OtraClase ();
// Del objDel1 = new Del (OtraClase.Metodo1);
Del objDel1 = objOtraClase.Metodo1;
objDel1 += objOtraClase.Metodo1;
Del objDel2 = objOtraClase.Metodo2;
Del objDel3 = objDel1 + objDel2;
objDel3 += OtraClase.Metodo3;
Del objDel4 = delegate (int nnn)
{ Console.WriteLine("nnn: " + nnn); };
objDel3 += objDel4;
int invocationCount = objDel3.GetInvocationList().GetLength(0);
objDel3 (2);
Console.WriteLine(invocationCount);
}
static void Main(string[] args)
{
string ruta = String.Format("{0}{1}{2}-{3}{4}.txt", DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute);
try
{
OtraClase aux = new OtraClase();
aux.MiMetodoInstancia(); //1)Llama al metodo de la clase OtraClase...
}
catch (Exception e)
{ //9) Aca llega DivideByZero + UnaException + MiException
if (!object.ReferenceEquals(e.InnerException, null))
{
do
{
Console.WriteLine(e.Message);
ArchivoTexto.Guardar(ruta, e.Message);
e = e.InnerException;
} while (!object.ReferenceEquals(e, null));
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
OtraClase otraClase;
try
{
otraClase = new OtraClase();
otraClase.UnMetodoDeInstancia();
}catch (MiExcepcion ex)
{
Console.WriteLine(ex.Message);
if (!(ex.InnerException is null))
{
Exception auxEx = ex.InnerException;
do
{
Console.WriteLine(auxEx.Message);
auxEx = auxEx.InnerException;
} while (!(auxEx is null));
}
}
Console.ReadKey();
}
public void TestMiException()
{
//Arrange
OtraClase clasePrueba;
bool capturoException = false;
//Act
try
{
clasePrueba = new OtraClase();
clasePrueba.MiMetodoDeInstancia();
}
catch (Exception e)
{
//Assert
Assert.IsInstanceOfType(e, typeof(MiException));
capturoException = true;
}
if (capturoException == false)
{
Assert.Fail();
}
}
static void Main(string[] args)
{
try
{
OtraClase oc = new OtraClase();
oc.MetodoDeInstancia();
}
catch (MiExcepcion ex)
{
Console.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Exception e = ex.InnerException;
do
{
Console.WriteLine(e.Message); //Muestra los msj de las InnerException
e = e.InnerException;
}while (e != null);
}
}
Console.ReadKey();
}
public void VerificarMetodo2()
{
OtraClase e = new OtraClase();
e.Metodo();
}
public void TestMethod4()
{
OtraClase oc = new OtraClase();
oc.metodo();
}
public void TestStaticMethodAnotherClass()
{
OtraClase.metodo();
}
static void Main(string[] args)
{
//STRING
Mensaje <string> tipoTexto = new Mensaje <string>();
tipoTexto.MiAtributo = "Hola";
Console.WriteLine(tipoTexto.MiAtributo);
Console.WriteLine(tipoTexto.ToString());
//MICLASE
Mensaje <MiClase> tipoMio = new Mensaje <MiClase>();
tipoMio.MiAtributo = new MiClase();
Console.WriteLine(tipoMio.MiAtributo);
Console.WriteLine(tipoMio.ToString());
Console.ReadLine();
//STRING - INT
Mensajero <string, int> tipoTextoEntero = new Mensajero <string, int>();
tipoTextoEntero.miAtr1 = "cadena";
tipoTextoEntero.miAtr2 = 3;
//CHAR - MICLASE
Mensajero <char, MiClase> tipoLetraMio = new Mensajero <char, MiClase>();
tipoLetraMio.miAtr1 = 'L';
tipoLetraMio.miAtr2 = new MiClase();
Console.WriteLine(tipoTextoEntero.ToString());
Console.WriteLine(tipoLetraMio.ToString());
Console.ReadLine();
//RESTRICTIVA
Restrictiva <MiClase> res = new Restrictiva <MiClase>();
res.miLista.Add(new MiClase());
Console.WriteLine(res.ToString());
//ERROR, NO ES DE TIPO MICLASE
//Restrictiva<string> res2 = new Restrictiva<string>();
//DERIVADA
Restrictiva <MiClase> res2 = new Restrictiva <MiClase>();
res2.miLista.Add(new MiClaseDerivada());
Console.WriteLine(res2.ToString());
//TIPOS CON RESTRICCIONES
RestrictivaVarios <MiClase, MiClaseDerivada> res3 = new RestrictivaVarios <MiClase, MiClaseDerivada>();
//TIPO CON MULTIPLES RESTRICCIONES
RestrictivaMultiple <MiClaseDerivada> res4 = new RestrictivaMultiple <MiClaseDerivada>();
//ERROR, NO CUMPLE CON RESTRICCIONES
//RestrictivaMultiple<MiClaseSinDefecto> res5 = new RestrictivaMultiple<MiClaseSinDefecto>();
//RESTRICTIVA CON UNMANAGED
RestrictivaUnmanaged <int> res5 = new RestrictivaUnmanaged <int>();
RestrictivaUnmanaged <ConsoleColor> res6 = new RestrictivaUnmanaged <ConsoleColor>();
Console.WriteLine(res5.ToString());
Console.WriteLine(res6.ToString());
//ERROR, NO ES UN TIPO UNMANAGED
//RestrictivaUnmanaged<string> res7 = new RestrictivaUnmanaged<string>();
Console.ReadLine();
//METODOS GENERICS
OtraClase oc = new OtraClase();
//ESTATICO Y RESTRICTIVO (CLASEDERIVADA)
MiClaseDerivada mcd = new MiClaseDerivada();
string parametro = "hola, que tal?";
Console.WriteLine(OtraClase.MetodoEstatico <MiClaseDerivada>(mcd, parametro));
Console.WriteLine(OtraClase.MetodoEstatico(mcd, parametro));
//ERROR, NO CUMPLE CON RESTRICCION
//Console.WriteLine(OtraClase.MetodoEstatico(3, "hola"));
//DE INSTANCIA, SIN RESTRICCIONES
oc.MetodoInstancia <int>(3);
oc.MetodoInstancia <string>("cadena");
oc.MetodoInstancia <MiClase>(mcd);
oc.MetodoInstancia(88.9f);
//DE INSTANCIA, CON RETORNO Y RESTRICCIONES
MiClaseDerivada retorno;
retorno = oc.OtroMetodo <MiClaseDerivada, MiClase>(mcd, new MiClase());
//ERROR, NO CUMPLE CON RESTRICCION
//oc.OtroMetodo<MiClaseSinDefecto, MiClase>(new MiClaseSinDefecto(0), new MiClase());
Console.ReadLine();
}
public void Test_OtraClase()
{
OtraClase auxClase = new OtraClase();
auxClase.MetodoInstancia();
}
static void Main(string[] args)
{
string fileName = $"{DateTime.Today.Year}{DateTime.Today.Month}{DateTime.Today.Day}-{DateTime.Now.Hour}{DateTime.Now.Minute}.txt";
string pathToSave = $"{Environment.CurrentDirectory}\\Logs";
string absolutePath = $"{pathToSave}\\{fileName}";
string message;
try {
OtraClase otraClase = new OtraClase();
otraClase.OtroMetodoInstancia(); //provoco la excepción.
} catch (MiExcepcion e) {
#region FileHandlerSave
message = $"Date: {DateTime.Now}.\nMessage: {e.Message}.\nInner: {e.InnerException.Message}.";
if (!Directory.Exists(pathToSave))
{
Directory.CreateDirectory(pathToSave);
}
if (ArchivoTexto.Guardar(absolutePath, message))
{
Console.WriteLine($"Archivo guardado en: {pathToSave}");
}
else
{
Console.WriteLine("Error al guardar el archivo.");
}
#endregion
#region MensajeDe_MiException
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n### Mensaje de la E ###");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(e.Message);
#endregion
#region PathDeInnerException
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n### Path de la IE ###");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(e.InnerException); //deberia mostrar el path de errores.
#endregion
#region MensajeDe_IE
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n### Mensaje de la IE ###");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(e.InnerException.Message);
#endregion
#region MensajeCompletoDe_IE
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n### Mensaje Completo de la IE ###");
Console.ForegroundColor = ConsoleColor.Cyan;
Exception ex = e.InnerException;
Console.WriteLine($"MENSAJE: {ex.Message} EN: {ex.Source}"); //Muestro la IE.
#endregion
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("\n### Mensaje de todas las IE ###");
Console.ForegroundColor = ConsoleColor.Cyan;
Exception ie = e.InnerException; //guardo la IE
//Loopeo hasta recorer todos los IE
while (!Object.ReferenceEquals(ie, null))
{
Console.WriteLine(ie.Message);
ie = ie.InnerException;
}
}
#region FileHandlerLoad
try {
Console.WriteLine(ArchivoTexto.Leer(absolutePath));
} catch (FileNotFoundException fe) {
Console.WriteLine("FileNotFound");
}
#endregion
Console.ReadKey();
}
public void TestMetodoDeInstancia()
{
OtraClase clase = new OtraClase();
clase.UnMetodoDeInstancia();
}
public void Metodo_Instancia_OtraClase()
{
OtraClase aux = new OtraClase();
aux.CapturarExMiClase();
}
