Coelho na Rede

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 Anderson Weller @  0 Comentários

Marcadores: CSharp, Desenvolvimento, DotNet

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

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

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