Konvertieren von dynamischen C# Objekte-array

Gibt es eine Möglichkeit zum konvertieren von einem dynamischen Objekt zu einem array, wenn es entweder ein einzelnes Objekt vom Typ Foo oder Foo[] ?

Beispielsweise

wenn der dynamische Foo konvertieren Foo[] mit 1 Objekt in der Reihe

wenn dynamisch ein array Foo[] mit n Anzahl der Objekte konvertieren Foo[] mit n Anzahl der Objekte im array.

  • Nur um zu verstehen, ob das Objekt ein Foo[] array, dann halten Sie es einfach so?
InformationsquelleAutor LB. | 2011-10-20
  1. 7

    Ich fühle mich ein wenig dumm... Ist dies wirklich, wollen Sie?

    class Test
{
}

dynamic dyn = new Test();

Test[] tests = null;

if (dyn is Test)
{
    tests = new Test[] { (Test)dyn };
}
else if (dyn is Test[])
{
    tests = (Test[])dyn;
}
    InformationsquelleAutor xanatos
  2. 3
    public Foo[] Create(dynamic fooOrFoos)
{
    return fooOrFoos.GetType().IsArray ? fooOrFoos as Foo[] : new Foo[] { fooOrFoos };
}

    Vielleicht mache ich das zu einfach... willst du damit sagen, dass Sie wissen nichts über das, was geben Sie den dynamischen Wert sein könnte?

    InformationsquelleAutor Amandalishus
  3. 2

    Durch die Verwendung eines dynamic variable, die variable ist dynamisch, nicht das Objekt-die variable bezieht. Das heißt, es ist keine statische Typprüfung, wenn Sie wollen, um den Zugriff auf Mitglieder der Objekt oder wollen, es zu konvertieren. Benötigen Sie eine andere Magie, um in der Lage sein, das zu tun.

    Könnten Sie wickeln Ihre Foo im DynamicObject dem Sie angeben können, wie die Konvertierung stattfindet.

    public class DynamicWrapper<T> : DynamicObject
{
    public T Instance { get; private set; }
    public DynamicWrapper(T instance)
    {
        this.Instance = instance;
    }

    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.ReturnType == typeof(T))
        {
            result = Instance;
            return true;
        }
        if (binder.ReturnType == typeof(T[]) && binder.Explicit)
        {
            result = new[] { Instance };
            return true;
        }
        return base.TryConvert(binder, out result);
    }

    public override string ToString()
    {
        return Convert.ToString(Instance);
    }
}

    Dann könnte man dies tun:

    dynamic dobj = new DynamicWrapper<Foo>(someFoo);
Foo foo1 = dobj;
Foo foo2 = (Foo)dobj;
Foo[] arr1 = (Foo[])dobj;
//someFoo == foo1 == foo2 == arr1[0]

dynamic darr = new DynamicWrapper<Foo[]>(arr1);
Foo[] arr2 = darr;
Foo[] arr3 = (Foo[])darr;
//arr1 == arr2 == arr3
//someFoo == arr2[0] == arr3[0]
    • +1 aber ich habe zu Fragen, warum Sie saveing MyType und MyTypeArray wenn Sie T (und für das array, das Sie haben T[])
    • Scratch, dass, was denke ich? Natürlich! typeof(T[]). Für eine Weile da, dachte ich, ich könnte das einfach nicht. Vielen Dank für den Hinweis. 🙂
    InformationsquelleAutor Jeff Mercado
Schreibe einen Kommentar