Excel – Ativando Macros Automaticamente

Excel Macros Ativar Para Sempre
Eis um assunto polêmico. Tão polêmico que desde a primeira versão vez em que tive contato com o Microsoft Excel e VBA, ouço falar dele. Para quem programa em VBA, ter as macros ativadas é um requisito para que todo seu código, fruto de suas longas horas de trabalho façam algum sentido na vida de seus usuários e clientes.

Infelizmente, não há como forçar sua ativação pelo próprio Excel. É preciso intervenção externa, seja via configuração (nível de segurança de macros) ou por aplicação externa. Existe a opção de certificados digitais, que é mais segura, mas exigem um nível de conhecimento e acesso ao computador muito específico. Não vou entrar em detalhes, pois acredito que se chegou até aqui, já deve ter passado por tudo isso.

A opção que vamos explorar para obter essa façanha é a “aplicação externa”, onde vamos produzir um aplicativo em um linguagem de programação que não o VBA para ativar as automaticamente as macros. A escolha desta opção se dá, principalmente pelo fato de facilitar a distribuição, uma vez que não é preciso ter acesso a máquina do usuário ou qualquer outra configuração. É a abordagem perfeita para aqueles que distribuem suas planilhas para clientes a distância.

O aplicativo externo

Utilizarei a linguagem C# rodando sobre .NET. Se não a conhece, recomendo dar uma lida neste curso, até porque, todas as instruções para seguir os passos do aplicativo que vamos construir estão nele.

O motivo da escolha é porque, primeiro, já trabalho com ela há mais de 10 anos (UAU!). Segundo, ela tem sido a linguagem  mais utilizada para produzir aplicações para Windows na última década e vem sendo atualizada constantemente. Terceiro, se está lendo este artigo de um computador com Windows, você provavelmente já a tem instalada, tanto para executar como para criar aplicativo.

Nosso aplicativo será responsável por executar o Microsoft Excel, abrir o arquivo  que contém as nossas macros com elas ativadas, sem intervenção  do usuário. Bom demais para ser verdade não? Pois é isso mesmo que iremos fazer.

Criando o aplicativo

Passarei as instruções para que você possa criar o aplicativo sem precisar de programas adicionais. No futuro, você poderá facilitar o processo utilizando ferramentas mais avançadas, como o Visual Studio Express (que possui versões gratuitas). Para o momento, usaremos o Bloco de Notas e o compilador que vem com o .NET Framework, já instalado no seu Windows.

Vamos começar. Primeiro, crie uma pasta no seu disco no caminho:

C:\ExcelMacros.

É aqui que vamos trabalhar neste tutorial. Esse caminho não é obrigatório. No produto final, ele poderá estar onde quiser.

Obtenha seu arquivo Excel com suas macros. De preferência, coloque uma macro no Auto_Open ou no Workbook_Open para ter a visão imediata de que as macros estão sendo executadas. Salve o arquivo dentro da pasta que acabamos de criar acima. Para exemplo, vou usar um arquivo chamado ExcelComMacros.xlsm com o seguinte código VBA:

Private Sub Workbook_Open()
    MsgBox "Funcionou!"
End Sub

Dessa forma, terei certeza se o código funcionou assim que executar o aplicativo.

Agora, abra o Bloco de Notas e insira nele o seguinte código:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Threading;
using System.Windows.Forms;
 
    static class Program
{
	// variáveis de instãncia
	static object oExcel = null;
	static object oBooks = null;
	static object oBook = null;
	static object oMissing = System.Reflection.Missing.Value;
	static System.Globalization.CultureInfo ci = Thread.CurrentThread.CurrentCulture;
 
	[STAThread]
	static void Main()
	{
		string CaminhoDoArquivo = @"C:\ExcelMacros\ExcelComMacros.xlsm";
 
		if (ExcelEstaInstalado())
		{
			try
			{
				if (System.IO.File.Exists(CaminhoDoArquivo))
				{
					AbrirArquivo(CaminhoDoArquivo); 
				}
				else
				{
					MessageBox.Show(string.Format("O arquivo {0} não foi encontrado", CaminhoDoArquivo));
				}
			}
			catch (System.IO.IOException)
			{
				MessageBox.Show("Erro de acesso ao arquivo. Verifique o arquivo de configuração ou as permissões de pasta");
			}
		}
		else
		{
			MessageBox.Show("Não foi possível encontrar a instalação do Microsoft Excel no seu computador");
		}
 
		Application.Exit();
	}
 
	private static void AbrirArquivo(string caminhoDoArquivo)
	{
		object oFileName = caminhoDoArquivo;
		oExcel = Activator.CreateInstance(Type.GetTypeFromProgID("Excel.Application"));
		oExcel.GetType().InvokeMember("AutomationSecurity", BindingFlags.SetProperty, null, oExcel, new object[] { 1 }, ci);
		oExcel.GetType().InvokeMember("Visible", BindingFlags.SetProperty, null, oExcel, new object[] { true }, ci);
		oBooks = oExcel.GetType().InvokeMember("Workbooks", BindingFlags.GetProperty, null, oExcel, null, ci);
		oBook = oBooks.GetType().InvokeMember("Open", BindingFlags.InvokeMethod, null, oBooks, new object[] { oFileName, oMissing, false }, ci);
	}
 
	public static bool ExcelEstaInstalado()
	{
		Type officeType = Type.GetTypeFromProgID("Excel.Application");
 
		if (officeType == null)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
}

Salve o arquivo com o seguinte nome e caminho:

C:\ExcelMacros\AbreExcelComMacros.cs

A extensão “.cs” é própria para arquivos da linguagem C#. Como o C# é uma linguagem compilada e não script (ver mais no curso já citado), precisamos compilar nosso pequeno programa para que ele se torne um executável. Para isso, no seu computador, navegue até a pasta:

C:\Windows\Microsoft.NET\Framework

Caso seu Windows seja 64bit, a pasta alvo será “Framework64”. Dentro desta pasta, você verá todas as versões do .NET Framework, necessários para executar programas em C# instalados no seu computador. Em nosso caso, vamos utilizar a versão v2.0.50727, ou simplesmente versão 2.0, que tem tudo o que precisamos e também porque temos mais certeza de que os computadores dos clientes o terão instalado.

Agora, abra o Prompt de Comando do Windows (sim, aquela tela preta esquisita) executando-a em modo administrador. Nele, navegue até a pasta que encontramos logo acima com o comando:

cd C:\Windows\Microsoft.NET\Framework\v2.0.50727

Nessa pasta, existe o executável chamado csc.exe (C–Sharp Compiler), que é nosso compilador, ou seja, o cara que vai transformar nosso “.cs” em um “.exe” pra lá de útil. Se algum dia chegou a estudar Java, ele é equivalente ao “javac”.

Por fim, vamos compilar nosso programa. Execute a seguinte linha de comando:

csc /target:winexe /out:”C:\ExcelMacros\AbreExcelComMacros.exe” “C:\ExcelMacros\AbreExcelComMacros.cs”

O que isso faz? Gera um arquivo “.exe” do nosso código C# pronto para ser executado. Se alguma coisa der errado aqui, como alguma mensagem de erro do compilador, volte e recomece desde a criação da pasta.

Os três parâmetros passados para o compilador foram:

  • out: o caminho do arquivo de saída
  • target: o tipo de aplicativo gerado, no caso, um Windows Application
  • no fim de tudo, o arquivo com o código fonte da aplicação

O resultado será provavelmente este:

A pasta C:\ExcelMacros após a compilação do aplicativo
A pasta C:\ExcelMacros após a compilação do aplicativo

Em destaque, nosso arquivo .exe gerado. Agora, execute-o (duplo-clique, enter, etc). Se tudo der certo, você verá seu arquivo Excel ser aberto com as macros ativadas.

Como funciona?

Aqui, há algumas coisas para explicar. Como a intenção aqui é ser simples, vou resumir ao máximo:

O código que faz a maior parte da mágica está dentro do método AbrirArquivo, que recebe o caminho do arquivo no Excel no disco. O código cria uma instância o aplicativo Excel, o que é bastante trivial até mesmo no VBA. A grande sacada está na propriedade AutomationSecurity, que aqui é definida para o nível de segurança mínimo, o que faz que com o Excel, neste contexto, aceite executar as macros automaticamente.

O resto é simples, abre o arquivo, define o aplicativo como visível, etc. Há algumas verificações “bônus”, como checar se o arquivo existe ou se o Excel está instalado no método ExcelEstaInstalado.

Outro detalhe que merece ser mencionado é o fato do código usar Reflection (no linguajar do VB, Late Binding) ao invés de fazer referência a bibliotecas. O motivo é que o Excel e todo o Office tem APIs versionadas. Se você fizer um código fazendo referência para a versão 2010, abrir na 2007 daria conflito. O código como está, evita esse problema.

Tudo pronto

De posse desta façanha, você pode agora distribuir suas planilhas com este arquivo de apoio que servirá para facilitar a execução de seus aplicativos. Para este caso em específico, se você dominar a linguagem C#, poderá incrementar seu aplicativo com uma séria e outras verificações.

Arquivos de Exemplo:

ExcelMacros.zip (11.5 KiB)

Acompanhem a discussão no fórum:

https://www.tomasvasquez.com.br/forum/viewtopic.php?f=23&t=2946

Bom proveito!

Biblioteca MsComCtl – Incompatibilidade com alguns SP´s do Office

Olá a todos do blog.

No início deste mês passei por um grande problema que foi solucionado após inúmeras pesquisas pela internet.

Meu sistema operacional (licenciado) fez uma atualização de algumas autalizações de segurança e SP´s do Office (licenciado). O computador foi reiniciado e, a partir desse iniciação, todas das planilhas que utilizaram algum objeto/script da biblioteca MSCOMCTL (ListView, TreeView, ProgressBar, StatusBar e outros) pararam de funcionar. Abria o arquivo e acusava uma enorme variedades de erros.

Este erro inclusive danificou algumas funcionalidades padrões do Office como: copiar, salvar, localizar, substituir,etc.

Após pesquisas, desistalações, instalações, baixar pacotes de componentes e tudo o quanto imaginar, a ponto já de desistir, encontrei o material do link abaixo:

http://technet.microsoft.com/pt-br/security/bulletin/ms12-027

Em resumo para os interessados. A biblioteca em questão possui uma incompatibilidade com alguns dos produtos da Microsoft. Melhor dizendo, algumas atualizações (Service Pack´s, por exemplo), causando uma situação de Vulnerabilidade no Sistema Operacional. No meu caso, foi incompatibilidade com o SP3 do Office 2007.

Neste link, esse problema é discutido para todos os pacotes e links para atualizações de correção são encontrados.

Bem, acredito que nínguem tenha passado por este problema, mas caso ocorra, fica ai uma boa solução. Caso não aconteça, e farei votos para isso, fica um material super interessante para conhecimeto.

Abraço galera e obrigado pela força que todos tem dado no Blog e no Fórum para meu aprendizado.

ASP.NET – Obtendo o valor de um WebControl no OnInit do WebForms

Bom, outro dia disse que também sabia escrever sobre .NET. Como o pessoal de tecnologia é cético e apesar dos artigos já escritos aqui, vou tentar me arriscar em mais para tirar a prova.

Se tem algo que gosto no WebForms, é a versatilidade. Montagem de páginas dinâmicas (entenda montar como adicionar controles na página em tempo de execução) foi algo com que sempre me dei bem. CMSs como DotNetNuke e Umbraco são exemplos dessa “dinamicidade”. Quem vive disso sabe do que estou falando, das suas vantagens, e problemas.

Dentre eles, é que, como trabalhamos com controle dinâmicos, temos o cuidado de montar todos eles no evendo OnInit da página para manter o ViewState intacto. Até aqui, sem segredos. O problema é quando precisamos aplicar alguma regra de negócio na montagem dos controles que dependa por exemplo, de um valor num TextBox. Isso é um problema porque no OnInit, o ViewState ainda não foi aplicado.

Bom, a informação está lá no ViewState, mas como chegar até ela? Na necessidade, vasculhando o próprio ViewState e com a ajuda deste “How To” da Microsoft, cheguei num método que recebe como parâmetro o UniqueID do controle e o HttpRequest, você consegue chegar no valor antes antes do Page_Load.

public static string getControlValueByRequest(string UniqueID, HttpRequest request)
{
    System.Collections.Specialized.NameValueCollection postedValues = request.Form;
    String nextKey;
    String value = string.Empty;
 
    for (int i = 0; i < postedValues.AllKeys.Length; i++)
    {
        nextKey = postedValues.AllKeys[i];
        if (nextKey.Substring(0, 2) != "__")
        {
            if (nextKey == UniqueID)
            {
                value = postedValues[i];
            }
        }
    }
 
    return value;
}

Aos mais entendidos, sabemos que a informação pode ser recuperada pelo Request.Form, mas o vínculo do valor com o controle de origem da informação que é o complicado, e é onde o método acima faz o trabalho sujo de passar por todo o conjunto de chaves/valor guardado no Request.Form e aplicando uma “regrinha” (atenção ao if (nextKey.Substring(0, 2) != “__”)) para chegar no valor desejado.

Isto posto, mais um helper para seus projetos WebForms, pelo menos para que ainda os cria. 🙂

Bom proveito!

How To da Microsoft

http://msdn.microsoft.com/en-us/library/6c3yckfw.aspx

Dicas – Renomeando arquivos em massa no C#

Por essas e outras é muito bacana ser um programador! 😀

Mas primeiro, um pouco de história. Precisando renomear um série de arquivos em uma pasta do computador, vamos lá buscar na internet quais são as opções que existem para fazê-lo. Nada além do que o Windows é capaz. O mesmo permite que você renomeie em massa, selecionando vários arquivos, eles terão o mesmo nome com extenções diferentes, ou indexados se tiverem a mesma. No caso, o que queria era remover uma determinada string de vários arquivos, ou substituir por outra.

O resultado? Um programa em C# feito em modo Console que foi capaz de executar a proeza. Levou um tempo para refiná-lo, mas ficou bacana:

using System;
using System.IO;
 
public class RenomeiaArquivos
{
	public static void Main(string[] args)
	{
		// coleta os parâmetros, se houver
		if (args.Length <= 0) {
			// encerra
			Console.WriteLine("Sem parâmetros?!?!?");
			return;
		}
		// 0 é a pasta
		string folder = args[0];
		// valida
		if (!Directory.Exists(folder)) {
			Console.WriteLine("Diretório inexistente");
			return;
		}
		// 1 é a string de procura
		string find = args[1];
		// valida
		if (string.IsNullOrEmpty(find)) {
			Console.WriteLine("A string de procura não pode ser vazia");
			return;
		}
		// 2 é a string de substituição
		string replace = args[2];
 
		foreach(string file in Directory.GetFiles(folder)) {
			Console.WriteLine(string.Format("Renomeando arquivo {0}",  new object[] { file }));
			try {
				File.Move(file, file.Replace(find, replace));
				Console.WriteLine("OK");
			}
			catch {
				Console.WriteLine("Ops! Não foi possível renomear este arquivo!");
			}
		}
	}
}

A chamada é simples, mas precisa ser feita em modo Console:

  • Abra o Prompt de comando
  • Aponte para a pasta em que está o executável (mais abaixo para download)
  • Digite RenomeiaArquivo “[PASTA]” “[PROCURA]” “[SUBSTITUI]”
  • Onde:
    • [PASTA] = É a pasta onde estão seus arquivos a serem renomeados
    • [PROCURA] = O texto procurado no nome do arquivo que será substituído
    • [SUBSTITUI] = O texto que será colocado no texto de procura

Voilá! Seus arquivos serão renomeados em massa! Rápido, simples, eficaz!

Fica a promessa de uma versão mais amigável ao usuário final com uma tela e tudo mais. Vão os arquivos desta versão logo abaixo:

Bom proveito!