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.

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.

Entendendo e utilizando construtores de classes em C# (CSharp)

1º O papel do construtor padrão

Cada classe em C# é fornecida com um construtor padrão gratuito, que pode ser redefinido se for necessário. Por definição, um construtor padrão nunca aceita argumentos. Além de alocar o novo objeto na memoria, o construtor padrão garante que todos os dados de campos configurados, para um calor padrão adequado. Se não estiver satisfeito com estas atribuições padrão, pode redefinir o construtor padrão de acordo com suas necessidades. Para ilustrar veja a classe abaixo:

class Carro
{
    public string Nome;
    public int VelocidadeCorrente;

    public Carro()
    {
        Nome = "GOLF GTI 1.8";
        VelocidadeCorrente = "60";
    }
}

Neste caso estamos forçando todos os objetos Carro a começar sua vida com o nome “GOLF GTI 1.8”, com a velocidade corrente de 60 km. Assim consegue criar um objeto Carro configurado para os seguintes valores padrão:

static void Main(string[] args)
{
    // Chamando o construtor padrao
    Carro CarroA = new Carro();

    // Imprimi a velocidade corrente de 60 km/h
    Console.Write(CarroA.VelocidadeCorrente);
}

2º Definindo construtores padrão

Tipicamente as classes definem construtores adicionais além do padrão. Ao fazer isso, você oferece ao usuário do objeto uma maneira simples e consistente para inicializar o estado de um objeto diretamente no momento da criação. Considere a seguinte atualização da classe “Carro” que agora ira suportar um total de três construtores de classe:

class Carro
{
    public string Nome;
    public int VelocidadeCorrente;

    // Construtor padrao personalizado
    public Carro()
    {
        Nome = "GOLF GTI 1.8";
        VelocidadeCorrente = "60";
    }

    // Aqui a VelocidadeCorrente recebera por padrao (zero)
    public Carro(string vNome)
    {
        Nome = vNome;
    }

    // Deixar que o chamandor configure o 'estado' completo do objeto Carro
    public Carro(string vNome, string vVelocidadeCorrente)
    {
        Nome = vNome;
        VelocidadeCorrente = vVelocidadeCorrente;
    }
}

Tenha em mente que o que diferencia um construtor do outro (aos olhos do compilador C#) é o numero e o tipo de argumentos do construtor. Portanto, o tipo “Carro” sobrecarregou o construtor para fornecer diversas maneiras de criar o objeto no momento da declaração. Seja qual for o caso, agora pode criar objetos “Carro” utilizando qualquer um dos construtores públicos. Por exemplo:

// Criar um carro Escort XR3
static void Main(string[] args)
{
    Carro CarroA = new Carro("ESCORT XR3");
}

// Criar um carro Escort XR3 com velocidade corrente de 90 km/h
static void Main(string[] args)
{
    Carro CarroA = new Carro("ESCORT XR3", "90");
}

3º Recusando o construtor padrão

No entanto, assim que define um construtor personalizado, o construtor padrão é silenciosamente removido da classe e não esta mais disponível! Pense desta forma: se não definir um construtor personalizado, o compilador C# fornecera um padrão para permitir que o usuário do objeto aloque uma instancia de seu tipo com dados de campo para valores padrão corretos. Entretanto quando define um construtor exclusivo, o compilador supõe que lidou com as coisas a sua maneira.

Portanto, se deseja permitir que o usuário do objeto, crie uma instancia de seu tipo com o construtor padrão, bem como seu construtor personalizado, você deve, explicitamente, redefinir o construtor padrão. Para isso, compreenda que uma grande maioria dos casos, a implementação do construtor padrão de uma classe é intencionalmente vazia, já que tudo o que precisa é a capacidade é criar um objeto com valores padrão. Considere a seguinte atualização da classe “Carro”:

class Carro
{
    public int Intencidade;

    public void Aceleracao()
    {
        for (int i = 0; i <= Intencidade; i++)
        {
            Console.Write("Yahoooooo Haaaaaewwwwww");
        }
    }

    // Recusar o construtor padrao
    public Carro()
    {

    }

    // Nosso construtor padrao agora!
    public Carro(int vIntencidade)
    {
        this.Intencidade = vIntencidade;
    }
}

Bom, finalizando esse foi mais um post sobre Construtores de Classe em C# (Csharp), espero que tenham gostado, pois lendo ele parece ser uma coisa ate simples, mas no dia-a-dia de um desenvolvedor de sistemas, nos deparamos como modificar um objeto a nosso favor em fim.

Ate à próxima!

Trabalhando com Listas (Coleções Genéricas)

Ola, Amigos.

Iniciaremos este tutorial falando sobre classe List<T> do namespace System.Collection.Generics ou também podemos falar objetos do tipo genérico.  O List<T> exige que especifique um único valor que descreva o tipo de item sobre o qual List<T> devera trabalhar ou armazenar. Portando se desejar criar três objetos List<T> para conter inteiros e os objetos SportCar() e Person(), terá que escrever o seguinte:

static void Main()
{
    List<int> MyInt = new List<int>();
    List<SportCar> MyCars = new List<SportCar>();           
    List<Person> MyPeople = new List<Person>();
}

Bom, no exemplo acima vemos como declarar um objeto do tipo List<T> e especificar o tipo que iremos objeto que este ira armazenar, podemos dizer que a classe List<T> é uma classe que pode armazenar vários tipos de objetos instanciados na memoria. Vejamos o exemplo abaixo:

private void addSportCarInList()
{
    SportCar MyCar = new SportCar();
   
    MyCar.returnModel = "Mazda";
    MyCar.returnColor = "White";
    MyCar.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);
}

No exemplo acima, nos criamos um objeto do tipo SportCar() e atribuímos as propriedades da classe que são: Modelo, Cor e Velocidade máxima, o valores que desejamos. Após isso criamos um objeto do tipo List<T> onde <T> nesta questão é do tipo SportCar ou seja <SportCar>.

No código acima nos podemos falar que o objeto List<SportCar> contem dentro de si uma instancia só do tipo SportCar, resumindo dentro de nossa Lista temos uma instancia de uma objeto Carro esportivo podemos comprovar isso pelo código abaixo:

MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);

No exemplo abaixo iremos adicionar vários carros em nossa lista de carros consequentemente no mundo POO (programação orientada a objeto) para cada carro iremos criar uma instancia. Vejamos no Exemplo:

private void addFiveSportCarInList()
{
    // Car 1
    SportCar MyCar1 = new SportCar();

    MyCar1.returnModel = "Mazda";
    MyCar1.returnColor = "White";
    MyCar1.returnMaxSpeed = 210;

    // Car 2
    SportCar MyCar2 = new SportCar();

    MyCar2.returnModel = "Subaru";
    MyCar2.returnColor = "Red";
    MyCar2.returnMaxSpeed = 180;

    // Car 3
    SportCar MyCar3 = new SportCar();

    MyCar3.returnModel = "Volvo";
    MyCar3.returnColor = "Green";
    MyCar3.returnMaxSpeed = 200;
   
    // Car 4
    SportCar MyCar4 = new SportCar();

    MyCar4.returnModel = "Volkswagen";
    MyCar4.returnColor = "Black";
    MyCar4.returnMaxSpeed = 240;
   
    // Car 5
    SportCar MyCar5 = new SportCar();

    MyCar5.returnModel = "Ferrari";
    MyCar5.returnColor = "Silver";
    MyCar5.returnMaxSpeed = 210;

    List<SportCar> MyCars = List<SportCar>();
    MyCars.Add(MyCar);

    MessageBox.Show("Total de carros em minha lista {0}", MyCars.Count);
}

Também podemos acessar métodos e propriedades do objeto SportCar() armazenado dentro de nossa lista, podemos fazer isso percorrendo nossa List<SportCar>, através de uma laço de repetição for, while, do while etc. visto que é uma lista ou também coleção de objetos. Vejamos o exemplo abaixo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    MessageBox.Show("Carro número {0} sua marca é: {1}", i.ToString(), MyCars[i].returnModel.ToString());
}

 
No código acima fazemos um laço de repetição “for” para contar nossa lista de carros e exibir o modelo de cada um deles, no caso acima igualamos nossa variável “i” igual a zero só que para uma lista a qual estamos trabalhando ou um Array (vetor) a quantidade de objetos dentro sempre se inicia em um e não em zero, é por esse motivo que colocamos no meio de laço “for”

i <= MyCars.Count - 1

O total de itens da nossa lista menos um, isso por que nosso contador “i” é iniciado em zero.  Vale apena lembrar que a ordem em que instanciamos os objetos do mesmo tipo é a mesma ordem que esta armazenado dentro do objeto List<SportCar>.

Podemos dizer então que no caso acima em que adicionamos cinco carros em nossa lista o primeiro que instanciamos a marca dele é Mazda, pois é esse é o primeiro da nossa lista, como no exemplo do laço podemos perceber que o nome do primeiro carro que aparece no laço é o da marca Mazda, e assim por diante, como na ordem de instanciação.

Podemos também remover objetos desta lista usando o método Remove de nossa lista criada.
Vejamos no exemplo:

int i = 0;
for (i = 0; i <= MyCars.Count - 1; i++)
{
    if (MyCars[i].returnModel == "Volvo")
    {
        SportCar MyCarRemove = MyCars[i];
        MyCars.Remove(MyCarRemove);

        MessageBox.Show("Carro removido da lista");
    }   
}

No código acima nos removemos de nossa lista de carros, o carro de marca “Volvo” podemos perceber que nos criamos um objeto, mas não instanciamos um novo usando a sintaxe new e assim criamos uma variável do tipo SportCar e igualamos essa variável a um carro que estava dentro de nossa lista, esta ai o motivo por que não precisamos instanciar e sim só referenciamos a um que já estava lá dentro na nossa lista e depois passamos a variável ou objeto do tipo SportCar para a lista através do método remove, e esse método é o que ira remover o carro da marca Volvo da nossa lista.

Para limpar uma lista com vários objetos dentro podemos usar o método Clear, podemos limpar a lista como no exemplo abaixo:

MyCars.Clear();

O método acima limpa todas as instancias de objetos que a lista aceita que por ventura esteja carregada. Como vimos à coleção de genéricos do framework dot net permite dar soluções para eventuais problemas de desenvolvimento de softwares de nosso dia-a-dia. Além disso, os tipos genéricos geralmente excluem a necessidade de construir tipos de coleção personalizados.

Podemos utilizar List<T> em inumeráveis situações no desenvolvimento de software seja desktop ou web uma situação ótima para citar a inclusão de uma Lista seria implementar um carrinho de compras para um sistema de e-commerce.

Espero que tenham gostado deste post, pois em minhas horas de desenvolvimento de software sempre estou utilizando generics, collections entre estes a classe List<T>, sempre para guardar objetos fortemente tipados do projeto em que estou trabalhando.

Até o próximo post.