wie schaffen Ausdruck Baum / lambda für eine Tiefe Eigenschaft aus einem string

Gegeben ein string: "Person.Adresse.Postleitzahl - " ich möchte in der Lage sein, um die get/set-dieses PLZ-Eigenschaft auf eine Instanz von Person. Wie kann ich dies tun? Meine Idee war split die Zeichenfolge "." und dann die Iteration über die Bauteile auf der Suche nach der Immobilie auf den vorherigen geben, dann erstellen Sie einen Ausdruck-Baum, der würde ungefähr so Aussehen (Entschuldigung für die pseudo-syntax):

(person => person.Address) address => address.Postcode

Ich habe echte Schwierigkeiten, konkret die Schaffung der Ausdruck, der Baum aber! Wenn dies der beste Weg ist, kann jemand empfehlen, wie man das macht, oder gibt es eine einfachere alternative?

Dank

Andrew

public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Address Address{ get; set; }

    public Person()
    {
        Address = new Address();
    }
}

public class Address 
{
    public string Postcode { get; set; }
}

InformationsquelleAutor Andrew Bullock | 2009-02-11

c#expression-trees lambda

Warum Sie nicht verwenden Sie Rekursion? So etwas wie:

setProperyValue(obj, propertyName, value)
{
  head, tail = propertyName.SplitByDotToHeadAndTail(); //Person.Address.Postcode => {head=Person, tail=Address.Postcode}
  if(tail.Length == 0)
    setPropertyValueUsingReflection(obj, head, value);
  else
    setPropertyValue(getPropertyValueUsingReflection(obj, head), tail, value); //recursion
}

ich versuche immer, über Dinge, Ingenieur. halten Sie es einfach! krank versuchen, ta
Denken Sie nur daran, dass C# ist nicht tail-rekursiv, so dass Sie könnte am Ende mit StackOverflow-exception.

InformationsquelleAutor Konstantin Savelev

Es klingt wie Sie sortiert sind mit regelmäßigen Reflexion, aber zur info, der code zum erstellen eines Ausdrucks für verschachtelte Eigenschaften sehr ähnlich diese order-by-code.

Beachten Sie, dass ein Wert festgelegt ist, müssen Sie verwenden GetSetMethod() auf dem Grundstück und berufen, - es gibt keine eingebaute Ausdruck zum zuweisen von Werten nach Konstruktion (obwohl es unterstützt 4.0).

(edit) etwa so:

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
class Foo
{
    public Foo() { Bar = new Bar(); }
    public Bar Bar { get; private set; }
}
class Bar
{
    public string Name {get;set;}
}
static class Program
{
    static void Main()
    {
        Foo foo = new Foo();
        var setValue = BuildSet<Foo, string>("Bar.Name");
        var getValue = BuildGet<Foo, string>("Bar.Name");
        setValue(foo, "abc");
        Console.WriteLine(getValue(foo));        
    }
    static Action<T, TValue> BuildSet<T, TValue>(string property)
    {
        string[] props = property.Split('.');
        Type type = typeof(T);
        ParameterExpression arg = Expression.Parameter(type, "x");
        ParameterExpression valArg = Expression.Parameter(typeof(TValue), "val");
        Expression expr = arg;
        foreach (string prop in props.Take(props.Length - 1))
        {
            //use reflection (not ComponentModel) to mirror LINQ 
            PropertyInfo pi = type.GetProperty(prop);
            expr = Expression.Property(expr, pi);
            type = pi.PropertyType;
        }
        //final property set...
        PropertyInfo finalProp = type.GetProperty(props.Last());
        MethodInfo setter = finalProp.GetSetMethod();
        expr = Expression.Call(expr, setter, valArg);
        return Expression.Lambda<Action<T, TValue>>(expr, arg, valArg).Compile();        

    }
    static Func<T,TValue> BuildGet<T, TValue>(string property)
    {
        string[] props = property.Split('.');
        Type type = typeof(T);
        ParameterExpression arg = Expression.Parameter(type, "x");
        Expression expr = arg;
        foreach (string prop in props)
        {
            //use reflection (not ComponentModel) to mirror LINQ 
            PropertyInfo pi = type.GetProperty(prop);
            expr = Expression.Property(expr, pi);
            type = pi.PropertyType;
        }
        return Expression.Lambda<Func<T, TValue>>(expr, arg).Compile();
    }
}

gerade auf der Suche nach einem ähnlichen Thema, und dies kam zuerst auf google, und beantwortet meine Frage 😀
Funktioniert gut - aber wenn die Leistung ist ein Problem, siehe stackoverflow.com/a/14708196/188926

InformationsquelleAutor Marc Gravell

2

Wenn jemand interessiert ist, in der performance trade-off zwischen der einfache reflektion Ansatz (auch schöne Beispiele hier und hier) und Marc Ausdruck-Gebäude Ansatz...

Meine test waren immer ein relativ tiefes Grundstück (A. B. C. D. E) 10.000 mal.
1. Einfache reflektion: 64 ms
2. Ausdruck-Gebäude: 1684 ms
Offensichtlich ist dies ein sehr spezifischer test, und ich habe es nicht als Optimierungen oder Eigenschaften, aber ich denke, ein 26x Leistung trifft, ist bemerkenswert.

Es gibt andere Routen, die auch in diesem Szenario; eine Func<,> erstellt über ILGenerator können sehr schnell sein, solange es zwischengespeichert und nicht neu erstellt wird pro Aufruf
Vereinbart, es ist definitiv caching-Potenzial, und dieser test ist sehr primitiv, dass es nur blind fordert die BuildGet Methode 1000 mal. Ich denke, es ist nur eine Warnung für die Kopie-rollenwechslern (wie mich!) die Schnellste OOTB-Lösung.
Ich bekam ähnliche Ergebnisse in LinqPad -- gist.github.com/zaus/6884806; ich dachte, es könnte helfen, wenn der Ausdruck nicht die ganze PropertyInfo, hat es aber nicht (sieht einfach "sauberer")

InformationsquelleAutor Dunc
1

Den Sie betrachten möchten, die Bereitstellung Ihrer eigenen PropertyDescriptor über TypeConverter oder einer anderen Quelle.

Ich umgesetzt haben, ist genau das, was Sie beschreiben, für das aktuelle Projekt (sorry, Werbung, sonst würde ich teilen), durch Ableitung vom BindingSource, und die Bereitstellung der Informationen über es.

Die Idee ist wie folgt:

Alles, was Sie tun müssen, ist, dass, sobald Sie haben die Art ist kaum zu schaffen 'Stapel' für die getter und setter der Eigenschaften, und diejenigen, die Sie sammeln können, über das Wandern der eigenschaftsbaum der Typ und seine Eigenschaften Breite zum ersten mal, die Begrenzung der Tiefe auf eine angegebene Anzahl von Ebenen und entfernen von Zirkelbezügen je nach Ihrer Datenstrukturen.

Ich bin mit dieser Recht erfolgreich mit Linq2SQL-Objekte und-in Kombination mit Ihrer verbindlichen Listen 🙂

InformationsquelleAutor leppie

-9

Expression Tree

struct tree
{
    char info;
    struct tree *rchild;
    struct tree *lchild;
};

int prec(char data);

typedef struct tree * node;

char pop_op();
node pop_num();
void push_op(char item);

node create()
{
    return((node)malloc(sizeof(node)));
}

node num[20],root=NULL;
char op[20],oprt,ev[20];
int nt=-1,ot=-1,et=-1;

main()
{
    node newnode,item,temp;
    char str[50];
    int i,k,p,s,flag=0;
    printf("ENTER THE EXPRESSION ");
    scanf("%s",str);
    printf("\n%s",str);
    for(i=0;str[i]!='\0';i++)
    {
        if(isalnum(str[i]))
        {
            newnode=create();
            newnode->info=str[i];
            newnode->lchild=NULL;
            newnode->rchild=NULL;
            item=newnode;
            push_num(item);
        }
        else
        {
            if(ot!=-1)
                p=prec(op[ot]);
            else
                p=0;
            k=prec(str[i]);
            if(k==5)
            {
                while(k!=1)
                {
                    oprt=pop_op();
                    newnode=create();
                    newnode->info=oprt;
                    newnode->rchild=pop_num();
                    newnode->lchild=pop_num();
                    //if(root==NULL)
                    root=newnode;
                    //else if((newnode->rchild==root)||(newnode->lchild==root))
                    //root=newnode;
                    push_num(root);
                    k=prec(op[ot]);
                }
                oprt=pop_op();
            }
            else if(k==1)
                push_op(str[i]);
            else
            {
                if(k>p)
                    push_op(str[i]);
                else
                {
                    if(k<=p)
                    {
                        oprt=pop_op();
                        newnode=create();
                        newnode->rchild=pop_num();
                        newnode->lchild=pop_num();
                        if(root==NULL)
                        root=newnode;
                        else if((newnode->rchild==root)||(newnode->lchild==root))
                        root=newnode;
                        push_num(newnode);
                        push_op(str[i]);
                        //k=prec(op[ot]);
                    }
                }
            }
        }
    }
    printf("\nThe prefix expression is\n ");
    preorder(root);
    printf("\nThe infix exp is\n ");
    inorder(root);
    printf("\nThe postfix expression is\n ");
    postorder(root);
    evaluate();
}
void push_op(char item)
{
    op[++ot]=item;
}
push_num(node item)
{
    num[++nt]=item;
}
char pop_op()
{
    if(ot!=-1)
    return(op[ot--]);
    else
    return(0);
}
node pop_num()
{
    if(nt!=-1)
    return(num[nt--]);
    else
    return(NULL);
}
int prec(char data)
{
    switch(data)
    {
        case '(':return(1);
            break;
        case '+':
        case '-':return(2);
            break;
        case '*':
        case '/':return(3);
            break;
        case '^':return(4);
            break;
        case ')':return(5);
            break;
    }
}


inorder(node temp)
{
    if(temp!=NULL)
    {
        inorder(temp->lchild);
        printf("%c ",temp->info);
        inorder(temp->rchild);
    }
}

preorder(node temp)
{
    if(temp!=NULL)
    {
        printf("%c ",temp->info);
        preorder(temp->lchild);
        preorder(temp->rchild);
    }
}

postorder(node temp)
{
    if(temp!=NULL)
    {
        postorder(temp->lchild);
        postorder(temp->rchild);
        printf("%c ",temp->info);
        ev[++et]=temp->info;
    }
}
evaluate()
{
    int i,j=-1,a,b,ch[20];
    for(i=0;ev[i]!='\0';i++)
    {
        if(isalnum(ev[i]))
            ch[++j]=ev[i]-48;
        else
        {
            b=ch[j];
            a=ch[j-1];
            switch(ev[i])
            {
                case '+':ch[--j]=a+b;
                    break;
                case '-':ch[--j]=a-b;
                    break;
                case '*':ch[--j]=a*b;
                    break;
                case '/':ch[--j]=a/b;
                    break;
            }
        }
    }
    printf("\nValue = %d",ch[0]);
}

InformationsquelleAutor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.