A Internet como ferramenta de TI

A tecnologia sofre um processo brutal de transformação, o que obriga que todos nós sempre estejamos alinhados a ela. A internet pode ser uma ótima ferramenta, estreitando os laços entre pessoas e empresas.

A tecnologia, como forte agente de transformação, viabiliza novas formas de pensar, se relacionar, fazer negócios, trabalhar, gerenciar, comprar, vender, etc. Entre todas as tecnologias da informação, uma das mais usadas hoje em dia é a Internet. Por meio dela criou-se uma nova estrutura digital, permitindo compartilhar informações entre pessoas, empresas, organizações e nações, que cada vez mais ficam dependentes da tecnologia para obterem sucesso, e em alguns casos, não resta a opção de não adotá-la.

A internet, como importante ferramenta de TI, acima de tudo, proporcionou o aumento de produtividade. Podemos utilizá-la com vários propósitos, entre eles para contatos profissionais, divulgação de estudos, divulgação de produtos, efetuar transações bancárias, dentre várias outras possibilidades.

Diariamente, as pessoas e organizações têm desafios cada vez maiores, e a competitividade aumenta rapidamente. Para se dar bem nesse cenário complexo, todos nós dependemos cada vez mais de informação de qualidade. Nas organizações, já é praticamente impossível não incorporar a tecnologia no Planejamento Estratégico.

Apenas para termos idéia do avanço tecnológico, o telefone celular que carregamos no bolso hoje é de 10 a 20 vezes mais rápido do que os computadores que usávamos há 12 ou 13 anos (aqueles que tinham o botão “Turbo”).

Com o aparecimento da Internet, a economia mundial passou a ter outro aspecto: A tecnologia tende a tornar-se a força dominante, aumentando o alcance da tecnologia de informação a mais e mais pessoas a cada dia.

Com todas essas mudanças no mercado, foram iniciadas novas formas de negócios onde as empresas estão quase que obrigadas a se adequar aos novos modelos, como lojas virtuais, catálogos digitais, realidade aumentada, etc. Através destes novos modelos, fornecem ao cliente formas diferenciadas de atendimento, novos produtos, preços diferenciados, etc.

Hoje é possível realizar quase todas as tarefas bancárias pela internet, entre elas, pagar contas e fazer transferências, ou seja, a internet facilitou imensamente o alcance à informação.

Apesar de toda essa facilidade, ainda existe certo receio de muitas pessoas em fazer transações pela internet, devido aos inúmeros casos de falta de segurança, pois informações importantes, como dados pessoais, passam por diversos sistemas antes de chegarem ao destino e podem ser copiadas, monitoradas, armazenadas em qualquer ponto, sendo utilizadas de forma inadequada por pessoas mal-intencionadas, etc.

CONCLUSÃO

Dizer que a vida das pessoas e empresas está nas mãos da tecnologia já não é mais assustador. As empresas estão tão dependentes de tecnologia que um único dia sem ela trará muito prejuízo. Para nós também! Em todo esse aspecto podemos incluir o uso da internet e telecomunicações em geral, cada vez mais crescente, e que aderem às necessidades dos usuários, tornando as pessoas cada vez mais próximas umas das outras.

__________________________________________

OBS: Este artigo foi escrito como trabalho a ser entregue na disciplina Gestão de Tecnologia da Informação do curso de Inteligência de Negócios da Faculdade de Tecnologia de Jaú – FATEC.

Referências

• O papel da internet como ferramenta da Tecnologia da Informação, e seus impactos nos diversos setores da economia
• O Crescimento da Internet – 1998 até 2008
• Info: Acesso à internet cresce 8,2% no Brasil
• G1: Brasil ocupa quinta posição em mercado de celulares e internet, diz ONU
• G1: Cresce índice de brasileiros com acesso ao computador
• CETIC.BR: Uso das Tecnologias da Informação e da Comunicação

Obrigado e até mais!

Top 10 Recursos de Desenvolvimento do SQL Server 2008

Encontrei hoje um artigo que mostra um top 10 dos melhores recursos de desenvolvimento no SQL Server 2008. Para quem tiver interesse, o link é este.

SQL server 2008 improves developer productivity by providing seamless integration between frameworks, data connectivity technologies, programming languages, Web services, development tools and data. This article covers the top 10 developer features introduced in SQL server 2008.

Fonte: The Database Journal

Obrigado e até mais!

Aplicando temas no Visual Studio 2010

A extensão “Visual Studio Color Theme Editor” permite aplicarmos temas no Visual Studio 2010. Alguns temas já são pré-preparados, como “Windows Aero”, “Windows Classic”, etc. Para fazer download basta acessar o site do Visual Studio no MSDN e ir em Gallery.

Permite aos usuários personalizar o Visual Studio 2010, as cores utilizada nos menus, barras de ferramentas, abas, barras de título e as cores do ambiente. A explicação passo a passo detalhado que descreve todas as características estão disponíveis aqui.

Aplicar temas: 

O menu Theme lista os temas atualmente instalados e permite trocar rapidamente os temas. 

Editar temas: 

Existem várias funcionalidades que tornam mais fácil a criação de novos temas ou editar temas existentes. 

Copiar e colar cores: 

Ao selecionar uma ou mais cores na caixa de diálogo Customize Colors, você pode copiar as cores. Na área de transferência, esses valores são armazenados como valores hexadecimais como RGB em uma seqüência delimitada por vírgulas. Você pode então colar os valores em outra cor. Você pode até mesmo usar as cores copiadas em células do Excel, por exemplo. 

Desfazer e refazer alterações: 

Qualquer uma das operações que tomar quando o a caixa de diálogo Customize Colors estiver aberta pode ser desfeita e refeita. 

Importação e exportação temas: 

Por padrão, o atual conjunto de temas personalizados é guardado no registro, e restaurado a cada vez que você iniciar o Visual Studio. No entanto, você pode exportar as cores em um arquivo VSTHEME para fins de backup ou para compartilhar com amigos.Tenha cuidado: a importação de um tema que você já tem irá substituir a cópia atual.

Fonte: Visual Studio Color Theme Editor – Microsoft

Depois de instalado, um novo menu será disponibilizado no Visual Studio permitindo a troca do tema ou criação de temas customizados.

Veja diferenças entre alguns temas disponíveis:

Default:

Windows XP Blue:

Emerald:

Para customizar algum tema ou criar um novo, escolha a opção Customize Colors.

Se desejar desinstalar / desabilitar esta extensão, vá em Tools > Extension Manager, escolha a aba All, clique sobre ‘Visual Studio Color Theme Editor’, e escolha a opção desejada (‘Disable’/’Uninstall’).

Obrigado e até mais!

Visual Studio LightSwitch

A Microsoft liberou para a comunidade do MSDN em 18/09 o download do Visual Studio LightSwitch na versão beta, que promete permitir que usuários não desenvolvedores criem aplicações windows, web e nas nuvens. Além disso, é possível utilizar VB.Net e C# nas aplicações.

O Visual Studio LightSwitch utiliza modelos e outros componentes que facilitam a criação de aplicações para PCs, para a Web e para a nuvem e, em muitos casos, não requer que o usuário tenha que lidar com o código durante o processo.

De acordo com a Microsoft, os usuários do LightSwitch podem usar o Visual Basic ou C# para as aplicações e podem até mesmo conectar suas aplicações ao Excel, SharePoint ou aos serviços do Windows Azure.

Além disso, os usuários podem criar suas aplicações para que elas sejam executadas em qualquer ambiente compatível com o Silverlight: navegadores (Internet Explorer, Safari, Firefox), em PCs com o Windows ou no Windows Azure, por exemplo.

Embora o Visual Studio LightSwitch Beta 1 esteja disponível hoje para os assinantes da MSDN, ele será disponibilizado para download público apenas na próxima segunda-feira, 23 de agosto, através do LightSwitch Developer Center.

Fonte: Baboo

Saiba mais:

• Visual Studio LightShitch Beta
• Exemplos
• Documentação
• Primeiras impressões por João Cardoso
• Introducing Visual Studio LightSwitch
• Introducing Microsoft® Visual Studio® LightSwitch™

Artigos da semana

Alguns links para artigos que vi nessa semana:

• Blog do Aurivan Galdino: SaaS – Software as a Service (Software como Serviço)
• Marquinhos Net Blog: Stop/Start no SQLSERVER via comandos C#
• Marquinhos Net Blog: SQL Server: Descobrir informações do banco de dados
• Israel Aece: Visualizador para JSON
• Israel Aece: Analisando a exceção ContractException
• .Net Unplugged: Testando com AAA (Arrange, Act, Assert)
• Renato Haddad: Aula gratuita de EF 4 – Dicas e truques
• Renato Haddad: Entenda Design Patterns passo a passo
• Patrícia Peck: DLP – Como Fazer sem Riscos Legais

Obrigado

Trabalhando com tipos anuláveis

Existem algumas situações onde precisamos estabelecer que uma variável pode ser nula. Isso acontece com muita frequência quando utilizando Modelos Objeto-Relacional, onde uma “cópia” da estrutura das tabelas da base de dados é feita dentro do modelo gerado no Visual Studio em forma de classes. Declarar variáveis como anuláveis é extremamente simples, e pode ser feito assim:

// C# - Pode ser assim
System.Nullable<decimal> decimalAnulavel = null;
System.Nullable<int> inteiroAnulavel = null;
System.Nullable<bool> booleanAnulavel = null;

// C# - Ou assim
decimal? decimalAnulavel = null;
int? inteiroAnulavel = null;
bool? booleanAnulavel = null;

' VB.NET - Existe uma única maneira
Dim decimalAnulavel As Nullable(Of Decimal) = Nothing
Dim inteiroAnulavel As Nullable(Of Integer) = Nothing
Dim booleanAnulavel As Nullable(Of Boolean) = Nothing

Como exemplo, uma variável bool anulável pode receber True, False e Null.

Ao declarar uma variável como anulável, são habilitadas duas novas propriedades:

• HasValue: determina se a variável anulável possue valor.
• Value: contém o valor não nulo da variável

Essas duas propriedades pode ser usadas em conjunto, como o código a seguir demonstra.

// C#
if (decimalAnulavel.HasValue)
    Console.WriteLine(decimalAnulavel.Value.ToString());
else
    Console.WriteLine("Valor nulo");

' VB.NET
If (decimalAnulavel.HasValue) Then
    Console.WriteLine(decimalAnulavel.Value.ToString)
Else
    Console.WriteLine("Valor Nulo")
End If

O Operador ?? do C#

O operador ?? facilita a manipulação de tipos anuláveis. Com ele podemos informar um valor fixo caso a variável seja nula.

// C#
Console.WriteLine((decimalAnulavel ?? decimal.Zero).ToString());

No VB.NET é bem parecido, mas não existe o operador ??, então usa-se o próprio If.

' VB.NET
Console.WriteLine((If(decimalAnulavel, Decimal.Zero)).ToString())

O Operador ?: do C#

O operador ?: funciona como um If, com a sintaxe (condicao ? true : false).

// C#
Console.WriteLine((decimalAnulavel.HasValue ?
                   decimalAnulavel.Value.ToString() :
                   "Valor nulo"));

No VB.NET é bem parecido, mas não existe o operador ?:, então usa-se o próprio If.

' VB.NET
Console.WriteLine((If(decimalAnulavel.HasValue, _
                      decimalAnulavel.Value.ToString(), _
                      "Valor nulo")))

Saiba mais:

• Nullable Types
• Operador ??
• Operador ?:
• Operadores do C#
• Nullable Types in VB.Net: Basic Introduction

Obrigado.

Dicas Windows 7

Esta semana, o local onde trabalho comprou alguns novos computadores DELL que já vieram com Windows 7. A maioria das pessoas que receberam esses novos computadores utilizavam anteriormente o Windows XP. Como já faz algum tempo que uso o Windows 7, alguns vieram me perguntar algumas coisas a respeito da utilização dele. Para ajudá-los, procurei algumas coisas na internet e achei alguns sites com dicas interessantes.

Veja:

• Info Wester: Quinze dicas para o Windows 7
• Guia do PC: 30 dicas e truques para o Windows 7
• Explorando e Aprendendo: Especial Windows 7

Mesmo usando o Windows 7 desde o seu lançamento, algumas coisas que li nesses links não conhecia. Muito Bom!

Obrigado

Exemplo de Implementação de IDisposable

A interface IDisposable é usada para liberar recursos. O garbage collector (coletor de lixo) libera automaticamente a memória alocada para um objeto gerenciado quando este objeto não estiver mais sendo utilizado. No entanto, não é possível prever quando esta coleta de lixo irá ocorrer. Além disso, o garbage collector não tem conhecimento dos recursos não gerenciados.

Usamos o método Dispose desta interface para liberar explicitamente recursos não gerenciados em conjunto com o garbage collector. O consumidor de um objeto pode chamar esse método quando o objeto não for mais necessário.

Inicialmente, precisamos fazer a classe que queremos implementar IDisposable herdar desta interface.

// C#
public class GerenciarClientes : IDisposable
{
    public void Dispose()
    {

    }
}

' VB.NET
Public Class GerenciarClientes
    Implements IDisposable

    Public Overridable Sub Dispose() Implements IDisposable.Dispose

    End Sub
End Class

OBS: Em C#, para que o próprio Visual Studio implemente o método Dispose, basta clicar com o botão direito do mouse sobre a interface, escolher a opção ‘Implement Interface’ e ‘Implement Interface’ novamente. Esse mesmo procedimento funciona com a implementação de qualquer interface em uma classe.

Para controlarmos corretamente a liberação dos recursos, é necessário criar uma variável do tipo booleana, que indicará se o método Dispose já foi disparado.

Além disso, precisamos criar um método privado que será chamado de lugares distintos e controlará quais recursos (gerenciados ou não) devem ser liberados.

// C#

// booleano para controlar se
// o método Dispose já foi chamado
bool disposed = false;

// método privado para controle
// da liberação dos recursos
private void Dispose(bool disposing)
{
    // Verifique se Dispose já foi chamado.
    if (!this.disposed)
    {
        if (disposing)
        {
            // Liberando recursos gerenciados

        }

        // Seta a variável booleana para true,
        // indicando que os recursos já foram liberados
        disposed = true;
    }
}

' VB.NET

' booleano para controlar se
' o método Dispose já foi chamado
Private disposed As Boolean = False

' método privado para controle
' da liberação dos recursos
Private Sub Dispose(ByVal disposing As Boolean)
    ' Verifique se Dispose já foi chamado.
    If Not Me.disposed Then
        If disposing Then
            ' Liberando recursos gerenciados

        End If

        ' Seta a variável booleana para true,
        ' indicando que os recursos já foram liberados
        disposed = True
    End If
End Sub

Dentro do método público Dispose, é necessário chamar o método privado Dispose e também informar o garbage collector para não chamar o método finalizador da classe, pois estamos controlando isso manualmente. Para isto, utilizamos o método GC.SuppressFinalize().

// C#
bool disposed = false;

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

' VB.NET
Dim disposed As Boolean = False

Protected Overridable Sub Dispose() Implements IDisposable.Dispose
    Dispose(True)
    GC.SuppressFinalize(Me)
End Sub

Por fim, precisamos programar o método finalizador da classe, que é invocado pelo garbage collector para liberar os recursos. Toda liberacao implementada dentro dele só será executada quando o metodo for invocado, porém não conseguimos saber quando isto vai acontecer e recursos importantes podem ficar presos até que isto aconteça.

// C#
~GerenciarClientes()
{
    Dispose(false);
}

' VB.NET
Protected Overrides Sub Finalize()
    Dispose(False)
    MyBase.Finalize()
End Sub

Pronto, implementamos IDisposable. Com essa implementação, sempre que tivermos uma instância da classe que não será mais utilizada, devemos chamar o método Dispose ou envolvê-la em um bloco using.

// C#

// forma simples
GerenciarClientes g1 = new GerenciarClientes();

// código consumidor da instância

// Liberando o recurso
g1.Dispose();

// usando try...finally
GerenciarClientes g2 = new GerenciarClientes();
try
{
    // código consumidor da instância
}
finally
{
    g2.Dispose();
}

// ou com using
using (GerenciarClientes g3 = new GerenciarClientes())
{
    // código consumidor da instância
} // aqui o método Dispose é invocado

' VB.NET

' forma simples
Dim g1 As New GerenciarClientes()
' código consumidor da instância

' Liberando o recurso
g1.Dispose()

' usando Try...Finally
Dim g2 As New GerenciarClientes()
Try
    ' código consumidor da instância
Finally
    g2.Dispose()
End Try

' ou com using
Using g3 As New GerenciarClientes()
    ' código consumidor da instância
End Using ' aqui o método Dispose é invocado

Referências

• Interface IDisposable
• Método GC.SuppressFinalize
• Garbage Collector
• Método IDisposable.Dispose
• Liberando os objetos de forma apropriada

Código Fonte

O código fonte deste post pode ser baixado aqui.

Obrigado

Dica: Breakpoint Condicional

Quando inserimos um breakpoint no código, existe a possibilidade de colocar uma condição para que o cursor realmente pare naquele ponto. Vamos imaginar o código a seguir:

// C#
for (int i = 0; i < 10; i++)
{
    Console.WriteLine("Contador atual: {0}", i.ToString());
}

Agora desejo colocar um breakpoint no comando Console.WriteLine, mas apenas para quando o contador i atingir o número 6.

Para isto, basta inserir o breakpoint na linha desejada (com o F9 mesmo), clicar com o botão direito do mouse sobre o breakpoint e, no menu de contexto aberto, escolher a opção Breakpoint > Condition.

Na tela Breakpoint Condition, basta inserir a condição desejada e clicar em OK.

Dessa forma, o cursor irá parar somente quando a condição for verdadeira.

Para mais informações sobre Debugging e Breakpoints (em inglês):

• Building and Debugging (Visual C#)
• Breakpoints and Tracepoints

OBS: Originalmente vi essa dica no blog do ScottGu.

Obrigado.

Passar parâmetros para Threads

Há algum tempo, escrevi um post que mostra formas de programar threads em C# e VB.NET. Na ocasião, mostrei uma forma de passar parâmetros para uma thread. O intuito deste post é mostrar uma outra forma existente para este mesmo objetivo.

Primeiro, criamos uma classe que conterá propriedades que representarão os parâmetros que devem ser passados para a Thread.

// C#
public class DadosLog
{
    public Exception Exception { get; set; }
    public string StrNomeProjeto { get; set; }
    public string StrNomeClasse { get; set; }
    public string StrNomeMetodo { get; set; }
}

' VB.NET
Public Class DadosLog
    Public Property Exception() As Exception
        Get
            Return _Exception
        End Get
        Set(ByVal value As Exception)
            _Exception = value
        End Set
    End Property
    Private _Exception As Exception
    Public Property StrNomeProjeto() As String
        Get
            Return _StrNomeProjeto
        End Get
        Set(ByVal value As String)
            _StrNomeProjeto = value
        End Set
    End Property
    Private _StrNomeProjeto As String
    Public Property StrNomeClasse() As String
        Get
            Return _StrNomeClasse
        End Get
        Set(ByVal value As String)
            _StrNomeClasse = value
        End Set
    End Property
    Private _StrNomeClasse As String
    Public Property StrNomeMetodo() As String
        Get
            Return _StrNomeMetodo
        End Get
        Set(ByVal value As String)
            _StrNomeMetodo = value
        End Set
    End Property
    Private _StrNomeMetodo As String
End Class

Em seguida, o método que executará o processo em segundo plano deve ter como parâmetro de entrada um object.

// C#
public void ExecutarLogErro(object _dadosLog)
{
    DadosLog dadosLog = (_dadosLog as DadosLog);

    // Gravar Log no Repositório ou no Log de Eventos do Windows
}

' VB.NET
Public Sub ExecutarLogErro(ByVal _dadosLog As Object)
    Dim dadosLog As DadosLog = TryCast(_dadosLog, DadosLog)

    ' Gravar Log no Repositório ou no Log de Eventos do Windows
End Sub

Para concluir, passamos a instância da classe DadosLog no método Start() no momento da chamada à thread.

// C#
public void LogarErro(Exception exception,
    string strNomeProjeto,
    string strNomeClasse,
    string strNomeMetodo)
{
    DadosLog dadosLog = new DadosLog()
    {
        Exception = exception,
        StrNomeClasse = strNomeClasse,
        StrNomeMetodo = strNomeMetodo,
        StrNomeProjeto = strNomeProjeto
    };

    GerenciaLogErro gle = new GerenciaLogErro();
    Thread t = new Thread(gle.ExecutarLogErro);
    t.IsBackground = true;
    t.Start(dadosLog);
}

' VB.NET
Public Sub LogarErro(ByVal exception As Exception, _
                     ByVal strNomeProjeto As String, _
                     ByVal strNomeClasse As String, _
                     ByVal strNomeMetodo As String)
    Dim dadosLog As New DadosLog() With { _
     .Exception = exception, _
     .StrNomeClasse = strNomeClasse, _
     .StrNomeMetodo = strNomeMetodo, _
     .StrNomeProjeto = strNomeProjeto _
    }

    Dim gle As New GerenciaLogErro()
    Dim t As New Thread(AddressOf gle.ExecutarLogErro)
    t.IsBackground = True
    t.Start(dadosLog)
End Sub

Essa é apenas mais uma maneira de passar informações para a Thread. Existem outras e mais para frente tentarei demonstrar aqui.

OBS: Este código fonte pode ser baixado aqui.

Obrigado.