Der dynamische anonyme Typ in Razor verursacht eine RuntimeBinderException

Ich erhalte die folgende Fehlermeldung:

'Objekt' enthält keine Definition für 'RatingName'

Wenn Sie sich den anonymen dynamischen Typ ansehen, hat er eindeutig RatingName.

Mir ist klar, dass ich dies mit einem Tupel tun kann, aber ich möchte verstehen, warum die Fehlermeldung auftritt.

Anonyme Typen mit internen Eigenschaften sind meiner Meinung nach eine schlechte Entscheidung für das .NET Framework-Design.

Hier ist eine schnelle und nette Erweiterung , um dieses Problem zu beheben, dh indem Sie das anonyme Objekt sofort in ein ExpandoObject konvertieren.

public static ExpandoObject ToExpando(this object anonymousObject)
{
    IDictionary<string, object> anonymousDictionary =  new RouteValueDictionary(anonymousObject);
    IDictionary<string, object> expando = new ExpandoObject();
    foreach (var item in anonymousDictionary)
        expando.Add(item);
    return (ExpandoObject)expando;
}

Es ist sehr einfach zu bedienen:

return View("ViewName", someLinq.Select(new { x=1, y=2}.ToExpando());

Natürlich aus Ihrer Sicht:

@foreach (var item in Model) {
     <div>x = @item.x, y = @item.y</div>
}

Ich fand die Antwort in einer verwandten Frage . Die Antwort finden Sie in David Ebbos Blogbeitrag Übergeben anonymer Objekte an MVC-Ansichten und Zugriff auf diese mithilfe von Dynamic

Der Grund dafür ist, dass der anonyme Typ im Controller intern übergeben wird, sodass nur innerhalb der Assembly zugegriffen werden kann, in der er deklariert ist. Da Ansichten separat kompiliert werden, beschwert sich der dynamische Ordner, dass er diese Baugruppengrenze nicht überschreiten kann.

Wenn Sie jedoch darüber nachdenken, ist diese Einschränkung des dynamischen Ordners tatsächlich ziemlich künstlich, denn wenn Sie private Reflexion verwenden, hindert Sie nichts daran, auf diese internen Mitglieder zuzugreifen (ja, es funktioniert sogar in mittlerer Vertrauenswürdigkeit). Der dynamische Standardordner ist also sehr bemüht, C # -Kompilierungsregeln durchzusetzen (bei denen Sie nicht auf interne Mitglieder zugreifen können), anstatt Sie das tun zu lassen, was die CLR-Laufzeit zulässt.

Die Verwendung der ToExpando- Methode ist die beste Lösung.

Hier ist die Version, für die keine System.Web- Assembly erforderlich ist :

public static ExpandoObject ToExpando(this object anonymousObject)
{
    IDictionary<string, object> expando = new ExpandoObject();
    foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(anonymousObject))
    {
        var obj = propertyDescriptor.GetValue(anonymousObject);
        expando.Add(propertyDescriptor.Name, obj);
    }

    return (ExpandoObject)expando;
}

Anstatt ein Modell aus einem anonymen Typ zu erstellen und dann zu versuchen, das anonyme Objekt in ein solches zu konvertieren ExpandoObject...

var model = new 
{
    Profile = profile,
    Foo = foo
};

return View(model.ToExpando());  // not a framework method (see other answers)

Sie können einfach die ExpandoObjectdirekt erstellen :

dynamic model = new ExpandoObject();
model.Profile = profile;
model.Foo = foo;

return View(model);

Anschließend legen Sie in Ihrer Ansicht den Modelltyp als dynamisch fest @model dynamicund können direkt auf die Eigenschaften zugreifen:

@Model.Profile.Name
@Model.Foo

Normalerweise würde ich für die meisten Ansichten stark typisierte Ansichtsmodelle empfehlen, aber manchmal ist diese Flexibilität praktisch.

Sie können die Framework Impromptu-Schnittstelle verwenden , um einen anonymen Typ in eine Schnittstelle einzubinden.

Sie würden einfach eine zurückgeben IEnumerable<IMadeUpInterface>und am Ende Ihrer Linq-Verwendung .AllActLike<IMadeUpInterface>();funktioniert dies, da die anonyme Eigenschaft über das DLR mit einem Kontext der Assembly aufgerufen wird, die den anonymen Typ deklariert hat.

Schrieb eine Konsolenanwendung und fügte Mono.Cecil als Referenz hinzu (Sie können es jetzt über NuGet hinzufügen ). Schreiben Sie dann den Code:

static void Main(string[] args)
{
    var asmFile = args[0];
    Console.WriteLine("Making anonymous types public for '{0}'.", asmFile);

    var asmDef = AssemblyDefinition.ReadAssembly(asmFile, new ReaderParameters
    {
        ReadSymbols = true
    });

    var anonymousTypes = asmDef.Modules
        .SelectMany(m => m.Types)
        .Where(t => t.Name.Contains("<>f__AnonymousType"));

    foreach (var type in anonymousTypes)
    {
        type.IsPublic = true;
    }

    asmDef.Write(asmFile, new WriterParameters
    {
        WriteSymbols = true
    });
}

Der obige Code würde die Assembly-Datei von den Eingabeargumenten abrufen und Mono.Cecil verwenden, um die Zugänglichkeit von intern zu öffentlich zu ändern. Dadurch würde das Problem behoben.

Wir können das Programm im Post Build-Event der Website ausführen. Ich habe einen Blog-Beitrag darüber auf Chinesisch geschrieben, aber ich glaube, Sie können einfach den Code und die Schnappschüsse lesen. :) :)

Basierend auf der akzeptierten Antwort habe ich den Controller überschrieben, damit er im Allgemeinen und hinter den Kulissen funktioniert.

Hier ist der Code:

protected override void OnResultExecuting(ResultExecutingContext filterContext)
{
    base.OnResultExecuting(filterContext);

    //This is needed to allow the anonymous type as they are intenal to the assembly, while razor compiles .cshtml files into a seperate assembly
    if (ViewData != null && ViewData.Model != null && ViewData.Model.GetType().IsNotPublic)
    {
       try
       {
          IDictionary<string, object> expando = new ExpandoObject();
          (new RouteValueDictionary(ViewData.Model)).ToList().ForEach(item => expando.Add(item));
          ViewData.Model = expando;
       }
       catch
       {
           throw new Exception("The model provided is not 'public' and therefore not avaialable to the view, and there was no way of handing it over");
       }
    }
}

Jetzt können Sie einfach ein anonymes Objekt als Modell übergeben, und es funktioniert wie erwartet.

Ich werde ein bisschen von https://stackoverflow.com/a/7478600/37055 stehlen

Wenn Sie das Paket dynamitey installieren , können Sie dies tun:

return View(Build<ExpandoObject>.NewObject(RatingName: name, Comment: comment));

Und die Bauern freuen sich.

Der Grund für die ausgelöste RuntimeBinderException ist meiner Meinung nach in anderen Beiträgen gut zu beantworten. Ich konzentriere mich nur darauf zu erklären, wie ich es tatsächlich zum Laufen bringe.

Weitere Informationen finden Sie unter Beantworten von @ DotNetWise- und Bindungsansichten mit der Sammlung anonymer Typen in ASP.NET MVC .

Erstellen Sie zunächst eine statische Klasse für die Erweiterung

public static class impFunctions
{
    //converting the anonymous object into an ExpandoObject
    public static ExpandoObject ToExpando(this object anonymousObject)
    {
        //IDictionary<string, object> anonymousDictionary = new RouteValueDictionary(anonymousObject);
        IDictionary<string, object> anonymousDictionary = HtmlHelper.AnonymousObjectToHtmlAttributes(anonymousObject);
        IDictionary<string, object> expando = new ExpandoObject();
        foreach (var item in anonymousDictionary)
            expando.Add(item);
        return (ExpandoObject)expando;
    }
}

In der Steuerung

    public ActionResult VisitCount()
    {
        dynamic Visitor = db.Visitors
                        .GroupBy(p => p.NRIC)
                        .Select(g => new { nric = g.Key, count = g.Count()})
                        .OrderByDescending(g => g.count)
                        .AsEnumerable()    //important to convert to Enumerable
                        .Select(c => c.ToExpando()); //convert to ExpandoObject
        return View(Visitor);
    }

In View, @model IEnumerable (dynamisch, keine Modellklasse) ist dies sehr wichtig, da wir das anonyme Typobjekt binden werden.

@model IEnumerable<dynamic>

@*@foreach (dynamic item in Model)*@
@foreach (var item in Model)
{
    <div>x=@item.nric, y=@item.count</div>
}

Bei der Eingabe von foreach habe ich weder bei der Verwendung von var noch bei dynamic einen Fehler .

Wenn Sie ein neues ViewModel erstellen, das mit den neuen Feldern übereinstimmt, können Sie das Ergebnis auch an die Ansicht übergeben.

Jetzt im rekursiven Geschmack

public static ExpandoObject ToExpando(this object obj)
    {
        IDictionary<string, object> expandoObject = new ExpandoObject();
        new RouteValueDictionary(obj).ForEach(o => expandoObject.Add(o.Key, o.Value == null || new[]
        {
            typeof (Enum),
            typeof (String),
            typeof (Char),
            typeof (Guid),

            typeof (Boolean),
            typeof (Byte),
            typeof (Int16),
            typeof (Int32),
            typeof (Int64),
            typeof (Single),
            typeof (Double),
            typeof (Decimal),

            typeof (SByte),
            typeof (UInt16),
            typeof (UInt32),
            typeof (UInt64),

            typeof (DateTime),
            typeof (DateTimeOffset),
            typeof (TimeSpan),
        }.Any(oo => oo.IsInstanceOfType(o.Value))
            ? o.Value
            : o.Value.ToExpando()));

        return (ExpandoObject) expandoObject;
    }

Die Verwendung der ExpandoObject-Erweiterung funktioniert, funktioniert jedoch nicht, wenn verschachtelte anonyme Objekte verwendet werden.

Sowie

var projectInfo = new {
 Id = proj.Id,
 UserName = user.Name
};

var workitem = WorkBL.Get(id);

return View(new
{
  Project = projectInfo,
  WorkItem = workitem
}.ToExpando());

Um dies zu erreichen, benutze ich dies.

public static class RazorDynamicExtension
{
    /// <summary>
    /// Dynamic object that we'll utilize to return anonymous type parameters in Views
    /// </summary>
    public class RazorDynamicObject : DynamicObject
    {
        internal object Model { get; set; }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (binder.Name.ToUpper() == "ANONVALUE")
            {
                result = Model;
                return true;
            }
            else
            {
                PropertyInfo propInfo = Model.GetType().GetProperty(binder.Name);

                if (propInfo == null)
                {
                    throw new InvalidOperationException(binder.Name);
                }

                object returnObject = propInfo.GetValue(Model, null);

                Type modelType = returnObject.GetType();
                if (modelType != null
                    && !modelType.IsPublic
                    && modelType.BaseType == typeof(Object)
                    && modelType.DeclaringType == null)
                {
                    result = new RazorDynamicObject() { Model = returnObject };
                }
                else
                {
                    result = returnObject;
                }

                return true;
            }
        }
    }

    public static RazorDynamicObject ToRazorDynamic(this object anonymousObject)
    {
        return new RazorDynamicObject() { Model = anonymousObject };
    }
}

Die Verwendung im Controller ist dieselbe, außer dass Sie ToRazorDynamic () anstelle von ToExpando () verwenden.

Um das gesamte anonyme Objekt abzurufen, fügen Sie am Ende einfach ".AnonValue" hinzu.

var project = @(Html.Raw(JsonConvert.SerializeObject(Model.Project.AnonValue)));
var projectName = @Model.Project.Name;

Ich habe das ExpandoObject ausprobiert, aber es funktionierte nicht mit einem verschachtelten anonymen komplexen Typ wie dem folgenden:

var model = new { value = 1, child = new { value = 2 } };

Meine Lösung bestand also darin, ein JObject to View-Modell zurückzugeben:

return View(JObject.FromObject(model));

und in .cshtml in dynamisch konvertieren:

@using Newtonsoft.Json.Linq;
@model JObject

@{
    dynamic model = (dynamic)Model;
}
<span>Value of child is: @model.child.value</span>