c# - 从匿名类型中获取价值？

Question

假设我们有以下方法：

public object Test()
{
    return new { A = "Test" };
}

是否有机会获得存储在A中的值？

var b = Test(); //Any chance to cast this to the anonymous type?

Answer 1

请注意，返回匿名类型或Tuple<>从方法返回是一件坏事

但是你问了一个关于如何做的问题，而不是“这是一个好主意”......

通过使用动态或反射...

dynamic b = Test();
string str = b.A;

或作弊：

public static object Test()
{
    return new { A = "Test" };
}

public static string GetA(object obj)
{
    // We create an anonymous type of the same type of the one in Test()
    // just to have its type.
    var x = new { A = string.Empty };

    // We pass it to Cast, that will take its T from the type of x
    // and that will return obj casted to the type of the anonymous
    // type
    x = Cast(x, obj);

    // Now in x we have obj, but strongly typed. So x.A is the value we
    // want
    return x.A;
}

public static T Cast<T>(T type, object obj) where T : class
{
    return (T)obj;
}

string str = GetA(Test());

在 C# 中，同一程序集中具有相同类型的相同属性的所有匿名类型都合并在一起。所以new { A }ofTest()和 ofGetA()属于同一类型。

这Cast<T>是从匿名类型中提取类型的有用技巧。您将键入的匿名类型作为第一个参数传递（该参数仅用于“激活”泛型T），并将您要转换的对象作为第二个参数传递。类似的技巧可用于创建泛型类型的集合，例如

public static T MakeList<T>(T type)
{
    return new List<T>();
}

Answer 2

//有没有机会将其转换为匿名类型？

是的，您可以通过示例使用 cast。

public static T CastByExample<T>(this object obj, T example) {
     return (T)obj;
}

请注意，这只适用于您在同一个程序集中的情况。如果匿名类型是同一个程序集，则它们具有相同的类型，并且属性具有相同类型的相同名称并且顺序相同。

然后：

object b = Test();
var example = new { A = "example" };
var casted = b.CastByExample(example);
Console.WriteLine(casted.A);

或者，您可以使用dynamic：

dynamic b = Test();
Console.WriteLine(b.A);

或者，使用反射：

object b = Test();
var property = b.GetType().GetProperty("A");
var value = property.GetValue(b);
Console.WriteLine(value);

或者，您可以做正确的事情并创建一个名义（即非匿名）类型。

Answer 3

有机会将其转换为匿名类型吗？

虽然你可以做到这一点，但它是非常不可靠的。因为每当您更改匿名类型的创建时，您的代码都会突然在其他地方中断而无影无踪。

您可以在此处阅读 Jon Skeet 的博客中的匿名类型转换的所有缺点。同样值得一读的是 Marc Gravel 的评论。

上述博客中讨论的重大变更示例。

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);            
    }
}

都好。现在如果你突然意识到你需要把 CreateCheeseCake 改成这样

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

那么你的这条线会发生什么

var stronglyTyped = GrottyHacks.Cast(weaklyTyped,
            new { Fruit="", Topping="" });

它不再起作用了。