PropertyInfo GetValue of List
Ich versuche seit ein paar Tagen eine Eigenschaft einer Klasse auszulesen, die von Typ System.Collections.Generic.List<Enum> ist.
Ich versuche über PropertyInfo diese Eigenschaft zu finden - das klappt auch.
Dann möchte ich gerne die Werte des PropertyInfos auslesen - da weiß ich nicht weiter.
Der Rückgabewert von PropertyInfo.GetValue ist System.Object, richtig ?
Sobald die List abgefragt wird, bekomme ich ein Object[] zurück. Verstehe ich auch noch.
Um es für euch etwas übersichtlicher zu machen, versuche ich nur die einzelnen Zeilen, die wichtig sind, zu posten:
PropertyInfo[] propertiesOfComponents = attachedComponent.GetType().GetProperties(); //Alle Eigenschaften des Komponententyps abrufen
foreach (PropertyInfo propOfComponent in propertiesOfComponents) //Alle Eigenschaften des Komponententyps durchlaufen
{
var propertyValue = propOfComponent.GetValue(attachedComponent, null); //Wert der Eigenschaft zwischenspeichern
if (propertyValue != null) //wenn der Wert ungleich null ist, dann
{
if (propertyValue.GetType().GetProperty("Count") != null &&
propertyValue.GetType().GetProperty("Count").PropertyType == typeof(System.Int32) &&
(int)propertyValue.GetType().GetProperty("Count").GetValue(propertyValue, null) > 0) //Wenn der gesuchte Wert mehr als einen Wert annimmt, dann besitzt das Objekt eine Eigenschaft mit dem Namen "Count", da ein Array zurückgegeben wird
{
if (propOfComponent.PropertyType.IsGenericType)
{
//Hier weiß ich nicht weiter..
}
}
}
Anbei findet Ihr einen Screenshot mit den Werten - einfach nur der Übersicht halber.
Ich weiß aber nicht wie ich die Werte des Object[] auslesen kann.
Vorerst möchte ich diese Werte über einen XmlWriter in eine xml-Datei schreiben.
Zu einem späteren Zeitpunkt möchte ich diese Werte wieder benutzen - aber das werde ich mir erst später ansehen.
Wie Ihr in dem Quellcode-Ausschnitt anbei sehen könnt, habe ich schon so einige Sachen versucht, um als Beispiel die BindingFlags zu verstehen - so richtig habe ich das aber noch nicht.
Ich habe bereits im Internet recharchiert, jedoch finde ich immer nur Beispiele, bei denen der Name der Eigenschaft bekannt ist:
propertyInfo.GetProperty("wasAuchImmer")...
Da ich aber alle Objecte, die von UnityEngine.Object erben, an meine Methode übergebe, möchte ich die Namen der Properties nicht wissen.
Ich hoffe ich habe mich eingiermaßen verständlich geäußert.
Gesamter Quellcode-Ausschnitt:
if (type == typeof(GameObject)) //Wenn unityObject ein GameObject ist,
{
GameObject thisGO = (GameObject)unityObject; //dann speichere dieses zwischen
Component[] attachedComponents = thisGO.GetComponents<Component>(); //Rufe alle Kompenenten dieses GameObjects ab
using (XmlWriter xmlWriter = XmlWriter.Create(filePath, xmlSettings))
{
xmlWriter.WriteStartDocument(); //XML Dokument Zeile einfügen
xmlWriter.WriteStartElement(unityObject.name); //Objektnamen schreiben
xmlWriter.WriteAttributeString("type", type.ToString()); //Klassentyp des Objektes als Attribut hinzufügen
int componentIndex = 0;
foreach (Component attachedComponent in attachedComponents) //Jede Komponente druchlaufen
{
xmlWriter.WriteStartElement("Component" + componentIndex); //Komponente symbolisieren - Komponentenname nicht schreiben, da eine Komponente keinen Namen trägt
componentIndex++;
xmlWriter.WriteAttributeString("type", attachedComponent.GetType().ToString()); //Klassentyp der Komponente schreiben
PropertyInfo[] propertiesOfComponents = attachedComponent.GetType().GetProperties(); //Alle Eigenschaften des Komponententyps abrufen
foreach (PropertyInfo propOfComponent in propertiesOfComponents) //Alle Eigenschaften des Komponententyps durchlaufen
{
try
{
var propertyValue = propOfComponent.GetValue(attachedComponent, null); //Wert der Eigenschaft zwischenspeichern
if (propertyValue != null) //wenn der Wert ungleich null ist, dann
{
if (propertyValue.GetType().GetProperty("Count") != null &&
propertyValue.GetType().GetProperty("Count").PropertyType == typeof(System.Int32) &&
(int)propertyValue.GetType().GetProperty("Count").GetValue(propertyValue, null) > 0) //Wenn der gesuchte Wert mehr als einen Wert annimmt, dann besitzt das Objekt eine Eigenschaft mit dem Namen "Count", da ein Array zurückgegeben wird
{
if (propOfComponent.PropertyType.IsGenericType)
{
var enumNames = Nullable.GetUnderlyingType(propOfComponent.PropertyType).Name;
var enumValues = System.Enum.GetValues(propertyValue.GetType());
PropertyInfo[] propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.Instance);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.Public);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.DeclaredOnly);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public);
propsGeneric = propOfComponent.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
FieldInfo[] fInfos = propOfComponent.GetType().GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo fInfo in fInfos)
{
Debug.Log(fInfo.Name + ": " + fInfo.GetRawConstantValue());
}
}
//AB HIER ERNEUT PRÜFEN
System.Object[] propArray = propertyValue.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach(PropertyInfo propValuesOfValue in propArray)
{
var valueOfValue = propValuesOfValue.GetValue(propertyValue, null);
}
/*xmlWriter.WriteStartElement(propertyValue.GetType().GetProperty()); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", propertyOfValueProperty.GetType().ToString()); //den Klassentypen als Attribute an das Element hängen
xmlWriter.WriteString(propertyOfValueProperty.ToString()); //den Wert der Eigenschaft schreiben
xmlWriter.WriteEndElement();*/
}
else //Wenn der gesuchte Wert nur ein Wert ist, dann:
{
xmlWriter.WriteStartElement(propOfComponent.Name); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", propertyValue.GetType().ToString()); //den Klassentypen als Attribute an das Element hängen
xmlWriter.WriteString(propertyValue.ToString()); //den Wert der Eigenschaft schreiben
xmlWriter.WriteEndElement();
}
}
else //wenn der Wert null ist, dann
{
xmlWriter.WriteStartElement(propOfComponent.Name); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", "null"); //den Klassentypen als Attribute an das Element hängen
xmlWriter.WriteString("null"); //den Wert der Eigenschaft schreiben
xmlWriter.WriteEndElement();
}
}
catch (Exception e)
{
Debug.LogWarning("SavegameManager: Property \"" + propOfComponent.Name + "\" could not be saved:\n" + e);
}
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
}
}
Was Du da machst, verstehe ich ab PropertyInfo.GetValue auch nicht so wirklich, das sieht sehr seltsam aus.
Ist der Typ der Auflistung bekannt? Wenn es nur eine Auflistung ist, kannst Du das Ergebnis von PropertyInfo.GetValue() nach IEnumerable oder IEnumerable<DeinTyp> casten. Danach kannst Du normal weiter arbeiten.
Wenn es genauer bekannt ist, kannst Du auch direkt genauer casten. Wenn Du nach Count suchst, klingt das nach ICollection, caste doch direkt nach ICollection?
Wenn der Typ nicht bekannt ist, wirst Du nur schwer mir den Vorhandenen Daten arbeiten können. Dann solltest Du lieber überlegen, ob Du nicht einen anderen Weg wählen kannst.
Du kannst zwar über die Namen nach Eigenschaften und Methoden suchen, aber das bedeutet immer ein Risiko, das Du mit einem Interface stark reduzieren kannst.
NuGet Packages im Code auslesen
lock Alternative für async/await
Beim CleanCode zählen nicht die Regeln, sondern dass wir uns mit diesen Regeln befassen, selbst wenn wir sie nicht befolgen - hoffentlich nach reiflichen Überlegungen.
Alles nach PropertyInfo.GetValue habe ich nur hingeschrieben, um die BindingFlags zu testen - ist also Quick&Dirty und kommt auch wieder weg.
Der genaue Typ ist nicht bekannt - ich weiß nur, dass es eine Liste mit enums ist - , also sollte ich nach IEnumerable casten, bzw nach ICollection, da es eine Liste ist.
Anschließend kann ich mit Hilfe von foreach die Werte der Liste abfragen - habe ich das richtig verstanden?
Genau
Such dir einen Typ, den der Property-Typ sicher implementiert und das bietet, was Du brauchst.
Bei einer Auflistung kannst Du eigentlich immer davon ausgehen, dass IEnumerable oder die generische Variante (wenn der generische Typ bekannt ist) implementiert wird.
Wenn Du nur per Schleife darüber laufen willst, würde ich auch gar nicht nach ICollection oder IList casten, sondern bei IEnumerable bleiben. Denn so gibt es mehr Freiheit bei der Wahl des Typs der Eigenschaft, er muss nur IEnumerable implementieren und das hat jede .NET-Auflistung inklusive dem Array.
NuGet Packages im Code auslesen
lock Alternative für async/await
Beim CleanCode zählen nicht die Regeln, sondern dass wir uns mit diesen Regeln befassen, selbst wenn wir sie nicht befolgen - hoffentlich nach reiflichen Überlegungen.
Mein Codeschnipsel sieht nun wie folgt aus:
if (type == typeof(GameObject)) //Wenn unityObject ein GameObject ist,
{
GameObject thisGO = (GameObject)unityObject; //dann speichere dieses zwischen
Component[] attachedComponents = thisGO.GetComponents<Component>(); //Rufe alle Kompenenten dieses GameObjects ab
using (XmlWriter xmlWriter = XmlWriter.Create(filePath, xmlSettings))
{
xmlWriter.WriteStartDocument(); //XML Dokument Zeile einfügen
xmlWriter.WriteStartElement(unityObject.name); //Objektnamen schreiben
xmlWriter.WriteAttributeString("type", type.ToString()); //Klassentyp des Objektes als Attribut hinzufügen
int componentIndex = 0;
foreach (Component attachedComponent in attachedComponents) //Jede Komponente druchlaufen
{
xmlWriter.WriteStartElement("Component" + componentIndex); //Komponente symbolisieren - Komponentenname nicht schreiben, da eine Komponente keinen Namen trägt
componentIndex++;
xmlWriter.WriteAttributeString("type", attachedComponent.GetType().ToString()); //Klassentyp der Komponente schreiben
PropertyInfo[] propertiesOfComponents = attachedComponent.GetType().GetProperties(); //Alle Eigenschaften des Komponententyps abrufen
foreach (PropertyInfo propOfComponent in propertiesOfComponents) //Alle Eigenschaften des Komponententyps durchlaufen
{
try
{
var propertyValue = propOfComponent.GetValue(attachedComponent, null); //Wert der Eigenschaft zwischenspeichern
if (propertyValue != null) //wenn der Wert ungleich null ist, dann
{
if (propOfComponent.PropertyType.IsGenericType) //Wenn der gesuchte Wert mehr als einen Wert annimmt
{
xmlWriter.WriteStartElement(propOfComponent.Name); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", propertyValue.GetType().ToString()); //den Klassentypen als Attribute an das Element hängen
IEnumerable valueItems = (IEnumerable)propertyValue;
foreach(IEnumerable valueItem in valueItems)
{
xmlWriter.WriteString(valueItem.ToString()); //den Wert der Eigenschaft schreiben
}
xmlWriter.WriteEndElement();
}
else //Wenn der gesuchte Wert nur ein Wert ist, dann:
{
xmlWriter.WriteStartElement(propOfComponent.Name); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", propertyValue.GetType().ToString()); //den Klassentypen als Attribute an das Element hängen
xmlWriter.WriteString(propertyValue.ToString()); //den Wert der Eigenschaft schreiben
xmlWriter.WriteEndElement();
}
}
else //wenn der Wert null ist, dann
{
xmlWriter.WriteStartElement(propOfComponent.Name); //Den Namen der Eigenschaft schreiben
xmlWriter.WriteAttributeString("type", "null"); //den Klassentypen als Attribute an das Element hängen
xmlWriter.WriteString("null"); //den Wert der Eigenschaft schreiben
xmlWriter.WriteEndElement();
}
}
catch (Exception e)
{
Console.Write(e);
Debug.LogWarning("SavegameManager: Property \"" + propOfComponent.Name + "\" could not be saved:\n" + e);
}
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
}
}
Eigentlich dachte ich, dass ich es verstanden habe, jedoch wirft
foreach(IEnumerable valueItem in valueItems)
folgende Exception:
Warnung 1 SavegameManager: Property "enemyTypes" could not be saved:
System.InvalidCastException: Cannot cast from source type to destination type.
at SavegameManager.Save () [0x002d2] in D:\Dropbox\shared\FatDogGames___The Lost Rescue Capsule\Unity\Assets_\Scripts\SavegameManager.cs:130 Assets/_/Scripts/SavegameManager.cs 156 1 Projektmappe "UnityVS.Unity" (2 Projekte)
Dann dachte ich an:
ICollection valueItems2 = (ICollection)propertyValue;
for(int i = 0; i < valueItems2.Count; i++)
{
xmlWriter.WriteString(valueItems2[i].ToString); //den Wert der Eigenschaft schreiben
}
Funktioniert auch nicht:
Fehler 36 Indizierung mit [] kann nicht auf einen Ausdruck vom Typ "System.Collections.ICollection" angewendet werden. D:\Dropbox\shared\FatDogGames___The Lost Rescue Capsule\Unity\Assets_\Scripts\SavegameManager.cs 138 67 UnityVS.Unity.CSharp
Anbei ein Screenshot.
//EDIT
Zusätzliche Frage, die mir gerade einfällt:
Ich habe die XML-Datei mal geöffnet und Folgendes gesehen:
<enemyTypes type="System.Collections.Generic.List`1[PlanetBaseClass+EnemyType]">
Wieso steht dort ein + und kein . ?
Könnte das evtl mit zu meinem Problem führen?
Hi Ismoh,
die Fehlermeldungen sind doch relativ eindeutig:
- Deine Auflistung ist nach deiner Aussage vom Typ IEnumerable<MyEnum>. Der Code sollte also so aussehen:
foreach (MyEnum item in items.Cast<MyEnum>())
Eine Collection hat keinen Indexer. Entweder castest du auf Array oder List anstatt ICollection, oder du verwendest die entsprechende ICollection-Methode zum Zugriff auf die Items.
Das + wird für Nested Klassen verwendet. Inwiefern das mit den o.g. Problemen zu tun haben sollte, erschließt sich mir nicht.
Christian
Weeks of programming can save you hours of planning
Okay. Wenn MyEnum als Typ nicht bekannt ist, sollte ich dann auf Array casten, richtig ?
Oder kann ich über den Typ also "System.Collections.Generic.List`1[PlanetBaseClass+EnemyType]" über beispielsweise String.Substring "rausschneiden" ? Ich versuche mal beides.-
Fehlermeldung:
System.InvalidCastException: Cannot cast from source type to destination type. finde ich nicht eindeutig. Die andere Exception kann ich nachvollziehen, wusste aber nicht wie man diese beseitigt.
- Ah verstehe, also eine Art Referenz ?
//EDIT:
foreach(Enum item in valueItems.Cast<Enum>)
funktioniert nicht, da ich .NET 2.0 nutze.
Ich hatte nun folgenden Ansatz:
ICollection valueItems = (ICollection)propertyValue;
Array[] valueItemsAsString = new Array[(int)propertyValue.GetType().GetProperty("Count").GetValue(propertyValue,null)];
valueItems.CopyTo(valueItemsAsString, 0);
for(int i= 0; i < valueItemsAsString.Length; i++)
{
xmlWriter.WriteString(valueItemsAsString[i].ToString()); //den Wert der Eigenschaft schreiben
}
Funktioniert auf Grund der unterschiedlichen Typen nicht.
Fehlermeldung:
Warnung 1 SavegameManager: Property "enemyTypes" could not be saved:
System.ArrayTypeMismatchException: (Types: source=PlanetBaseClass+EnemyType; target=System.Array)
at System.Array.Copy (System.Array sourceArray, Int32 sourceIndex, System.Array destinationArray, Int32 destinationIndex, Int32 length) [0x00165] in /Users/builduser/buildslave/mono-runtime-and-classlibs/build/mcs/class/corlib/System/Array.cs:999
at System.Collections.Generic.List`1[PlanetBaseClass+EnemyType].System.Collections.ICollection.CopyTo (System.Array array, Int32 arrayIndex) [0x00000] in /Users/builduser/buildslave/mono-runtime-and-classlibs/build/mcs/class/corlib/System.Collections.Generic/List.cs:652
at SavegameManager.Save () [0x002e9] in D:\Dropbox\shared\FatDogGames___The Lost Rescue Capsule\Unity\Assets_\Scripts\SavegameManager.cs:131 Assets/_/Scripts/SavegameManager.cs 157 1 Projektmappe "UnityVS.Unity" (2 Projekte)
Dann dachte ich:
Kann man den Typ der nested Klasse, bzw. der Eigenschaft abfragen?
- und 2. du hast probiert MyEnum in die Schnitstelle IEnumerabel umzuwandeln (cast). Das geht nicht z.B. kann eine Katze nicht in eine Auto gewandelt werden. Und genau das sagt der Fehler.
Die Code Zeile von MrSparkle sollte funktionieren. Da wird MyEnum in MyEnum gecastet.
Sollte man mal gelesen haben:
Deine Fragen vermitteln irgendwie immer weniger den Eindruck, als verstehst du wirklich, was du da machst. In erster Linie geht es nämlich bei deinen Fragen um korrekte Typumwandlungen und Zuweisungen von Variablen. Wir können dir das aber nicht alles im Einzelnen erklären, dafür gibt es die FAQs, z.B. [Hinweis] Syntaxfehler selbst lösen (Compilerfehlermeldungen) und auch [FAQ] Wie finde ich den Einstieg in C#?.
Zu deiner Herangehensweise im Allgemeinen würde ich sagen, daß du wahrscheinlich mit einer XML-Serialisierung schneller zum Erfolg kommst. Das ist nämlich bereits im Framework integriert und unterstützt das Speichern und Laden von Objekten.
Abgesehen davon ist es sicherlich nicht ideal, die internen GameObject-Klasse(n) der Unity-Engine zu speichern und zu laden. Stattdessen wäre es besser, du hättest zur Verwaltung des aktuellen Spielzustandes ein eigenes Datenmodell. Das kannst du dann viel einfacher in einer XML-Datei, Binärdatei oder Datenbank speichern und wieder laden. In diesem Zusammenhang wäre evtl. dieser Artikel interessant: [Artikel] Drei-Schichten-Architektur.
Christian
PS: Wie du gesehen hast, habe ich von allen deinen bisherigen Posts die Fullquotes entfernt. Ich würde dich bitten, unseren [Hinweis] Wie poste ich richtig?, Punkt 2.3 zu beachten: Sparsam zitieren, keine Full Quotes.
PPS: Evtl. solltest du dir auch mal dieses Video anschauen: Unity - Persistence - Saving and Loading Data
Weeks of programming can save you hours of planning
Danke für die Links, aber PlayerPrefs möchte ich nicht nutzen.
3 Schichtenmodell kenne ich von JEE und RoR, aber sehe ich momentan keine Verbindung zu einem MVC-Modell.
Ich weiß auch nicht was ich hier mache.
Habe bisher noch nie mit Reflection gearbeitet.
Datentyp des Enum ist nicht bekannt, naja ist es schon nur möchte ich da nicht "EnemyType" hinschreiben, da eine andere Liste einen anderen Datentypen haben kann.
Vielleicht kenne ich noch nicht so viele Fachbegriffe wie ihr, oder benutze diese nicht, da ich mir diese nicht merke, aber völliger Anfänger bin ich nicht.
Evtl fehlt einfach die praktische Erfahrung.
Könnten wir bitte zum eigentlichen Problem zurückkehren ?
Ich weiß auch nicht was ich hier mache.
Vielleicht kenne ich noch nicht so viele Fachbegriffe wie ihr, oder benutze diese nicht, da ich mir diese nicht merke, aber völliger Anfänger bin ich nicht.
Evtl fehlt einfach die praktische Erfahrung.
Nein, dir fehlt die Einsicht das herumfrickeln deutlich langsamer geht als sich endlich hinzusetzen und die Grundlagen zu erlesen.
...vielleicht wäre es auch mal hilfreich zu erklären, was Du eigentlich versuchst mit Deinem Code zu erreichen - ich seh in der Idee an sich grad keinen all zu tiefen Sinn 😉
Ich hab schon einiges mit Reflection gearbeitet und könnte mir durchauch Anwendungsszenarien vorstellen in denen man zu irgendwelchen ähnlichen Lösungsvorschlägen wie Deinem kommt - aber aus Deinen Fragen & Antworten schlussfolgere ich, das der Hund wo völlig anders begraben liegt (Probleme mit der Architektur, Unkenntniss der vorhandenen Möglichkeiten, etc.)
Ich lese zwischen den Zeilen, dass es um irgendeine Art von (De-?) Serialisierung in (nach?) XML geht...
Bart Simpson
Praxis ist wenn alles funktioniert und keiner weiss warum.
Theorie ist wenn man alles weiss, aber nichts funktioniert.
Bei uns wird Theorie und Praxis vereint: Nichts funktioniert und keiner weiss warum...
Nachdem ich nun den Typ auslesen konnte, habe ich tatsächlich auch schon drüber nachgedacht, dass Reflection eventuell nicht wirklich der richtige Ansatz ist.
Eigentliche Idee war, dass ich eine Liste mit Objekten habe, die gespeichert werden sollen - aktuelle Werte der Eigenschaften und deren Typen.
Eine einfache Textdatei möchte ich nicht benutzen, da ich mich um die Struktur dieser ebenfalls kümmern müsste, also dachte ich an JSON.
Nachdem ich mir JSON etwas genauer angeschaut habe, gefiel mir es nicht mehr, da es ebenfalls Werte in eine Zeile schreibt - ist meiner Meinung nach ebenso unübersichtlich wie eine einfache Textdatei.
Da XML angesprochen wurde, habe ich mich für XML entschieden.
(De)Serialisierung ist ebenso Neuland wie Reflection.
Auf Grund der Idee dachte ich, dass man die Eigenschaften der Objekte auslesen können müsste - Reflection.
Deshalb entschied ich mich für Reflection.
Mittlerweile denke ich, dass ich mir aber nochmal die bereits implementierte (De)Serialisierung von .NET anschauen sollte.
Auf Grund der Idee dachte ich, dass man die Eigenschaften der Objekte auslesen können müsste - Reflection.
Deshalb entschied ich mich für Reflection.
Mittlerweile denke ich, dass ich mir aber nochmal die bereits implementierte (De)Serialisierung von .NET anschauen sollte.
Du hast schon den richtigen Denkansatz gehabt, keine Sorge. Die eingebaute Serialisierung/Deserialisierung von Objekten in .NET funktioniert über Reflection, aus genau den Gründen, die du erkannt hast. Nur, dass sie dir schon jemand abnimmt.
LaTino
"Furlow, is it always about money?"
"Is there anything else? I mean, how much sex can you have?"
"Don't know. I haven't maxed out yet."
(Furlow & Crichton, Farscape)