Continuando a serie sobre fundamentos do .NET Framework 2.0, vamos falar sobre user-defined types.
Os tipos User-Defined são chamados de
estruturas ou structs.
As structs são tipos por valor, na maioria das vezes se
parecem muito com uma classe, a única diferença é que ela é armazenada na pilha
como se fosse um objeto referenciado por valor
Structs são agrupamentos de dados que facilitam o trabalho.
Por exemplo, o System.Drawing.Point , que é uma estrutura que contem as coordenadas
X e Y de um ponto qualquer.
Você poderia perfeitamente criar uma variável inteira para X
e outra para Y, mas agrupa-las numa struct provê uma forma mais fácil de
trabalhar com as coordenadas, dando a possibilidade de usar um construtor por
exemplo.
System.Drawing.Point
ponto = new System.Drawing.Point(100,200);
Como se pode observar, a forma de se trabalhar com struct é
idêntica a um classe. Para declarar uma estrutura, é usada a palavra reservada struct em C#.
Segue um exemplo de struct:
struct ponto{
int X, Y;
//campos - atributos
//Construtor
que recebe as coordenadas X e Y como parametros
public ponto(int coordX, int
coordY){
X = coordX;
Y = coordY;
}
//Propriedade
que manipula a coordenada X
public int CoordenadaX{
get { return X; }
set { X = value; }
}
//Propriedade que manipula a
coordenada Y
public int CoordenadaY{
get { return Y }
set { Y= value; }
}
}
Como da para perceber, pode-se converter facilmente essa
struct para uma classe, a diferença é que ela passará a ser um tipo por
referencia e ocupará mais espaço na memória. Um tipo por valor, ocupa 4 bytes
para cada campo inteiro. No caso dessa struct ela teria o tamanho de 8 bytes,
já se fosse uma classe teria 16 bytes.
Structs são normalmente mais eficientes e
performáticas que classes, pois um tipo por valor tem melhor desempenho que
tipos por referencia.
Com esse segundo post, acabamos por aqui uma explicação breve e superficial sobre tipos por valor no .net framework 2.0, mas que pode orientar você que está começando seus estudos.
Olá galera!
Neste primeiro post no blog falarei sobre um tema que chama muito minha atenção: Segurança da Informação.
A idéia de falar sobre essas ferramentas surgiu enquanto eu realizava uma pesquisa para resolver alguns problemas com o Internet Information Server da empresa onde trabalho. Durante minha pesquisa, dei de cara com uma ferramenta chamada IIS Lockdown Tool que ajuda a reduzir a superfície de ataque ao IIS 6.0. A partir dela, fui descobrindo outras ferramentas da MS, vou apresentar algumas:
- IIS Lockdown Tool: Previne ataques a dispositivos não-utilizados, aumentando a segurança
http://www.microsoft.com/technet/security/tools/locktool.mspx (em Inglês)
- Microsoft Security Assessment Tool: Permite qua as organizações entendam e avaliem seus riscos.
http://www.microsoftsecurityassessment.com/ (em Inglês)
- Threat Modeling Tools: Ferramenta que ajuda a proteger sua aplicação utilizando modelagem.
http://msdn2.microsoft.com/en-us/security/aa570411.aspx (em Inglês)
- URL Security Scan: É uma ferramenta que restringe requisições HTTP maliciosas cheguem ao IIS.
http://www.microsoft.com/technet/security/tools/URLscan.mspx (em Inglês)
Existem outras ferramentas, mas vou apresentá-las em outra oportunidade.
[ ]'s
Moacir Filho
Fundamentos do Framework
Esse é o primeiro artigo de uma serie que irá falar sobre fundamento do .NET Framework 2.0 utilizando C#.
O objetivo é falar de alguns pontos importantes do framework para quem está começando com .NET 2.0
Grande parte do conteúdo foi baseado no livro Microsoft .NET FRAMEWORK 2.0 Application Development Foundation que serve de guia para prova 70-536 da Microsoft.
Vamos começar essa serie falando sobre algo muito básico. Os tipos por Valor e por Referencia.
Tipos por valor guardam diretamente os dados, enquanto tipos por referencia são apenas apontadores para alguma área de memória.
Os tipos por valor são guardados numa área de memória chamada stack(pilha), onde o runtime pode criar, ler, atualizar e deletar rapidamente, com o mínimo de sobrecarga.
Quando você copia um tipo por valor os dados da variável são copiados em outro ponto da pilha. Ficando assim armazenados em dois locais diferentes na pilha, se você altera um deles, o outro continua com o mesmo valor.
A vantagem mais obvia de se usar tipos por valor é a performance. Mais tarde discutiremos os ganhos com tipos por valor.
Existem 3 categorias básicas de tipos por valor
- Built-in
- User-Defined
- Enumeration
Built-in, são tipos fornecidos pelo .NET Framework. Todos os tipos numéricos básicos inclusos no .NET Framework, são tipos por valor.
Exemplos:
- sbyte
- byte
- short
- int
- uint
- long
- float
- double
*Nota do Livro*
Segundo os autores o runtime otimiza a performance dos inteiros de 32 bits ou seja, o int (System.Int32).
Para operações de ponto flutuante o recomendado seria double(System.Double), pois suas operações são otimizadas pelo hardware.
Alguns tipos não numéricos também são tipos por valor.
Exemplos:char (System.Char) bool(System.Boolean) date(System.DateTime)
Esses são os tipos mais comuns, porem existem outros tipos por valor que são fornecidos pelo framework.
Tipos por valor Built-in possuem construtores implícitos, por isso não há necessidade de se declarar com a palavra “new” como é feito com classes normais.
*Lembrando que todos as classes herdam de System.Object.*
Exemplos de inicialização em variáveis por valor.
int x; bool k = false;
double y = 10.2;
No .NET FRAMEWORK 2.0, temos um novo tipo por valor, o Nullable.
Esse tipo pode assumir 3 valores (true, false, null).
Pode ser aplicado em uma rotina onde os valores possíveis são true e false, mas que se deseja ter um controle sobre o campo.
Exemplo, se o usuário preencheu o campo então a variável receberá true ou false de acordo com o escolhido pelo usuário, mas se o usuário não preencheu o campo, então o valor fica null.
Existem também outras possibilidades para o uso do Nullable
Um exemplo de declaração:
Nullable<bool> b = null;
Em um futuro artigo iremos falar sobre essa sintaxe de declaração do Nullable, abordando Generics.
Por hoje ficaremos por aqui para que o post não fique muito extenso.
No proximo post continuaremos falando sobre tipos por valor e em seguida entraremos em tipos por referencia.
Espero que tenha ajudado a quem está começando com .NET e C#