Coelho na Rede

Recentemente tive um pequeno problema com o sistema que desenvolvi em C# Windows Forms, Visual Studio 2008.

O aplicativo é padrão Windows com janelas MDI, assim os usuários podem abrir várias janelas de consulta e cadastro ao mesmo tempo, agilizando o serviço deles.

Uma vez, uma das funcionárias me mostrou que não conseguia mudar entre as janelas filhas do sistema, clicando dentro do formulário que ela queria trabalhar. Porém, me mostrou que se clicasse na barra de título dessa janela ela passaria a ter o foco, ficando no topo das outras janelas.

Jamais havia percebido esse problema nas máquinas de desenvolvimento. Fiz o teste aqui novamente e não ocorreu o problema para mim.

Devido às prioridades do sistema, essa solicitação ficou aguardando até esta semana, retornei ao usuários e pedi para me mostrassem novamente o problema. Para minha surpresa, o problema não só persistia, mas também estava generalizado em todas as máquinas de produção.

Teoricamente as máquinas de desenvolvimento e as máquinas dos usuários (produção) são iguais, tirando os softwares de desenvolvimento nas nossas máquinas e as permissões, que são mais restritivas nos computadores de produção.

Depois de uma pesquisa na internet, acabei verificando que era um problema já reportado no Visual Studio 2003.

Então, bastou codificar um método na minha janela ancestral (bendita Orientação à Objetos) para propagar a correção para todos os meus sistemas.

Se você estiver tendo esse mesmo problema, basta codificar o seguinte método nas suas janelas, ou de preferência crie uma janela ancestral para acomodar o procedimento:

   /// <summary>
   /// Corrige Bug, do VisualStudio, que impede a mudança de foco entre as janelas MDI
   /// clicando dentro do formulário.
   /// A mudança de foco só ocorre se usuário clicar na barra de título da janela MDI.
   /// -------------------------------------------------------------------------------
   /// Referência:
   /// http://support.microsoft.com/kb/871045/pt-br
   /// </summary>
   /// <param name="m"></param>
   protected override void WndProc(ref Message m)
   {
      int WM_MOUSEACTIVATE = 0x21;
      if (m.Msg == WM_MOUSEACTIVATE)
      {
         this.Focus();
      }
       base.WndProc(ref m);
   }

Para mais detalhes sobre o problema e outras possíveis soluções (em Visual Basic) veja o seguinte link da Microsoft:
-  Erro: um formulário MDI filho não poderá maximizar se o formulário filho contém um controle ActiveX no Visual Studio .NET 2003(http://support.microsoft.com/kb/871045/pt-br)

Marcadores: CSharp, Desenvolvimento, Dicas, Visual Studio, Windows

O Windows Forms do C#, no Visual Studio 2005, tem um "bug" que não afeta o funcionamento do programa, mas o efeito visual gerado por ele é muito feio.
Ao criar um formulário, para aplicações MDI, e definir que ele não deve apresentar o botão maximizar (MaximizeBox = false), espera-se que ele nunca apareça maximizado, porém isso nem sempre acontece.
O problema ocorre quando o aplicativo está com uma janela aberta e maximizada. Ao abrimos o segundo , não modal (janela.Show()) e com o botão maximizar desabilitado, esta última também inicia de forma maximizada. Somente depois de clicar em seu botão restaurar é que ele passa a funcionar corretamente.
Para contornar esse erro, você deve definir durante o evento "Load" desses formulários, que eles não devem retornar ao tamanho normal caso estejam maximizados.
Então, crie uma janela ancestral, para todas as suas janelas e codifique o evento Load assim:

#region Correção de Bug do VisualStudio na apresentação de janelas com botão MAXIMIZAR desabilitado
// Se o formulário está com o botão maximizar desabilitado
if (!this.MaximizeBox)
{
    // E o estado atual dele é maximizado, então
    if (this.WindowState == FormWindowState.Maximized)
    {
        // Muda o estado para normal durante o load da janela (Correção de Bug do VisualStudio)
        this.WindowState = FormWindowState.Normal;
        if (this.MdiParent != null)
        {
            this.MdiParent.Refresh();
        }
        else
        {
            this.Refresh();
        }
    }
}

Marcadores: CSharp, Desenvolvimento, Dicas, DotNet

## Link ## postado por Coelho na Rede @  0 Comentários Links para esta postagem

Seguindo a mesma linha da propriedade "AutoSelectTextOnFocus" que apresentei aqui tempos atrás, que seleciona o conteúdo de um campo quando ele recebe o foco, apresento agora o "HighlightControlOnFocus" que configura a cor de fundo de todos os campos editáveis em um formulário C# Windows Forms.
Para fazer isso basta adicionar a propriedade "HighlightControlOnFocus" ao formulário pai e configurá-lo nas janelas filhas:

• Criando a propriedade:

        /// <summary>
        /// Muda a cor de fundo de um campo (habilitado) quando ele está em foco
        /// </summary>
        private bool bolHighlightControlOnFocus = false;
        [Category("Focus")]
        [Description("Define se a cor de fundo de um campo é alterada sempre quando ele estiver em foco.")]
        [DisplayName("HighlightControlOnFocus")]
        public bool HighlightControlOnFocus
        {
            get { return bolHighlightControlOnFocus; }
            set { bolHighlightControlOnFocus = value; }
        }

• Codificando a propriedade:

        private void ConfiguraEnterComponente(object sender, EventArgs e)
        {
            if (sender is Control)
            {
                Control controle = (Control)sender;
                if (controle.Enabled)
                {
                    controle.BackColor = Color.LightYellow;
                }
            }
        }

        private void ConfiguraLeaveComponente(object sender, EventArgs e)
        {
            if (sender is Control)
            {
                Control controle = (Control)sender;
                if (controle.Enabled)
                {
                    controle.BackColor = Color.White;
                }
            }
        }

        private void ConfigurarFocoComponentes(Control controle)
        {
            // Configura o Enter e o Leave do componente
            if ( (controle is MaskedTextBox)  ||
                 (controle is ComboBox)       ||
                 (controle is TextBox)        ||
                 (controle is RichTextBox)    ||
                 (controle is NumericUpDown))
            {
                controle.Enter += this.ConfiguraEnterComponente;
                controle.Leave += this.ConfiguraLeaveComponente;
            }

            if (controle is DateTimeEdit)
            {
                controle.Validated += this.ConfiguraLeaveComponente;
            }

            if (controle is ComboBox)
            {
                ComboBox combo = (ComboBox)controle;
                combo.DropDown += this.ConfiguraLeaveComponente;
            }

            // Chamada recursiva para configurar os controles filhos do item atual
            foreach (Control controleFilho in controle.Controls)
            {
                this.ConfigurarFocoComponentes(controleFilho);
            }
        }

• Iniciando a propriedade (Configurar o "Load" da janela pai):

        private void JanelaBasica_Load(object sender, System.EventArgs e)
        {
            //...
            //...
            // Configura a cor de fundo dos campos que estão com o foco
            if (this.HighlightControlOnFocus)
            {
                this.ConfigurarFocoComponentes(this);
            }
            //...
            //...
        }

Artigos Relacionados:

Criando e configurando propriedades em C#

Selecionar conteúdo dos campos assim que estiverem com o Foco - C#

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas

Marcadores: CSharp, Desenvolvimento, DotNet

Já havia feito isso a um bom tempo atrás, mas hoje estava precisando fazer novamente o código que substitui caracteres com acento pelo correspondente sem acento no momento que a pessoa digitar a letra.
Porém, estava com preguiça de escrevê-lo novamente então acessei o Google para procurar.
Putz, nada... Será que ninguém mais usa Delphi aqui no Brasil ou o pessoal têm preguiça de postar uma dica na internet, hehe.
Brincadeiras a parte, resolvi publicar aqui no Coelho Na Rede. Então lá vai.
Basta codificar da seguinte forma o evento KeyPress do Edit que não pode ter caracter acentuado ou cedilha:

procedure TfrmCadastroPessoa.dbeNomePessoaKeyPress(Sender: TObject; var Key: Char);
begin
   inherited;
   case Key of
      'Á', 'Â', 'Ã', 'À', 'Ä', 'Å': Key := 'A';
      'á', 'â', 'ã', 'à', 'ä', 'å': Key := 'a';
      'é', 'ê', 'è', 'ë'          : Key := 'e';
      'É', 'Ê', 'È', 'Ë'          : Key := 'E';
      'í', 'î', 'ì', 'ï'          : Key := 'i';
      'Í', 'Î', 'Ì', 'Ï'          : Key := 'I';
      'ó', 'ô', 'õ', 'ò', 'ö'     : Key := 'o';
      'Ó', 'Ô', 'Õ', 'Ò', 'Ö'     : Key := 'O';
      'ú', 'û', 'ù', 'ü'          : Key := 'u';
      'Ú', 'Û', 'Ù', 'Ü'          : Key := 'U';
      'ç'                         : Key := 'c';
      'Ç'                         : Key := 'C';
      'ñ'                         : Key := 'n';
      'Ñ'                         : Key := 'N';
      'ý', 'ÿ'                    : Key := 'y';
      'Ý', 'Ÿ'                    : Key := 'Y';
   end;
end;

No mais é isso, outras dicas interessantes sobre como efetuar essa mudança você pode conferir no seguinte link (Evitar acentuação e cedilha da TiFórum)

Marcadores: Como_Fazer, Delphi, Desenvolvimento, Dicas

Estava precisando criar um 'Select' contendo um campo 'Observacao' (do tipo Text) adicionado de um outro campo 'Descricao' [de uma outra tabela, do tipo Varchar(100)], porém como esse tipo de campo, 'Text', é muito problemático [em vários aspectos, tanto que a recomendação é a utilização do VARCHAR(MAX)], não é possível concatená-lo a uma outra string utilizando o caracter de adição (+).
Portanto, como resolver esse problema? A maneira mais fácil é a de converter o 'Text' para 'Varchar(8000)' antes de efetuar a concatenação, dessa forma:
SELECT CONVERT(VARCHAR(8000), campoText) + campoVarchar AS novoNomeCampo
FROM <...>

Mas lembre-se, quando estiver criando uma nova tabela prefira utilizar VARCHAR ao TEXT. Para conferir mais sobre o assunto verifique o site da Microsoft (Leia o artigo: Using text and image Data), repare que no início desse artigo eles avisam que o tipo TEXT será descontinuado nas próximas versões do SqlServer:

Important: This feature will be removed in a future version of Microsoft SQL Server. Avoid using this feature in new development work, and plan to modify applications that currently use this feature. Use varchar(max), nvarchar(max) and varbinary(max) data types instead. For more information, see Using Large-Value Data Types.

Marcadores: BancoDeDados, Como_Fazer, Desenvolvimento, SqlServer

Para utilizar uma lista ordenada no C#, basta utilizar a classe SortedList.
Sempre que for adicionar um novo item à lista devemos informar uma chave (Object key) e um valor (Object value):
=> .Add(Key, Value) = Para adicionar novos itens
=> Key   = Pode ser qualquer objeto. Essa será a informação utilizada para a organização da lista.
=> Value = Esse campo armazena o objeto cuja lista precisa ser ordenada.

// (...)
SortedList lstListaOrdenada = new SortedList();
// Monta uma lista ordenada
foreach (Disciplina disciplina in lstDisciplinas)
{
   lstListaOrdenada.Add(disciplina.ObterNomeDisciplina(), disciplina);
}
// (...)
// Acessa os objetos da lista ordenada
foreach (DictionaryEntry linha in lstListaOrdenada)
{
    Disciplina disciplina = (Disciplina)linha.Value;
    // (...processa cada uma dos objetos...)
}
// (...)

Uma outra coisa interessante nesse tipo de lista é que, quando quisermos encontrar o valor correspondente a uma chave, não é necessário pesquisar toda a lista, bastando então acessar diretamente o índice informando a chave, por exemplo:
disciplina = lstListaOrdenada['Matemática'];

Referência: MSDN

Marcadores: CSharp, Desenvolvimento, Dicas, DotNet

Durante a implantação de um sistema verificamos que algumas pessoas se confundem com a abertura de janelas MDI.
Assim, após abrir uma janela e efetuar o cadastramento de alguma informação, minimizam o formulário e começam a realizar alguma outra tarefa.
Depois de um tempo, ao invés de retornar para a tela minimizada, acessam o item de menu e abrem outra instância da mesma janela. Assim, acabam se confundindo quando restauram a primeira janela minimizada e se deparam com dados desatualizados.
Para evitar esse problema, devemos restaurar a janela minimizada, ao invés de abrir uma nova instância dela.
A codificação consiste em verificar se o formulário já está na lista de janelas MdiChildren da janela principal e reativá-lo caso ele seja encontrado.
Portanto, a codificação do evento Click de um item de menu (da janela principal) ficaria o seguinte:

private void imenuInclusaoTeste_Click(object sender, EventArgs e)
{
    try
    {
        // Localiza o formulario
        foreach (Form form in this.MdiChildren)
        {
            if (form is JanCadastroTeste)
            {
                // Torna-o ativo
                form.WindowState = FormWindowState.Normal;
                form.Activate();
                return;
            }
        }
        // Senão, abre uma instancia da janela
        JanCadastroTeste janCadastro = new JanCadastroTeste();
        janCadastro.MdiParent = this;
        janCadastro.Show();
    }
    catch (Exception exception)
    {
        // Tratamento do Erro ...
    }
}

Referências:

Single Instance Children Forms in MDI Applications

Introduction to MDI Forms with C#

Marcadores: CSharp, Desenvolvimento, Dicas, Visual Studio

O Visual Studio é uma grande IDE para o desenvolvimento de aplicações DotNet, porém, por ser uma ferramenta da Microsoft, somente pode ser utilizada em máquinas Windows.
Portanto, para realizar o desenvolvimento em máquinas Linux devemos utilizar o MonoDevelop, que também é uma IDE gratuita para ambientes GNOME Linux criada pela Novell.
O MonoDevelop faz parte do projeto Mono, que torna possível a utilização de aplicativos .Net no Linux.

Download: MonoDevelop

Marcadores: CSharp, Desenvolvimento, DotNet, Linux, Mono, OpenSource, Ubuntu, Visual Studio

Perambulando pela internet a procura de um tutorial sobre JavaScript, para poder incrementar uma extensão do Firefox que eu estou desenvolvendo (em breve apresento aqui), acabei encontrando um site muito bom (W3Schools) que fala não só sobre JavaScript mas também sobre várias técnicas para desenvolvimento Web (html, xml, Ajax...).
Um dos detalhes mais interessantes que encontrei no site foram os exemplos de JavaScript. É o chamado TryIt Editor onde é possível não apenas visualizar o exemplo mas também alterar seu conteúdo e visualizar o resultado final dele (veja um dos exemplos).
Vale a pena lembrar que todo o conteúdo do site é gratuito (tutorias, dicas, exemplos, etc) e não é necessário nem cadastro.

Referência: Tutorial JavaScript

Marcadores: Blog, Browser, Desenvolvimento, Java, Tutorial

Hibernate é uma biblioteca, para a linguagem Java, que mapeia um banco de dados relacional em objetos, criando uma camada de abstração que isola a regra de negócio da arquitetura utilizada na persistência das informações.
Além disso, o Hibernate é um software gratuito e OpenSource, distribuído sob os termos da GNU Lesser General Public License, o que torna muito interessante a sua utilização.
Como não poderia deixar de ser, a Red Hat também desenvolveu essa mesma ferramenta para ser utilizada no ambiente .NET, chamada NHibernate.

Para quem quiser aprender como utilizar esse "framework", utilizando o Visual Studio, basta acessar o site CodeProject (ótimo site sobre .NET). Lá tem um artigo muito bom, que explica passo-a-passo como criar um projeto em C# utilizando o NHibernate, chamado "NHibernate Made Simple".
Obs.: Caso você queira fazer o download do exemplo, será necessário que você se cadastre no site.

Marcadores: CSharp, Desenvolvimento, Dicas, DotNet

No meu artigo anterior, sobre como configurar o auto-select no C# Windows Forms, eu expliquei como selecionar o conteúdo de campos texto (ex.: TextBox e NumericUpDown) quando o ele receber o foco.
Para evitar a repetição de código, podemos acrescentar aqueles métodos a um formulário ancestral.
Alem disso, devemos criar uma propriedade para que as janelas descendentes possam decidir se desejam ativar esse serviço. Para isso, basta acrescentar o seguinte código à janela ancestral (além dos outros códigos do artigo anterior):

private bool bolAutoSelectOnFocus;

[Category("Focus")]
[Description("Ativa o método de AutoSelect dos campos da interface.")]
[DisplayName("AutoSelectOnFocus")]
public bool AutoSelectOnFocus
{
    get { return bolAutoSelectOnFocus; }
    set { bolAutoSelectOnFocus = value; }
}

Depois disso, é só codificar o evento "Load" da ancestral de forma a ativar o serviço somente se for solicitado pela janela descendente:

private void JanelaPadrao_Load(object sender, System.EventArgs e)
{
    //...
    if (this.AutoSelectOnFocus)
    {
        this.DelegateEnterFocus(this);
    }
}

Observe que na criação da propriedade podemos configurar alguns atributos dele. Caso você não informe a categoria, a propriedade irá aparecer no grupo "Misc" da "Properties Windows".

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

Quando você precisar que o conteúdo de um campo editável tipo TextBox e MaskedTextBox (herdados de TextBoxBase) ou NumericUpDown (UpDownBase) você pode extender o funcionamento desses componentes através de herança, mas isso deixa para depois.
Uma maneira mais fácil é criar um método com a mesma assinatura dos eventos "Enter" do controle e delegar esse método para todos os campos do formulário que precisam dessa funcionalidade.
Abaixo eu apresento o código do método "SelectText_Enter" que fica encarregado de selecionar o conteúdo do campo, de acordo com o tipo dele (no meu caso os herdados de "TextBoxBase" e "UpDownBase") e o evento "DelegateEnterFocus" que fica responsável por procurar todos os campos do formulário e delegar a funcionalidade criada para o evento "Enter" deles:

//___ Seleciona todo o texto de um controle. _______________________________________
private void SelectText_Enter(object sender, System.EventArgs e)
{
    // Executa o método de forma assíncrona - pois o MaskedTextBox já executa um
    // select no evento "Enter" do foco, que acaba desfazendo a seleção.
    this.BeginInvoke((MethodInvoker)delegate()
    {
        if (sender is UpDownBase)
        {
            ((UpDownBase)sender).Select(0, ((UpDownBase)sender).Text.Length);
        }
        else if (sender is TextBoxBase)
        {
            ((TextBoxBase)sender).SelectAll();
        }
    });
}


//__ Associa o evento "SelectText_Enter" a cada um dos campos com texto ____________
private void DelegateEnterFocus(Control ctrl)
{
    if ((ctrl is UpDownBase) || (ctrl is TextBoxBase))
    {
        ctrl.Enter += SelectText_Enter;
        return;
    }

    // Chamada recursiva para associar o evento a todos os controles da interface
    foreach (Control ctrlChild in ctrl.Controls)
    {
        this.DelegateEnterFocus(ctrlChild);
    }
}


Depois de criados esses métodos, codifique o evento "Load" do formulário com a chamada para o evento "DelegateEnterFocus":

//___ Configura o evento "Enter" dos campos com texto ______________________________
private void JanTeste_Load(object sender, EventArgs e)
{
    this.DelegateEnterFocus(this);
}

Tópicos Relacionados

Criando e configurando propriedades em C#

Mudar a cor do campo quando recebe o foco (C# Windows Forms)

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

Eu já publiquei no artigo "Como usar o ENTER como TAB..." uma forma de simular o funcionamento da tecla TAB quando for pressionado o ENTER utilizando o método "SelectNextControl".
Uma outra maneira de realizar esse procedimento é o de chamar o método estático "Send" da classe "SendKeys":

SendKeys.Send("{TAB}");

Portanto, se você quer que o ENTER funcione igual ao TAB (até quando o usuário utilizar em conjunto com a tecla SHIFT) utilize o seguinte código no evento "OnKeyPress" do um campo (Obs.: se quiser que ele funcione para todos os campos do formulário, confira o artigo anterior):

if (e.KeyCode == Keys.Enter)
{
    if (e.Shift)
    {
        SendKeys.Send("+{TAB}");
    }
    else
    {
        SendKeys.Send("{TAB}");
    }
}

Ou simplificando a função:

if (e.KeyCode == Keys.Enter)
{
    SendKeys.Send((e.Shift ? "+" : "") + "{TAB}");
}


Observação - Na combinação de teclas faça o seguinte:
=> Shift + Tab:
SendKeys.Send("+{TAB}");
=> Ctrl + Tab:
SendKeys.Send("^{TAB}");
=> Alt + Tab:
SendKeys.Send("%{TAB}");

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

O Visual Studio, assim como outras ferramentas RAD, possibilita a alteração da sua configuração padrão de cores. Até ai tudo bem. Somando-se a isso, o VS permite a exportação/importação de suas configurações e com isso desenvolvedores começaram a gerar arquivos contendo apenas as configurações de fontes e cores. Assim, criaram "Temas" para o Visual Studio e começaram a disponibilizar na internet, o que é muito interessante pois são muitos itens para configurar e demora muito tempo.
Os temas mais interessantes que encontrei foram:
- Midtone Scheme
- Vibrant-Ink & Vibrant-Ink v2
- HumaneStudio

O meu tema (Midtone Complete) é uma complementação do Midtone Scheme (pois este não têm a configuração de vários itens como as de arquivos CSS e XML).

Para instalar algum esquema de cores siga os seguintes passos (lembre-se de fazer o backup de suas configurações primeiro):

1. Vá ao menu "Tools | Import and Export Settings...";
2. Marque a opção "Import selected environment settins" (Obs: Marque a opção "Export selected..." para efetuar o backup de suas configurações atuais);
   
3. Clique em "Next >";
4. Marque "No, just import new settings, overwriting...". (Obs: nesse ponto vc tem a última chance para efetuar o backup, marcando a opção "Yes, save my...");
5. Clique em "Next >";
6. Clique em ""Browse...", localize e abra o arquivo de configuração;
7. Clique em "Next >";
8. Desmarque todas as opções e deixe apenas o item "Fonts and Colors" que está em "All Settings | Options | Environment". (Obs: Nesse ponto preste bastante atenção para importar apenas a configuração de Fontes e Cores (caso não seja a única): ;
9. Clique em "Finish." para aplicar as configurações ao Visual Studio.

Para alterar manualmente, ou apenas verificar, essas configurações basta:

1. Ir ao menu "Tools | Options...";
2. Expanda o item "Environment";
3. Clique na opção "Fonts and Colors".
   

Marcadores: CSharp, Desenvolvimento, Dicas, DotNet

Para fazer a tecla ENTER funcionar como a TAB no Windows Forms, basta fazer duas coisas:
(1) Alterar a propriedade KeyPreview do Formulário para " true"
(2) Preencha o evento KeyDown do Formulário com o seguinte código:
if (e.KeyCode == Keys.Enter)
{
    this.SelectNextControl(this.ActiveControl, !e.Shift, true, true, true );
}

Obs.1: O código " !e.Shift" indica que é para mudar para o próximo campo se pressionado ENTER, e ir para o campo anterior se pressionados SHIFT e ENTER simultaneamente (o mesmo funcionamento do SHIFT + TAB).

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

O controle Combobox do Visual Studio possui várias configurações que permite que seu funcionamento seja alterado.
Como exemplo, digamos que necessitamos que temos uma lista de dados que não muda, portanto, o usuário deverá escolher um entre esses itens. Além disso, o usuário não quer abrir a lista e procurar a linha a ser selecionada, ele deseja digitar o nome ou o código e quer que o registro seja selecionado automaticamente.
Isso nada mais é do que uma pesquisa incremental na lista de itens da Combobox.
A partir da versão 2005 do Visual Studio essa opção foi adicionada ao controle, e para configurá-la configurada basta selecionar as seguintes propriedades:
· DropDownStyle = DropDownList
· AutoCompleteSourec = ListItens
· AutoCompleteMode = Append

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

Como a Microsoft esqueceu de incluir uma propriedade Visible para os TabPages do controle TabControl é necessário utilizar um artifício para ocultar e reapresentar um ou vários tabpages.
Abaixo eu apresento um exemplo dos métodos que devem ser codificados para simular o Visible do TabPage.
Obs.: No meu exemplo inserir um TabControl (tabControl1) e dois TabPages dentro dele (tabPage1 e tabPage2). No meu caso, o TabPage2 é que ficará oculto (Lembre-se que o primeiro índice de arrays no C# é o Zero).

namespace ...
{
    public partial class ...
    {
...
        private TabPage _tabPage2;
...
        // Ao iniciar a janela armazena a TabPage que precisará ser ocultada
        private void JanelaTeste_Load(object sender, EventArgs e)
        {
            // Armazena um ponteiro para a tabpage2
            this._tabPage2 = this.tabControl1.TabPages[1];

            // Oculta a visualização da tabpage2
            this.tabControl1.TabPages.RemoveAt(1);
        }
...
        private void ConfiguraTabPage2(bool abVisible)
        {
            if (abVisible)
            {
                // Se ela ainda não está visível
                if (this.tabControl1.TabPages.Count == 1)
                {
                    // torne-a visivel no TabControl
                    this.tabControl1.TabPages.Add (this._tabPage2);
                }
            }
            else
            {
                // Senão, oculta essa tabpage
                if (this.tabControl1.TabPages.Count == 2)
                {
                    this.tabControl1.TabPages.RemoveAt(1);
                }
            }
        }
...
    }
}

Marcadores: Como_Fazer, CSharp, Desenvolvimento, Dicas, DotNet

É comum falar em desenvolvimento de sistemas com acesso a banco de dados, porém, quando se elabora um bom projeto de sistemas, um dos pré-requisitos é a criação de uma camada de persistência para ser a única responsável pelo acesso às informações armazenadas, tornando a camada de regras de negócio independente do tipo de solução de banco de dados escolhida, sendo fácil migrar de MySql para SqlServer ou Oracle, por exemplo.
Para isso existem várias ferramentas e uma das mais utilizadas em Java é o Hibernate. E, como não podia deixar de ser, o mesmo grupo criou uma API chamada NHibernate, muito similar à versão Java, para atender à comunidade DotNet.
Para quem quer aprender um pouco mais sobre essa ferramenta, pode acessar a documentação do NHibernate e para fazer o download delas clique aqui.
Outros Links:
- NHibernate Quick Start Guide
- I want to learn Hibernate for Java!

Marcadores: BancoDeDados, CSharp, Desenvolvimento, DotNet, Java

Depois de rodar por várias ferramentas de programação, PowerBuilder, Delphi, Visual Basic e Java, chegou a vez do Visual C#.Net.
Por falar nisso, quem quiser utilizá-lo, basta fazer o download do Visual C# Express diretamente do site da Microsoft, de graça, e começar a praticar...
Por falar nisso, a Microsoft acabou de liberar, nessa segunda-feira o link para o download do Visual Studio 2008 Express Editions, que contém todas as ferramentas de programação da série Express, que eu já comentei que são gratuitas, além do SqlServer 2005 Express.
Para isso, vá até o final da página de downloads e clique no link do Visual Studio (Offline Install) e baixe o arquivo .ISO.
Eu já baixei e instalei aqui em casa, realmente a ferramenta é muito boa.

Marcadores: CSharp, Desenvolvimento, DotNet

Atualmente já não é aconselhável ficar criando aplicações Delphi com BDE como conexão aos bancos de dados. Além disso, a própria Microsoft informa que não desenvolve mais conexões nativas para seus BD e que as melhores opções são o ODBC, ADO e OLE. Com isso, Delphi, como em outras ferramentas de desenvolvimento, possibilita a conexão através dessas tecnologias.
Lendo a documentação do Delphi você encontra várias informações de como efetivar esse tipo de conexão. Para quem está sem um ponto de partida tem que ler o seguinte artigo da ajuda do Delphi: Building a VCL Forms ADO Database Application.
Em breve, vou publicar um passo-a-passo de como fazer uma conexão via OLE DB.

Marcadores: Delphi, Desenvolvimento

Dúvidas sobre como acentuar em HTML ou como inserir caracteres especiais na sua página???
Seus "pobremas" acabaram!!!
Agora no Coelho Na Rede você encontra todos os caracteres que você estava procurando. Basta acessar a página Acentuação HTML que eu disponibilizei.

Marcadores: Desenvolvimento

A pouco tempo atrás eu estava precisando desenvolver um cadastro que possibilitasse armazenar uma foto de cada pessoa cadastrada.
Como utilizo o Delphi 2005 com banco de dados Firebird (versões 1.5 e 2.0) não foi difícil desenvolver essa tela. Mas, como fazer para obter a foto da pessoa cadastrada diretamente de uma Webcam, facilitando assim a utilização do sistema.
Procurei na internet e acabei achando um site que falava sobre um componente que capturava imagens da webcam, porém, não estava completo e também só funcionava até o Delphi 7. Consegui baixar do SourceForge os componentes que faltavam e as atualizações dos que eu já tinha. Precisei fazer algumas alterações para que a captura passasse a funcionar, além de baixar duas Dll's do DirectX que são necessárias para a codificação funcionar.
Abaixo estão os links para o download dos componentes, das dll's e da janela de teste de captura de imagens:
* Componentes DSPack => (Download com as minhas alterações p/ Delphi 2005)
* Janela de Testes => (Download)
* Dll's do DirectX 9.2 => (Download)

Abaixo eu apresento algumas imagens de como ficou a janela de captura, que foi adaptada do exemplo que vem junto com o pacote do DSPack.

Fig1.: Preparando a captura


Fig2.: Efetuando a captura


Fig3.: Enviando imagem para a tela de cadastro

Quem tiver alguma dúvida, pode mandar uma mensagem que eu respondo.

Agradecimentos ao blog do DProgrammer que foi a fonte inicial da minha pesquisa.

Marcadores: Como_Fazer, Delphi, Desenvolvimento, Download