Arquivo da Categoria: C#

Artigos da secção “C#”

As novidades do C# 6

Com o recente lançamento do Visual Studio 2015, foi lançada a versão 6 da linguagem de programação para a plataforma .NET C#.

Como neste lançamento o enfoque principal foi na nova plataforma de compiladores (“Roslyn”), os melhoramentos e adições à linguagem foram escassos mas, tal como os melhoramentos e adições das versões anteriores, tornarão a vida de quem desenvolve usando a linguagem de programação C# muito melhor.

Continuar a ler

Async-Await – A alegoria do restaurante

Introdução

Com a introdução de capacidades assíncronas nas linguagens de programação C# e Visual Basic todas as APIs assíncronas tendem a seguir este padrão.

No entanto, muitos programadores não entendem ainda como lidar com esta nova realidade.

Este artigo não pretende explicar como funciona esta funcionalidade, mas apresentar uma alegoria que permite formar um modelo mental de como se deve funcionar com esta tecnologia.

Continuar a ler

C# – Novas Funcionalidades do C# 6.0 – Antevisão de Abril de 2014

Introdução

No passado evento //Build/, a Microsoft disponibilizou uma versão de antevisão da versão 6.0 da linguagem de programação C#.

Trata-se de uma versão preliminar, pelo que algumas funcionalidades poderão sofre alterações, não fazer parte da versão final ou novas funcionalidades poderão ainda ser adicionadas.

Esta nova versão da linguagem inaugura também uma nova postura da Microsoft no que diz respeito ao código aberto e participação da comunidade.

Continuar a ler

Resolução de Sobrecarga de Método

O enigma desta edição é-nos trazido por Jon Skeet.

Dado o seguinte código:

class X
{
  static int M(Func<int?, byte> x, object y) { return 1; }
  static int M(Func<X, byte> x, string y) { return 2; }

  const int Value = 1000;

  static void Main()
  {
    var a = M(X => (byte)X.Value, null);

    unchecked
    {
      Console.WriteLine(a);
      Console.WriteLine(M(X => (byte)X.Value, null));
    }
  }
}

Qual é o resultado da sua execução?

Continuar a ler

Os Perigos das Estruturas Mutáveis

Dada a seguinte estrutura:

public struct S : IDisposable
{
    public int Value { get; private set; }

    public S(int value) : this()
    {
        this.Value = value;
    }
    public void SetValue(int value)
    {
        this.Value = value;
    }

    public void Dispose()
    {
        Console.WriteLine(
            "Disposing: {0}",
            this.Value);
        this.Value = 0;
    }
}

Qual é o resultado da execução do seguinte código?

 using (var s1 = new S(1))
{
    s1.SetValue(-1);
}
Console.WriteLine();

var s2 = new S(2);
using (s2)
{
    s2.SetValue(-1);
}
Console.WriteLine("Disposed: {0}", s2.Value);
Console.WriteLine();

var s3 = new S(3);
try
{
    s3.SetValue(-1);
}
finally
{
    s3.Dispose();
}
Console.WriteLine("Disposed: {0}", s3.Value);
Console.WriteLine();

var s4 = new S(4);
try
{
    s4.SetValue(-1);
}
finally
{
    ((IDisposable)s4).Dispose();
}
Console.WriteLine("Disposed: {0}", s4.Value);
Console.WriteLine();

Continuar a ler