Até o C# 6.0, chamar um método que utiliza parâmetros out não é tão fluido, pois você precisa declarar as variáveis antes de chamar o método, e nem é possível usar o var já que normalmente não se inicializa variáveis que são argumentos do método out.

Então você precisa verificar quais os tipos das variaveis utilizadas nos parametros out, voltar e declarar antes do método:

public void OutVariablesExample60()
{
    int myX;//var myX doesn't work
    int myY;

    if(MethodOut(out myX, out myY))
    {
        Console.WriteLine(myX);
    }
}

No C# 7.0 esta experiência será melhorada, ao chamar o método você pode declarar as variáveis de forma inline. Com isso o compilador sabe os tipos delas, permitindo inclusive o uso do var:

public void OutVariablesExample70()
{
    if (MethodOut(out int myX, out var myY))
    {
        Console.WriteLine(myX);
    }
}

As variáveis declaradas estarão no escopo do bloco onde o método é chamado. No Preview 4 o compilador ainda restinge o escopo para o statement onde a variável foi declarada, por isso só funciona como no exemplo acima, onde temos um bloco IF. Esta restrição será removida até a versão final.

Sempre que novas funcionalidades são acrescentadas acho interessante verificar como o código IL é gerado para saber como foi feita a implementação. Neste caso é bem simples, o novo código gera uma versão identica ao exemplo em C# 6.0.

Permalink | Comments (0)

Tags: c#7.0

Categories: Artigos

Se você ainda não está usando o Visual Studio 2015 RC, que vem com uma extensão do GitHub, vai ter problemas ao sincronizar seu repositório com o GitHub após ativar o Two Factor Authentication.

Para quem ainda não viu a nova extensão pro VS2015:

Atualmente, quem usa o VS2013, vai se deparar um com erro 401, e a tela de login.

Clique em Sync

Será exibida a tela de login.

Não adianta colocar seu login e senha. Pois agora o Two Factor Authentication está ativo.

Como o Visual Studio não suporta essa funcionalidade, você vai precisar criar um Token no site do GitHub. O que é bem simples, acesse o link https://github.com/settings/tokens e clique em "Generate new token"

As opções padrões são suficientes:

Guarde o token gerado

Ele deve ser usado no login do login, a senha deve ficar em branco:

Com isso você vai conseguir sincronizar com sucesso:

Permalink | Comments (0)

Tags: visual studio 2013 GitHub Source Control

Categories: Artigos

Perguntei para o Eric Lippert por que o C# usa UTF-16, já que não é compacto como o UTF-8 nem com comprimento fixo como o UTF-32.

Em resumo, por compatibilidade com o VB e COM. Você pode ler a resposta completa no blog da Coverity

Permalink | Comments (0)

Tags: c# encoding string

Categories: Artigos

Estamos acostumados a usar transações sempre que trabalhamos com banco de dados, mesmo pra quem usa um ORM como o Entity Framework, que cria as transações implicitamente. Isso tudo pra garantir que nossas alterações sejam atomicas, evitando pedidos de compra sem itens, um débito sem um crédito, um pagamento de salário sem marcá-lo como pago, etc.

Esse processo fica mais complicado quando temos arquivos em disco envolvidos, por exemplo, um processo onde se insere uma linha no banco e move um arquivo, principalmente dentro de um laço. Se ocorrer uma exception de disco cheio no 10º arquivo, como fazer pra voltar os 9 anteriores ao local original? Tratar manualmente não parece muito confiável e limpo.

Pra estes casos existe uma biblioteca chamada .NET Transactional File Manager, é bem simples e funciona praticamente sem overhead, implementando a interface IEnlistmentNotification, permitindo participar de uma transação do System.Transactions.Transaction.

A biblioteca não usa o Transactional NTFS, o que permite o uso no Windows XP e Windows Server 2003, por isso também não faz uso do DTC.

Então a biblioteca não é confiavel? Depende! Da maneira que ela funciona não vai garantir o Rollback em caso de falha de hardware ou se o processo for finalizado, ela funciona automatizando o que teriamos que tratar manualmente se a transação for cancelada, movendo de volta os arquivos, apagando o que foi copiado ou criado, etc. No meu caso é o suficiente. Se for necessário usar Transactional NTFS existe a biblioteca AlphaFS.

A utilização é muito simples, parecido com a classe File, só não é static, não sei o motivo.

new TxFileManager().Move(fonte, destino);

.NET Transactional File Manager no Codeplex

.NET Transactional File Manager no NuGet

Permalink | Comments (1)

Categories: Artigos

A melhor forma de ver a grande diferença que o async faz é usando exemplos. Saindo de um código não só maior, mas muito mais complicado, com callbacks, tratamento de contexto e thread de execução, tratamento de erros aninhados com os callbacks, pra um código simples, como se fosse um código síncrono comum.

Código Antigo:

void ShowStuff ()
{
	var client = new WebClient ();
	var content = JsonValue.Parse (client.DownloadString ("http://api.worldbank.org/countries?format=json&per_page=50"));
	int number_of_countries = content [0] ["total"];
	int done = 0, error = 0;

	InvokeOnMainThread (() => {
		CountriesLabel.Text = string.Format ("Countries: {0} done: 0 error: 0", number_of_countries);
	});

	foreach (JsonObject c in content [1]) {
		string country_url = string.Format ("http://api.worldbank.org/countries/{0}/indicators/NY.GDP.MKTP.CD&format=json", (string)c ["id"]);
		JsonValue json = null;

		try {
			json = JsonValue.Parse (client.DownloadString (country_url));
		} catch (Exception e){
			++error;
			InvokeOnMainThread (()=> status.Text = "Got exception "+ e);
			continue;
		}

		ThreadPool.QueueUserWorkItem (delegate {
			Map map = null;
			try {
				map = LoadCountryLogo (c ["name"]).Result;
			} catch (Exception e){
				++error;
				InvokeOnMainThread (()=> status.Text = "Got exception "+ e);
			}
			if (map != null){
				ThreadPool.QueueUserWorkItem (delegate {
					Position position = null;

					try {
						position = LookupCountryPosition (c ["longitude"], c ["latitude"]).Result;
						if (position != null)
							InvokeOnMainThread (() => {
								AddPin (map, position); 
								++done;
								status.Text = json ["name"];

							});
					} catch (Exception e){
						error++;
						InvokeOnMainThread (()=> status.Text = "Got exception "+ e);
					}

				});
			}
		});
		
		InvokeOnMainThread (() => CountriesLabel.Text = string.Format ("Countries: {0} done: {1} error: {2}", number_of_countries, done, error));
	}
	InvokeOnMainThread (() => {
		CountriesLabel.Text = string.Format ("Countries: {0}", number_of_countries);
	});
}

Código usando C# 5.0:

async Task ShowStuffAsync ()
{
	var client = new HttpClient ();

	var content = JsonValue.Parse (await client.GetStringAsync ("http://api.worldbank.org/countries?format=json"));
	int number_of_countries = content [0] ["per_page"];
	int done = 0, error = 0;

	CountriesLabel.Text = string.Format ("Countries: {0} done: 0 error: 0", number_of_countries);

	foreach (JsonObject c in content [1]) {
		try {
			string country_url = string.Format ("http://api.worldbank.org/countries/{0}/indicators/NY.GDP.MKTP.CD&format=json", (string)c ["id"]);
			var json = JsonValue.Parse (await client.GetStringAsync (country_url));
			var map = await LoadCountryLogoAsync (json ["name"]);
			if (map != null){
				var position = await LookupCountryPositionAsync (c ["longitude"], c ["latitude"]);
				if (position != null){
					AddPin (map, position);
					status.Text = json ["name"];
					++done;
				}
			}

		} catch (Exception e) {
			++error;
			status.Text = "Got exception "+ e;
		}
		CountriesLabel.Text = string.Format ("Countries: {0} done: {1} error: {2}", number_of_countries, done, error);
	}
	CountriesLabel.Text = string.Format ("Countries: {0}", number_of_countries);
}

Permalink | Comments (0)

Tags: c# C#5.0

Categories: Artigos