Dicas de programação: Escrevendo operadores de "cast" em C#

No C#, dá para escrever operadores para conversão de tipos. Por exemplo:

    //Estrutura Pessoa 
    struct Pessoa
    {
        //Propriedade Nome
        public String Nome
        {
            get; set;
        }

        //Propriedade Idade
        public int Idade
        {
             get; set;
        }

        //Converte o objeto pessoa para String (de maneira implicita, sem precisar fazer "(String)pessoa")
        public static implicit operator String(Pessoa pessoa)
        {
            return pessoa.Nome;
        }

        //Converte o objeto pessoa para int(de maneira explicita, precisando fazer "(int)pessoa")
        public static explicit operator int(Pessoa pessoa)
        {
            return pessoa.Idade;
        }

    }

    static void Main(string[] args)
    {
          //Crio o objeto pessoa
          Pessoa pessoa = new Pessoa();
          //Seto o nome e a idade
          pessoa.Nome = "Ricardo";
          pessoa.Idade = 100;
          //Converto os valores
          String nomePessoa = pessoa;
          int idadePessoa = (int) pessoa;
         //Exibo na tela
          Console.WriteLine("Nome: " + nomePessoa + " Idade: " + idadePessoa);
    }

Até mais!

Mercado Municipal de Campinas

Você não sabe aonde comprar chá de quebra-pedra? Ou nori? Ou feijão-fradinho por quilo?

Pois é, existe um lugar em Campinas que tem tudo isso e muito mais... E, este espaço, nós chamamos carinhosamente de Mercadão:

Oxê... Me deu uma saudade do comércio no Centro de Campinas... (para quem não sabe, já "trabalhei" lá :P )

Até mais!

Dicas de Programação: Enumeração em Swift

Uma coisa meio estranha no Swift, é que dá para colocar parâmetros dentro das "constantes" enumeradas e trabalhar com elas:

import Foundation

enum Log {

    //Constante debug com um parâmetro String

    case debug(String)

    //Constante warning com um parâmetro String

    case warning(String)

    //Constante error com um parâmetro String

    case error(String)

    //Função do enumerador que escreve no console/terminal

    func write() {

        //Obtém a data atual

        let now = Date()

        switch (self) {

         //Caso o enumerador seja debug 

        case Log.debug(let d):

           //Escreve na tela a data atual, a palavra [DEBUG] e o parâmetro "d" passado na constante

           print("\(now) [DEBUG] \(d)")

        //Caso o enumerador seja warning 

        case Log.warning(let w):

           //Escreve na tela a data atual, a palavra [WARNING] e o parâmetro "w" passado na constante

           print("\(now) [WARNING] \(w)")

        //Caso o enumerador seja error

        case Log.error(let e):

           //Escreve na tela a data atual, a palavra [ERROR] e o parâmetro "e" passado na constante

           print("\(now) [ERROR] \(e)")

        //Caso não seja nenhum deles, dá um erro

        default:

            fatalError("Unsupported")

        }

    }

} 

//Exemplo de uso

Log.error("Ocorreu um erro").write()

Log.warning("Variavel é nula, utilizando valor 0 como default").write()

let pi = 3.14

Log.debug("Valor da constante pi=\(pi)").write()

Bizarro, não?

Até mais!

Black Kamen Rider: original ou dublado?

Qual seria melhor? A abertura original de Black Kamen Rider (sim, isso mesmo, quem canta é o protagonista da história):

Ou a dublada:

Fiquei na dúvida... :P

Até mais!

Dicas de programação: Reescrevendo operadores em Swift

Para reescrever operadores em Swift é bem simples: basta criar uma função estática com o "nome do operador", seus parâmetros e seu retorno (por exemplo, se for o operador ==, tenho dois parâmetros para comparar e um retorno do tipo booleano):

//Estrutura que guarda os dados de uma pessoa
struct Pessoa {
    //Nome da pessoa
    var nome: String
    //Idade da pessoa
    var idade: Int
    
    //Reescrevendo o operador ==
    static func ==(_ first: Pessoa, _ second:Pessoa) -> Bool {
        //Comparo o nome e a idade, se os dois forem iguais, retorno true, senão, retorno false
        return first.nome == second.nome && first.idade == second.idade
    }

}

//Crio os dados de uma pessoa
let pessoa1 = Pessoa(nome: "Ricardo Takemura", idade: Int.max)
//Crio os mesmos dados (em outro objeto)
let pessoa2 = Pessoa(nome: "Ricardo Takemura", idade: Int.max)
//Comparo um com o outro, se for igual exibo "{dado1} é igual que {dado2}" senão "{dado1} é diferente que {dado2}"
print("\(pessoa1) é \(pessoa1 == pessoa2 ? "igual" : "diferente") que \(pessoa2)")

Legal, não?

Até mais!

Dicas de programação: Estruturas/Objetos anônimos em Swift

Quantas vezes a gente não teve preguiça de criar um objeto/estrutura para guardar dois ou três dados...

Pois é, existe um jeito de criar um objeto no Swift sem ter que declara-lo! E é muito fácil: basta declarar as "propriedades" dentro de parênteses "()". Por exemplo:

//Função que retorna "meu dados" (nome do tipo String e idade do tipo Int)
func me() -> (nome: String, idade: Int) {

     //Retorno meu nome e idade (estou velho...)
    return (nome: "Ricardo Takemura", idade: Int.max)
}

//Crio uma "constante" x com o retorno da função acima
let x = me()

//Exibo os campos nome e idade na tela
print("Nome: \(x.nome) Idade: \(x.idade)")

Legal, né?

Até mais!

Dicas de programação: Criando e chamando métodos de um "objeto anônimo" em Java

Eu já falei de classe anônima em algum post mais antigo... Geralmente, a gente implementa uma interface ou "herda" uma classe abstrata com a classe anônima e (também) implementa seus métodos. Mas, como seria se, por necessidade, eu quisesse incluir uma nova função em um objeto de uma classe já implementada?

Pois é, dá para fazer isso com o uso da mesma técnica:

import java.util.*;
import java.io.*;

public class Teste {

     //Método principal
     public static void main(String[] args) throws Exception {
          Object objeto = new Object() {

               //Propriedade privada
               private String helloWorld = "Hello World";

               //Método público
               public String talk() {
                        return helloWorld;
               }

               //Método público que existe na classe Object
               public String toString() {
                        return helloWorld;
               }
          };

          //Chamando o método toString da classe Object e exibindo seu resultado
          System.out.println(objeto.toString());

          //Chamando o método que não existe na classe Object mas que existe na "classe anônima"
          String ret = objeto.getClass().getDeclaredMethod("talk").invoke(objeto).toString();

          //Exibindo o resultado
          System.out.println(ret);
    }
}

Loucura, não? :P

Até mais!

Alguém se lembra: Rastan para Master System?

Um guerreiro bárbaro precisando salvar seu mundo de criaturas diabólicas!

"Conan?" -- você pensaria.

"Nope, Rastan para Master System!" -- eu responderia. :)

Rastan é um dos poucos jogos para Master System que não foi reprogramado ou criado pela SEGA e sim pela Taito Corporation.

Baseado em um arcade da própria empresa, consiste em controlar um bárbaro que precisa percorrer sua terra atrás de seres malignos. (Grande estória? Claro que não! Quem, nos anos 90, se importava com estória?)

Com jogabilidade simples (e travada), é um game legal para se jogar em um fim-de-semana.

Vale muito mais pela nostalgia.

Abaixo, uma jogatina feita pelo canal World of Longplays:

Até mais!

Cultura em Campinas?

Bem, eu já fiz um post parecido com este em 2011 (eu acho). Mas só queria atualizar. :)

Museu do esporte de Campinas:
https://www.facebook.com/pages/Museu-Do-Esporte-De-Campinas/186022495197948

Museu aberto de astronomia:
https://www.facebook.com/museuabertodeastronomia/

Museu de arte contemporânea de Campinas:
https://www.facebook.com/MAC-CAMPINAS-1659900337557500/

Museu da imagem e do som de Campinas:
https://www.facebook.com/campinasMIS/

Instituto cultural Nipo Brasileiro:
https://www.facebook.com/nipocampinas

Casa de Portugal:
https://www.facebook.com/casadeportugalcamp/

Instituto CPFL:
http://www.institutocpfl.org.br/

SESC Campinas:
https://www.sescsp.org.br/unidades/16_CAMPINAS/#/uaba=programacao#/fdata=id%3D16

Dicas de programação: Extensões em C#

Uma vez, eu escrevi de como fazer extensões em Swift (iOS).

Pois é, agora eu descobri que dá para fazer algo semelhante em C#:

using System;

///Usado para fazer extensões
using System.Linq;

namespace Teste
{
    /// 

    /// Classe estática para extensão do tipo/classe int

    ///

    public static class IntExtension
    {
        ///

        /// Converte um número decimal em binário (String)
        ///

        /// Número a ser convertido (this)
        /// String com o valor em formato binário
        public static String ToBinary(this int number)
        {
            String str = "";
            do
            {
                int rest = number % 2;
                str = rest.ToString() + str;
                number = number / 2;
            }
            while (number > 0);
            return str;
        }
    }
  
  class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine("Dois em binário: {0}", 2.ToBinary());
            Console.ReadKey();
        }
    }
}

Esta certo que converter um número em binário desta forma é meio "arcaico", mas sou um programador raiz. (ou Nutella, em alguns casos... :P)

Até mais!

Dicas de programação: Reescrevendo operadores em C#

A coisa mais estranha e legal é quando uma linguagem deixa sobrescrever operadores (tipo mais [+] ou vezes [*]).

Podemos fazer barbaridades com isso... Por exemplo, dizer que uma mesma variável não é igual a ela mesma!

Sim, dá para fazer isso em C#:

using System;
namespace Teste
{
    class Program
    {
        ///

        /// Reescrevendo o operador de comparação "igual" (==) da classe Program
        ///

        /// O primeiro objeto a ser comparado
        /// O segundo objeto a ser comparado
        /// Sempre false
        public static Boolean operator ==(Program p1, Program p2)
        {
            //Em qualquer situação, retorno false
            return false;
        }

        ///

        /// Reescrevendo o operador de comparação "diferente" (!=) da classe Program
        ///

        /// O primeiro objeto a ser comparado
        /// O segundo objeto a ser comparado
        /// Sempre true
        public static Boolean operator !=(Program p1, Program p2)
        {
            //Em qualquer situação, retorno true
            return true;
        }

        static void Main(string[] args)
        {
            Program p = new Program();
            Console.WriteLine("Este programa é igual a ele mesmo? " + (p == p ? "Sim" : "Não"));
            Console.ReadKey();
        }
    }
}

Ele sempre vai dizer que p não é igual a p (ou seja, p == p dá false).

Bizarro, não?

Até mais!

Testes automatizados para .Net: SpecFlow

Sabe o Cucumber?

Bem, se você não sabe, é uma ferramenta de automação aonde você escreve os cenários (com linguagem natural) e ele vai executando este conforme seu passo a passo. (mágico? bem, eu diria que nem tanto....)

Então, tem gente que gosta, tem gente que detesta (eu até gostaria, se me pagassem bem para "programar" nele... :P). Mas você sabia que existe uma ferramenta parecida para .Net?

Pois é, e se chama SpecFlow:

https://specflow.org/

Obs.: Se é bom? Então... Depende do gosto (e de quão custoso é configurar ele e o ambiente de teste).
Obs. 2: Hum... Já disse que mudei de linguagem este semana? Agora sou programador .Net! :)

Até mais!

Alguém se lembra: El Hazard?

Sabe aqueles animes que passavam na Band e que mal a gente sabia que passavam (tipo Tenchi Muyo!)?

Pois é, dentre estes, tinha um que era baseado em um tema que não era nada comum para um desenho japonês (tipo, coisas árabes, como as histórias das "Mil e uma noites").

Ele se chamava El Hazard:

É uma animação muito louca (se bem que TODA coisa japonesa é meio LOUCA), que contava a história dos estudantes (e um professor) que foram transportados para um reino cheio de magia, aonde, sem a menor explicação, eles recebem poderes sobrenaturais.

Muitas confusões e aventuras (sim, tipo "Sessão da Tarde") acontecerão com nosso protagonista e seus amigos. (e inimigos -- sendo que um deles é um dos colegas de escola dele!)

Abaixo, a abertura mostrada no saudoso Band Kids:

Obs.: Se é divertido? É. Se dá para entender alguma coisa? Bem, ai você esta pedindo demais... :P

Até mais!