2

与えられたクラス

public class MyClass
{
    public MyInnerClass Property1 {get;set;}
    public MyInnerClass2 Field1
    public MyInnnerClass[] Property2 {get;set;}
}

上記を次のディクショナリにシリアライズするには、MVC シリアライザーとは異なり、シリアライザーが必要です。

new {
        {
            "Property1.InnerField", "1",
        },
        {
            "Field1.InnerProperty", "7/7/2007"
        },
        {
            "Property2[0].InnerProperty", "0"
        },
        {
            "Property2[1].InnerProperty", "1"
        }
}

基本的に、場所とネイティブ値が必要です。または、非参照型が見つかるまでさらに再帰します。

4

1 に答える 1

3

あなたの質問について話すと、私たちは答えを教訓的な方法で置き、既存のシリアル化アーキテクチャを除外するかもしれません。そうすれば、Reflectionを使用せずにオブジェクト参照ツリーに自由にアクセスして、結果ディクショナリにデータを入力できます。

特定のオブジェクトにアクセスし、パブリックプロパティごとに再帰的に自分自身を呼び出す簡単なメソッドが必要です。署名には、現在の親チェーン（例：）を示す文字列が含まれている"Property1.InnerProperty4.InnerProperty7"必要があり、戻り値のタイプはDictionary<string,string>現在のオブジェクトとネストされたオブジェクトからのものだけを使用します。最初に、引数が値型であるかどうかを確認する必要があります。前者の場合は、新しいディクショナリを作成し、新しいKeyValuePair（parent + name、value）を追加して戻ります。後者の場合、新しいディクショナリを作成し、foreachパブリックプロパティがそれ自体を呼び出して、現在のプロパティ、親+名前の文字列を渡し、返されたディクショナリを以前に作成したディクショナリと結合し、ループの最後にこの大きなディクショナリを返します。渡されたオブジェクトがIEnumerableインターフェイスのようなものを実装しているかどうかを確認する最初に、別の条件を追加する場合があります。その場合、メンバーをループするだけでなく、インデクサーをループして、各アイテムのメソッドを呼び出します。

昨日説明したことを実装する時間が見つかりました。ここに、指定されたオブジェクトの（public property fullnames）-（value）ペアのディクショナリを返すように設計された再帰メソッドがあります。もちろん、あなたが達成したいことは正確には詳細ではないかもしれませんが、あなたはあなた自身を構成するためのたくさんのトリック、アイデア、そして概念を見つけるでしょう：

namespace MyNamespace
{
    public class ClassA {
        int p1 = 1;
        string p2 = "abcdef"; 
        List<string> p3 = new List<string>() { "ghi","lmn" };
        ClassB p4 = new ClassB();
        ClassB p5 = null;

        public int PA1 { get { return p1; } }
        public string PA2 { get { return p2; } }
        public List<string> PA3 { get { return p3; } }
        public ClassB PA4 { get { return p4; } }
        public ClassB PA5 { get { return p5; } }
    }

    public class ClassB{
        private string p1 = "zeta";
        public string PB1 { get { return p1; } }
    }

    public class Program {

        public void Main()
        {
            ClassA o = new ClassA();
            Dictionary<string, string> result = GetPropertiesDeepRecursive(o, "[o]", new List<string>() { "MyNamespace" });
        }

        /// <summary>
        /// Returns a dictionary of propertyFullname-value pairs of the given object (and deep recursively for its public properties)
        /// note: it's object oriented (on purpose) and NOT type oriented! so it will just return values of not null object trees
        /// <param name="includedNamespaces">a list of full namespaces for whose types you want to deep search in the tree</param>
        /// </summary>        
        public Dictionary<string, string> GetPropertiesDeepRecursive(object o, string memberChain, List<string> includedNamespaces)
        {

            List<string> types_to_exclude_by_design = new List<string>() { "System.string", "System.String" };

            //the results bag
            Dictionary<string, string> r = new Dictionary<string, string>();

            //if o is null just return value = [null]
            if (o == null)
            {
                r.Add(memberChain, "[null]");
                return r;
            }

            //the current object argument type
            Type type = o.GetType();

            //reserve a special treatment for specific types by design (like string -that's a list of chars and you don't want to iterate on its items)
            if (types_to_exclude_by_design.Contains(type.FullName))
            {
                r.Add(memberChain, o.ToString());
                return r;
            }

            //if the type implements the IEnumerable interface...
            bool isEnumerable =
                type
                .GetInterfaces()
                .Any(t => t == typeof(System.Collections.IEnumerable));
            if (isEnumerable)
            {
                int i_item = 0;
                //loop through the collection using the enumerator strategy and collect all items in the result bag
                //note: if the collection is empty it will not return anything about its existence,
                //      because the method is supposed to catch value items not the list itself                
                foreach (object item in (System.Collections.IEnumerable)o)
                {
                    string itemInnerMember = string.Format("{0}[{1}]", memberChain, i_item++);
                    r = r.Concat(GetPropertiesDeepRecursive(item, itemInnerMember, includedNamespaces)).ToDictionary(e => e.Key, e => e.Value);
                }
                return r;
            }

            //here you need a strategy to exclude types you don't want to inspect deeper like int,string and so on
            //in those cases the method will just return the value using the specific object.ToString() implementation
            //now we are using a condition to include some specific types on deeper inspection and exclude all the rest
            if (!includedNamespaces.Contains(type.Namespace))
            {
                r.Add(memberChain, o.ToString());
                return r;
            }

            //otherwise go deeper in the object tree...            
            //and foreach object public property collect each value
            PropertyInfo[] pList = type.GetProperties();
            foreach (PropertyInfo p in pList)
            {
                object innerObject = p.GetValue(o, null);
                string innerMember = string.Format("{0}.{1}", memberChain, p.Name);
                r = r.Concat(GetPropertiesDeepRecursive(innerObject, innerMember, includedNamespaces)).ToDictionary(e => e.Key, e => e.Value);
            }
            return r;
        }
    }
}
于 2012-07-25T00:44:31.163 に答える