Olá Pessoal,
esse é um post rapidinho só para descontrair...
Durante o seu desenvolvimento com asp.net você pode ter se deparado com a dificuldade de customizar alguns controles. Mas essa é uma tarefa muito simples.
Cada controle ASP.NET no final das contas é renderizado como um controle HTML. O GridView por exemplo, é renderizado como uma tabela e pode ter todas as propriedades que uma tabela html normal tem.
Exemplo:
O GridView possui as GridLines que podem ser setadas como Horizontal, Vertical ou Both.
Mas na aba do controle não possui nenhum campo para modificar a cor da linha, só que para fazer isso é simples.
Na code behind faça no page load ou onde for necessario:
meuGrid.Attributes.Add("bordercolor", "black");
Pronto agora você já tem um GridView com separadores na cor preta. Você pode também colocar a cor no formato html:
meuGrid.Attributes.Add("bordercolor", "#FFFFFF");
Esse ultimo atribui a cor branca as linhas separadoras.
Simples rapido e facil!
Espero que seja util.
terça-feira, 11 de novembro de 2008
Mudando a cor das Gridlines no GridView
Postado por João Bosco Seixas às 14:31 0 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
quarta-feira, 15 de outubro de 2008
Dica: Response.Redirect usando UpdatePanel - AJAX
Essa é uma dica rápida de 5 minutos.
Quando se está utilizando o UpdatePanel, você já deve ter notado que os comandos do tipo Response.Redirect e Server.Transfer, não funcionam ou funcionam com falha.
Um jeito que eu encontrei de contornar isso rapidamente foi adicionando um javascript no ScriptManager para que ele redirecionasse a pagina depois do postback.
Ficaria mais ou menos assim:
ScriptManager.RegisterStartupScript(Page, typeof(Page), "redirecionamento","window.location.href='ProximaPagina.aspx?param=123';", true);
O primeiro parâmetro é o controle que está registrando o script.
O segundo é o tipo do controle.
O terceiro parâmetro diz respeito a chave a qual vai ser associada seu script.
O quarto e mais importante parâmetro é o script em si.
E o quinto e ultimo parametro é um booleano que faz com que o proprio .NET adicione as tags de script.
Caso você escolha false, no parametro 4 é preciso colocar as tags de script correspondentes - - Por exemplo.
Espero que essa pequena dica rapida possa ajudar alguem.
Postado por João Bosco Seixas às 16:42 0 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
terça-feira, 9 de setembro de 2008
Inserindo de arquivos para o banco de dados - Inserção em massa - SQLBULKCOPY
Vamos ao cenario que acontece com frequencia nas atividades de desenvolvedores de back office.
Um arquivo texto ou excel, repleto de informações que precisam ser persistidas no banco, de forma consistente e com uma boa performance.
Isso é muito comun e existem inumeras soluções. Desde soluções diretas no SQL Server por exemplo, a soluções "menos sofisticadas" como ler e inserir linha a linha do arquivo no banco.
Em outra oportunidade irei falar também do Bulk Insert do SQL Server, que tem o uso muito simples, mas tem algumas limitações.
Mas agora, vou falar rapidamente de uma forma "elegante" e muito simples que quebrou um galho muito bom pra mim.
O SqlBulkCopy, que é uma classe que está no namespace System.Data.SqlClient.
Com está classe, basta que você passe um DataTable, faça o mapeamento, indicando qual coluna do DataTable equivale a qual coluna no banco de dados e pronto. Depois disso é só correr pro abraço. Originalmente foi projetado para atuar no SQL Server, não sei se essa classe é capaz de trabalhar com outros bancos.
Um exemplo bem simples segue abaixo:
public void InserirFuncionarios(DataTable tabela)
{
try
{
//Atribuindo a string de conexao ao objeto SqlConnection
SqlConnection con = new SqlConnection(StringConexao);
//Criando o objeto de BulkCopy, passando a conexao
SqlBulkCopy bc = new SqlBulkCopy(con);
//Definindo a tabela destino no banco de dados
bc.DestinationTableName = "Funcionario";
//Criando o Mapeamento de colunas do DataTable para o banco
SqlBulkCopyColumnMappingCollection cols = bc.ColumnMappings;
//Percorrendo as colunas da tabela e associando as colunas da tabela do banco
//Isso só é possivel porque as colunas da tabela tem o mesmo nome das colunas do banco
//Assim a DestinationComlumn deve receber o nome da coluna do banco
//E a sourceColumn deve receber o nome da coluna da tabela
foreach (DataColumn coluna in tabela.Columns)
{
SqlBulkCopyColumnMapping c = new SqlBulkCopyColumnMapping();
c.DestinationColumn = coluna.ColumnName;
c.SourceColumn = coluna.ColumnName;
cols.Add(c);
}
//Abrindo a conexão, Escrevendo no banco e fechando a conexão
con.Open();
bc.WriteToServer(tabela);
con.Close();
}
catch (Exception e) {
throw new Exception(e.Message);
}
}
Espero que ajude alguem esse trecho de codigo simples que explica como fazer inserção em bloco no SQL Server utilizando a classe SqlBulkCopy em C#
Se alguem tiver uma forma melhor de fazer com essa classe, fique a vontade de deixar um comentario.
Postado por João Bosco Seixas às 11:05 0 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
terça-feira, 29 de abril de 2008
Visão geral de threads em C#
Neste blog existem alguns posts sobre threads em C#, que ensinam como criar uma thread, como passar parametro na inicialização de uma thread etc...
Vou tentar nos proximos posts, da uma visão geral sobre threads e mostrar alguns pontos importantes do funcionamento.
Vou começar dando um simples exemplo de como funciona.
Temos no C#, como em outras linguagens, suporte a execução paralela de codigo, através de multithreading.
Uma thread é "quase um outro programa".
Ela é uma caminho de execução indepentende e que pode rodar ao mesmo tempo que outras threads.
Um programa em C# começa com uma thread principal que é criada automaticamente pelo CLR do .NET Framework e pelo sistema operacional é a thread("main")
Então o programa se torna multithreading a partir da criação de outras threads a partir dessa thread principal.
Vou colocar um exemplo de codigo para ilustrar como funciona a thread e que elas compartilham recursos em comun, no caso o console.
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
namespace ThreadTest
{
class Program
{
static void Main(string[] args)
{
Thread minhaThread = new
Thread(new ThreadStart(Escreve));
minhaThread.Start();
for (int i = 0; i < 1000; i++)
{
Console.Write("_");
}
Console.ReadLine();
}
public static void Escreve()
{
for (int i = 0; i < 1000; i++)
{
Console.Write("-");
}
}
}}
A thread principal("main"), cria uma nova thread que irá executar a função
Escreve(), esta função mostrará na tela o hifen"-"
Ao mesmo tempo que isso
ocorre, a thread principal escreve na tela "_"(underline).Execute o programa e veja como ele irá se comportar.
Note que
repetindo a execução varias vezes, o comportamento não se repete.Ficaremos por aqui com esse exemplo, para que você possa visualizar como uma thread funciona, e brincar com as possibilidades
No proximo post tentarei explicar um pouco mais sobre como compartilhar variaveis entre diferentes threads.
Postado por João Bosco Seixas às 09:24 0 comentários
quarta-feira, 23 de abril de 2008
Persistir dados em XML - Manipulação XML
Nunca tive necessidade de persistir dados em XML.
Porém recentemente tive faze-lo para agilizar uma tarefa no trabalho.
Já sabia que o .NET framework dava um suporte muito bom a manipulação de arquivos XML, então resolvi colocar a mão na massa!
Em 5 minutos já havia aprendido tudo que eu necessitava para a tarefa.
Isso é fruto de uma comunidade ativa e uma documentação completa.
Uma rapida busca pela internet e encontrei muito material, bem completo. Mas como eu precisava de pouca coisa, fui aprendendo no melhor estilo hands-on
A intenção desse post é fazer você também aprender em 5 minutos uma das formas de manipulação de arquivos XML.
Gravar dados em XML é uma tarefa bem fácil.
Primeiro crie um DataTable
Depois adicione as colunas, como uma tabela no banco de dados ou uma planilha no excel.
Por fim basta chamar o método WriteXmlSchema passando o nome do arquivo XML a ser criado.
Bem simples até agora, e vai continuar muito simples.DataTable planilha = new DataTable("Template");
planilha.Columns.Add("Matricula");
planilha.Columns.Add("Nome");
planilha.Columns.Add("Nota1");
planilha.Columns.Add("Nota2");
planilha.WriteXmlSchema("TemplateAlunos.xml");
Agora que já temos o schema feito, basta inserir os dados.
Vamos então criar outro arquivo XML para inserir os dados.
Lembrando que esse exemplo é só uma maneira, no caso, a maneira que melhor contribuiu para que eu resolvesse o problema no momento
Então, criando um novo DataTable, lendo o schema já pronto no "TemplateAlunos.xml"
Depois vamos adicionar uma nova linha a tabela e por fim escrever os dados no xml
//lendo o schema criado
anteriormente
tabela.ReadXmlSchema("TemplateAlunos.xml");
//criando uma
nova linha
DataRow linha = tabela.NewRow();
//atribuindo valores a linha
linha["Matricula"] = "243343";
linha["Nome"] = "Joao Bosco";
linha["Nota1"] = "10";
linha["Nota2"] = "5";
//adicionando linhas a
tabela
tabela.Rows.Add(linha);
//escrevendo os dados em um novo
XML
tabela.WriteXml("alunos.xml");
Pronto!
Bem simples e rápido.
Agora com o DataTable você pode fazer qualquer coisa e depois gravar no XML.
Você pode por exemplo jogar os dados do DataTable para o grid e trabalhar com eles lá, inserção edição e etc... e no final gravar no arquivo XML
Espero que essa dica ajude alguem, e que ninguém perca mais de 5 minutos para aprender isso!
Postado por João Bosco Seixas às 00:06 1 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
terça-feira, 18 de março de 2008
Dica .NET e C# - Passando parametros para Thread em C#
Para passar parametros a uma Thread em C# é muito simples.
Basta usar a delagate ParametrizedThreadStart
Vamos seguir um passo a passo para fazer isso então.
1- Você precisa estar familiarizado com criação de threads em C#
para isso, no próprio blog a um outro post que explica como fazer.
2- O método criado que irá executar ao inicializar a thread não deve ter retorno(void) e deve receber como parâmetro apenas uma variável do tipo Object
Exemplo:
static void TrabalharComParametro(Object o){
//uma boa pratica é tratar o tipo de objeto recebido para saber se corresponde com o esperado
//teremos aqui a logica do metodo
}
3- Agora vamos usar nossa Thread parametrizada
//Vamos criar nossa delegate e passar como parametro o nome do metedo que queremos
// que seja executado quando a thread comece
ParametrizedThreadStart operacao = new ParametrizedThreadStart(TrabalharComParametro);
//Agora vamos passar a delegate como parametro para inicialização da thread no momento
// em que instaciamos a thread
Thread minhaThread = new Thread(operacao);
//Agora basta dar um start na thread passando como parametro o objeto e esperar o resultado
minhaThread.Start("String também é objeto, tudo é objeto");
Se nosso método que trabalha recebendo parâmetro tivesse o trabalho de imprimir na tela o que ele recebeu como parâmetro então o texto impresso seria:
String também é objeto, tudo é objeto
Espero que essa dica rápida ajude os navegantes.
Postado por João Bosco Seixas às 15:17 3 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
segunda-feira, 25 de fevereiro de 2008
C# e .NET - Thread - Usando MUTEX para fazer com que seu programa só execute uma instancia
O objetivo deste post é fazer com que só exista uma instancia do programa executando por vez.
Como vimos nos posts anteriores podemos "travar" um bloco de codigo para que ele só seja executado por uma thread por vez.
Então que tal bloquear toda a sua aplicação para que ela rode apenas uma por vez??
Como o MSN por exemplo que só roda um cliente na maquina por vez.
É obvio que se você usar o recurso lock não vai dar nenhum pouco certo, pois a nova instancia de seu programa será uma nova thread e ela vai executar normalmente aquele bloco de codigo porque para todos os efeitos o bloco da nova instancia é outro bloco.
Em C# podemos usar a classe Monitor, ao inves do lock como foi explicado no post anterior. A classe Monitor se comporta exatamente como o lock. Se ela se comporta da mesma maneira então não conseguiremos resultados diferentes.
Porém o sistema operacional tem um objeto que pode fazer a mesma coisa.
O nome dele é MUTEX.
Ele é cerca de 33 vezes mais lento do que usar a classe Monitor, porém ele pode bloquear peças de codigo entre diferentes AppDomains.
Descuple a falta de referencia mas esse dado da performance foi tirado do livro CLR via C#, infelizmente não lembro o nome do autor.
Isso é perfeito para o que queremos, pois duas instancias da nossa aplicação são duas appDomains diferentes.
Então vamos deixas as palavras de lado, já que eu não sou muito bom com elas, e começaremos a mostrar o codigo.
//Utilizamos a classe MUTEX
Mutex meuPrograma = null;
try
{
//essa declaração deve ser feita dentro do bloco try,
// pois se nao existir instancia do programa rodando ele vai gerar uma excessão
meuPrograma = Mutex.OpenExisting("PROGRAMA");
}
catch (WaitHandleCannotBeOpenedException) {
Console.WriteLine("Não existe Instancia do programa aberto");
}
if (meuPrograma == null)
{
meuPrograma = new Mutex(true, "PROGRAMA");
Console.WriteLine("Só pode haver um");
Console.ReadLine();
}
else {
Console.WriteLine("Já existe uma instancia rodando");
Console.ReadLine();
}
Vou deixar as explicações tecnicas um pouco de lado e explicar de maneira didatica.
Você vai criar uma aplicação, ela vai ter um "apelido" para o sistema operacional.
Quando for abrir uma nova aplicação o seu programa vai perguntar ao sistema operacional
se existe alguem rodando que tenha o mesmo apelido.
Caso exista ele vai exibir a mensagem "Já existe uma instancia rodando"
Caso não exista ele vai abrir seu programa normalmente.
Espero ter sido claro na explicação.
Postado por João Bosco Seixas às 11:11 1 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
quarta-feira, 20 de fevereiro de 2008
C# e .NET - Thread Lock - Trancando recursos para execução de threads
Esse texto pode ser melhor visualizado na pagina da Inteligência Digital.
Para acessa-lo, basta clicar aqui.
As vezes é necessario que suas Threads acessem o mesmo objetos e modifiquem valores nesses objetos.
Porém se você estiver trabalhando com um computador multi-processado, por vezes os resultados serão erradospois uma thread vai desfazer o que a outra já fez.
Vou explicar melhor essa historia.
Exemplo Classico:
Temos um contador numa classe X
int contador = 0;
Só existe uma instancia da classe X no seu programa, e toda vez que suas threads fizerem determinada atividade,elas deve incrementar em 1 esse contador.
Nada mais normal do que a classe X possuir um metodo
public void AtualizaContador(){
contador++;
}
Para esse simples exemplo não estamos levando em conta as boas praticas e questões de encapsulamentoque são muito importantes também.
Agora num ambiente multi-processado, imagine 2 Threads no mesmo momento tentando fazer a atualização do contador.
Suponto que nesse ponto o contador tenha o valor 10
De maneira generica, para fazer a atualização, os passos dados pelo processador seriam:
- Salvar o valor 10 no registrador do processador
- Incrementar o valor contido no registrador em 1
- retornar o valor para memoria
Voltando ao exemplo...
Se duas Threads pegassem ao mesmo tempo o valor 10
as duas iam incrementar o valor para 11
porem na hora de salvar em memoria, uma delas ia salvar primeiro o valor 11
por consequencia a outra deveria salvar o valor 12 mas isso não acontece,
ela salva o valor 11 novamente por cima do valor 11 que já estava lá
Causando uma inconsistencia nos dados da nossa aplicação.
Temos diversas formas de tratar isso, principalmente porque incrementação é uma operação thread safe,então temos classes e metodos para tratar especificamente dessa situação.
Mas vamos tratar aqui como se fosse uma situação generica.
Dessa forma usaremos o lock do C#
De maneira muito simples de usar, o lock irá bloquear os recursos do objeto até que a thread que está utilizando o trecho do codigo acabe de processa-lo
Teriamos então o seguinte codigo:
public void AtualizaContador(){
lock(this){
contador++;
}
}
o lock recebe como parametro o this que é uma palavra reservada do C# que referencia o objeto em questão.
No caso, como o metodo está dentro da classe X o this então, representa a classe X
É como se a propria classe estivesse se referenciando.
Espero ter conseguido passar um pouco da importancia do lock.
Existem outras formas de fazer isso, mas teriamos que entrar em outras discussões como dead lock e etc...
então trarei isso em um outro post.
Talvez vocês não enxerguem a importancia disso num exemplo simples como esse, mas em ambientes complexos isso toma proporções enormes.
Espero ter ajudado
Até a proxima.
Esse texto pode ser melhor visualizado na pagina da Inteligência Digital.
Para acessa-lo, basta clicar aqui.
Postado por João Bosco Seixas às 10:51 3 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
terça-feira, 19 de fevereiro de 2008
Dica C# - Critical Region - Thread
Quando trabalhamos com threads podemos ter a nescessidade de abortar o processo durante a execução.
Para isso temos o metodo Abort() que é muito simples de se utilizar.
Porém, abortar uma Thread durante sua execução pode levar algum objeto de seu sistemaa um estado de inconsistencia.
Imagine o seguinte cenario:
Você tem as seguintes linhas para serem executadas dentro da sua Thread
MinhaClasse.NomePessoa = "JOAO";
MinhaClasse.Idade = "22";
MinhaClasse.Hobby = "Programação";
Se você lança um comando Abort(), durante a execução de qualquer uma dessas linhas, a thread vai pararimediatamente.
Imagine seu objeto agora ficando somente com o atributo nome.
Esse objeto não servirá para nada, pois os outros dados importantes não estão contidos nele.
Para evitar que uma chamada Abort(), termine a thread de maneira errada, podemos usar os metodos:
BeginCriticalRegion()
e
EndCriticalRegion()
voltando ao nosso exemplo, poderiamos fazer da seguinte forma:
Thread.BeginCriticalRegion();
MinhaClasse.NomePessoa = "JOAO";
MinhaClasse.Idade = "22";
MinhaClasse.Hobby = "Programação";
Thread.EndCriticalRegion();
Desta maneira, se nosso programa chamasse o metodo Abort() da nossa Thread, enquanto fosse processada alguma das linhas entre as chamadas de Thread.BeginCriticalRegion() e Thread.EndCriticalRegion()
A thread irá esperar a execução acabar para depois, mandar o sinal de termino a thread.
O objetivo é fazer com que todas as linhas na região critica sejam executadas de forma atomica, como se fossem apenas uma linha.
Espero que a dica seja proveitosa para alguem.
Postado por João Bosco Seixas às 00:03 0 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
domingo, 17 de fevereiro de 2008
Criando uma Thread em C#
Nesse post simples, vou mostrar como criar uma Thread em C#.
É importante se trabalhar com Threads para ter uma performance melhor na aplicação.
Por exemplo, se na sua aplicação windows form, você tem uma tarefa que consome muito tempo, e faz essa programação normalmente, o form irá travar enquanto sua aplicação processa essa tarefa.
Usando Threads você evita que isso aconteça, pois sua aplicação irá processar a tarefa "em paralelo" numa outra thread e seu form poderá ser utilizado normalmente.
Vamos ao codigo de uma aplicação console utilizando threads.
class Program
{
//Primeiro Criamos um metodo void que não recebe parametros
//Esse metodo fará o trabalho das Threads
static void Trabalho()
{
Console.WriteLine("Esse é o id da Thread: " + Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Esse é o nome da Thread: " + Thread.CurrentThread.Name);
//Como podem ver é um trabalho bem simples
//Apenas escrevemos o ID e o nome da Thread em execução
}
static void Main(string[] args)
{
//Aqui utilizamos uma delegate que recebe nosso metodo como parametro
//Note que esta delegate só pode receber como parametro
//um metodo void que não recebe argumentos
ThreadStart operacao = new ThreadStart(Trabalho);
//Agora já estamos prontos para criar nossa Thread
//A Thread deve receber como parametro a delagate que indica
//o que deve ser executado quando a Thread for iniciada
Thread minhaThread1 = new Thread(operacao);
//Nome da Thread
minhaThread1.Name = "Exemplo-1";
//Aqui Inicializamos a Thread, então ela executará o que
//foi especificado pela delegate operação
minhaThread1.Start();
//Aqui executamos o mesmo codigo novamente para
//iniciar uma segunda Thread e compararmos os IDs
Thread minhaThread2 = new Thread(operacao);
minhaThread2.Name = "Exemplo-2";
minhaThread2.Start();
Console.ReadLine();
}
}
Essa foi uma introdução simploria a Threads
Em breve postarei mais exemplos...
Postado por João Bosco Seixas às 17:38 2 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
terça-feira, 5 de fevereiro de 2008
Bloqueando Estação de trabalho do Windows
Para mostrar como é facil operar com bibliotecas do windows, farei essa rapida demonstração de como bloquear estação de trabalho do windows.
Normalmente você tem que apertar ctrl + alt + del
depois disso escolher a opção bloquear computador.
Para brincar um pouco com a biblioteca user32.dll vamos fazer essa aplicação muito simples que ao ser ativada bloqueia a estação de trabalho exigindo que seja colocada a senha do usuario novamente para voltar as atividades.
static class Program
{
//Nessa simples linha estamos importando a dll user32 do windows
//que é uma das bibliotecas principais do windows
[DllImport("user32.dll", SetLastError = true)]
//A bliblioteca user32 tem um metodo que não recebe parametros
//chamado LockWorkStation que faz essa função de bloquear a estação de trabalho
//nessa linha declaramos o metodo LockWorkStation(),
//que está no user32.dll, como um metodo externo
public static extern int LockWorkStation();
static void Main()
{
LockWorkStation();
}
}
Postado por João Bosco Seixas às 18:06 1 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft
sábado, 12 de janeiro de 2008
C# - Listar Drives do computador
As vezes nos assustamos com determinadas tarefas pois achamos que teremos que trabalhar com um nivel de abstração mais baixo para fazer coisas que lidam mais diretamente com o sistema de arquivos e com o hardware de maneira geral.
Nesse ponto o .NET framework da show de bola, pois tem abstrações necessarias para varias tarefas que poderiam ser um pouco mais trabalhosas.
Nesse QuickPost vou mostrar como listar os drives de seu computador com pouquissimas linhas de codigo em C#
//Lembrete: importar a biblioteca necessaria ---> using System.IO;
//A classe DriveInfo provê a abstração necessaria para lidar com os Drives do computador
//Nessa classe você encontrará metodos para pegar o espaço livre de cada drive do computador
//você pode ter informação tambem sobre o espaço total de de cada drive e etc...
//para pegar os drives do compuador basta a chamada ao metodo estatico GetDrives()
//da classe DriveInfo
DriveInfo[] drives = DriveInfo.GetDrives();
//laço foreach que é especifico para percorrer coleções de dados
foreach (DriveInfo d in drives) {
Console.WriteLine("Nome: " + d.Name); //pega o nome do drive
Console.WriteLine("Tipo: " + d.DriveType.ToString()); //pega o tipo do drive
Console.WriteLine("Raiz: " + d.RootDirectory.FullName); //pega o diretorio raiz do drive
Console.WriteLine("-----------------------------------------------------");
}
Console.ReadLine();
PS: A listagem para drives de DVD, aponta o tipo como CDROM
PS2: Obter o espaço livre de drives de DVD e CD geram uma exceção caso não haja nenhuma midia no drive.
Daqui pra frente postarei mais pequenas dicas como essa.
Espero que essa dica ajude alguem!!
Até a proxima.
Postado por João Bosco Seixas às 14:19 0 comentários
Marcadores: .NET, C#, Desenvolvimento, Microsoft