Est-il un moyen de revenir Anonyme de Type de méthode?

De le retourner comme un System.Object est le seulement façon de retourner un type anonyme à partir d'une méthode. Malheureusement, il n'existe pas d'autre moyen de le faire puisque les types anonymes ont été conçues spécifiquement afin d'empêcher leur utilisation dans cette voie.

Il y a quelques trucs que vous pouvez faire pour en conjonction avec le retour d'un Object qui vous permet de vous rapprocher. Si vous êtes intéressé par cette solution de contournement veuillez lire Ne peut pas revenir en anonyme type de méthode? Vraiment?.

Avertissement: Même si l'article que j'ai lié montre une solution de contournement qui ne veut pas dire que c'est une bonne idée de le faire. Je vous déconseillons fortement l'utilisation de cette approche lors de la création d'un type ordinaire serait plus sûr et plus facile à comprendre.

public object MyMethod() 
{
    return new
    {
         Property1 = "test",
        Property2 = "test"
     };
}

static void Main(..)
{
    dynamic o = MyMethod();  
    var p1 = o.Property1;
    var p2 = o.Property2;
}

Comme alternative, à partir de C# 7 on peut utiliser ValueTuple. Un petit exemple de ici:

public (int sum, int count) DoStuff(IEnumerable<int> values) 
{
    var res = (sum: 0, count: 0);
    foreach (var value in values) { res.sum += value; res.count++; }
    return res;
}

Et sur la fin de réception:

var result = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {result.Sum}, Count: {result.Count}");

Ou:

var (sum, count) = DoStuff(Enumerable.Range(0, 10));
Console.WriteLine($"Sum: {sum}, Count: {count}");

Non, les types anonymes ne peuvent pas exister en dehors du contexte dans lequel ils sont créés, et comme un résultat ne peut pas être utilisé comme une méthode de type de retour. Vous pouvez retourner l'instance comme un object, mais c'est une bien meilleure idée de créer explicitement votre propre type de conteneur à cette fin.

Désolé, vous n'êtes pas vraiment censé le faire. Vous pouvez pirater autour d'elle, de réflexion, ou de faire un générique de la méthode d'assistance pour retourner le type pour vous, mais c'est vraiment à l'encontre de la langue. Il suffit de déclarer le type de sorte qu'il est clairement ce qui se passe.

Vous pouvez également inverser le flux de contrôle, si possible:

    public abstract class SafeAnon<TContext>
    {
        public static Anon<T> Create<T>(Func<T> anonFactory)
        {
            return new Anon<T>(anonFactory());
        }

        public abstract void Fire(TContext context);
        public class Anon<T> : SafeAnon<TContext>
        {
            private readonly T _out;

            public delegate void Delayed(TContext context, T anon);

            public Anon(T @out)
            {
                _out = @out;
            }

            public event Delayed UseMe;
            public override void Fire(TContext context)
            {
                UseMe?.Invoke(context, _out);
            }
        }
    }

    public static SafeAnon<SomeContext> Test()
    {
        var sa = SafeAnon<SomeContext>.Create(() => new { AnonStuff = "asdf123" });

        sa.UseMe += (ctx, anon) =>
        {
            ctx.Stuff.Add(anon.AnonStuff);
        };

        return sa;
    }

    public class SomeContext
    {
        public List<string> Stuff = new List<string>();
    }

et puis plus tard somwhere d'autre:

    static void Main()
    {
        var anonWithoutContext = Test();

        var nowTheresMyContext = new SomeContext();
        anonWithoutContext.Fire(nowTheresMyContext);

        Console.WriteLine(nowTheresMyContext.Stuff[0]);

    }