Devolver tipo anónimo en C #

Tengo una consulta que devuelve un tipo anónimo y la consulta está en un método. ¿Cómo escribes esto?

public "TheAnonymousType" TheMethod(SomeParameter)
{
  using (MyDC TheDC = new MyDC())
  {
     var TheQueryFromDB = (....
                           select new { SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();

      return "TheAnonymousType";
    }
}

No puedes.

Sólo puede volver object, o contenedor de objetos, por ejemplo IEnumerable<object>, IList<object>, etc.

Puede regresar, lo dynamicque le dará una versión verificada en tiempo de ejecución del tipo anónimo, pero solo en .NET 4+

En C # 7 podemos usar tuplas para lograr esto:

public List<(int SomeVariable, string AnotherVariable)> TheMethod(SomeParameter)
{
  using (MyDC TheDC = new MyDC())
  {
     var TheQueryFromDB = (....
                       select new { SomeVariable = ....,
                                    AnotherVariable = ....}
                       ).ToList();

      return TheQueryFromDB
                .Select(s => (
                     SomeVariable = s.SomeVariable, 
                     AnotherVariable = s.AnotherVariable))
                 .ToList();
  }
}

System.ValueTupleSin embargo, es posible que deba instalar el paquete nuget.

No puede devolver tipos anónimos. ¿Puedes crear un modelo que se pueda devolver? De lo contrario, debe utilizar un object.

Aquí hay un artículo escrito por Jon Skeet sobre el tema.

Código del artículo:

using System;

static class GrottyHacks
{
    internal static T Cast<T>(object target, T example)
    {
        return (T) target;
    }
}

class CheesecakeFactory
{
    static object CreateCheesecake()
    {
        return new { Fruit="Strawberry", Topping="Chocolate" };
    }

    static void Main()
    {
        object weaklyTyped = CreateCheesecake();
        var stronglyTyped = GrottyHacks.Cast(weaklyTyped,
            new { Fruit="", Topping="" });

        Console.WriteLine("Cheesecake: {0} ({1})",
            stronglyTyped.Fruit, stronglyTyped.Topping);            
    }
}

O aquí hay otro artículo similar

O, como otros comentan, puede usar dynamic

Puede usar la clase Tuple como sustituto de tipos anónimos cuando sea necesario regresar:

Nota: Tuple puede tener hasta 8 parámetros.

return Tuple.Create(variable1, variable2);

O, para el ejemplo de la publicación original:

public List<Tuple<SomeType, AnotherType>> TheMethod(SomeParameter)
{
  using (MyDC TheDC = new MyDC())
  {
     var TheQueryFromDB = (....
                           select Tuple.Create(..., ...)
                           ).ToList();

      return TheQueryFromDB.ToList();
    }
}

http://msdn.microsoft.com/en-us/library/system.tuple(v=vs.110).aspx

El compilador de C # es un compilador de dos fases. En la primera fase, solo verifica los espacios de nombres, jerarquías de clases, firmas de métodos, etc. Los cuerpos de los métodos se compilan solo durante la segunda fase.

Los tipos anónimos no se determinan hasta que se compila el cuerpo del método.

Por lo tanto, el compilador no tiene forma de determinar el tipo de retorno del método durante la primera fase.

Esa es la razón por la que los tipos anónimos no se pueden utilizar como tipo de retorno.

Como han sugerido otros, si está usando .net 4.0 o rallador, puede usar Dynamic.

Si yo fuera usted, probablemente crearía un tipo y devolvería ese tipo del método. De esa manera es fácil para los futuros programadores que mantienen su código y más legible.

Tres opciones:

Opción 1:

public class TheRepresentativeType {
    public ... SomeVariable {get;set;}
    public ... AnotherVariable {get;set;}
}

public IEnumerable<TheRepresentativeType> TheMethod(SomeParameter)
{
   using (MyDC TheDC = new MyDC())
   {
     var TheQueryFromDB = (....
                           select new TheRepresentativeType{ SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();

     return TheQueryFromDB;
   } 
}

Opcion 2:

public IEnumerable TheMethod(SomeParameter)
{
   using (MyDC TheDC = new MyDC())
   {
     var TheQueryFromDB = (....
                           select new TheRepresentativeType{ SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();
     return TheQueryFromDB;
   } 
}

puedes iterarlo como objeto

Opcion 3:

public IEnumerable<dynamic> TheMethod(SomeParameter)
{
   using (MyDC TheDC = new MyDC())
   {
     var TheQueryFromDB = (....
                           select new TheRepresentativeType{ SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();

     return TheQueryFromDB; //You may need to call .Cast<dynamic>(), but I'm not sure
   } 
}

y podrás iterarlo como un objeto dinámico y acceder a sus propiedades directamente

Puede devolver la lista de objetos en este caso.

public List<object> TheMethod(SomeParameter)
{
  using (MyDC TheDC = new MyDC())
  {
     var TheQueryFromDB = (....
                           select new { SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();

      return TheQueryFromDB ;
    }
}

Usando C # 7.0 todavía no podemos devolver tipos anónimos pero tenemos soporte para tipos de tupla y, por lo tanto, podemos devolver una colección de tuple( System.ValueTuple<T1,T2>en este caso). Actualmente Tuple types no se admiten en árboles de expresión y necesita cargar datos en la memoria.

La versión más corta del código que desea puede verse así:

public IEnumerable<(int SomeVariable, object AnotherVariable)> TheMethod()
{
    ...

    return (from data in TheDC.Data
        select new { data.SomeInt, data.SomeObject }).ToList()
        .Select(data => (SomeVariable: data.SomeInt, AnotherVariable: data.SomeObject))
}

O usando la sintaxis fluida de Linq:

return TheDC.Data
    .Select(data => new {SomeVariable: data.SomeInt, AnotherVariable: data.SomeObject})
    .ToList();
    .Select(data => (SomeVariable: data.SomeInt, AnotherVariable: data.SomeObject))

Usando C # 7.1 podemos omitir los nombres de las propiedades de la tupla y se deducirán de la inicialización de la tupla como funciona con tipos anónimos:

select (data.SomeInt, data.SomeObject)
// or
Select(data => (data.SomeInt, data.SomeObject))

public List<SomeClass> TheMethod(SomeParameter)
{
  using (MyDC TheDC = new MyDC())
  {
     var TheQueryFromDB = (....
                           select new SomeClass{ SomeVariable = ....,
                                        AnotherVariable = ....}
                           ).ToList();

      return TheQueryFromDB.ToList();
    }
}

public class SomeClass{
   public string SomeVariable{get;set}
   public string AnotherVariable{get;set;}
}

Crear su propia clase y consultarla es la mejor solución que conozco. Por lo que sé, no puede usar valores de retorno de tipo anónimo en otro método, porque no solo será reconocido. Sin embargo, se pueden usar en el mismo. método. Solía ​​devolverlos como IQueryableo IEnumerable, aunque todavía no te permite ver qué hay dentro de la variable de tipo anónimo.

Me encontré con algo como esto antes mientras intentaba refactorizar un código, puede verificarlo aquí: Refactorización y creación de métodos separados

Con reflexión.

public object tst() {
    var a = new {
        prop1 = "test1",
        prop2 = "test2"
    };

    return a;
}


public string tst2(object anonymousObject, string propName) {
    return anonymousObject.GetType().GetProperties()
        .Where(w => w.Name == propName)
        .Select(s => s.GetValue(anonymousObject))
        .FirstOrDefault().ToString();
}

Muestra:

object a = tst();
var val = tst2(a, "prop2");

Salida:

test2

Solo puede utilizar palabras clave dinámicas,

   dynamic obj = GetAnonymousType();

   Console.WriteLine(obj.Name);
   Console.WriteLine(obj.LastName);
   Console.WriteLine(obj.Age); 


   public static dynamic GetAnonymousType()
   {
       return new { Name = "John", LastName = "Smith", Age=42};
   }

Pero con la palabra clave de tipo dinámico perderá seguridad en el tiempo de compilación, IDE IntelliSense, etc.

Otra opción podría ser el uso de automapper: convertirá a cualquier tipo de su objeto devuelto anónimo a medida que las propiedades públicas largas coincidan. Los puntos clave son, devolver el objeto, usar linq y autommaper. (o use una idea similar que devuelva json serializado, etc. o use la reflexión ..)

using System.Linq;
using System.Reflection;
using AutoMapper;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            var data = GetData();

            var firts = data.First();

            var info = firts.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).First(p => p.Name == "Name");
            var value = info.GetValue(firts);

            Assert.AreEqual(value, "One");
        }


        [TestMethod]
        public void TestMethod2()
        {
            var data = GetData();

            var config = new MapperConfiguration(cfg => cfg.CreateMissingTypeMaps = true);
            var mapper = config.CreateMapper();

            var users = data.Select(mapper.Map<User>).ToArray();

            var firts = users.First();

            Assert.AreEqual(firts.Name, "One");

        }

        [TestMethod]
        public void TestMethod3()
        {
            var data = GetJData();


            var users = JsonConvert.DeserializeObject<User[]>(data);

            var firts = users.First();

            Assert.AreEqual(firts.Name, "One");

        }

        private object[] GetData()
        {

            return new[] { new { Id = 1, Name = "One" }, new { Id = 2, Name = "Two" } };
        }

        private string GetJData()
        {

            return JsonConvert.SerializeObject(new []{ new { Id = 1, Name = "One" }, new { Id = 2, Name = "Two" } }, Formatting.None);
        }

        public class User
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }
    }

}

Ahora con funciones locales especialmente, pero siempre puede hacerlo pasando un delegado que haga el tipo anónimo.

Entonces, si su objetivo era ejecutar una lógica diferente en las mismas fuentes y poder combinar los resultados en una sola lista. No estoy seguro de qué matiz falta para cumplir con el objetivo establecido, pero siempre que devuelva un Ty pase un delegado para hacer T, puede devolver un tipo anónimo de una función.

// returning an anonymous type
// look mom no casting
void LookMyChildReturnsAnAnonICanConsume()
{
    // if C# had first class functions you could do
    // var anonyFunc = (name:string,id:int) => new {Name=name,Id=id};
    var items = new[] { new { Item1 = "hello", Item2 = 3 } };
    var itemsProjection =items.Select(x => SomeLogic(x.Item1, x.Item2, (y, i) => new { Word = y, Count = i} ));
    // same projection = same type
    var otherSourceProjection = SomeOtherSource((y,i) => new {Word=y,Count=i});
    var q =
        from anony1 in itemsProjection
        join anony2 in otherSourceProjection
            on anony1.Word equals anony2.Word
        select new {anony1.Word,Source1Count=anony1.Count,Source2Count=anony2.Count};
    var togetherForever = itemsProjection.Concat(otherSourceProjection).ToList();
}

T SomeLogic<T>(string item1, int item2, Func<string,int,T> f){
    return f(item1,item2);
}
IEnumerable<T> SomeOtherSource<T>(Func<string,int,T> f){
    var dbValues = new []{Tuple.Create("hello",1), Tuple.Create("bye",2)};
    foreach(var x in dbValues)
        yield return f(x.Item1,x.Item2);
}

De hecho, es posible devolver un tipo anónimo de un método en un caso de uso particular. ¡Echemos un vistazo!

Con C # 7 es posible devolver tipos anónimos de un método, aunque viene con una ligera restricción. Vamos a utilizar una nueva característica del lenguaje llamada función local junto con un truco de indirección (otra capa de indirección puede resolver cualquier desafío de programación, ¿verdad?).

Aquí hay un caso de uso que identifiqué recientemente. Quiero registrar todos los valores de configuración después de haberlos cargado AppSettings. ¿Por qué? Porque hay cierta lógica en torno a los valores perdidos que vuelven a los valores predeterminados, algunos análisis, etc. Una forma fácil de registrar los valores después de aplicar la lógica es ponerlos todos en una clase y serializarlos en un archivo de registro (usando log4net). También quiero encapsular la lógica compleja de lidiar con las configuraciones y separar eso de lo que tenga que hacer con ellas. ¡Todo sin crear una clase con nombre que exista para un solo uso!

Veamos cómo resolver esto usando una función local que crea un tipo anónimo.

public static HttpClient CreateHttpClient()
{
    // I deal with configuration values in this slightly convoluted way.
    // The benefit is encapsulation of logic and we do not need to
    // create a class, as we can use an anonymous class.
    // The result resembles an expression statement that
    // returns a value (similar to expressions in F#)
    var config = Invoke(() =>
    {
        // slightly complex logic with default value
        // in case of missing configuration value
        // (this is what I want to encapsulate)
        int? acquireTokenTimeoutSeconds = null;
        if (int.TryParse(ConfigurationManager.AppSettings["AcquireTokenTimeoutSeconds"], out int i))
        {
            acquireTokenTimeoutSeconds = i;
        }

        // more complex logic surrounding configuration values ...

        // construct the aggregate configuration class as an anonymous type!
        var c = new
        {
            AcquireTokenTimeoutSeconds =
                acquireTokenTimeoutSeconds ?? DefaultAcquireTokenTimeoutSeconds,
            // ... more properties
        };

        // log the whole object for monitoring purposes
        // (this is also a reason I want encapsulation)
        Log.InfoFormat("Config={0}", c);
        return c;
    });

    // use this configuration in any way necessary...
    // the rest of the method concerns only the factory,
    // i.e. creating the HttpClient with whatever configuration
    // in my case this:
    return new HttpClient(...);

    // local function that enables the above expression
    T Invoke<T>(Func<T> func) => func.Invoke();
}

He logrado construir una clase anónima y también encapsular la lógica de lidiar con la gestión de entornos complejos, todo dentro CreateHttpClienty dentro de su propia "expresión". Puede que esto no sea exactamente lo que quería el OP, pero es un enfoque ligero con tipos anónimos que actualmente es posible en C # moderno.