Exemple #1
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notacao Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                { "If - Estruturas de Controle", EstruturaIf.Executar },
                { "If/Else - Estruturas de Controle", EstruturasIfElse.Executar },
                { "If/Else/If - Estruturas de Controle", EstruturaIfElseIf.Executar },
                { "Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Do While - Estruturas de Controle", EstruturaDoWhile.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #2
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notacao Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numero", FormatandoNumero.Executar },
                { "Conversões", Conversoes.Executar },
                { "Operadores Aritméticos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais", OperadoresRelacionais.Executar },
                { "Operadores Logicos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição", OperadoresAtribuicao.Executar },

                //Estrutura de Controle
                { "Estrutura If", EstruturaIf.Executar },

                //Classes e Métodos
                { "Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e metodos", Construtores.Executar },
                { "Construtores - Classes com retorno", MetodosComRetorno.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #3
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", FirstProgram.Executar },
                { "Comentários - Fundamentos", Comentary.Executar },
                { "Variaveis e Constantes - Fundamentos", VariableAndConstants.Executar },
                { "Inferência - Fundamentos", Inference.Executar },
                { "Interpolação - Fundamentos", Interpolation.Executar },
                { "Notação Ponto - Fundamentos", NotationPoint.Executar },
                { "Lendo Dados - Fundamentos", ReadData.Executar },
                { "Formatando Numeros - Fundamentos", NumberFormat.Executar },
                { "Conversões - Fundamentos", Conversion.Executar },
                { "Operadores Aritmeticos - Fundamentos", Operator.Executar },
                { "Operadores Relacionais - Fundamentos", OperatorRelational.Executar },
                { "Operadores Lógicos - Fundamentos", OperatorLogics.Executar },
                { "Operadores de Atribuição - Fundamentos", OperatorAtribuition.Executar },
                { "Operadores Unários - Fundamentos", OperatorUnary.Executar },
                { "Operadores Ternário - Fundamentos", OperatorTernary.Executar },

                { "Estrutura If - Estruturas de Controle", StructureIf.Executar },
                { "Estrutura If e Else - Estruturas de Controle", StructureIfElse.Executar },
                { "Estrutura If e Else IF - Estruturas de Controle", StructureIfElseIf.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #4
0
        //Método Main é o método inicial do aplicativo
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritmeticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                // Estruturas de Controle
                { "Estrutura If - Estruturas de Contole", EstruturaIf.Executar },
                { "Estrutura Switch - Estruturas de Contole", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Contole", EstruturaWhile.Executar },
                { "Estrutura Do While - Estruturas de Contole", EstruturaDoWhile.Executar },
                { "Estrutura For - Estruturas de Contole", EstruturaFor.Executar },
                { "Estrutura ForEach - Estruturas de Contole", EstruturaForEach.Executar },

                // Classe e Métodos
                { "Membros - Classes e Métodos", Membros.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #5
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Operadores Aritimeticos - Fundamentos", OperadoresAritimeticos.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Unarios - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternario - Fundamentos", OperadorTernario.Executar },
                // Estruturas de Controle
                { "Estrutura If - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura If/Else - Estruturas de Controle", EstruturaIfElse.Executar },
                { "Estrutura If/Else If - Estruturas de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura DoWhile - Estruturas de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura Foreach - Estruturas de Controle", EstruturaForeach.Executar },
                { "Estrutura Break - Estruturas de Controle", EstruturaBreak.Executar },
                { "Estrutura Continue - Estruturas de Controle", EstruturaContinue.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #6
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferências - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuição - Fundamentos", OperadoresAtribucao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                // Estruturas de Controle
                { "Estrutura If - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura Foreach - Estruturas de Controle", EstruturaForEach.Executar },
                { "Usando Break - Estruturas de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estruturas de Controle", UsandoContinue.Executar },

                // Classes e métodos
                { "Membros - Classes e métodos", Membros.Executar },
                { "Desafio Atributo - Classes e métodos", DesafioAtributo.Executar },
                { "Params - Classes e métodos", Params.Executar },
                { "Parametros Nomeados - Classes e métodos", ParametrosNomeados.Executar },
                { "Propridades - Classes e métodos", Props.Executar },
                { "Read Only - Classes e métodos", ReadOnly.Executar },
                { "Exemplo Enum - Classes e métodos", ExemploEnum.Executar },
                { "Exemplo Struct - Classes e métodos", ExemploStruct.Executar },
                { "Struct VS Classe - Classes e métodos", StructVsClasse.Executar },
                { "Parâmetros por Referência - Classes e métodos", ParamsPorRef.Executar },
                { "Parâmetro Padrão - Classes e métodos", ParametroPadrao.Executar },

                // Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "List - Coleções", ColecoesList.Executar },
                { "ArrayList - Coleções", ColecoesArrayList.Executar },
                { "Set - Coleções", ColecoesSet.Executar },
                { "Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Stack - Coleções", ColecoesStack.Executar },
                { "Dictionary - Coleções", ColecoesDictionary.Executar },

                // OO
                { "Herança - Orientação a Objetos", Heranca.Executar },
                { "Construtor This - Orientação a Objetos", ConstrutorThis.Executar },
                { "Encapsulamento - Orientação a Objetos", OO.Encapsulamento.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #7
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #8
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                //Fundamentals
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritimeticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operadores Ternários - Fundamentos", OperadoresTernarios.Executar },

                //Control Structure
                { "Estrutura If - Estrutura de Controle", EstruturaIf.Executar },
                { "Estrutura If/Else - Estrutura de Controle", EstruturaIfElse.Executar },
                { "Estrutura If/Else/If - Estrutura de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estrutura de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estrutura de Controle", EstruturaWhile.Executar },
                { "Estrutura DoWhile - Estrutura de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estrutura de Controle", EstruturaFor.Executar },
                { "Estrutura Foreach - Estrutura de Controle", EstruturaForeach.Executar },
                { "Usando Break - Estrutura de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estrutura de Controle", UsandoContinue.Executar },

                //Menbers
                { "Membros - Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e Metodos", Construtores.Executar },
                { "Metodos Com Retorno - Classes e Metodos", MetodosComRetorno.Executar },
                { "Metodos Estáticos - Classes e Metodos", MetodosEstaticos.Executar },
                { "Atributos Estáticos - Classes e Metodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e Metodos", DesafioAtributo.Executar },
                { "Params - Classes e Metodos", Params.Executar },
                { "Parametros Nomeados - Classes e Metodos", ParametrosNomeados.Executar },
                { "Get Set - Classes e Metodos", GetSet.Executar },
                { "Props - Classes e Metodos", Props.Executar },
                { "Read Only - Classes e Metodos", Readonly.Executar },
                { "Enum - Classes e Metodos", ExemploEnum.Executar },
                { "Struct - Classes e Metodos", ExemploStruct.Executar },
                { "Struct VS Classes- Classes e Metodos", StructVsClasse.Executar },
                { "Valor VS Referencia- Classes e Metodos", ValorVsReferencia.Executar },
                { "Parametros Por Referencia- Classes e Metodos", ParametrosPorReferencia.Executar },
                { "Parametros com Valor Padrão- Classes e Metodos", ParametroPadrao.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #9
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariavesEConstantes.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #10
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                //fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto- Fundamentos", Notacao.Executar },
                { "Lendo dados- Fundamentos", LendoDados.Executar },
                { "Formatando Número- Fundamentos", FormatandoNumero.Executar },
                { "Conversões- Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos- Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais- Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos- Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuicao- Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários- Fundamentos", OperadoresUnarios.Executar },
                { "Operadores Ternário- Fundamentos", OperadorTernario.Executar },
                //Estruturas de controle
                { "Estrutura If- Esruturas de controle", EstruturaIf.Executar },
                { "Estrutura IfElse- Esruturas de controle", EstruturaIfElse.Executar },
                { "Estrutura IfElseIf- Esruturas de controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch- Esruturas de controle", EstruturaSwitch.Executar },
                { "Estrutura While- Esruturas de controle", EstruturaWhile.Executar },
                //Classes e métodos
                { "Membros- Classes e Métodos", Membros.Executar },
                { "Contrutores- Classes e Métodos", Construtores.Executar },
                { "Métodos com retorno- Classes e Métodos", MetodosComRetorno.Executar },
                { "Métodos Estáticos- Classes e Métodos", MetodosEstaticos.Executar },
                { "Atributos Estáticos- Classes e Métodos", AtributosEstaticos.Executar },
                { "Desafio Atributo- Classes e Métodos", DesafioAtributo.Executar },
                { "Params- Classes e Métodos", Params.Executar },
                { "Parametros Nomeados- Classes e Métodos", ParametrosNomeados.Executar },
                { "Get Set- Classes e Métodos", GetSet.Executar },
                { "Props- Classes e Métodos", Props.Executar },
                { "Readonly- Classes e Métodos", Readonly.Executar },
                { "Enum- Classes e Métodos", ExemploEnum.Executar },
                { "Struct- Classes e Métodos", ExemploStruct.Executar },
                { "Struct Vs Classe- Classes e Métodos", StructVsClasse.Executar },

                //Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "ColeçõesList - Coleções", ColecoesList.Executar },
                { "ColeçõesArrayList - Coleções", ColecoesArrayList.Executar },
                { "ColeçõesSet - Coleções", ColecoesSet.Executar },
                { "Igualdade - Coleções ", Igualdade.Executar },
                //{ "ColeçõesQueue - Coleções", ColecoesQueue.Executar},
            });

            central.SelecionarEExecutar();
        }
Exemple #11
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", First.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Membros - Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e Metodos", Construtores.Executar },
                { "Métodos Retorno - Classes e Metodos", MetodosRetorno.Executar },
                { "Métodos Estaticos - Classes e Metodos", MetodosEstaticos.Executar },
                { "Atributos Estaticos - Classes e Metodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e Metodos", DesafioAtributo.Executar },
                { "Params - Classes e Metodos", Params.Executar },
                { "Params nomeados - Classes e Metodos", ParamsNomeados.Executar },
                { "Get Set - Classes e Metodos", GetSet.Executar },
                { "ReadOnly - Classes e Metodos", ReadOnly.Executar },
                { "Enum - Classes e Metodos", Enuum.Executar },
                { "ParametrosReferencia - Classes e Metodos", ParametrosReferencia.Executar },
                { "Array - Colecoes", ColecoesArray.Executar },
                { "Lista - Colecoes", Lista.Executar },
                { "Fila - Colecoes", ColecoesQueue.Executar },

                { "Heranca - OO", Heranca.Executar },
                { "Construtor This", ConstrutorThis.Executar },
                { "Encapsulamento", Encampsulamento.Executar },
                { "Abstrata", Abstrata.Executar },
                { "Interface", Interfacee.Executar },
                { "Sealed", Sealed.Executar },


                { "Exemplo Lambda", ExemploLambda.Executar },
                { "Delegate Lambda", LambdaDelegate.Executar },
                { "Usando delegate", UsandoDelegate.Executar },
                { "Parametro como função", DelegateParametro.Executar },
                { "Métodos Extensao", MetodosExtensao.Executar },

                { "Exceções - Primeira", Primeiro.Executar },
                { "Exceções - Personalizada", Personalizadas.Executar },


                { "Api - Primeiro Arquivo", PrimeiroArquivo.Executar },
                { "Api - Lendo Arquivo", LendoArquivo.Executar },

                { "Tópicos Avançados", Linq1.Executar },
                { "Tópicos Avançados Linq2", Linq2.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #12
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // OO
                { "Herança - OO", Heranca.Executar },
                // Métodos e funções
                { "Exemplo Lambda - Métodos e funções", ExemploLambda.Executar },
                { "Lambdas com Delegates - Métodos e funções", LambdaDelegate.Executar },
                { "Usando Delegates - Métodos & Funções", UsandoDelegate.Executar },
                { "Delegates com Funções Anônimas- Métodos & Funções", DelegateFuncAnonima.Executar }
            });

            central.SelecionarEExecutar();
        }
Exemple #13
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveiseConstante.Executar },
                { "Inferencia - fundamentos", Inferencia.Executar },
                { "Interpolacao - fundamentos", Interpolacao.Executar },
                { "Entrada de dados - fundamentos", EntradaDados.Executar },
                { "Formatando numeros - fundamentos", FormatandoNumeros.Executar },
            });;

            central.SelecionarEExecutar();
        }
Exemple #14
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "VariaveisEConstantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "NotacaoPonto - Fundamentos", NotacaoPonto.Executar },
                { "LendoDados - Fundamentos", LendoDados.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #15
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritiméticos - Fundamentos", OperadoresAritimeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                //Estruturas de Controle
                { "Estrutura If - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura If/Else - Estruturas de Controle", EstruturaIfElse.Executar },
                { "Estrutura If/Else/If - Estruturas de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura DoWhile - Estruturas de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura ForEach - Estruturas de Controle", EstruturaForEach.Executar },
                { "Usando Break - Estruturas de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estruturas de Controle", UsandoContinue.Executar },

                //Classes e Metodos
                { "Membros - Classes e Métodos", Membros.Executar },
                { "Construtores - Classes e Métodos", Construtores.Executar },
                { "Métodos Com Retorno - Classes e Métodos", MetodosComRetorno.Executar },
                { "Métodos Estáticos - Classes e Métodos", MetodosEstaticos.Executar },
                { "Atributos Estáticos - Classes e Métodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e Métodos", DesafioAtributo.Executar },
                { "Params - Classes e Métodos", Params.Executar },
                { "Parametros Nomeados - Classes e Métodos", ParametrosNomeados.Executar },
                { "Get Set - Classes e Métodos", GetSet.Executar },
                { "Props - Classes e Métodos", Props.Executar },
            });

            central.SelecionarEExecutar();
        }
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Exercicio 1: Celsius Fahrenheit - Fundamentos", CelsiusFahrenheit.Executar },
                { "Exercicio 2: Fahrenheit Celsius - Fundamentos", FahrenheitCelsius.Executar },
                { "Exercicio 3: Calcular IMC - Fundamentos", IMC.Executar },
                { "Exercicio 4: Ao Quadrado e Ao Cubo - Fundamentos", QuadradoCubo.Executar },
                { "Exercicio 5: Calcular Área Triangulo - Fundamentos", AreaTriangulo.Executar },
                { "Exercicio 5: Calcular Equacao de Segundo Grau - Fundamentos", EquacaoSegundoGrau.Executar },

                { "Exercicio 5: Calcular Equacao de Segundo Grau - Estruturas de Controle", EquacaoSegundoGrau.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #17
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentals
                { "First Program - Fundamentals", FirstProgram.Execute },
                { "Comments - Fundamentals", Comments.Execute },
                { "Variables And Constants - Fundamentals", VariablesAndConstants.Execute },
                { "Inference - Fundamentals", Inference.Execute },
                { "Interpolation - Fundamentals", Interpolation.Execute },
                { "Getting Data From Console - Fundamentals", GettingDataFromConsole.Execute },
                // Control Structures
                { "If/Else Structure - Control Structures", IfElseStructure.Execute },
                { "Switch Structure - Control Structures", SwitchStructure.Execute },
            });

            central.SelecionarEExecutar();
        }
Exemple #18
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Segundo Programa - Fundamentos", Class1.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Interpolacao de Strings - Fundamentos", InterpolacaoDeStrings.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Números - Fundamentos", FormatandoNumeros.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },

                // Classe e Métodos
                { "Membros - Classes e Métodos", Membros.Executar },
                { "Membros - Métodos com Retorno", MetodosComRetorno.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #19
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEContantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversoes - Fundamentos", Conversoes.Executar },
                { "Operadores Aritimeticos", OperadoresAritimeticos.Executar },
                { "Operadores Relacionais", OperadoresRelacionais.Executar },
            });

            central.SelecionarEExecutar();
        }
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                //FUNDAMENTOS
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notacao Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversoes - Fundamentos", Conversoes.Executar },
                { "Operadores Aritmeticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuicao - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unarios - Fundamentos", OperadoresUnarios.Executar },
                { "Operadores Ternario - Fundamentos", OperadorTernario.Executar },

                //ESTRUTURA DE COTROLE
                { "Estrutura If - Estrutura de Controle", EstruturaIf.Executar },
                { "Estrutura If/Else - Estrutura de Controle", EstruturaIfElse.Executar },
                { "Estrutura If/Else/If - Estrutura de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estrutura de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estrutura de Controle", EstruturaWhile.Executar },
                { "Estrutura Do While - Estrutura de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estrutura de Controle", EstruturaFor.Executar },
                { "Estrutura Foreach - Estrutura de Controle", EstruturaForeach.Executar },
                { "Usando Break - Estrutura de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estrutura de Controle", UsandoContinue.Executar },

                //CLASSES E METODOS
                { "Membros - Classes e Metodos", Membros.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #21
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                // Estruturas de controle
                { "Estrutura IF - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura IF/ELSE - Estruturas de Controle", EstruturaIFELSE.Executar },
                { "Estrutura IF/ELSE/IF - Estruturas de Controle", EstruturaIfElseIF.Executar },
                { "Estrutura Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura Do While - Estruturas de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura Foreach - Estruturas de Controle", EstruturaForEach.Executar },
                { "Usando BREAK - Estruturas de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estruturas de Controle", UsandoContinue.Executar },

                // Metodos e Classes
                { "Membros - CLasses e Metodos", Membros.Executar },
                { "Construtores - CLasses e Metodos", Construtores.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #22
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "NotacaoPonto - Fundamentos", NotacaoPonto.Executar },
                { "LendoDados - Fundamentos", LendoDados.Executar },
                { "Formatando Números - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuicao - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unarios - Fundamentos", OperadoresUnarios.Executar },
                { "Operadores Ternarios - Fundamentos", OperadoresTernarios.Executar },
                // Estruturas de controle
                { "Estrutura IF - Controle", EstruturaIf.Executar },
                { "Estrutura ForEach - Controle", EstruturaForEach.Executar },
                // Classes e Metodos
                { "Membros - Classes e metodos", Membros.Executar },
                { "Construtores - Classes e metodos", Construtores.Executar },
                { "Métodos Com Retorno - Classes e metodos", MetodosComRetorno.Executar },
                { "Métodos Estáticos - Classes e metodos", MetodosEstaticos.Executar },
                { "Atributos Estáticos - Classes e metodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e metodos", DesafioAtributo.Executar },
                { "Params - Classes e metodos", Params.Executar },
                { "Parametros Nomeados - Classes e Métodos", ParametrosNomeados.Executar },
                { "Get Set - Classes e Métodos", GetSet.Executar },
                { "Props - Classes e Métodos", Props.Executar },
                { "Read Only - Classes e Métodos", ReadOnly.Executar },
                { "Exemplo Enum - Classes e Métodos", ExemploEnum.Executar },
                { "Enum - Classes e Métodos", ExemploStruct.Executar },
                { "Valor Vs Referência - Classes e Métodos", ValorVsReferencia.Executar },
                { "Parametros por Referencia - Classes e Métodos", ParametrosPorReferencia.Executar },
                { "Parametros padrao - Classes e Métodos", ParametrosPadrao.Executar },
                // Coleções
                { "Array - Colecoes", Colecoes.Array.Executar },
                { "Colecoes List - Colecoes", ColecoesList.Executar },
                { "Colecoes Array List - Colecoes", ColecoesArrayList.Executar },
                { "List Set - Colecoes", ColecoesSet.Executar },
                { "List Queue - Colecoes", ColecoesQueue.Executar },
                { "Igualdade - Colecoes", Igualdade.Executar },
                { "Colecoes Stack - Colecoes", ColecoesStack.Executar },
                { "Dictionary MAPA - Colecoes", ColecoesDictionary.Executar },
                // Orientação a Objetos
                { "Heranca - OO", Heranca.Executar },
                { "Construtor This - OO", ConstrutorThis.Executar },
                { "Encapsulamento - OO", OO.Encapsulamento.Executar },
                { "Polimorfismo - OO", Polimorfismo.Executar },
                { "Interface - OO", Interface.Executar },
                { "Sealed - OO", Sealed.Executar },
                // Metodos e Funcoes
                { "Exemplo Lambda - Metodos e Funcoes", ExemploLambda.Executar },
                { "Lambdas Delegate - Metodos e Funcoes", LambdasDelegate.Executar },
                { "Delegate com Funcoes Anonimas - Metodos e Funcoes", DelegateFunAnonima.Executar },
                { "Delegate como Parametros - Metodos e Funcoes", DelegatesComoParametros.Executar },
                { "Metodos de Extensao - Metodos e Funcoes", MetodosDeExtensao.Executar },
                // Metodos e Funcoes
                { "Primeira Excecao - Metodos e Funcoes", PrimeiraExcecao.Executar },
                { "Excecoes Personalizadas - Metodos e Funcoes", ExcecoesPersonalizadas.Executar },
                // API
                { "Primeiro Arquivo - API", PrimeiroArquivo.Executar },
                { "Lendo Arquivos - API", LendoArquivos.Executar },
                { "Exemplo FileInfo - API", ExemploFileInfo.Executar },
                { "Diretorios - API", Diretorios.Executar },
                { "Exemplo Directory Info - API", ExemploDirectoryInfo.Executar },
                { "Exemplo Path - API", ExemploPath.Executar },
                { "Exemplo DateTime - API", ExemploDateTime.Executar },
                { "Exemplo Time Span - API", ExemploTimeSpan.Executar },
                // Topicos Avancados
                { "LINQ#1 - Tópicos Avançados", LINQ1.Executar },
                { "LINQ#2 - Tópicos Avançados", LINQ2.Executar },
                { "Nullables - Tópicos Avançados", Nullables.Executar },
                { "Dynamics - Tópicos Avançados", Dynamics.Executar },
                { "Generics - Tópicos Avançados", Generics.Executar },
            });

            central.SelecionarEExecutar();
            Console.WriteLine("Pressione ENTER para sair...");
            Console.Read();
        }
Exemple #23
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes- Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - fundamentos", Inferencia.Executar },
                { "Interpolacao - fundamentos", interpolacao.Executar },
                { "Notacao Ponto - fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - fundamentos", LendoDados.Executar },
                { "Formatando Números - fundamentos", FormatandoNumeros.Executar },
                { "Conversoes - fundamentos", Conversoes.Executar },
                { "Operadores Aritmeticos - fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais- fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógico- fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuição- fundamentos", OperadoresAtribuicao.Executar },
                //Estruturas de controle
                { "Estrutura If-  Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura Switch-  Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While-  Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura For-  Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura ForEach-  Estruturas de Controle", EstruturaForEach.Executar },
                // Classes e metodos
                { "Membros - Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e Metodos", Construtores.Executar },
                { "Metodos com retorno - Classes e Metodos", MetodosComRetorno.Executar },
                { "Desafio Atributo  - Classes e Metodos", DesafioAtributo.Executar },
                { "Params - Classes e Metodos", Params.Executar },
                { "Parametros Nomeados - Classes e Metodos", ParametrosNomeados.Executar },
                { "Getters e Setters - Classes e Metodos", GetSet.Executar },
                { "Propriedades - Classes e Metodos", Props.Executar },
                { "ReadOnlye - Classes e Metodos", ReadOnly.Executar },
                { "Struct vs Classe - Classes e Metodos", StructVsClasse.Executar },
                { "Parametros Por Referencia - Classes e Metodos", ParametrosPorReferencia.Executar },
                //Colecoes
                { "Array Colecoes - Classes e Metodos", ArrayColecao.Executar },
                { "List Colecoes - Classes e Metodos", ListColecao.Executar },
                { "Array ListColecoes - Classes e Metodos", ArrayListColecao.Executar },
                { "Set Colecoes - Classes e Metodos", SetColecao.Executar },
                { "Queue Colecoes - Classes e Metodos", QueueColecao.Executar },
                { "IgualdadeColecoes - Classes e Metodos", IgualdadeColecao.Executar },
                { "Stack Colecoes - Classes e Metodos", StackColecao.Executar },
                { "Dictionary Colecoes - Classes e Metodos", DictionaryColecao.Executar },
                //Orientacao a objeto
                { "Herança - Orientação a objeto", heranca.Executar },
                { "Polimorfismo - Orientação a objeto", Polimorfismo.Executar },
                { "Interface - Orientação a objeto", Interface.Executar },

                // Metodos e funções
                { "Exemplo lambda - Metodos e funções", ExemploLambda.Executar },
                { "Delegates lambda - Metodos e funções", LambdasDelegate.Executar },
                { "Delegates como parametros - Metodos e funções", DelegateComoParametro.Executar },


                //  Excecoes

                { "Excessões Personalizadas - Exceções", ExcessoesPersonalizadas.Executar },


                // Explorando API

                { "Explorando APi primeiro arquivo - API", PrimeiroArquivo.Executar },
                { "Lendo Arquivo- API", LendoArquivos.Executar },

                // Topicos Avançados
                { "Linq 1- Topicos Avançados", Linq1.Executar },
                { "Nulabes - Topicos Avançados", Nulabes.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #24
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                // Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Váriaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Número - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritmeticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                // Estruturas de Controle
                { "Estrutura If - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura If/Else - Estruturas de Controle", EstruturaIfElse.Executar },
                { "Estrutura If/Else/If - Estruturas de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura Do While - Estruturas de Controle", EstruturaDoWhile.Executar },
                { "Estrutura For - Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura Foreach - Estruturas de Controle", EstruturaForEach.Executar },
                { "Usando Break - Estruturas de Controle", UsandoBreak.Executar },
                { "Usando Continue - Estruturas de Controle", UsandoContinue.Executar },

                // Classes e Métodos
                { "Membros - Classes e Métodos", Membros.Executar },
                { "Construtores - Classes e Métodos", Construtores.Executar },
                { "Métodos Com Retorno - Classes e Métodos", MetodosComRetorno.Executar },
                { "Métodos Estáticos - Classes e Métodos", MetodosEstaticos.Executar },
                { "Atributos Estáticos - Classes e Métodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e Métodos", DesafioAtributo.Executar },
                { "Params - Classes e Métodos", Params.Executar },
                { "Parametros Nomeados - Classes e Métodos", ParametrosNomeados.Executar },
                { "Get Set - Classes e Métodos", GetSet.Executar },
                { "Props - Classes e Métodos", Props.Executar },
                { "Readonly - Classes e Métodos", Readonly.Executar },
                { "Enum - Classes e Métodos", ExemploEnum.Executar },
                { "Struct - Classes e Métodos", ExemploStruct.Executar },
                { "Struct Vs Classe - Classes e Métodos", StructVsClasse.Executar },
                { "Valor Vs Referência - Classes e Métodos", ValorVsReferencia.Executar },
                { "Parâmetros Por Referência - Classes e Métodos", ParametrosPorReferencia.Executar },
                { "Parâmetro com Valor Padrão - Classes e Métodos", ParametroPadrao.Executar },

                // Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "List - Coleções", ColecoesList.Executar },
                { "Array List - Coleções", ColecoesArrayList.Executar },
                { "Set - Coleções", ColecoesSet.Executar },
                { "Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Stack - Coleções", ColecoesStack.Executar },
                { "Dictionary - Coleções", ColecoesDictionary.Executar },

                // OO
                { "Herança - OO", Heranca.Executar },
                { "Construtor This - OO", ConstrutorThis.Executar },
                { "Encapsulamento - OO", OO.Encapsulamento.Executar },
                { "Polimorfismo - OO", Polimorfismo.Executar },
                { "Abstract - OO", Abstract.Executar },
                { "Interface - OO", Interface.Executar },
                { "Sealed - OO", Sealed.Executar },

                // Métodos & Funções
                { "Exemplo Lambda - Métodos & Funções", ExemploLambda.Executar },
                { "Lambdas Como Delegates - Métodos & Funções", LambdasDelegate.Executar },
                { "Usando Delegates - Métodos & Funções", UsandoDelegates.Executar },
                { "Delegates Como Função Anonima - Métodos & Funções", DelegateFunAnonima.Executar },
                { "Delegates Como Parâmetros - Métodos & Funções", DelegatesComoParametros.Executar },
                { "Métodos de Extensão - Métodos & Funções", MetodosDeExtensao.Executar },

                // Exceções
                { "Primeira Exceção - Exceções", PrimeiraExcecao.Executar },
                { "Exceções Personalizadas - Exceções", ExcecoesPersonalizadas.Executar },

                // Api
                { "Primeiro Arquivo - Usando API", PrimeiroArquivo.Executar },
                { "Lendo Arquivos - Usando API", LendoArquivos.Executar },
                { "Exemplo FileInfo - Usando API", ExemploFileInfo.Executar },
                { "Diretórios - Usando API", Diretorios.Executar },
                { "Exemplo DirectoryInfo - Usando API", ExemploDirectoryInfo.Executar },
                { "Exemplo Path - Usando API", ExemploPath.Executar },
                { "Exemplo DateTime - Usando API", ExemploDateTime.Executar },
                { "Exemplo Timespan - Usando API", ExemploTimeSpan.Executar },

                // Tópicos Avançados
                { "LINQ #01 - Tópicos Avançados", LINQ1.Executar },
                { "LINQ #02 - Tópicos Avançados", LINQ2.Executar },
                { "Nullables - Tópicos Avançados", Nullables.Executar },
                { "Dynamics - Tópicos Avançados", Dynamics.Executar },
                { "Genéricos - Tópicos Avançados", Genericos.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #25
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                //Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumeros.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritmédicos - Fundamentos", OperadoresAritmedicos.Executar },
                { "Operadores Relacionais - Fundamentos", OperacoesRelacionais.Executar },
                { "Operadores Logico - Fundamentos", OperadoresLogico.Executar },

                //Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "List - Coleções", ColecoesList.Executar },
                { "Coleções Array List - Coleções", ColecoesArrayList.Executar },
                { "Set - Coleções", ColecoesSet.Executar },
                { "Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Stck - Coleções", ColecoesStack.Executar },
                { "Dicionary - Coleções", ColecoesDicionary.Executar },


                //Classes e Metodos
                { "Membros - Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e Metodos", Construtores.Executar },
                { "Metodos com Retorno - Classes e Metodos", MetodosComRetorno.Executar },
                { "Metodos Estaticos - Classes e Metodos", MetodosEstaticos.Executar },
                { "Atributos Estaticos - Classes e Metodos", AtributosEstaticos.Executar },
                { "Desafio Atributo - Classes e Metodos", DesafioAtributo.Executar },
                { "Params - Classes e Metodos", Params.Executar },
                { "Parammetros Nomeados - Classes e Metodos", ParametrosNomeados.Executar },
                { "Get Set - Classes e Metodos", GetSet.Executar },
                { "Props - Classes e Metodos", Props.Executar },
                { "Readonly - Classes e Metodos", Readonly.Executar },
                { "Enum - Classes e Metodos", Enums.Executar },
                { "Structs - Classes e Metodos", ExemploStructs.Executar },
                { "Struct vs Classes - Classes e Metodos", StructVsClasses.Executar },
                { "Valor vs Referencia - Classes e Metodos", ValorVsReferencia.Executar },
                { "Parametros por Referencia - Classes e Metodos", ParametrosPorReferencia.Executar },
                { "Parametro com valor Padrão - Classes e Metodos", ParametroPadrao.Executar },

                //Orientaçaao a Objetos
                { "Herança - Orientaçaao a Objetos", Heranca.Executar },
                { "Construtor This - Orientaçaao a Objetos", ConstrutorThis.Executar },
                { "Encapsulamento - Orientaçaao a Objetos", OrientacaoAObjetos.Encapsulamento.Executar },
                { "Polimorfismo - Orientaçaao a Objetos", Polimorfismo.Executar },
                { "Abstract - Orientaçaao a Objetos", Abstract.Executar },
                { "Interface - Orientaçaao a Objetos", Interface.Executar },
                { "Sealed - Orientaçaao a Objetos", Sealed.Executar },

                //Metodos e Funções
                { "Lambd - Metodos & Funções ", ExemploLambda.Executar },
                { "Lambda Delegate - Metodos & Funções ", LambdasDelegate.Executar },
                { "Usando Delegate - Metodos & Funções ", UsandoDelegate.Executar },
                { "Delegates com funções anonimas - Metodos & Funções ", DelegateFuncAnnonima.Executar },
                { "Delegates como Parametros - Metodos & Funções ", DelegatesComoParametros.Executar },
                { "Metodos de Extençãos - Metodos & Funções ", MetodosDeExtensao.Executar },

                // Exceções
                { "Primeira Excecao - Exceções ", PrimeiraExcecao.Executar },
                { "Excecoes Personalizadas - Exceções ", ExcecoesPersonalizadas.Executar },

                //Topicos Avancados
                { "LINQ1 - Topicos Avançados ", LINQ1.Executar },
                { "LINQ2 - Topicos Avançados ", LINQ2.Executar },
                { "Nullables - Topicos Avançados ", Nullables.Executar },
                { "Dynamic - Topicos Avançados ", Dynamics.Executar },
                { "Genericoss - Topicos Avançados ", Genericos.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #26
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variaveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Pontos- Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados- Fundamentos", LendoDados.Executar },
                { "Formatando Numeros- Fundamentos", FormantoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos- Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unarios - Fundamentos", Operadoresunirarios.Executar },
                { "Operadores Ternario - Fundamentos", OperadorTernario.Executar },

                //Estrutura de controles
                { "Estrutura de IF - EstruturaDeControles", EstruturaIf.Executar },
                { "Estrutura de IF/Else - EstruturaDeControles", EstruturaIfElse.Executar },
                { "Estrutura de IF/Else/if - EstruturaDeControles", EstruturaIfElseIf.Executar },
                { "Estrutura Swith - EstruturaDeControles", EstruturaSwith.Executar },
                { "Estrutura While - EstruturaDeControles", EstruturaWhile.Executar },
                { "Estrutura Do While - EstruturaDeControles", EstrturaDoWhile.Executar },
                { "Estrutura For - EstruturaDeControles", EstrturaFor.Executar },
                { "Estrutura ForEach - EstruturaDeControles", EstruturaForEach.Executar },
                { "Estrutura Usando Break - EstruturaDeControles", UsandoBreak.Executar },
                { "Estrutura Usando Continue - EstruturaDeControles", UsandoContinue.Executar },

                //Classe e Metodos
                { "Membros - Classe e Metodos", Membros.Executar },
                { "Construtores - Classe e Metodos", Construtores.Executar },
                { "Metodos com Retorno - Classe e Metodos", MetodosComRetorno.Executar },
                { "Metodos Estaticos - Classe e Metodos", MetodosEstaticos.Executar },
                { "Atributos Estaticos - Classe e Metodos", AtributosEstaticos.Executar },
                { "Desafio Atributos - Classe e Metodos", DesafioAtributos.Executar },
                { "Parametros - Classe e Metodos", Params.Executar },
                { "Parametros Nomeados - Classe e Metodos", ParametrosNomeados.Executar },
                { "Get e Set - Classe e Metodos", GetSet.Executar },
                { "Props - Classe e Metodos", Props.Executar },
                { "Readonly- Classe e Metodos", Readonly.Executar },
                { "Exemplo Enum - Classe e Metodos", ExemploEnum.Executar },
                { "Struct - Classe e Metodos", ExemploStruct.Executar },
                { "Struct VC Classe - Classe e Metodos", StructVsClasse.Executar },
                { "Valor VC Refereancia Classe e Metodos", ValorVSReferencia.Executar },
                { "Parametros por Referencia - Classe e Metodos", ParametrosPorReferencia.Executar },
                { "Parametros Padrão - Classe e Metodos", ParametrosPadrao.Executar },


                //Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "Coleções List - Coleções", ColecoesList.Executar },
                { "Coleções Array List - Coleções", ColecoesArrayList.Executar },
                { "Coleções Set - Coleções", ColecoesSet.Executar },
                { "Coleções Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Coleções Stack - Coleções", ColecaoStack.Executar },
                { "Coleções Dictionary - Coleções", ColecoesDictionary.Executar },

                //Orientação a Objetos
                { "herança - OO", Heranca.Executar },
                { "Contrutor This - OO", ConstrutorThis.Executar },
                { "Encapsulamento - OO", OO.Encapsulamento.Executar },
                { "Polimorfismo - OO", Polimorfismo.Executar },
                { "abstract - OO", Abstract.Executar },
                { "Interface - OO", Interface.Executar },

                //Metodos & Funções
                { "Exemplo Lambda - Metodos & Funcoes", ExemploLambda.Executar },
                { "Lambda como Delegate - Metodos & Funcoes", LambdaDelegate.Executar },
                { "Usando Delegates - Metodos & Funcoes", UsandoDelegates.Executar },
                { "Delegate Função Anônima- Metodos & Funcoes", DelegateFuncAnonimas.Executar },
                { "Delegate com Parâmetros- Metodos & Funcoes", DelegatesComParametros.Executar },
                { "Metodos De Extensão- Metodos & Funcoes", MetodosDeExtensao.Executar },

                //Exceções
                { "Primeira Exceção- Execeções", PrimeiraExcecao.Executar },

                //API
                { "Primeiro Arquivo - API", PrimeiroArquivo.Executar },
                { "Lendo Arquivos - API", LendoArquivos.Executar },
                { "Exemplo File Info - API", ExemploFileInfo.Executar },
                { "Diretórios - API", Diretorios.Executar },
                { "Exemplo DirectoruInfo - API", ExemplodirectoryInfo.Executar },
                { "Exemplo Path - API", ExemploPath.Executar },
                { "Exemplo Date Time - API", ExemploDateTime.Executar },
                { "Exemplo Time Span - API", ExemploTimeSpan.Executar },

                //Topicos Avançados
                { "LINQ1 - Topicos Avançados", LINQ1.Executar },
                { "LINQ2 - Topicos Avançados", LINQ2.Executar },
                { "Nullables - Topicos Avançados", Nullables.Executar },
                { "Dynamics - Topicos Avançados", Dynamics.Executar },
                { "Genericos - Topicos Avançados", Genericos.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #27
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Referência - Fundamentos", Inferecia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados do Console - Fundamentos", LendoDados.Executar },
                { "Formatando Números - Fundamentos", FormatandoNumeros.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unários - Fundamentos", OperadoresUnarios.Executar },
                { "Operador ternário - Fundamentos", OperadorTernario.Executar },

                //Estruturas de Controle
                { "Estrutura If", EstruturaIf.Executar },
                { "Estruturas De Repetição", EstruturasDeRepeticao.Executar },

                //Classes e Métodos
                { "Membros - Classes e Métodos", Membros.Executar },
                { "Métodos e Atributos Estáticos - Classes e Métodos", MetodosAtributosEstaticos.Executar },
                { "Parâmetros Variáveis - Classes e Métodos", Params.Executar },
                { "Getters e Setters - Classes e Métodos", GettersAndSetters.Executar },
                { "Propriedades - Classes e Métodos", Propriedades.Executar },
                { "Struct VS Class- Classes e Métodos", StructVsClasse.Executar },

                //Coleções
                { "Array - Coleções", Colecoes.Array.Executar },
                { "List - Coleções", ColecoesList.Executar },
                { "ArrayList - Coleções", ColecoesArrayList.Executar },
                { "Set - Coleções", ColecoesSet.Executar },
                { "Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Pilha - Coleções", ColecoesStack.Executar },
                { "Dictionary - Coleções", ColecoesDictionary.Executar },

                //OO
                { "Herança - OO", Heranca.Executar },
                { "Encapsulamento - OO", OO_OrientacaoAObjetos.Encapsulamento.Executar },
                { "Polimorfismo - OO", Polimorfismo.Executar },
                { "Classe Abstrata - OO", ClasseAbstrata.Executar },
                { "Interface - OO", Interface.Executar },
                { "Classe e Método Sealed - OO", Interface.Executar },

                //Métodos e Funções
                { "Lambda - Métodos e Funções", ExemploLambda.Executar },
                { "Lambda com Delegate - Métodos e Funções", LambdasDelegate.Executar },
                { "Usando Delegates - Métodos e Funções", UsandoDelegates.Executar },
                { "Delegates com Funções Anônimas - Métodos e Funções", DelegatesFuncAnonima.Executar },
                { "Delegates como Parâmetros - Métodos e Funções", DelegatesComoParametros.Executar },

                //Exceções
                { "Primeira Exceção - Exceções", PrimeiraExcecao.Executar },
                { "Exceção Personalizada - Exceções", ExcecaoPersonalizada.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #28
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroProgrma.Executar },
                { "Comentarios - Fundamentos", Comentarios.Executar },
                { "Variaveis e constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferencia - Fundamentos", Inferencia.Executar },
                { "Interpolacao - Fundamentos", Interpolacao.Executar },
                { "Notacao Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversoes - Fundamentos", Conversoes.Executar },
                { "Operadores Aritimeticos - Fundamentos", OperadoresAritimeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Unarios - Fundamentos", OperadoresUnarios.Executar },
                { "Operadores  de atribuição  - Fundamentos", OperadoreAtribuicao.Executar },
                { "Operadores Ternario - Fundamentos", OperadorTernario.Executar },
                // Estrutura de Controle
                { "Estrutura de Controle - Estrutura IF", EstruturaIf.Executar },
                { "Estrutura de Controle - Estrutura IF/else", EstruturaIfElse.Executar },
                { "Estrutura de controle - Estutura If/Else/If", EstruturaifElseif.Executar },
                { "Estrutura de Controle - Estrutura Switch", EstruturaSwitch.Executar },
                { "Estrutura de Controle - Estrutura While", EstruturaWhile.Executar },
                { "Estrutura de Controle - Estrutura DoWhile", EstruturaDoWhile.Executar },
                { "Estrutura de Controle - Estrutura For", EstruturaFor.Executar },
                { "Estrutura de Controle - Estrutura ForEach", EstruturaForEach.Executar },
                { "Estrutura de Controle - Estrutura Break", EstruturaBreak.Executar },
                { "Estrutura de Controle - Estrutura Continue", EstruturaContinue.Executar },
                // Classes e metodos
                { "Membros - Classes e Metodos", Membros.Executar },
                { "Construtores - Classes e Metodos", Construtores.Executar },
                { "Metodos Com Retorno - Classes e Metodos", MetodoscComRetorno.Executar },
                { "Metodos Com Retorno 2 - Classes e Metodos", MetodoComRetorno2.Executar },
                { "Metodos Estaticos - Classes e Metodos", MetodoEstatico.Executar },
                { "Atributos Estaticos - Classes e Metodos", AtributosEstaticos.Executar },
                { "Desafio atributo - Classes e Metodos", DesafioAtributo.Executar },
                { "Params - Classe e Metodos", Params.Executar },
                { "Parametros Nomeados - Classe e Metodos", ParametrosNomeados.Executar },
                { "Get e Set  - Classe e metodos ", GetSet.Executar },
                { "Props - Classes e Metodos", Props.Executar },
                { "ReadOnly  - Classes e Metodos", ReadOnly.Executar },
                { "Enumeracoes - Classe e Metodos", ExemploEnum.Executar },
                { "Structs - Classes e Metodos", ExemploStruct.Executar },
                { "Classe vs Struct Classes e Metodos", StructVsClasse.Executar },
                { "Valor vs Referencia - Classes e Metodos", ValorVsReferencia.Executar },
                { "Parametros por referencia - Classes e Metodos", ParemetrosPorReferencia.Exeutar },
                { "Parametro com Valor Padrao - Classes e Metodos ", ParamentroPadrao.Executar },
                // Colecoes

                { "Array- Colecões ", CursoCsharp07.Colecao.Array.Executar },
                { "List - Colecões ", ColecoesList.Executar },
                { "ArrayList - Colecões ", ColecoesArrayList.Executar },
                { "Set - Colecões ", ColecoesSet.Executar },
                { "Queue - Colecões ", ColecaoQueue.Executar },
                { "igualadade - Colecões ", Igualdade.Executar },
                { " Stack - Colecoes", ColecaoStack.Executar },
                { " Dictonary - Colecoes", ColecoesDictionary.Executar },

                // Orientacao a Objeto
                { " Heranca - Orientacao a Objeto", Heranca.Executar },
                { " Construtor This - Orientacao a Objeto", ConstrutorThis.Executar },
                { " Encapsulamento - Orientacao a Objeto", CursoCsharp07.OO.Encapsulamento.Executar },
                { " Polimorfismo - Orientacao a Objeto", CursoCsharp07.OO.Polimorfismo.Executar },
                { " Classe Abstrata - Orientacao a Objeto", Abstract.Executar },
                { " Interface - Orientacao a Objeto", Interface.Executar },
                { " Sealed - Orientacao a Objeto", Sealed.Executar },


                // Metodos e Funçoes
                { " Exemplo Lambda - Metodos e Funçoes", ExLambida.Executar },
                { " Delegate com Lambda - Metodos e Funçoes", LambdaDelegate.Executar },
                { " Delegate  - Metodos e Funçoes", UsandoDelegates.Executar },
                { " Delegate como funcao anonima- Metodos e Funçoes", DelegateFuncAnonima.Executar },
                { " Delegate como Parametro - Metodos e Funçoes", DelegateComoParametro.Executar },
                { " Metodos de Extensao- Metodos e Funçoes", MetodosDeExtensao.Executar },


                //Excecao
                { " Primeira Excecao - Excecoes", PrimeiraExcecao.Executar },
                { " Excecao Personalizada - Excecoes", ExcecaoPersonalizada.Executar },
                //Api
                { " Primeiro Arquivo - Usando API", PrimeiroArquivo.Executar },
                { " Lendo Arquivo - Usando API", LendoArquivos.Executar },
                { " FILE INFO - Usando API", ExemploFileInfo.Executar },
                { " DIRETORIOS - Usando API", Diretorios.Executar },
                { " Exemplo Directory Info - Usando API", ExemploDirectonaryInfo.Executar },
                { " Exemplo Path - Usando API", ExemploPath.Executar },
                { " Exemplo Date time- Usando API", ExemploDateTime.Executar },
                { " Exemplo Time Span- Usando API", ExemploTimeSpan.Executar },

                // Topicos Avançados LINQ
                { "LINK #01 - Topicos Avançados", ExemploLinq.Executar },
                { "LINK #02 - Topicos Avançados", ExemploLINQ2.Executar },
                { "Nullables - Topicos Avançados", Nullables.Executar },
                { "Dynamics - Topicos Avançados", Dynamics.Executar },
                { "Generics - Topicos Avançados", Genericos.Executar }
            });

            central.SelecionarEExecutar();
        }
Exemple #29
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                //Fundamentos
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários CSharp - Fundamentos", Comentarios.Executar },
                { "Variáveis e Constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "Inferência - Fundamentos", Inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação Ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando Números - Fundamentos", FormatandoNumero.Executar },
                { "Conversões - Fundamentos", Conversoes.Executar },
                { "Operadores Aritméticos - Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais - Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Lógicos - Fundamentos", OperadoresLogicos.Executar },
                { "Operadores de Atribuição - Fundamentos", OperadoresDeAtribuicao.Executar },
                { "Operador Ternário - Fundamentos", OperadorTernario.Executar },

                //Estruras de Controle
                { "Estrutura IF - Estruturas de Controle", EstruturaIf.Executar },
                { "Estrutura IF/ELSE - Estruturas de Controle", EstruturaIfElse.Executar },
                { "Estrutura IF/ELSE/IF - Estruturas de Controle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch - Estruturas de Controle", EstruturaSwitch.Executar },
                { "Estrutura While - Estruturas de Controle", EstruturaWhile.Executar },
                { "Estrutura For - Estruturas de Controle", EstruturaFor.Executar },
                { "Estrutura ForEach - Estruturas de Controle", EstruturaForEach.Executar },

                //Classes e Métodos
                { "Membros - Classes e Métodos", Membros.Executar },
                { "Construtores -  Classes e Métodos ", Construtores.Executar },
                { "Metodos com Retorno -  Classes e Métodos ", MetodosComRetorno.Executar },
                { "Metodos Estaticos -  Classes e Métodos ", MetodosEstaticos.Executar },
                { "Atributos Estaticos -  Classes e Métodos ", AtributosEstaticos.Executar },
                { "Desafio -  Classes e Métodos ", Desafio.Executar },
                { "Parametros Variavei -  Classes e Métodos ", Params.Executar },
                { "Parametros Nomeados -  Classes e Métodos ", ParametrosNomeados.Executar },
                { "Getters e Setters -  Classes e Métodos ", GettersESetters.Executar },
                { "Readonly -  Classes e Métodos ", Readonly.Executar },
                { "Enum -  Classes e Métodos ", EnumExemplo.Executar },

                //Coleções
                { "Array -  Coleções ", ArrayExe.Executar },
                { "List -  Coleções ", ColecoesList.Executar },
                { "ArrayList -  Coleções ", ColecoesArrayList.Executar },
                { "Igualdade -  Coleções ", Igualdade.Executar },

                //Orientação a Objetos
                { "Herança -  OO ", Heranca.Executar },
                { "Construtor This -  OO ", ConstrutorThis.Executar },

                //Exceções
                { "Excecoes -  Excecoes ", PrimeiraExcecoes.Executar },

                //Api
                { "Arquivos Escrita -  API ", PrimeiroArquivo.Executar },
                { "Arquivos Leitura -  API ", LendoArquivo.Executar },

                //Topicos Avançados
                { "LINQ1 - Topicos Avançados ", LINQ1.Executar },
                { "LINQ2 - Topicos Avançados ", LINQ2.Executar },
            });

            central.SelecionarEExecutar();
        }
Exemple #30
0
        static void Main(string[] args)
        {
            var central = new CentralDeExercicios(new Dictionary <string, Action>()
            {
                { "Primeiro Programa - Fundamentos", PrimeiroPrograma.Executar },
                { "Comentários - Fundamentos", Comentarios.Executar },
                { "Variaveis e constantes - Fundamentos", VariaveisEConstantes.Executar },
                { "inferencia - Fundamentos", inferencia.Executar },
                { "Interpolação - Fundamentos", Interpolacao.Executar },
                { "Notação ponto - Fundamentos", NotacaoPonto.Executar },
                { "Lendo Dados - Fundamentos", LendoDados.Executar },
                { "Formatando numeros - Fundamentos", FormatandoNumero.Executar },
                { "Conversoes- Fundamentos", Conversoes.Executar },
                { "Operadores Aritmeticos- Fundamentos", OperadoresAritmeticos.Executar },
                { "Operadores Relacionais- Fundamentos", OperadoresRelacionais.Executar },
                { "Operadores Logicos- Fundamentos", OperadoresLogicos.Executar },
                { "Operadores De Atribuição- Fundamentos", OperadoresAtribuicao.Executar },
                { "Operadores Unarios- Fundamentos", OperadoresUnarios.Executar },
                { "Operadores Ternario- Fundamentos", OperadorTernario.Executar },

                { "Estrutura If- EstruturaDeControle", EstruturaIf.Executar },
                { "Estrutura If/Else- EstruturaDeControle", EstruturaIfElse.Executar },
                { "Estrutura If/Else If- EstruturaDeControle", EstruturaIfElseIf.Executar },
                { "Estrutura Switch- EstruturaDeControle", EstruturaSwitch.Executar },
                { "Estrutura While- EstruturaDeControle", EstruturaWhile.Executar },
                { "Estrutura DoWhile- EstruturaDeControle", EstruturaDoWhile.Executar },
                { "Estrutura For- EstruturaDeControle", EstruturaFor.Executar },
                { "Estrutura ForEach- EstruturaDeControle", EstruturaForEach.Executar },
                { "Usando Break- EstruturaDeControle", UsandoBreak.Executar },
                { "Usando Continue- EstruturaDeControle", UsandoContinue.Executar },

                { "Membros- ClassesEMetodos", Membros.Executar },
                { "Construtores- ClassesEMetodos", Construtores.Executar },
                { "Metodos Com Retorno- ClassesEMetodos", MetodosComRetorno.Executar },
                { "Metodos estaticos- ClassesEMetodos", MetodosEstaticos.Executar },
                { "Atributos estaticos- ClassesEMetodos", AtributosEstaticos.Executar },
                { "Desafio atributo- ClassesEMetodos", DesafioAtributo.Executar },
                { "Params- ClassesEMetodos", Params.Executar },
                { "Parametros Nomeados- ClassesEMetodos", ParametrosNomeados.Executar },
                { "Props- ClassesEMetodos", Props.Executar },
                { "ReadOnly- ClassesEMetodos", ReadOnly.Executar },
                { "Enum- ClassesEMetodos", ExemploEnum.Executar },
                { "Struct- ClassesEMetodos", ExemploStruct.Executar },
                { "Struct Vs Class- ClassesEMetodos", StructVsClasse.Executar },
                { "Valor Vs Referência- ClassesEMetodos", ValorVsReferencia.Executar },
                { "Parametros por referência- ClassesEMetodos", ParametrosPorReferencia.Executar },
                { "Parametros Padrao- ClassesEMetodos", ParametroPadrao.Executar },

                { "Array - Coleções", Colecoes.Array.Executar },
                { "Lista - Coleções", ColecoesList.Executar },
                { "ArrayLista - Coleções", ColecoesArrayLista.Executar },
                { "Set - Coleções", ColecoesSet.Executar },
                { "Queue - Coleções", ColecoesQueue.Executar },
                { "Igualdade - Coleções", Igualdade.Executar },
                { "Stack - Coleções", ColecoesStack.Executar },
                { "Dicionario - Coleções", ColecoesDictionary.Executar },


                { "Herança - OO", Heranca.Executar },
                { "Construtor This - OO", ConstrutorThis.Executar },
                { "Encapsulamento - OO", OO.Encapsulamento.Executar },
                { "Polimorfismo- OO", OO.Polimorfismo.Executar },
                { "Classe Abstract- OO", OO.Abstract.Executar },
                { "Interface- OO", OO.Interface.Executar },
                { "Sealed- OO", Sealed.Executar },

                { "ExemploLambda- Metodos e funções", ExemploLambda.Executar },
                { "Lambda com delegate- Metodos e funções", LambdasDelegate.Executar },
                { "Usando Delegates- Metodos e funções", UsandoDelegates.Executar },
                { "Delegates com funcões anonimas- Metodos e funções", DelegateFunAnonima.Executar },
                { "Delegates como parametros- Metodos e funções", DelegatesComoParametros.Executar },
                { "Metodos de Extensao- Metodos e funções", MetodosDeExtensao.Executar },

                { "Primeira Excecao - Excecões", PrimeiraExcecao.Executar },
                { " Excecoes Personalizadas - Excecões", ExcecoesPersonalizadas.Executar },

                { "Primeiro Arquivo - Usando API", PrimeiroArquivo.Executar },
                { "Lendo Arquivo - Usando API", LendoArquivos.Executar },
                { "Exemplo FileInfo - Usando API", ExemploFileInfo.Executar },
                { "Diretórios - Usando API", Diretorios.Executar },
                { "Diretórios info - Usando API", ExemploDirectoryInfo.Executar },
                { "Exemplo Path - Usando API", ExemploPath.Executar },
                { "Exemplo DateTime  - Usando API", ExemploDateTime.Executar },
                { "Exemplo TimeSpan - Usando API", ExemploTimeSpan.Executar },

                { "LINK1 - Topicos Avançados", LINK1.Executar },
                { "LINK2 - Topicos Avançados", LINK2.Executar },
                { "Nullable - Topicos Avançados", TopicosAvancados.Nullable.Executar },
                { "Dynamics - Topicos Avançados", Dynamics.Executar },
                { "Generics - Topicos Avançados", Genericos.Executar },

                { "Exercicios", ex1.Executar },
                { "Exercicios2", ex2.Executar },
                { "Exercicios3", ex3.Executar },
                { "Exercicios4", ex4.Executar },
                { "Exercicios5", ex5.Executar },
                { "Exercicios6", ex6.Executar },
                { "Exercicios7", ex7.Executar },
                { "Exercicios8", ex8.Executar },
                { "Exercicios9", ex9.Executar },
                { "Exercicios10", ex10.Executar },
                { "Exercicios11", ex11.Executar },
            });

            central.SelecionarEExecutar();
        }