Erstellen Sie einen Ausdruck<U<,>> mit der spiegelung

Im mit Moq erstellen spottet, von einem Daten-set.

Habe ich eine kleine Helfer-Klasse, die es mir erlauben eine in-memory-Speicher anstatt mit einer Datenbank, macht die unit-Tests ein Kinderspiel. Auf diese Weise kann ich Elemente hinzufügen und entfernen von meinem mock-Daten-set, das erlaubt mir, um zu testen, meine insert-und delete-service-Aufrufe.

Während der Installation von mock ich habe eine Zeile, die wie folgt aussieht

this.Setup(i => i.AcademicCycles).Returns(mockStore.GetList<AcademicCycle>());

Mein mock hat eine Menge von Eigenschaften, so möchte ich ausführen dieses setup Schritt mit der spiegelung. Ich habe es geschafft, die Returns Teil des Prozesses der Arbeit über die Reflexion, sondern ich bin fest auf der lambda-Methode zu Setup.

Setup nimmt eine

Expression<Func<GoalsModelUnitOfWork, IQueryable<AcademicCycle>>> entspricht der i => i.AcademicCycles

und ich möchte dies dynamisch. Mit der spiegelung habe ich Folgendes:

Den Namen der Eigenschaft: "AcademicCycles"

Art IQueryable<AcademicCycle>

Art AcademicCycle

Ich habe auch die Instanz der i im lambda-Anweisung, die eine GoalsModelUnitOfWork

InformationsquelleAutor Aran Mulholland | 2012-05-23
  1. 29

    Den code zum erstellen der Ausdruck dynamisch wäre, wie diese:

    ParameterExpression parameter = Expression.Parameter(typeof (GoalsModelUnitOfWork), "i");
MemberExpression property = Expression.Property(parameter, "AcademicCycles");

var queryableType = typeof (IQueryable<>).MakeGenericType(typeof (AcademicCycle));
var delegateType = typeof (Func<,>).MakeGenericType(typeof (GoalsModelUnitOfWork), queryableType);

var yourExpression = Expression.Lambda(delegateType, property, parameter);

    Ergebnis wird die gewünschte Art, aber das problem ist, dass der Rückgabetyp der Expression.Lambda() ist LambdaExpression und Sie können nicht führen Sie eine Typumwandlung zu Expression<Func<...>> zu übergeben Sie es als parameter in der setup-Funktion, weil Sie nicht wissen, die generischen Typ-Parameter für die Func. So haben Sie zum aufrufen des Setup Methode, die von Reflexion, zu:

    this.GetType().GetMethod("Setup", yourExpression.GetType()).Invoke(this, yourExpression);
    • Eigentlich ist das Ergebnis des Ausdrucks.Lambda-Ausdruck umgewandelt werden kann Expression<Func<...>> wenn Sie statisch kennen die parameter-und Rückgabetypen. Intern Ausdruck.Lambda macht konstruieren eine Instanz der entsprechenden Expression<Func<...>> geben, auch wenn der Rückgabetyp des Ausdrucks.Lambda ist schwach typisiert.
    • Auch ich glaube nicht, dass Sie brauchen, die zwei mittleren Linien. Von den Tests in einem einfacheren Fall var lambda = Expression.Lambda(parameter, property) funktionieren sollte (Expression.Lambda wird der Delegat-Typ aus, der Arten und Eigenschaften). Aber mein test code war etwas anders zu verkaufen und verwendet einfachere Arten, so kann Ihre Laufleistung variieren...!
    InformationsquelleAutor fero
  2. 2

    Ich beschloss, nehmen einen Riss an es und landete mit diesem Gott schrecklich Stück code.

    Ich bin keine Reflexion Experten, und dies ist nur ein Erster Versuch, etwas zu arbeiten. Ich wäre sehr daran interessiert, was andere Ansätze, die Menschen haben, oder ob die relfection wrapper-Bibliotheken können diese schöner.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Moq;
using Xunit;

namespace MyExample
{
    public class Tests
    {
        [Fact]
        public void Test()
        {
            Dictionary<Type, object> data = new Dictionary<Type, object>
            {
                { typeof(IQueryable<Cycle>), new List<Cycle> { new Cycle { Name = "Test" } }.AsQueryable() },
                { typeof(IQueryable<Rider>), new List<Rider> { new Rider { Name = "1"}, new Rider { Name = "2" } }.AsQueryable() }
            };

            var mock = new Mock<IDataContext>();
            var setup = mock.GetType().GetMethods().Single(d => d.Name == "Setup" && d.ContainsGenericParameters);
            var param = Expression.Parameter(typeof(IDataContext), "i");
            foreach (var property in typeof(IDataContext).GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                //Build lambda
                var ex = Expression.Lambda(Expression.MakeMemberAccess(param, property), param);

                //Get generic version of the Setup method
                var typedSetup = setup.MakeGenericMethod(property.PropertyType);

                //Run the Setup method
                var returnedSetup = typedSetup.Invoke(mock, new[] { ex });

                //Get generic version of IReturns interface
                var iReturns = typedSetup.ReturnType.GetInterfaces().Single(d => d.Name.StartsWith("IReturns`"));

                //Get the generic Returns method
                var returns = iReturns.GetMethod("Returns", new Type[] { property.PropertyType });

                //Run the returns method passing in our data
                returns.Invoke(returnedSetup, new[] { data[property.PropertyType] });
            }

            Assert.Equal(1, mock.Object.Cycles.Count());
        }
    }

    public class Cycle
    {
        public string Name { get; set; }
    }

    public class Rider
    {
        public string Name { get; set; }
    }

    public interface IDataContext
    {
        IQueryable<Cycle> Cycles { get; set; }

        IQueryable<Rider> Riders { get; set; }
    }
}
    InformationsquelleAutor Chris Sainty
  3. 2

    Diese Methode sollte zu konstruieren, die den lambda-Ausdruck. Da werden Sie den Aufruf der Setup-Methode durch Reflexion, brauchen Sie nicht eine stark typisierte lambda-Ausdruck; Sie gehen, um es zu übergeben, die als Teil einer Objekt-array beim Aufruf Invoke:

        public LambdaExpression PropertyGetLambda(string parameterName, Type parameterType, string propertyName, Type propertyType)
    {
        var parameter = Expression.Parameter(parameterType, parameterName);
        var memberExpression = Expression.Property(parameter, propertyName);
        var lambdaExpression = Expression.Lambda(memberExpression, parameter);
        return lambdaExpression;
    }

    Ich glaube nicht, dass Sie tatsächlich benötigen den parameter-Namen. Wenn ich mich Recht über das, könnten Sie vereinfachen ein wenig:

        public LambdaExpression PropertyGetLambda(Type parameterType, string propertyName, Type propertyType)
    {
        var parameter = Expression.Parameter(parameterType);
        var memberExpression = Expression.Property(parameter, propertyName);
        var lambdaExpression = Expression.Lambda(memberExpression, parameter);
        return lambdaExpression;
    }
    InformationsquelleAutor phoog
Schreibe einen Kommentar