Desafio V - Retornando tipos anônimos

1/13/2010 12:41:00 PM By Felipe Pessoto

Os tipos anônimos introduzidos no C# 3.0 para facilitar o uso do LINQ agilizam o desenvolvimento, evitando que tenhamos que declarar uma classe em casos específicos.

Mas esses tipos tem alguma limitações, intencionais, por exemplo, não podemos usar os tipos gerados como retorno ou parâmetro de um método. Até porque os tipos gerados são internal.

O desafio é retornar um tipo anônimo e usá-lo no seu código, sem usar Reflection. Não tem uso prático, já que não é uma boa prática fazer isso, mas serve como exercício.

 

Para adiantar, vou postar o método que faz o retorno:

public static object RetornaAnonimo()
{
    return new {Id = 1, Nome = "João"};
}

 

Agora resta conseguir usar o tipo numa chamada. Ex.:

var retorno = RetornaAnonimo();
...

 

Desafio IV - Sobrecarga de métodos

9/25/2009 3:10:00 AM By Felipe Pessoto

Considerando o seguinte código, qual será o resultado?

class Program
{
      static void Main()
      {
           Derived c = new Derived();
           c.Metodo(1);
      }
}

public class Base
{
      public void Metodo(int a)
      {
           Console.WriteLine("Int32 / " + a.GetType());
      }
}

public class Derived:Base
{
      public void Metodo(object a)
      {
          Console.WriteLine("Object / " + a.GetType());
      }
}

Desafio III - Membros Static

8/14/2009 3:24:00 PM By Felipe Pessoto

As seguintes classes geram o mesmo resultado? Se não, por quê?

public class A
{
     public static string X = "A";
}

public class A
{
     public static string X;

     static A()
     {
          X = "A";
     }
}




Teoricamente deveriam ser iguais, mas a segunda classe é equivalente à:

public class A
{
     public static string X = "A";

     static A()
     {
     }
}



A diferença está existência ou não do construtor. Quando não há construtor a classe é marcada como beforefieldinit, fazendo com que o type initializer seja chamado antes mesmo de qualquer referência à algum membro da classe.

Podemos perceber isso com o seguinte código:

class Program
{
     static void Main(string[] args)
     {
          Console.WriteLine("Iniciando");
          A.Escrever("Escrever");
          Console.WriteLine("Depois de escrever");
          string y = A.X;
          Console.WriteLine("Depois de acessar o campo X");

          Console.ReadKey();
     }
}

public class A
{
     public static string X = Escrever("X (Type Initializer)");

     public static string Escrever(string s)
     {
          Console.WriteLine(s);
          return s;
     }
}



Antes de qualquer coisa, o tipo já é inicializado. Mas se você criar um construtor, mesmo que vazio, a ordem das chamadas vai mudar.

O Type Initializer só é executado antes da primeira referência ao tipo. No caso antes do A.Escrever("Escrever").

Curioso, e pode gerar um comportamento inesperado.

Desafio I - Dynamic Iterators

7/16/2008 3:46:00 PM By Felipe Pessoto

Vou propor um desafio: Qual o resultado do seguinte código? E por quê?

    public class MainClass
    {
        static bool DeveMudar = false;
 
        public static void Main()
        {
            Console.WriteLine(DeveMudar);
            MetodoQualquer();
            Console.WriteLine(DeveMudar);
            Console.ReadKey();
        }
 
        public static IEnumerable<int> MetodoQualquer()
        {
            DeveMudar = true;
            yield return 1;
        }
    }