Fácil, é só deixar ele serializavel:
using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
public class Program
{
//Classe que representa dados de uma pessoa
[Serializable()]
public class Pessoa {
public string Nome { get; set; }
public int Idade {get; set; }
public static explicit operator String(Pessoa p)
{
return String.Format("Nome: {0} Idade: {1}", p.Nome, p.Idade);
}
}
public static void Main()
{
//Se arquivo Data.bin existe...
if (File.Exists("Data.bin"))
{
//Leio os dados gravados nele e transformo em um objeto do tipo Pessoa
Stream stream = File.OpenRead("Data.bin");
BinaryFormatter binary = new BinaryFormatter();
Pessoa p = (Pessoa) binary.Deserialize(stream);
stream.Close();
Console.WriteLine(String.Format("Lendo - {0}", (String)p));
}
//Se o arquivo não existe...
else
{
//Crio os dados do objeto do tipo Pessoa e gravo ele no arquivo Data.bin
Pessoa p = new Pessoa();
p.Nome = "Me";
p.Idade = 18;
Stream stream = File.Create("Data.bin");
BinaryFormatter binary = new BinaryFormatter();
binary.Serialize(stream, p);
stream.Close();
Console.WriteLine(String.Format("Escrevendo - {0}", (String)p));
}
}
}
Obs.: Sempre que um objeto precisa ser "gravado"/"transportado", seja na rede ou no arquivo (binário, xml ou json), ele precisa ser serializado.
Até mais!
Mostrando postagens com marcador C#. Mostrar todas as postagens
Mostrando postagens com marcador C#. Mostrar todas as postagens
quinta-feira, 6 de junho de 2019
sexta-feira, 14 de dezembro de 2018
Dicas de Programação: Parâmetros nomeados em C#
Sabe aquelas funções que tem n parâmetros que tem que passar, mas que você só quer passar uma e todas as outras são nulas (ou valores "default").
Então, dá para fazer isso em C#, com parâmetros nomeados na função. Por exemplo:
using System;
public class Program
{
public static int soma(int i = 2, int j = 1) {
return i + j;
}
public static void Main()
{
Console.WriteLine("Soma: " + soma(10));
Console.WriteLine("Soma: " + soma(10, 5));
Console.WriteLine("Soma: " + soma(i: 10));
Console.WriteLine("Soma: " + soma(j: 10));
}
}
Se você ver, ao passar um valor nomeado (seja "i" ou seja "j") a outra variável vai estar atribuído com o valor default (o que esta depois do igual, na função).
Legal, né? (Ah... Sim, isso funciona no Swift e no Kotlin)
Até mais!
Então, dá para fazer isso em C#, com parâmetros nomeados na função. Por exemplo:
using System;
public class Program
{
public static int soma(int i = 2, int j = 1) {
return i + j;
}
public static void Main()
{
Console.WriteLine("Soma: " + soma(10));
Console.WriteLine("Soma: " + soma(10, 5));
Console.WriteLine("Soma: " + soma(i: 10));
Console.WriteLine("Soma: " + soma(j: 10));
}
}
Se você ver, ao passar um valor nomeado (seja "i" ou seja "j") a outra variável vai estar atribuído com o valor default (o que esta depois do igual, na função).
Legal, né? (Ah... Sim, isso funciona no Swift e no Kotlin)
Até mais!
sexta-feira, 21 de setembro de 2018
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!
//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!
terça-feira, 11 de setembro de 2018
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!
Pois é, agora eu descobri que dá para fazer algo semelhante em C#:
using System;
///Usado para fazer extensões
using System.Linq;
namespace Teste
{
///
public static class IntExtension
{
///
/// Converte um número decimal em binário (String)
///
/// Número a ser convertido (this)
///
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!
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
///
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
///
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!
Assinar:
Postagens (Atom)