Пример #1
0
        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();
        }
Пример #2
0
        public void TestMetodoInstancia()
        {
            //Arrange
            OtraClase otra = new OtraClase();

            //Act
            otra.MetodoInstancia();
            //Assert
        }
Пример #3
0
        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();
            }
        }
        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();
        }
Пример #5
0
        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();
        }
Пример #6
0
        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();
        }
Пример #7
0
        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();
        }