Continuando a falar sobre as novidades do C# 6.0, disponível no Visual Studio 2015, é possível simplificar a escrita de métodos ou propriedades através do expression-bodied methods.

Para exemplificar, vou utilizar uma classe chamada Ponto com as propriedades X e Y, mais o método ToString, conforme código abaixo:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public override string ToString()
    {
        return $"Ponto ({X}, {Y})";
    }
}

Utilizando a nova sintaxe, é possível simplificar o método ToString em uma única linha:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public override string ToString() => $"Ponto ({X}, {Y})";
}

Esta mesma sintaxe pode ser utilizada para propriedades, vamos supor que eu tenha uma propriedade qualquer que retorne um valor:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public int propriedade 
    {
        get
        {
            return this.X * this.Y; 
        }
    }
}

Ela pode ser simplificada da seguinte forma:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public int propriedade => this.X * this.Y;
}

Observe que não é necessário informar o get neste caso, pois está implícito. Com esta sintaxe, não é possível ter o get e o set para a propriedade.

Para quem tiver interesse em conhecer todas as novidades do C# 6.0 acesse o link.

No post anterior comentei sobre uma das novidades do C# 6.0, a interpolação de strings.

Agora neste post vou comentar sobre o operador condicional nulo, que particularmente, dentre as novidades, foi a que mais me agradou.

Com certeza você já teve ter passado por uma situação na qual precisasse testar se determinado objeto é nulo para então acessar uma propriedade ou método. Pois se acessarmos uma propriedade ou método de um objeto nulo ocorrerá uma exceção de referência nula.

Para exemplificar, vamos supor que eu possua uma classe Ponto com as propriedades X e Y. E esta mesma classe possua um método estático para instanciar um objeto do tipo Ponto a partir de um objeto Json, conforme código abaixo:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public static Ponto FromJson(JObject json)
    {
        if (json != null &&
            json["X"] != null &&
            json["X"].Type == JTokenType.Integer &&
            json["Y"] != null &&
            json["y"].Type == JTokenType.Integer)
        {
            return new Ponto() { X = (int)json["X"], Y = (int)json["Y"] };
        }

        return null;
    }
}

Agora, para simplificar este código vamos utilizar o operador condicional nulo, e vamos reescrever novamente a classe:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public static Ponto FromJson(JObject json)
    {
        if (json != null &&
            json["X"]?.Type == JTokenType.Integer &&
            json["Y"]?.Type == JTokenType.Integer)
        {
            return new Ponto() { X = (int)json["X"], Y = (int)json["Y"] };
        }

        return null;
    }
}

Perceba que foi utilizado o caractere ? no código fonte. Isto significa que a propriedade Type somente será acessada se o objeto for diferente de nulo, evitando que ocorra uma exceção. Ainda podemos diminuir mais um pouco o código:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public static Ponto FromJson(JObject json)
    {
        if (json?["X"]?.Type == JTokenType.Integer &&
            json?["Y"]?.Type == JTokenType.Integer)
        {
            return new Ponto() { X = (int)json["X"], Y = (int)json["Y"] };
        }

        return null;
    }
}

Agora ele somente acessará o “X” e o “Y” se o objeto json recebido por parâmetro não for nulo.

Outro uso que podemos dar para este operador é para quando estamos trabalhando com eventos. Se você já trabalhou com eventos provavelmente já deve ter escrito o seguinte trecho de código:

if (OnChanged != null)
{
    OnChanged(this, args);
}

Utilizando o operador condicional nulo, podemos reescrever este mesmo código da seguinte forma:

OnChanged?.Invoke(this, args);

O uso deste operador, quando bem utilizado, pode evitar vários erros de referência, além de reduzir o código fonte.

Para quem tiver interesse em conhecer todas as novidades do C# 6.0 acesse o link.

O Visual Studio 2015, lançado oficialmente no dia 20 de julho de 2015, trouxe algumas novidades sendo uma delas o C# 6.0.

Não foram grandes mudanças, mas surgiram recursos que podem aumentar a produtividade do programador. Dentre as novidades uma delas é a interpolação de strings.

Para exemplificar, vamos considerar o seguinte cenário. Digamos que você precise criar uma classe chamada Ponto com as propriedades X e Y. Esta classe possuirá o método ToString retornando o texto “Ponto (X, Y)”, sendo X e Y o valor das propriedades. Para fazer isso, no método ToString, você usaria o string.Format para fazer a concatenação do meu texto:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public override string ToString()
    {
        return string.Format("Ponto ({0}, {1})", X, Y);
    }
}

Com o C# 6.0 podemos escrever este mesmo trecho de código de uma forma mais simples, utilizando a interpolação de strings:

class Ponto
{
    public int X { get; set; }

    public int Y { get; set; }

    public override string ToString()
    {
        return $"Ponto ({X}, {Y})";
    }
}

Observe que ao invés de utilizar um número dentro das chaves, como era feito com o string.Format, podemos colocar diretamente a variável dentro das chaves. Para isto basta colocar no início da string o caractere $.

Para quem tiver interesse em conhecer todas as novidades do C# 6.0 acesse o link.