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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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);
}
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();
}
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);
}
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);
}
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());
}
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);
}
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);
}
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));
}
}
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;
}
public string Post([FromBody] Soma soma)
{
total += soma.valor;
return("R$" + total);
}
public void ImprimeSoma(Soma soma)
{
throw new NotImplementedException();
}
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)
});
}
static void Main(string[] args)
{
Console.WriteLine(Soma.OpSoma(2, 2));
}
//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
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();
}
public void SomaSucesso(int x, int y)
{
var soma = new Soma();
Assert.True((x + y) == soma.Calcula(x, y));
}
public static void Executar()
{
Soma op1 = MinhaSoma;
System.Console.WriteLine(op1(2, 3));
}
public ISoma Create(IList <Synapse> dendrites, double bias)
{
return(Soma.GetInstance(dendrites, _summationFunction, bias));
}
