コード例 #1
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(4.4, 5.5));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(8.7, 3);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(MinhaSoma(2.5, 4));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #2
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(17, 9);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(23.8, 11.1));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(124.9, 12.9);
        }
コード例 #3
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3.9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.5, 7);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(7.5, 8.5));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(3, 3);
        }
コード例 #4
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(15, 27));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(25, 17);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(37, 5));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(40, 2);
        }
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3.9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.4, 8);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #6
0
        public static void Executar()
        {
            Soma soma = MinhaSoma;

            Console.WriteLine(soma(2.2, 10));

            ImprimirSoma imp = MeuImprimirSoma;

            imp(1, 6.0);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(44.2, 56));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(1, 6.2);
        }
コード例 #7
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(3, 4));

            ImpimirSoma i1 = MeuImprimirSoma;

            i1(9, 10);

            Func <double, double, double> funcTeste = MinhaSoma;

            Console.WriteLine(funcTeste(10, 20));

            Action <double, double> actTest = MeuImprimirSoma;

            actTest(30, 40);
        }
コード例 #8
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3.5));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.6, 8);
            Console.WriteLine();

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(10.5, 9.5));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(23.4, 8.1);
        }
コード例 #9
0
        public static void Executar()
        {
            //precisa haver compatibilidade dos parametros, tipo de retorno
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3));

            ImprimirSoma op2 = MeuImprimir;

            op2(5.4, 8);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimir;

            op4(7.7, 23.4);
        }
コード例 #10
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma; // delegate associado a uma funcão // fazendo sempre com os parametros que recebo com o tipo de retorno

            Console.WriteLine(op1(3, 4));

            imprimirSoma op2 = MeuImprimirSoma;

            op2(3.4, 8); //

            // essa funcao esta em um delegate
            Func <double, double, double> op3 = MinhaSoma; // são 3 dobles na funcao, sendo que sempre o ultimo é o tipo de retorno

            Console.WriteLine(op3(9.5, 4));

            // esse action tambem esta em delegate porem nao tem retorno por isso só tem DOIS double
            Action <double, double> op4 = MeuImprimirSoma;

            op4(2.5, 4);
        }
コード例 #11
0
        public static void Executar()
        {
            Soma p1 = MinhaSoma;

            Console.WriteLine(p1(10, 5));

            ImprimirSoma op2 = ImprimirMinhaSoma;

            op2(35.28934723, 15.23452345);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(123.5, 123.5));

            Action <double, double> op4 = ImprimirMinhaSoma;

            op4(12.5, 12.5);

            Console.ReadKey();
        }
コード例 #12
0
        public static void Executar()
        {
            // Associando uma função pré existente a um delegate, não necessariamente é preciso passar um Lambda
            // A única coisa que precisa é que haja uma compatibilidade entre as assinaturas.
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(1, 3.9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.4, 8);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #13
0
        public static void Executar()
        {
            // Associando delegate à função existente
            // Precisa ter mesma assinatura
            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3.9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.4, 8);

            // Associando Func e Action à funções existentes
            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #14
0
        static void Main(string[] args)
        {
            IExpressao esquerda            = new Soma(new Numero(1), new Numero(10));
            IExpressao direita             = new Subtrai(new Numero(17), new Numero(4));
            IExpressao resultSoma          = new Soma(esquerda, direita);
            IExpressao resultMultiplicacao = new Multiplicacao(esquerda, direita);
            IExpressao resultDivisao       = new Divisao(esquerda, direita);

            Console.WriteLine(resultSoma.Avalia());
            Console.WriteLine(resultMultiplicacao.Avalia());

            Impressora impressora = new Impressora();

            resultSoma.Aceita(impressora);
            resultMultiplicacao.Aceita(impressora);
            resultDivisao.Aceita(impressora);

            // Avaliador de Expressões da própria linguagem C#
            // Expression soma = Expression.Add(Expression.Constant(10), Expression.Constant(29));
            // Func<int> funcao = Expression.Lambda<Func<int>>(soma).Compile();
            // Console.WriteLine(funcao.Invoke());
        }
コード例 #15
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma; // se houver igualdade nos tipos, quant e ordem dos params

            // e o tipo de retorno é mesmo. Então conseguimos fazer
            // a associacão de uma funcão que já existe usando um
            // delegate como tipo e armezenando dentro de uma var.

            Console.WriteLine(op1(2, 3.9));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.4, 8);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #16
0
        public static void Executar()
        {
            // podemos pegar uma função que já existe e
            // armazenar ele dentro de um delegate
            // (só precisa existir uma compatibilidade entre as assinaturas):
            // parâmetros e tipo de retorno!

            Soma op1 = MinhaSoma;

            Console.WriteLine(op1(2, 3));

            ImprimirSoma op2 = MeuImprimirSoma;

            op2(5.4, 8);

            Func <double, double, double> op3 = MinhaSoma;

            Console.WriteLine(op3(2.5, 3));

            Action <double, double> op4 = MeuImprimirSoma;

            op4(7.7, 23.4);
        }
コード例 #17
0
 public ISoma Create(IList <Synapse> dendrites, double bias, Type summationFunction)
 {
     if (summationFunction == typeof(AverageSummation))
     {
         return(Soma.GetInstance(dendrites, new AverageSummation(), bias));
     }
     else if (summationFunction == typeof(MaxSummation))
     {
         return(Soma.GetInstance(dendrites, new MaxSummation(), bias));
     }
     else if (summationFunction == typeof(MinSummation))
     {
         return(Soma.GetInstance(dendrites, new MinSummation(), bias));
     }
     else if (summationFunction == typeof(SimpleSummation))
     {
         return(Soma.GetInstance(dendrites, new SimpleSummation(), bias));
     }
     else
     {
         throw new NotSupportedException(string.Format("{0} is not a supported summation function type for Create()", summationFunction));
     }
 }
コード例 #18
0
    public Mon(byte[] _id)  //string _name, HEXTokenType _tokenType, Age _age, Vector3 _attunement, Vector3 _race, Vector3 _job, Vector3 _soma, Vector3 _ego)
    {
        if (_id.Length == 32)
        {
            id = _id;
        }
        else
        {
            Debug.Log("Invalid ID: Must be 32 bytes"); return;
        }

        int setAge        = 0;
        int setAttunement = 0;
        int setRace       = 0;
        int setJob        = 0;

        soma = new Soma();
        ego  = new Ego();

        for (int i = 0; i < 32; i++)
        {
            UnityEngine.Random.InitState(id[i]);
            //setAge += UnityEngine.Random.;
            setAttunement += Random.Range(0, 5);
            setRace       += Random.Range(0, 5);
            setJob        += Random.Range(0, 5);

            soma.Intelligence += Random.Range(0, 24);
            soma.Strength     += Random.Range(0, 24);
            soma.Defense      += Random.Range(0, 24);
            soma.Dexterity    += Random.Range(0, 24);
            soma.Health       += Random.Range(0, 9999);
            soma.Mana         += Random.Range(0, 9999);

            ego.Movespeed += Random.Range(2, 5);
            ego.Lifespan  += Random.Range(24, 100);
            ego.Power     += Random.Range(1, 24);
        }

        setAge        = setAge % 6;
        setAttunement = setAttunement % 6;
        setRace       = setRace % 6;
        setJob        = setJob % 6;

        age        = (Age)setAge;
        attunement = (Attunement)setAttunement;
        race       = (Race)setRace;
        job        = (Job)setJob;

        soma.Intelligence = soma.Intelligence % 24;
        soma.Strength     = soma.Strength % 24;
        soma.Defense      = soma.Defense % 24;
        soma.Dexterity    = soma.Dexterity % 24;
        soma.Mana         = soma.Mana % 9999;
        soma.Health       = soma.Health % 9999;

        ego.Movespeed  = (ego.Movespeed % 4) + 1;
        ego.Lifespan   = (ego.Lifespan % 99) + 24;
        ego.Power      = (ego.Power % 24) + 1;
        ego.Size       = 1;
        ego.Level      = 1;
        ego.Generation = 0;
    }
コード例 #19
0
 public string Post([FromBody] Soma soma)
 {
     total += soma.valor;
     return("R$" + total);
 }
コード例 #20
0
ファイル: Impressora.cs プロジェクト: JoaoMML/Alura
 public void ImprimeSoma(Soma soma)
 {
     throw new NotImplementedException();
 }
コード例 #21
0
 public static void Executar()
 {
     Soma op1 = MinhaSoma;
 }
        private Models.Principal BuscarRegistros(Int32 Ano, Int32 Mes, bool BuscarQuitado)
        {
            string NomeUsuario          = GetLogOnSessionModel().Nome;
            string IdentificadorUsuario = GetLogOnSessionModel().Identificador;

            List <Models.Registro> objRegistros = RegistroFinanceiroController.BuscarRegistros(new BuscaRegistros()
            {
                Ano = Ano, Mes = Mes
            }, IdentificadorUsuario, !BuscarQuitado, BuscarQuitado);

            List <Models.SituacaoGeralMes> objDespesasRetorno = new List <SituacaoGeralMes>();

            Models.SituacaoGeralMes objDespesasReceita = null;
            double ValorReceita      = 0;
            double ValorDespesa      = 0;
            double ValorTotalReceita = 0;

            if (objRegistros != null && objRegistros.Count > 0)
            {
                string CodigoCategoriaGeralDespesaEssencial = Enumeradores.CategoriaGeral.DESPESAESSENCIAL.RecuperarValor();
                string CodigoReceita = Enumeradores.TipoFonte.CREDITO.RecuperarValor();
                List <Models.SituacaoGeralMes> objDespesasGastos = null;


                objDespesasReceita = (from Models.Registro r in objRegistros
                                      where r.CodigoTipoRegistro == CodigoReceita     //&& r.BolSalario == true
                                      group r by r.CodigoTipoRegistro into Soma
                                      select new Models.SituacaoGeralMes()
                {
                    DescricaoCategoriaGeral = "Receita",
                    ValorGasto = Soma.Sum(vg => vg.Valor),
                    Ordem = 1
                }).FirstOrDefault();


                if (objDespesasReceita == null)
                {
                    objDespesasReceita = new SituacaoGeralMes()
                    {
                        DescricaoCategoriaGeral = "Receita",
                        ValorGasto = 0
                    }
                }
                ;

                ValorReceita = objDespesasReceita.ValorGasto;

                ValorTotalReceita = (from Models.Registro r in objRegistros
                                     where r.CodigoTipoRegistro == CodigoReceita && r.BolSalario == true
                                     group r by r.CodigoTipoRegistro into Soma
                                     select Soma.Sum(vg => vg.Valor)).FirstOrDefault();

                objDespesasReceita.ValorGasto = ValorTotalReceita;

                objDespesasGastos = (from Models.Registro r in objRegistros
                                     where r.CodigoTipoRegistro != CodigoReceita
                                     group r by r.CategoriaGeral into Soma
                                     select new Models.SituacaoGeralMes()
                {
                    DescricaoCategoriaGeral = (from Tuple <string, string, double, Int32> v in Classes.Parametros.CategoriasGerais
                                               where v.Item1 == Soma.First().CategoriaGeral
                                               select v.Item2).FirstOrDefault(),
                    ValorGasto = Soma.Sum(vg => vg.Valor),
                    PorcentagemIdeal = (from Tuple <string, string, double, Int32> v in Classes.Parametros.CategoriasGerais
                                        where v.Item1 == Soma.First().CategoriaGeral
                                        select v.Item3).FirstOrDefault(),
                    PorcentagemGasta = ((Soma.Sum(vg => vg.Valor) * 100) / ValorTotalReceita),
                    ValorIdeal = (from Tuple <string, string, double, Int32> v in Classes.Parametros.CategoriasGerais
                                  where v.Item1 == Soma.First().CategoriaGeral
                                  select(v.Item3 * ValorTotalReceita) / 100).FirstOrDefault(),
                    Ordem = (from Tuple <string, string, double, Int32> v in Classes.Parametros.CategoriasGerais
                             where v.Item1 == Soma.First().CategoriaGeral
                             select v.Item4).FirstOrDefault()
                }).ToList();

                if (objDespesasGastos != null && objDespesasGastos.Count > 0)
                {
                    objDespesasRetorno.AddRange(objDespesasGastos);

                    ValorDespesa = (from Models.Registro r in objRegistros
                                    where r.CodigoTipoRegistro != CodigoReceita
                                    select r.Valor).Sum();
                }

                if (objDespesasRetorno == null)
                {
                    objDespesasGastos = new List <SituacaoGeralMes>();
                }
                foreach (var tv in Classes.Parametros.CategoriasGerais)
                {
                    if (!objDespesasRetorno.Exists(d => d.DescricaoCategoriaGeral == tv.Item2))
                    {
                        objDespesasRetorno.Add(new SituacaoGeralMes()
                        {
                            DescricaoCategoriaGeral = tv.Item2,
                            ValorGasto       = 0,
                            PorcentagemIdeal = tv.Item3,
                            PorcentagemGasta = ((0 * 100) / ValorTotalReceita),
                            ValorIdeal       = (tv.Item3 * ValorTotalReceita) / 100,
                            Ordem            = tv.Item4
                        });
                    }
                }
            }

            return(new Models.Principal()
            {
                NomeUsuario = NomeUsuario, BuscarQuitado = BuscarQuitado, Ano = Ano.ToString(), Mes = Mes.ToString(), SituacaoGeralMes = objDespesasRetorno, Receita = objDespesasReceita, TotalDespesa = ValorDespesa, SequenciaTotal = 100, Saldo = (ValorReceita - ValorDespesa)
            });
        }
コード例 #23
0
 static void Main(string[] args)
 {
     Console.WriteLine(Soma.OpSoma(2, 2));
 }
コード例 #24
0
        //MENU
        public static void Criar()
        {
            while (true)
            {
                Console.WriteLine("##############################                          ###############################");
                Console.WriteLine("##############################    MENU DO SISTEMA       ###############################");
                Console.WriteLine("##############################                          ###############################");

                Console.WriteLine("\n");
                Console.WriteLine("[1]-Ler Arquivo " +
                                  "\n[2]-Calcular Média" +
                                  "\n[3]-Somar" +
                                  "\n[4]-Tabuada" +
                                  "\n[5]-Cliente" +
                                  "\n[6]-Usuário" +
                                  "\n[7]-Envia email" +
                                  "\n[8]-Fornecedor" +
                                  "\n[9]-Sair");
                Console.WriteLine("\n");
                Console.WriteLine("##############################                          ###############################");
                Console.WriteLine("##############################    OPÇÕES DO SITEMAS     ###############################");
                Console.WriteLine("##############################                          ###############################");

                Console.WriteLine("##############################    bbbbbbbbbbbbbbb       ###############################");
                Console.WriteLine("##############################    bbbbbbbbbbbbbbbb      ###############################");
                Console.WriteLine("##############################    bbbb       bbbbb      ###############################");
                Console.WriteLine("##############################    bbbb       bbbbb      ###############################");
                Console.WriteLine("##############################    bbbbbbbbbbbbbb        ###############################");
                Console.WriteLine("##############################    bbbbbbbbbbbbbb        ###############################");
                Console.WriteLine("##############################    bbbb       bbbbbb     ###############################");
                Console.WriteLine("##############################    bbbb       bbbbbbb    ###############################");
                Console.WriteLine("##############################    bbbbbbbbbbbbbbbbbb    ###############################");
                Console.WriteLine("##############################    bbbbbbbbbbbbbbbbb     ###############################");



                int valor = int.Parse(Console.ReadLine());

                if (LER_ARQUIVO == valor)
                {
                    Arquivo.Ler(1);//Ler Arquivo
                }
                else if (CALCULO_MEDIA == valor)
                {
                    Media.Aluno();
                }
                else if (SOMA == valor)
                {
                    Soma.CalcularSoma();
                }
                else if (TABUADA == valor)
                {
                    Tabuada.CalacularTabuada();
                }
                else if (CADASTRAR_CLIENTE == valor)
                {
                    TelaCliente.Chamar();
                }
                else if (CADASTRAR_USUARIO == valor)
                {
                    TelaUsuario.Chamar();
                }
                else if (ENVIAR_EMAIL == valor)
                {
                    TelaEmail.EnviaEmail();
                }
                else if (CADASTRAR_FORNECEDOR == valor)
                {
                    TelaFornecedor.Chamar();
                }
                else if (SAIR == valor)
                {
                    break;
                }
                else
                {
                    Console.WriteLine("Opção inválida.");
                }
            }
        }//MENU FIM
コード例 #25
0
        static void Main(string[] args)
        {
            NotasMusicais notas  = new NotasMusicais();
            IList <INota> musica = new List <INota>()
            {
                notas.Pega("do"),
                notas.Pega("re"),
                notas.Pega("mi"),
                notas.Pega("fa"),
                notas.Pega("fa"),
                notas.Pega("fa"),
            };

            Piano piano = new Piano();

            piano.Toca(musica);

            //Memento
            Historico historico = new Historico();
            Contrato  c         = new Contrato(DateTime.Now, "Euler Vital", TipoContrato.Novo);

            historico.Adiciona(c.SalvaEstado());
            c.Avanca();
            historico.Adiciona(c.SalvaEstado());
            c.Avanca();
            historico.Adiciona(c.SalvaEstado());
            Console.WriteLine(c.Tipo);
            Console.WriteLine(historico.Pega(2).Contrato.Tipo);
            Console.ReadLine();

            //Interpreter
            //((1 + 100) + 10) + (20 - 10)
            //Pode ser usado toda vezque nós temos uma arvore de expressoes que queremos avaliar
            IExpressao esquerda = new Soma(new Soma(new Numero(1), new Numero(100)), new Numero(10));
            IExpressao direita  = new Subtracao(new Numero(20), new Numero(10));
            IExpressao soma     = new Soma(esquerda, direita);

            Console.WriteLine(soma.Avalia());

            //API Expression do C#
            Expression soma_01 = Expression.Add(Expression.Constant(10), Expression.Constant(100));
            Func <int> funcao  = Expression.Lambda <Func <int> >(soma_01).Compile();

            Console.WriteLine(funcao());

            //Visitor
            Console.WriteLine(soma.Avalia());
            ImpressoraVisitor impressora = new ImpressoraVisitor();

            soma.Aceita(impressora);

            //Bridge (Separa responsabilidade)
            IMensagem mensagem = new MensagemCliente("Euler");

            mensagem.Enviador = new EnviaPorEmail();
            mensagem.Envia();
            Console.ReadLine();

            //Command
            //OBS: Ideal para api´s que serão consumidas por celulares
            //Pois pode ser excutado posteriormente
            FilaDeTrabalho fila    = new FilaDeTrabalho();
            Pedido         pedido1 = new Pedido("Euler", 120.90);
            Pedido         pedido2 = new Pedido("Jean", 110.90);

            fila.Adiciona(new PagaPedido(pedido1));
            fila.Adiciona(new PagaPedido(pedido2));
            fila.Adiciona(new FinalizaPedido(pedido1));
            fila.Processa();


            //Adpter
            //Usado para aptar o codigo usado pela biblioteca nativa c#
            Cliente cliente = new Cliente();

            cliente.Nome             = "Euler";
            cliente.Endereco         = "Rua vergueiro";
            cliente.DataDeNascimento = DateTime.Now;
            string xml = new GeradorDeXml().GeraXml(cliente);

            Console.WriteLine(xml);
            Console.ReadLine();
        }
コード例 #26
0
ファイル: SomaTests.cs プロジェクト: nallonp/LibraryCalc17
        public void SomaSucesso(int x, int y)
        {
            var soma = new Soma();

            Assert.True((x + y) == soma.Calcula(x, y));
        }
コード例 #27
0
        public static void Executar()
        {
            Soma op1 = MinhaSoma;

            System.Console.WriteLine(op1(2, 3));
        }
コード例 #28
0
 public ISoma Create(IList <Synapse> dendrites, double bias)
 {
     return(Soma.GetInstance(dendrites, _summationFunction, bias));
 }