Exchange 2010: High Availability and Disaster Recovery

Usando herança em C#

fonte: http://www.arquivodecodigos.net/dicas/c-csharp-usando-heranca-em-c-2505.html


Herança é um dos três princípios fundamentais da programação orientada a objectos porque ela permite a criação de hierarquia nos objectos que compõem o sistema. Em C#, uma classe que tem seus dados e métodos herdados por outra é chamada de classe base ou super classe e a classe que herda tais dados é chamada de classe derivada ou sub-classe.

O que um aluno, um professor e um funcionário possuem em comum? Todos eles são pessoas e, portanto, compartilham alguns dados comuns. Todos têm nome, idade, endereço, etc. E, o que diferencia um aluno de uma outra pessoa qualquer? Um aluno possui uma matrícula; Um funcionário possui um código de funcionário, data de admissão, salário, etc; Um professor possui um código de professor e informações relacionadas à sua formação.

É aqui que a herança se torna uma ferramenta de grande utilidade. Podemos criar uma classe Pessoa, que possui todos os atributos e métodos comuns a todas as pessoas e herdar estes atributos e métodos em classes mais específicas, ou seja, a herança parte do geral para o mais específico. Comece criando uma classe Pessoa como mostrado no código a seguir:

class Pessoa

{
  public string nome;
  public int idade;
}

Esta classe possui os atributos nome e idade. Estes atributos são comuns a todas as pessoas. Veja agora como podemos criar uma classe Aluno que herda estes atributos da classe Pessoa e inclui seu próprio atributo, a saber, seu número de matrícula. Eis o código:

class Aluno: Pessoa

{
  public string matricula;
}

Observe que, em C#, os dois-pontos são usados para indicar a herança. A classe Aluno agora possui três atributos: nome, idade e matricula. Veja um aplicativo demonstrando este relacionamento:

static void Main(string[] args)

{
  // cria um objeto da classe Aluno
  Aluno aluno = new Aluno();

  aluno.nome = "Osmar J. Silva";
  aluno.idade = 36;
  aluno.matricula = "AC33-65";

  // Exibe o resultado
  Console.WriteLine("Nome: " + aluno.nome + "\n" +
    "Idade: " + aluno.idade + "\n" +
    "Matrícula: " + aluno.matricula);

  Console.WriteLine("\n\nPressione uma tecla para sair...");
  Console.ReadKey();
}

A herança nos fornece um grande benefício. Ao concentrarmos características comuns em uma classe e derivar as classes mais específicas a partir desta, nós estamos preparados para a adição de novas funcionalidades ao sistema. Se mais adiante uma nova propriedade comum tiver que ser adicionada, não precisaremos efectuar alterações em todas as classes. Basta alterar a superclasse e pronto. As classes derivadas serão automaticamente actualizadas.

VARIÁVEIS E TIPOS DE DADOS

Fonte: http://www.juliobattisti.com.br/tutoriais/herbertgois/programandocsharp005.asp

 

Nomeando uma variável:

 
A documentação do Microsoft .Net Framework da as seguintes recomendações para a nomeação das variáveis:

• Evite usar underline;
• Não crie variáveis que apenas se diferenciem apenas pela sua forma. Exemplo: minhaVariavel e outra chamada MinhaVariavel;
• Procure iniciar o nome com uma letra minúscula;
• Evite usar todas as letras maiúsculas;
• Quando o nome tiver mais que uma palavra, a primeira letra de cada palavra após a primeira deve ser maiúscula (conhecido como notação camelCase);
• Não use notação Húngara.

Convenção PascalCasing

 
Para usar a convenção PascalCasing para nomear suas variáveis, capitalize o primeiro caractere de cada palavra. Exemplo:
 
void InitializeData();
 
A microsoft recomenda usar o PascalCasing quando estiver nomeando classes, métodos, propriedades, enumeradores, interfaces, constantes, campos somente leitura e namespaces.
 

Convenção camelCasing

 
Para usar esse tipo de convenção, capitalize a primeira letra de cada palavra menos da primeira. Como o exemplo:
 
int loopCountMax;
 
A Microsoft recomenda usar essa convenção na nomeação de variáveis que definem campos e parâmetros.
 
Para maiores informações sobre convenção de nomes pesquise “Naming Guidelines”, na documentação do Visual Studio.
 

Palavras reservadas:

 
A linguagem C# reserva setenta e cinco palavras para seu próprio uso. Estas palavras são chamadas de palavras reservadas e cada uma tem um uso particular.
 
Palavras reservadas também não são permitidas como nome de variáveis.
 
Segue uma lista que identifica todas estas palavras:
 

abstract	as	base	Bool
break	byte	case	Catch
char	checked	class	Const
continue	decimal	default	Delegate
do	double	else	Enum
event	explicit	extern	false
finally	fixed	float	for
foreach	goto	if	implicit
in	int	interface	internal
is	lock	long	namespace
new	null	object	operator
out	override	params	private
protected	public	readonly	ref
return	sbyte	sealed	short
sizeof	stackalloc	static	string
struct	switch	this	throw

 
No painel de código do Visual Studio .NET as palavras reservadas são identificadas pela cor de letra azul.
 

Declarando variáveis:

 
Antes de usar uma variável é necessário declará-la. Neste momento alucamos espaço para esta variável na memória e dizemos que tipo de dado pode ser armazenado nela. O tipo de dado indica qual o tamanho do espaço vai ser reservado para a variável.
 
O C# pode armazenar diferentes tipos de dados: como inteiros, números de ponto flutuante, textos e caracteres. Assim que declaramos uma variável precisamos identificar que tipo de dado ela armazenará.
 
Declaramos especificando o tipo de dado seguido do nome da variável como no exemplo:
 
int contador;
 
Esse exemplo declara uma variável chamada contador do tipo integer. Ou seja ela deverá armazenar números inteiros, mais a frente estudaremos melhor o que armazenar em cada tipo de dado.
 
Podemos também declarar múltiplas variáveis de uma vez, fazemos isso da seguinte maneira:
 
int contador, numeroCarro;
 
Estamos declarando nesse exemplo duas variáveis do tipo integer, uma chamada contador e a outra numeroCarro.
 

Atribuindo valor a variáveis ;

 
Depois de declarar sua variável você precisa atribuir um valor a ela. No C# você não pode usar uma variável antes de colocar um valor nela, isso gera um erro de compilação.
 
Exemplo de como atribuir um valor a uma variável:
 
int numeroFuncionario;
 
numeroFuncionario = 23;
 
Primeiro nos declaramos nossa variável do tipo integer. Depois atribuímos o valor 23 a ela. Entendemos pelo sinal de igual como recebe. Assim numeroFuncionario recebe 23.
 
Podemos também atribuir um valor a variável quando a declaramos, dessa forma:
 
int numeroFuncionario = 23;
 
Isso faz a mesma coisa que o exemplo anterior, só que tudo em uma linha.
 
Mais um exemplo:
 
char letraInicial = ‘M’;
 

Tipos de variáveis:

 
A seguinte tabela mostra os tipos do C# com sua referencia no Framework.
 
Os tipos da tabela abaixo são conhecidos como tipos internos ou Built-in.
 

C# Type	.NET Framework type
bool	System.Boolean
byte	System.Byte
sbyte	System.SByte
char	System.Char
decimal	System.Decimal
double	System.Double
float	System.Single
int	System.Int32
uint	System.UInt32
long	System.Int64
ulong	System.UInt64
object	System.Object
short	System.Int16
ushort	System.UInt16
string	System.String

 
Cada tipo no C# é um atalho para o tipo do Framework. Isso quer dizer que se declararmos a variável desta forma:
 
string nome;
 
ou dessa forma
 
System.String nome;
 
teremos o mesmo resultado. O atalho serve apenas para facilitar na hora de desenvolver a aplicação.
 
A seguinte tabela mostra os tipos de variáveis e os valores possíveis de se armazenar em cada uma delas.
 

C# Type	Valores possíveis de se armazenar
bool	Verdadeiro ou Falso (Valores booleandos)
byte	0 a 255 (8 bits)
sbyte	-128 a 127 (8 bits)
char	Um caractere (16 bits)
decimal	±1.0 × 10−28 a ±7.9 × 1028 (128 bits)
double	±5.0 × 10−324 a ±1.7 × 10308 (64 bits)
float	±1.5 × 10−45 a ±3.4 × 1038 (32 bits)
int	-2,147,483,648 a 2,147,483,647 (32 bits)
uint	0 a 4,294,967,295 (32 bits)
long	–9,223,372,036,854,775,808 a 9,223,372,036,854,775,807 (64 bits)
ulong	0 a 18,446,744,073,709,551,615 (64 bits)
object	Qualquer tipo.
short	-32,768 a 32,767 (16 bits)
ushort	0 a 65,535 (16 bits)
string	Seqüência de caracteres (16 bits por caractere)

 
Todos os tipos na tabela com exceção dos tipos object e string são conhecidos como tipos simples.
 
Para retornar o tipo de qualquer variável do C# você pode usar o método GetType(); Como no exemplo:
 
Console.WriteLine(minhaVariavel.GetType());
 
Isso retornaria o tipo da variável minhaVariavel.
 
Para maiores informações sobre tipos de variáveis consulte a documentação do Visual Studio por “data types”.
 

Adicionando valor a uma variável :

 
É muito comum precisarmos adicionar ou subtrair valores de uma variável usando no calculo o valor que já esta armazenado na mesma.
 
O código seguinte declara uma variável do tipo integer chamada contador e armazena o valor 2 nesta variável, depois incrementa o valor 40:
 
int contador;
contador = 2;
contador = contador + 40;
 
No final do código acima a variável contador tem qual valor?
 
A resposta é 42, claro, criamos a variável, adicionamos o valor 2 nela e após, pegamos o valor dela (que era 2) e adicionamos 40, e armazenamos o valor na mesma.
 
Preste atenção na seguinte linha de código:
 
contador = contador + 40;
 
Perceba que para somar o valor a variável precisamos repetir o nome da variável.
 
Podemos fazer da seguinte forma também em C#:
 
contador += 40;
 
Isso teria o mesmo resultado e é uma maneira mais elegante.
 
Você pode subtrair também valores, como o exemplo:
 
contador -= 23;
 
Isso subtrairia 23 do valor da variável.
 
Na verdade você pode fazer isso com todos os operadores aritméticos, como multiplicação e divisão também.
 
Para saber mais você pode consultar a documentação do Visual Studio e procurar por “assignment”.

Script (Primeira Prova de Programação)

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace PrimeiraProva
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

//Função para calcular a media
public float calcMedia(float primNota, float segNota, float tercNota, float quartNota)
{
float resultCalc = primNota - segNota - tercNota - quartNota;
return resultCalc;

}
//Botão que recebe os dados das caixas de textos e faz os calculos
private void btnCalcular_Click(object sender, EventArgs e)
{
//Variaveis que vão receber os valor e fazer casting
float varPrimNota = float.Parse(txtPrimNota.Text);
float varSegNota=float.Parse(txtSegNota.Text);
float varTercNota=float.Parse(txtTerceirNota.Text);
float varQuartNota = float.Parse(txtQuartNota.Text);
// Resultado
float resultTemp = calcMedia(varPrimNota, varSegNota, varTercNota, varQuartNota);

//Estrutura de controles
if (resultTemp < 8) { txtResult.Text = resultTemp.ToString() + "Não Apto"; } else if (resultTemp > 8 && resultTemp < 10) { txtResult.Text = resultTemp.ToString() + " Recurso"; } else if (resultTemp >= 10 && resultTemp < 14) { txtResult.Text = resultTemp.ToString() + " Exame"; } else if (resultTemp >= 14)
{
txtResult.Text = resultTemp.ToString() + " Apto";
}

else
txtResult.Text = resultTemp.ToString()+" Nota Muito Baixa";

}

// Botão que limpa as caixas de textos
private void button1_Click(object sender, EventArgs e)
{
txtPrimNota.ResetText();
txtSegNota.ResetText();
txtTerceirNota.ResetText();
txtQuartNota.ResetText();
txtResult.ResetText();

}
}
}

Topicos p/ Trabalho de Base de Dados

Segue no link abaixo os tópicos para o trabalho de Base de Dados

http://www.4shared.com/document/TP2PgsKD/Trab_Prof_Paulo_Doria.html

Tipos de dados no SQL Server

Posto uma dica que acho muito importante antes de começar criando tabelas em um banco de dados com o SQL, precisa-se saber os tipos de dados e sua declaração.

Artigo Original: http://imasters.uol.com.br/artigo/244/sql_server/tipos_de_dados_no_sql_server_parte_1

Créditos: Mauro Pichiliani

Antes de começar, vou mostrar como podemos criar uma tabela através da sintaxe básica da instrução SQL CREATE TABLE:

CREATE TABLE table_name

(
nome_campo tipo_dado [[NOT] NULL] ,
nome_campo1 tipo_dado [[NOT] NULL] ,
nome_campo2 tipo_dado [[NOT] NULL] ,
nome_campo3 tipo_dado [[NOT] NULL] ,
...
)

A instrução CREATE TABLE possui mais opções, porém a sintaxe básica que eu apresentei aqui está no padrão ANSI e pode ser utilizada para criar tabelas em outros bancos de dados como o Oracle, MySQL, DB, etc. Um exemplo de criação de uma tabela com dois campos:

CREATE TABLE Exemplo1

(
codigo INT NOT NULL ,
nome CHAR(30) NULL
)

A tabela chamada Exemplo1 foi criada com dois campos: codigo, do tipo INT e nome do tipo CHAR(30). Junto com o tipo de dados, devemos especificar se este campo permite ou não seu preenchimento com NULO (nulabilidade), que quer dizer ausência de dados. Se não especificarmos nada para o campo, por padrão o campo irá aceitar valores NULL.
Abaixo segue uma relação dos tipos de dados básicos do SQL Server, sendo que os tipos que estiverem marcados com
* somente funcionam a partir do SQL Server 2000

TINYINT: Valores numéricos inteiros variando de 0 até 256

SMALLINT: Valores numéricos inteiros variando de –32.768 até 32.767

INT: Valores numéricos inteiros variando de -2.147.483.648 até 2.147.483.647

* BIGINT: Valores numéricos inteiros variando de –92.23.372.036.854.775.808 até 9.223.372.036.854.775.807

BIT: Somente pode assumir os valores 0 ou 1. Utilizado para armazenar valores lógicos.

DECIMAL(I,D) e NUMERIC(I,D): Armazenam valores numéricos inteiros com casas decimais utilizando precisão. I deve ser substituído pela quantidade de dígitos total do número e D deve ser substituído pela quantidade de dígitos da parte decimal (após a vírgula). DECIMAL e NUMERIC possuem a mesma funcionalidade, porém DECIMAL faz parte do padrão ANSI e NUMERIC é mantido por compatibilidade. Por exemplo, DECIMAL(8,2) armazena valores numéricos decimais variando de – 999999,99 até 999999,99

Lembrando sempre que o SQL Server internamente armazena o separador decimal como ponto (.) e o separador de milhar como vírgula (,). Essas configurações INDEPENDEM de como o Windows está configurado no painel de controle e para DECIMAL E NUMERIC, somente o separador decimal (.) é armazenado

SMALLMONEY: Valores numéricos decimais variando de -214.748,3648 até 214.748,3647

MONEY: Valores numéricos decimais variando de -922.337.203.685.477,5808 até 922.337.203.685.477,5807
REAL: Valores numéricos aproximados com precisão de ponto flutuante, indo de
-3.40E + 38 até 3.40E + 38
FLOAT: Valores numéricos aproximados com precisão de ponto flutuante, indo de
-1.79E + 308 até 1.79E + 308
SMALLDATETIME: Armazena hora e data variando de 1 de janeiro de 1900 até 6 de junho de 2079. A precisão de hora é armazenada até os segundos.
DATETIME: Armazena hora e data variando de 1 de janeiro de 1753 até 31 de Dezembro de 9999. A precisão de hora é armazenada até os centésimos de segundos.

CHAR(N): Armazena N caracteres fixos (até 8.000) no formato não Unicode. Se a quantidade de caracteres armazenada no campo for menor que o tamanho total especificado em N, o resto do campo é preenchido com espaços em branco.

VARCHAR(N): Armazena N caracteres (até 8.000) no formato não Unicode. Se a quantidade de caracteres armazenada no campo for menor que o tamanho total especificado em N, o resto do campo não é preenchido.

TEXT: Armazena caracteres (até 2.147.483.647) no formato não Unicode. Se a quantidade de caracteres armazenada no campo for menor que 2.147.483.647, o resto do campo não é preenchido. Procure não utilizar este tipo de dado diretamente, pois existem funções específicas para trabalhar com este tipo de dado.

NCHAR(N): Armazena N caracteres fixos (até 4.000) no formato Unicode. Se a quantidade de caracteres armazenada no campo for menor que o tamanho total especificado em N, o resto do campo é preenchido com espaços em branco.

NVARCHAR(N): Armazena N caracteres (até 4.000) no formato Unicode. Se a quantidade de caracteres armazenada no campo for menor que o tamanho total especificado em N, o resto do campo não é preenchido.

NTEXT: Armazena caracteres (até 1.073.741.823) no formato Unicode. Se a quantidade de caracteres armazenada no campo for menor que 1.073.741.823, o resto do campo não é preenchido. Procure não utilizar este tipo de dado diretamente, pois existem funções específicas para trabalhar com este tipo de dado.