Css (Cascading Style Sheets) para iniciantes

O que significa a sigla CSS ?

CSS é a sigla para Cascading Style Sheet, que, em português, foi traduzido para folhas de estilo em cascata, e nada mais é do que um documento no qual são definidas regras de formatação de estilos a serem aplicadas aos elementos estruturais de marcação.

Qual é a finalidade das CSS ?

A finalidade das CSS é retirar do (X)HTML toda e qualquer declaração que vise a formatação ou á apresentação do documento. Isto significa dizer que as tags do tipo <font>, <bold>, <em>, <i> etc., bem como uso das colunas e linhas de tabelas para a obtenção de espaçamentos, não são admitidas ou admitidas com restrições em um projeto CSS. Simplificando, vale dizer: (X)HTML para estruturas e CSS para apresentar.

Por que devo usar CSS ?

CSS permite que você retire da marcação (X)HTML toda formatação ou apresentação do documento web. Quem vai determinar cores, formas, tipos e tamanhos, posicionamentos, e todo o visual da pagina são as CSS. As vantagens estão relatadas nas respostas a seguir.

Quais são as vantagens de usar CSS ?

Inúmeras são as vantagens de uso das CSS nos documentos web. Eis as principais:

• Controle total sobre a apresentação do site e a partir de um arquivo central;
• Agilização da manutenção de redesign do site;
• Saída para diferentes tipos de mídia a partir de uma versão única de (X)HTML;
• Redução do tempo de carga dos documentos web;
• Adequação simplificada aos critérios de acessibilidade e usabilidade;
• Elaboração de documento consistentes com as aplicações de usuários futuras;
• Aumento considerável na portabilidade dos documentos web;

As CSS estão de acordo com as Web Standards (Padrões da Web) ?

Sim estão. As CSS estão entre as praticas vivamente recomendadas pelo W3c, para projetos web. Os esforços dos órgãos normalizadores apontam no momento atual para elaboração de documentos web acessíveis, usáveis e portáveis com grande ênfase. Além do mais, as CSS facilitam e simplificam a obtenção destas três características.

O que é Seletor ?

Seletor é uma entidade que identifica um elemento (X)HTML ou entidade do DOM, na qual a regra de estilo ser a aplicada.
Por exemplo:

p {font-size:12px;}

Seletor ‘p’ (elemento (X)HTML paragrafo) e a regra CSS determinam que os paragrafor teram uma mesma fonte de tamanho 12px.

p, ul {font-size:10px;}

Os seletores são ‘p’ e ‘ul’.

O que é seletor do tipo classe ?

São tipos de seletores que podem ser escritos em tags de documentos (X)HTML eles podem estar em uma ou mais tags (X)HTML não importando sua repetição. Exemplo:

.minhaClasse
{
color: red;
}

<p class='minhaClasse'>

ou

<a class='minhaClasse'>

ou tambem

<span class='minhaClasse'>

O que são seletores do tipo ID ?

Seletores do tipo ID são iguais seletores de classe so que não pode se repetir, pois no documento (X)HTML cada tag deve ter um ID (nome) diferente e nenhum deve ser igual, através disso podemos estilizar uma tag (X)HTML pelo seu ID também mas somente aquela tag. Por Exemplo:

#minhaClasse
{
color: red;
font-size:12px;
font-family:"Arial", Helvetica, Tahoma;
}

<span id="minhaClasse">

Neste caso acima só pode ter uma tag com esse mesmo ID no documento inteiro mesmo que seja outro tipo de tag exemplo <a>, <ul>, <img>, so podemos ter uma no documento com esse mesmo ID ou mesmo nome, sendo assim estilizamos essa tag pela classe #minhaClasse, o símbolo # antes do nome da classe indica que este deve ser o nome do ID de uma tag dentro do documento web.

Entendendo o ciclo de vida de um Form (Windows Forms)

Neste post iremos aprender como é o ciclo de vida de um Form na plataforma descktop, ou seja Windows Forms, trabalharemos com delegates, EventHandler, objetos e eventos da classe System.ComponetModel, veremos em que momento são disparados eventos em tempo de vida de um Form como Closed, Closing, Activated, e Deactivated.

Uma breve explicação sobre o que é um “delegate”

Essencialmente um delegate é um objeto com segurança de tipo, ou seja, ele aponta para um método ou possivelmente uma lista de métodos, na aplicação, e que pode ser chamado no futuro, especificadamente um objeto delegate mantem três informações importantes:

O endereço do método no qual ele faz a chamada.
Os argumentos, se houver deste método.
O valor de retorno, se houver deste método.

Observação: Os delegates na plataforma .NET pode apontar para métodos estáticos e instancias.

Um delegate em .NET possui a capacidade de chamar método de maneira sincronizada ou assíncrona. Este fato simplifica e muito as tarefas de programação, já que podemos chamar um método de uma cadeia de execução dentro de nossa aplicação (Thread = Cadeia). Breve estarei publicando um post neste blog abrangendo mais a fundo o termo delegate e thread.

Criando a Aplicação para ver o ciclo de vida do Form

Se você programou interfaces de usuário utilizando o kit de ferramentas GUI, como Java Swing, Mac OS-X, ou API bruta Win32, você esta ciente que tipos “tipo janelas” possuem uma quantidade de eventos que disparam durante seu tempo de vida. O mesmo acontece com Windows Form. Como você viu a vida útil de um formulário começa quando o construtor de tipo é chamando antes de ser passado ao método Application.Run().  Assim que o objeto é alocado na Heap gerenciado, o framework dispara o evento Load. Dentro de um manipulador de evento Load, você é livre para configurar a aparência e funcionalidade do Form, preparar quaisquer controles filhos contidos (como ListBox, Treeviews e qualquer outro), ou simplesmente alocar recursos utilizados durante a operação Form, (conexões de banco, proxys para objetos remotos como Client-Server).

Uma vez disparado o evento Load, o próximo evento a ser disparado é o Activated (Ativado), esse evento será ativado quando o formulário receber o foco com a janela ativa na área de trabalho. A parte contraria digamos assim desse evento é o Deactivate (Desativado) que disparara varias vezes pelo tempo de vida de um Form qualquer, assim que o usuário navegar entre os aplicativos ativos. Suponha que o usuário escolheu fechar o formulário em questão, dois disparos em eventos focados em fechar: Closing e Closed. O evento Closing é disparado primeiro e é um lugar ideal para mostrar ao usuário final uma mensagem muito odiada (mas util): Voce tem certeza que deseja fechar este aplicativo. Esse passo adaptável é extremamente útil para assegurar que o usuário tenha uma chance de salvar quaisquer dados focados em aplicativo, antes de terminar o programa.

O evento Closing funciona como um delegado CancelEventHandler definido no namespace System.ComponetModel. Se você ajustar a propriedade CancelEventArgs.Cancel para true, você evitara que a janela seja destruída e a instruirá para retornar para a operação normal. Se você ajustar o CancelEventArgs.Cancel para false, o evento Closed disparará, o aplicativos Windows Form descarregara o AppDomain e p processo terminara. Para solidificar a sequencia de eventos que tomam lugar durante o tempo de vida do formulário, suponha que você tenha um novo projeto Windows Form chamando FormLifeTime e tenha renomeado o formulário inicial para MainWindow.cs (Através do Solution Explorer) agora dentro do seu construtor de formulário manipule o evento Load,

Activated
Deactivate
Closing
Closed

Observação: Para gerar automático o evento do delegado correto basta pressionar TAB duas vezes depois digitar +=

public MainWindow()
 {
 InitializeComponent();
// Delegados apontados para os Eventos do Formulario
 Closing += new CancelEventHandler(MainWindow_FormClosing);
 Load += new EventHandler(MainWindow_Load);
 Closed += new EventHandler(MainWindow_FormClosed);
 Activated += new EventHandler(MainWindow_Activated);
 Deactivate += new EventHandler(MainWindow_Deactivate);
 }

Dentro dos manipuladores de eventos Load, Closed, Activated, Deactivated, você estará atualizando o valor de uma nova variável membro string de nível de Form, que acaba de ser interceptada. Assim note que dentro do manipulador de evento Closed, você mostrara o valor dessa string dentro de uma caixa de mensagem:

// Evento ao carregar formulario
private void MainWindow_Load(object sender, EventArgs e)
{
lifeTimeInfo += ">>> Carregando \n";
}

// Evento quando o formulario é ativo
private void MainWindow_Activated(object sender, EventArgs e)
{
lifeTimeInfo += ">>> Ativado \n";
}

// Evento quando o formulario é desativado
private void MainWindow_Deactivate(object sender, EventArgs e)
{
lifeTimeInfo += ">>> Desativado \n";
}

// Evento quando o formulario é fechado
private void MainWindow_FormClosed(object sender, EventArgs e)
{
lifeTimeInfo += ">>> Fechado \n";
MessageBox.Show(lifeTimeInfo);
}

Dentro do manipulador de evento Closing, você induzira o usuário para assegurar que ele ou ela terminem o aplicativo utilizando o CancelEventArgs de chagada. No código seguinte, note que o método MessageBox.Show() retornará um tipo DialogResult, que contem um valor que representa qual o botão oi selecionado pelo usuário final. Dessa forma, produziremos  uma caixa de mensagem que mostrara Yes (Sim) e No (Não)  então, estamos interessados em descobri r se o valor de retorno de Show() será DialogResult.No.

// Evento quando o formulario esta sendo fechado ele é chamando antes do evento Closed
private void MainWindow_FormClosing(object sender, CancelEventArgs e)
{
lifeTimeInfo += "Fechando \n";
DialogResult dr = MessageBox.Show(this, "Você deseja realmente fechar esta janela", "Evento Fechando (Closing) deste Form", MessageBoxButtons.YesNo, MessageBoxIcon.Information);

// Qual dos Botoes foi clicado ?
if (dr == DialogResult.No)
e.Cancel = true;
else
e.Cancel = false;
}

Agora rode o aplicativo e mova o formulário para fora de foco algumas vezes (não dispare os eventos Activated e Deactivated). Uma vez desligado o aplicativo você vera uma caixa de mensagem que se parece como a figura a baixo:

Espero que tenham entendido os eventos em tempo de vida de um Form ou seja quando ele esta ativo na area de trabalho do usuario, varias coisas podem acontecer ao ativar, inativar, fechar um form, minimizar etc.

Abraços.
Até o próximo post.

Documentando seu Código Fonte em C# (Csharp) no Visual Studio 2008

Este post terá a finalidade de mostrar como documentar funções, métodos, atributos de uma classe em nosso dia-a-dia de desenvolvimento de software, utilizando os recursos do Visual Studio 2008. Quando desejar documentar seus tipos C# no Visual Studio 2008, seu primeiro passo é utilizar a nova notação de comentário de código com três barras “///”. Uma vez que um comentário da documentação tenha sido declarado, você tem liberdade para utilizar quaisquer elementos XML bem formados, inclusive o conjunto recomendado mostrado a baixo:

Elementos Pre-Definidos de Documento XML  e suas descrições

<c> – Indica que o texto a seguir deve ser uma “fonte de código” especificada.
<code> -Indica que varias linhas devem ser marcadas como código.
<exemple> – Cria um exemplo de código para o item que esta sendo descrito.
<exception> – Documenta quais exceções uma determinada classe pode gerar.
<list> – Insere uma lista ou tabela ao arquivo de documentação.
<param> – Descreve um determinando parâmetro.
<paramref> – Associa uma terminada Tag XML com um parâmetro especificado.
<permission> – Documenta os limites de segurança para um determinado membro.
<remarks> – Constrói uma descrição para um determinado membro.
<returns> – Documenta o valor de retorno do membro.
<see> – Faz referencia cruzada aos itens do documento.
<seealso> – Constrói uma seção “See Also” ou “Veja Também” em uma descrição.
<summary> – Documenta o “Resumo Executivo” para um determinado membro.
<values> – Documenta uma determinada propriedade.

Exemplo sem passagem de parâmetro e sem retorno

/// <summary>
/// Abre a Conexao com o banco de dados ou exibe o erro caso a base esteja
/// inconsistente
/// </summary>
private static void abreConexao()
{
    try
    {
       conn.Open(); //Abre a conexão com BD
    }
    catch (Exception e)
    {
       throw new Exception("Erro ao abrir a conexão: " + e.Message);
    }
}

Exemplo com passagem de parâmetros e com retorno do membro

/// <summary>
/// Executa uma query SELECT considerando os parâmetros (SqlParameter)
/// </summary>
/// <param name="query">Query a ser executado no banco de dados</param>
/// <param name="parameters">Parâmetros da query (Ex. "@cod, @num, @nome") etc.</param>
/// <returns>Retorna o DataSet da query executada</returns>
public static DataSet seleciona(string query, params SqlParameter[] parameters)
{
    try
    {
        DataSet ds = new DataSet();
        abreConexao();

        SqlCommand cmd = new SqlCommand(query, conn);
        foreach (SqlParameter param in parameters)
        cmd.Parameters.Add(param);
        SqlDataAdapter da = new SqlDataAdapter(cmd);
        da.Fill(ds); //Preenche DataSet
        cmd.Parameters.Clear();
        return ds;  //Retorna o DataSet já contendo os dados
    }
    catch (Exception e)
    {
        throw new Exception("Erro ao selecionar query " + query + "\n" + e.Message);
    }
    finally
    {
        fechaConexao();
    }
}

Bom esse post foi bem simples, com a finalidade de mostrar os recursos disponíveis pelo Visual Studio 2008 para documentação de código, para quem é desenvolvedor, vale uma dica, se atente em documentar pela tabela acima mostrada neste post, fica mais organizado e profissional.

Abraços até a próxima.