public bool Transferir(double valor, ContaCorrente contaDestino)
{
if (_saldo < valor)
{
return(false);
}
_saldo -= valor;
contaDestino.Depositar(valor);
return(true);
}
/// <summary>Método para transferência de valores por contas.
/// <para><see valor/> Valor a ser transferido via depósito.</para>
/// </summary>
public bool Transferir(double valor, ContaCorrente contaDestino)
{
bool resultadoTransferencia = false;
if (this._saldo > valor)
{
resultadoTransferencia = true;
this._saldo -= valor;
contaDestino.Depositar(valor);
}
return(resultadoTransferencia);
}
//public void SetSaldo(double saldo)
//{
// if (saldo < 0)
// return;
// this.saldo = saldo; // this obrigatório
//}
public bool Transferir(double valor, ContaCorrente contaDestino)
{
if (this._saldo < valor) // this não obrigatório
{
return(false);
}
contaDestino.Depositar(valor);
this.Sacar(valor);
return(true);
}
private static void TestaInnerException()
{
try
{
ContaCorrente conta1 = new ContaCorrente(4564, 789684);
ContaCorrente conta2 = new ContaCorrente(7891, 456794);
//conta1.Transferir(10000, conta2);
conta1.Sacar(10000);
}
catch (OperacaoFinanceiraException e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
//Console.WriteLine("INFORMAÇÕES DA INNER EXCEPTION (exceção interna):");
//Console.WriteLine(e.InnerException.Message);
//Console.WriteLine(e.InnerException.StackTrace);
}
try
{
ContaCorrente conta = new ContaCorrente(456, 4578420);
ContaCorrente conta2 = new ContaCorrente(485, 4564780);
conta2.Transferir(1000, conta);
conta.Depositar(50);
Console.WriteLine(conta.Saldo);
conta.Sacar(-500);
}
catch (ArgumentException e)
{
Console.WriteLine("Ocorreu uma exceção do tipo ArgumentException.");
Console.WriteLine("Argumento com problema: " + e.ParamName);
Console.WriteLine(e.Message);
}
catch (SaldoInsuficienteException e)
{
Console.WriteLine(e.Saldo);
Console.WriteLine(e.ValorSaque);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.Message);
Console.WriteLine("Exceção do tipo SaldoInsuficienteException.");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public string Transferir(double valor, ContaCorrente contaDestino)
{
if (_saldo < valor)
{
return("Saldo insufuciente!");
}
else
{
_saldo -= valor;
contaDestino.Depositar(valor);
return("Transferencia efetuado com sucesso!");
}
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciasNaoPermitidas++;
throw new OperacaoFinanceiraException("Operação não realizada", ex);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
try
{
ContaCorrente conta = new ContaCorrente(123, 123);
conta.Depositar(500);
conta.Sacar(1000);
}
catch (OperacaoFinanceiraException e)
{
Console.WriteLine(e.Message);
}
}
private static void TestaInnerExecption()
{
try
{
ContaCorrente conta = new ContaCorrente(1612, 58479);
ContaCorrente conta2 = new ContaCorrente(1612, 14985);
conta.Depositar(200);
//conta.Sacar(10000);
conta.Transferir(10000, conta2);
}
catch (ArgumentException ex)
{
Console.WriteLine("Argumento com Problema " + ex.ParamName);
Console.WriteLine("Ocorreu um erro do tipo ArgumentException");
Console.WriteLine(ex.Message);
}
catch (SaldoInsuficienteException ex)
{
/*Neste momento é possivel acessaro estado da aplicação no momento da exceção */
Console.WriteLine(ex.StackTrace);
Console.WriteLine();
Console.WriteLine(ex.Message);
Console.WriteLine("Exceção do tipo saldo insuficiente");
Console.WriteLine("Valor do saldo: " + ex.Saldo);
Console.WriteLine("Valor do saque: " + ex.ValorSaque);
}
catch (OperacaoFinanceiraException ex)
{
Console.WriteLine(ex.StackTrace);
Console.WriteLine(ex.Message);
Console.WriteLine("Informaçoes da INNER EXCPTION (exceção interna)");
Console.WriteLine("Pego pela exceção Operação Financeira Exception");
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace);
Console.WriteLine(ex.Message);
Console.WriteLine("Informaçoes da INNER EXCPTION (exceção interna)");
Console.WriteLine(ex.InnerException.Message);
Console.WriteLine(ex.InnerException.StackTrace);
}
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
/*Ao tentar sacar um valor menorque zero, irá cair na exceção abaixo aonde é verificado de o valor aser trandferido
* é menor que 0*/
if (valor < 0)
{
throw new ArgumentException("Valor Invalido para a transferencia. ", nameof(valor));
}
/*Caso passou na condiçãoa cima do "IF". o metodo Sacar é iniciado, aonde é debitado o valor
* da conta do cliente */
Sacar(valor);
/*Caso o cliente tenha saldo suficiente, o sair do metodo Sacar()
* o Valor será depositado na conta Destino seguindo o metodo abaixo */
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor inválido para a transferência.", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciasNaoPermitidas++;
throw new SaldoInsuficienteException("Operação não realizada.", ex);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor invalido para transferencia. ", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException e)
{
ContTransferenciasNaoPermitidos++;
throw new OperaçãoFinanceiraException("Operação Não Realizada", e);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("valor invalido para a transferencia", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciaNaoPermitido++;
throw new OperacaoFinanceiraException("Não permitido", ex);
}
contaDestino.Depositar(valor);
}
public static void TestaInnerException()
{
try
{
ContaCorrente conta = new ContaCorrente(456, 4578420);
ContaCorrente conta2 = new ContaCorrente(485, 456478);
conta2.Transferir(10000000, conta);
conta.Depositar(50);
Console.WriteLine(conta.Saldo);
conta.Sacar(500);
}
catch (ArgumentException ex)
{
Console.WriteLine("Argumento com problemas: " + ex.ParamName);
Console.WriteLine("Ocorreu uma exceção do tipo ArgumentException");
//Console.WriteLine(ex.Message);
}
catch (SaldoInsuficienteException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("Exceção do tipo SaldoInsuficienteException");
}
catch (OperacaoFinanceiraException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
Console.WriteLine("Message Inner Exception: ----------- " + ex.InnerException.Message);
Console.WriteLine("StackTrace Inner Exception: ----------- " + ex.InnerException.StackTrace);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
//Console.WriteLine(ContaCorrente.TaxaOperacao);
Console.ReadLine();
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor de saque nao pode ser negativo", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciasNaoPermitidas++;
throw new OperacaoFinanceiraException("Operação não realizada.", ex);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor <= 0)
{
throw new ArgumentException("O valor do transferencia deve ser maior que Zero", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException e)
{
ContadorTransferenciasNaoPermitidas++;
throw new OperacaoFinanceiraException("Operação não permitida", e);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor de saque menor que 0, operação impossível.");
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteExcepetion ex)
{
TotalTransferenciasNaoPermitido++;
throw new OperacaoFinanceiraException("Operação não relizada.", ex);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
try
{
//Metodo();
ContaCorrente conta = new ContaCorrente(456, 4578420);
ContaCorrente conta2 = new ContaCorrente(485, 456478);
conta2.Transferir(-10, conta);
conta.Depositar(50);
Console.WriteLine(conta.Saldo);
conta.Sacar(-500);
}
catch (DivideByZeroException e)
{
Console.WriteLine("Não é possivel divisão por zero");
}
catch (ArgumentException ex)
{
if (ex.ParamName == "numero")
{
}
Console.WriteLine("Argumento com problema: " + ex.ParamName);
Console.WriteLine("Ocorreu uma exceção do tipo ArgumentException");
Console.WriteLine(ex.Message);
}
catch (SaldoInsuficienteException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Exceção do tipo SaldoInsuficienteException");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine("Aconteceu um erro");
}
Console.ReadLine();
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor de tranferência menor que 0", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciasNaoPermitidas++;
throw new OperacaoFinanceiraException("Não foi possível executar a operação de Tranferir", ex);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
var marcos = new Cliente()
{
nome = "Marcos",
cpf = "477.444",
profissao = "Desenvolvedor"
};
ContaCorrente contaMarcos = new ContaCorrente(100, 56526)
{
Titular = marcos
};
contaMarcos.Saldo = 120.60;
ContaCorrente contaPaulo = contaMarcos;
contaPaulo.Sacar(50);
contaPaulo.Depositar(500);
var gabriela = new Cliente()
{
nome = "Gabriela",
cpf = "555.444",
profissao = "Desenvolvedor SR"
};
ContaCorrente contaDaGabriela = new ContaCorrente(120, 333)
{
Titular = gabriela
};
contaPaulo.Tranferir(100, contaDaGabriela);
Console.WriteLine(contaMarcos.Titular);
Console.WriteLine(contaMarcos.Saldo);
Console.WriteLine(contaPaulo.Titular);
Console.WriteLine(contaPaulo.Saldo);
Console.WriteLine(contaDaGabriela.Titular);
Console.WriteLine(contaDaGabriela.Saldo);
Console.WriteLine(ContaCorrente.TotalDeContasCriadas);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor Invalido para efetuar a transferência." + nameof(valor));
}
try
{
this.Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorSaquesNaoPermitidos++;
throw new Exception("Transferencia não permitida!", ex);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Ops! Valor da transferência não pode ser menor que 0.", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
TransferenciasNaoPermitidas++;
throw new Exception("Operação não realizada!", ex);
}
contaDestino.Depositar(valor);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor inválido para transferência.", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException e)
{
ContadorErroTransferencia++;
throw new OperacaoFinanceiraException("Operação não realizada.", e);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
try
{
ContaCorrente conta = new ContaCorrente(1612, 58479);
ContaCorrente conta2 = new ContaCorrente(1612, 14985);
conta.Depositar(200);
conta.Sacar(100);
conta.Transferir(5000, conta2);
}
catch (ArgumentException ex)
{
Console.WriteLine("Argumento com Problema " + ex.ParamName);
Console.WriteLine("Ocorreu um erro do tipo ArgumentException");
Console.WriteLine(ex.Message);
}
catch (SaldoInsuficienteException ex)
{
/*Neste momento é possivel acessaro estado da aplicação no momento da exceção */
Console.WriteLine(ex.Message);
Console.WriteLine("Exceção do tipo saldo insuficiente");
Console.WriteLine("Valor do saldo: " + ex.Saldo);
Console.WriteLine("Valor do saque: " + ex.ValorSaque);
Console.WriteLine(ex.StackTrace);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
//onsole.WriteLine(conta.Agencia);
//onsole.WriteLine(conta.Numero);
//onsole.WriteLine(ContaCorrente.TaxaDeOperacao);
Console.ReadLine();
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
// usado nameof para forçar a troca do nome do argumento caso "valor" for alterado no método.
throw new ArgumentException("Valor Invalido para a transferência ", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException e)
{
ContadorTransferenciasNaoPermitidas++;
// Lançando a exceção em um objeto a maquina virtual troca o stackTrace e volta direto para o Main.
// O throw no contexto do Catch pode ser vazio e irá deixar o stackTrace sem alterações
// Uma forma de guardar os dados sigilosos de uma exceção é lançar uma nova exception com construtor de mensagem e o objeto referente à exceção que originou o erro.
throw new OperacaoFinanceiraException("Operação não realizada", e);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
try
{
Metodo();
ContaCorrente conta = new ContaCorrente(123, 456654);
ContaCorrente conta2 = new ContaCorrente(321, 987654);
Console.WriteLine("Saldo atual: R$" + conta.Saldo);
conta.Depositar(500);
Console.WriteLine("Saldo atual: R$" + conta.Saldo);
conta.Transferir(700, conta2);
Console.WriteLine("Saldo atual: R$" + conta.Saldo);
Console.WriteLine("Saldo atual: R$" + conta2.Saldo);
}
catch (ArgumentException e)
{
Console.WriteLine("Erro no parâmetro: " + e.ParamName);
Console.WriteLine(e.Message);
}
catch (OperacaoFinanceiraException e)
{
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.Message);
Console.WriteLine("\n\nINFORMAÇÕES DA INNER EXCEPTION");
Console.WriteLine(e.InnerException.StackTrace);
Console.WriteLine(e.InnerException.Message);
}
catch (Exception erro)
{
Console.WriteLine(erro.Message);
Console.WriteLine(erro.StackTrace);
Console.WriteLine("Exceção tratada.");
}
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor inválido para transferência, argumento: " + nameof(valor));
}
try
{
Sacar(valor);
}
catch (OperacaoFincanceiraException ex)
{
ContadorDeTransferenciasNaoPermitidas++;
throw new OperacaoFincanceiraException("Operação não realizada!", ex);
}
contaDestino.Depositar(valor);
}
private static void TestaInner()
{
try
{
ContaCorrente conta = new ContaCorrente(50, 564654);
ContaCorrente conta2 = new ContaCorrente(458, 457715);
conta2.Transferir(10000, conta);
conta.Depositar(100);
Console.WriteLine(conta.Saldo);
conta.Sacar(500);
}
catch (ArgumentException ex)
{
if (ex.ParamName == "numero")
{
}
Console.WriteLine("Argumento com problema: " + ex.ParamName);
Console.WriteLine("Ocorreu um erro do tipo ArgumentException");
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
catch (SaldoInsuficienteException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Exceção do tipo saldo insuficiente exception");
}
catch (OperacaoFinanceiraException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
Metodo();
//ContaCorrente conta = new ContaCorrente(546, 754874);
//Console.WriteLine(ContaCorrente.TaxaOperacao);
}
public void Transferir(double valor, ContaCorrente contaDestino)
{
if (valor < 0)
{
throw new ArgumentException("Valor Invalido para a transferencia. ", nameof(valor));
}
try
{
Sacar(valor);
}
catch (SaldoInsuficienteException ex)
{
ContadorTransferenciasNãoPermitidas++;
//Excecão innerException(Exceção Interna)
throw new OperacaoFinanceiraException("Operação não realizada.", ex);
}
contaDestino.Depositar(valor);
}
static void Main(string[] args)
{
try
{
ContaCorrente conta = new ContaCorrente(456, 4578420);
ContaCorrente conta2 = new ContaCorrente(485, 456478);
conta2.Transferir(-10, conta);
conta.Depositar(50);
Console.WriteLine(conta.Saldo);
conta.Sacar(-500);
Console.WriteLine(conta.Saldo);
}
catch (ArgumentException ex)
{
if (ex.ParamName == "numero")
{
}
Console.WriteLine("Argumento com problema: " + ex.ParamName);
Console.WriteLine("Ocorreu uma exceção do tipo ArgumentException");
Console.WriteLine(ex.Message);
}
catch (SaldoInsuficienteException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Exceção do tipo SaldoInsuficienteException");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
//Metodo();
Console.WriteLine("Execução finalizada. Tecle enter para sair");
Console.ReadLine();
}
private static void RegistrarContas()
{
Conta contaBruno = new ContaCorrente(836, 836754);
Cliente bruno = new Cliente();
bruno.Nome = "Bruno";
contaBruno.Titular = bruno;
contaBruno.Depositar(100);
Conta contaLarissa = new ContaPoupanca(836, 836755, new DateTime(2020, 2, 5));
Cliente larissa = new Cliente();
larissa.Nome = "Larissa";
contaLarissa.Titular = larissa;
contaLarissa.Depositar(100);
contaLarissa.Sacar(50);
contaBruno.Sacar(50);
EscreverContaESaldo(contaLarissa);
EscreverContaESaldo(contaBruno);
}
