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.

Linha de Código - Cadastro de um Consultório em Windows Forms, com C# e SQL Server – Parte 7

Linha de Código - Cadastro de um Consultório em Windows Forms, com C# e SQL Server – Parte 7

Posted using ShareThis

C# - Sintaxe e conceitos básicos

Pretendo com esse tuto... atender à muitas duvidas de colegas na Area de Programação em C - Sharp (C#).

Origem:www.macoratti.net

Declarando variáveis

Declarar variáveis em C# é simples , abaixo temos a diferentes formas de declarar variáveis em C#
int a;
double area = 0;
int salario, imposto , soma;
int contador = 10;

string nome;
string nomeCompleto = "Little John";

Estruturas de repetição ( Laços )
while

int i = 0;
while ( i < 5 )
{
Console.WriteLine ( i );
++i;
}

repete 5 vezes e imprime o valor de i.


Resultado do laço while:

0
1
2
3
4



for

int i = 0;
for ( int i = 0; i < 5; i++ )
{
Console.WriteLine ( i );
}


Resultado do laço For:

0
1
2
3
4


do ... while

int i = 0;
do
{
Console.WriteLine ( i );

i++;
}
while ( i < 5 );


O laço Do/While é quase igual ao laço While.

A única diferença é que o código dentro do laço será executado pelo menos uma vez pois a seguir é feita a verificação da condição.

foreach

string [] nomes = new string[] { "Macoratti", "Miriam"};
foreach ( string nome in nomes )
{
Console.WriteLine ( nome );
}




O laço - foreach - pode ser usado para iterar através de
uma coleção como um array , ArrayList ,etc.

A saida para o laço é :

Macoratti
Miriam


Operadores Condicionais

if ... else


string nome = "Macoratti";
if ( nome == "Pedro" )
{
Console.WriteLine( "Você esta no bloco 'if'" );
}
else
{
Console.WriteLine( "Você esta no bloco 'else'" );
}


Operador usado para testar condições lógicas e executar a porção de código baseado na condição.

No exemplo se o nome definido for igual a 'Pedro' teremos: Você esta no bloco 'if'

Se o nome definido não for igual a 'Pedro' , teremos:
Você esta no bloco 'else'

Controle de fluxo em laços

break

string [] nomes = new string[] { "Macoratti", "Miriam", "Pedro"};
foreach ( string nome in nomes )
{
Console.WriteLine ( nome );

if ( nome == "Miriam" )
break;
}


O comando break é usado para a saída de laços ( while, for , switch, etc..)

No exemplo ao lado quando o nome for igual a 'Miriam' haverá a saída do laço devido ao comando break;

A saida será:

Macoratti
Miriam

continue


string [] nomes = new string[] { "Macoratti", "Miriam", "Pedro"};
foreach ( string nome in nomes )
{
if ( nome == "Miriam" )
continue;
Console.WriteLine ( nome );
}

O comando continue também é usado em laços(while, for, etc.) quando em execução o comando continue irá mover a execução para o próxima iteração no laço sem executar as linhas de código depois de continue.

No exemplo a saída será:

Macoratti
Pedro

switch

int i = 6;

switch ( i )
{
case 5:
Console.WriteLine( "Valor de i é : " + 5 );
break;
case 6:
Console.WriteLine( "Valor de i é : " + 6 );
break;
case 4:
Console.WriteLine( "Valor de i é : " + 4 );
break;
default:
Console.WriteLine( "Valor de i é : " + i );
break;
}

O comando Switch é uma boa opção se você tiver que escrever muitas condições if..else.

No exemplo , dependendo do valor do item condicional o código do case apropriado será executado.

A saída para o exemplo será:

Valor de i é : 6

Note que usamos instruções break para sair do bloco. Sem isto o próximo bloco Case seria executado.

Se você chegou até aqui nesta pequena introdução 'light' sobre conceitos básicos da linguagem C# parabéns. Creio que concordará comigo que C# é mais fácil do que parece.

C# - Caracteristicas

Origem: Wikipedia

C# é uma linguagem de programação orientada a objectos criada pela Microsoft, faz parte da sua plataforma. NET. A empresa baseou C# nas linguagens C++ e Java, e ela é considerada a linguagem símbolo do. NET, por ter sido criada praticamente do zero para funcionar na nova plataforma, sem preocupações de compatibilidade com código existente. O compilador C# foi o primeiro a ser desenvolvido, e a maior parte das classes da plataforma foram desenvolvidas nesta linguagem.


O C# é constituído por diversificadas características. Por exemplo, a linguagem suporta ponteiros através da palavra reservada unsafe (código não-seguro), que é obrigatório. Seu uso não é aconselhável, e blocos de códigos que o usam geralmente requisitam permissões mais altas de segurança para poderem ser executados. As operações aritméticas são verificadas contra transbordamento de dados. C# também suporta as operações aritméticas básicas como adição, subtracção, multiplicação e divisão. Esses símbolos são chamados operadores, e "operam" os valores das variáveis.

Um colector de lixo também é suportado, um processo usado para a manutenção de memória. Com este recurso, é possível recuperar a zona de memória que um programa já não utiliza. Quando isto não ocorre pode acontecer a chamada perda de memória, um erro comum que pode levar ao término não desejado do programa em execução por esgotamento da memória livre.

Em C# não existe herança múltipla, ou seja, cada classe só pode herdar apenas uma outra classe e não mais do que uma, no entanto é possível simular herança múltipla utilizando interfaces. Assim, através da herança reduzimos código através da sua reutilização.

Os destrutores são funções que se encarregam de realizar as tarefas que são necessárias executar quando um objecto deixa de existir. Quando este já não está a ser utilizado por nenhuma variável, deixa de ter sentido que esteja armazenado na memória, portanto, o objecto deve ser destruído para liberar espaço. Para isto é chamada a função destrutor. Os destrutores não podem ser definidos em estruturas, são apenas usados em classes, e uma classe pode apenas ter um destrutor, eles não podem ser herdados ou sobrecarregados, nem podem ser chamados pois são invocados automaticamente. Também não pode ser modificado nem de algum modo ter parâmetros.

O C# suporta sobrecarga de métodos e de operadores, mas não suporta argumentos padrão. As únicas conversões implícitas por padrão são conversões seguras tais como, a ampliação de inteiros e conversões de um tipo derivado para um tipo base. Não existem conversões implícitas entre inteiros e variáveis booleanas, enumerações e ponteiros nulos. Qualquer conversão implícita definida pelo utilizador deve ser explicita, apesar do C# ser baseado em variáveis estáticas é possível converter os tipos de dados de uma variável, desde que essa conversão seja possível, pode ser convertido qualquer tipo primitivo para string, mas nem sempre é possível o contrário. Uma string que representa um número pode ser convertida para um tipo numérico, um número pode sempre ser convertido para um número com mais bits, exemplo, um tipo byte (8 bits) pode ser convertido para um do tipo int (32 bits). O contrário nem sempre é possível, de um tipo com mais bits para representá-lo para um com menos bits. Desde que o valor não exceda o limite do tipo menor, a conversão ocorrerá sem problemas, senão a execução lança uma excepção. Nas conversões que sempre poderão acontecer, o mesmo é feito automaticamente, sem precisar "forçar" nenhuma dessas conversões. A forma mais simples de efectuar a conversão é usando a classe Convert, que implementa vários métodos que permite a conversão de qualquer tipo para outro. Todas as conversões de tipo são validadas em função do tipo real da variável em tempo de execução, sem excepções.

Existem diversos mecanismos para criação de novos tipos de dados a partir de tipos já existentes. Um desses mecanismos permite a criação de vectores. Os vectores são todos derivados de uma mesma classe do ambiente .NET, o que significa compartilhar várias operações, métodos e atributos. Os objectos e vectores são necessariamente alocados dinamicamente na memória heap (área de memória reservada) com o uso do operador new.

Os gabaritos não são suportados, mas a linguagem possui um suporte abrangente a generics. Nela podem se usar tipos genéricos para a maximização da reutilização de código, segurança de tipo, e desempenho. A utilização mais frequente é para a criação de classes. Pode criar as suas próprias interfaces genéricas, métodos, classes, eventos e delegates. As classes genéricas podem ser utilizadas para permitir acesso aos métodos usando tipos de dados específicos. Informações sobre os tipos usados em um tipo de dados genérico podem ser obtidas em tempo de execução por meio de reflexão.

Passagem de parâmetros

Há três tipos de passagem de parâmetros em C#, por valor, por referência e por saída. Na passagem por valor é feita uma cópia do argumento da chamada do método para o parâmetro do mesmo. Isso significa que as alterações que ocorrem nas variáveis passadas por cópia dentro do método não se reflectem fora dele. Na passagem por referência toda alteração feita na variável passada por referência dentro do método alterará também seu valor fora dele.

Por padrão todo objecto e vector são passados por referência e toda estrutura e variáveis primitivas são passadas por valor. Para se forçar a passagem por referência, tanto a chamada do método como a declaração dele devem estar com os argumentos e parâmetros precedidos pelas palavras reservadas ou ref ou out. A primeira é usada para se manipular um parâmetro já inicializado antes da chamada do método, de forma a somente editá-lo. A segunda é usada para se inicializar um parâmetro durante a execução do método, retornando o resultado para o método que o chamou.

As 11 regras de Bill Gates

Por essas caminhadas na net achei e gostei
as 11 regras do tio Bill

1. A vida não é fácil — acostume-se com isso.
2. O mundo não está preocupado com a sua auto-estima. O mundo espera que você faça alguma coisa útil por ele ANTES de sentir-se bem com você mesmo.
3. Você não ganhará R$20.000 por mês assim que sair da escola. Você não será vice-presidente de uma empresa com carro e telefone à disposição antes que você tenha conseguido comprar seu próprio carro e telefone.
4. Se você acha seu professor rude, espere até ter um chefe. Ele não terá pena de você.
5. Vender jornal velho ou trabalhar durante as férias não está abaixo da sua posição social. Seus avós têm uma palavra diferente para isso: eles chamam de oportunidade.
6. Se você fracassar, não é culpa de seus pais. Então não lamente seus erros, aprenda com eles.
7. Antes de você nascer, seus pais não eram tão críticos como agora. Eles só ficaram assim por pagar as suas contas, lavar suas roupas e ouvir você dizer que eles são “ridículos”. Então antes de salvar o planeta para a próxima geração querendo consertar os erros da geração dos seus pais, tente limpar seu próprio quarto — adorei essa!
8. Sua escola pode ter eliminado a distinção entre vencedores e perdedores, mas a vida não é assim. Em algumas escolas você não repete mais de ano e tem quantas chances precisar até acertar. Isto não se parece com absolutamente NADA na vida real. Se pisar na bola, está despedido… RUA!!! Faça certo da primeira vez!
9. A vida não é dividida em semestres. Você não terá sempre os verões livres e é pouco provável que outros empregados o ajudem a cumprir suas tarefas no fim de cada período.
10. Televisão NÃO é vida real. Na vida real, as pessoas têm que deixar o barzinho ou a boate e ir trabalhar.
11. Seja legal com os CDFs (aqueles estudantes que os demais julgam que são uns babacas). Existe uma grande probabilidade de você vir a trabalhar PARA um deles.