Question

我有一个班级

class ABC
{
    Public int one = 10;
    Public String two = "123";
  public override string ToString()
   {
   }
}

我的问题我希望在我将创建该类的对象时，在字符串类“ABC”中获取字段信息/值。例如：

Public Class Test
{
    public static void Main()
    {
        ABC a = new ABC();
        a.ToString();
    }
}

现在我在这里创建一个类“ABC”的对象，然后我想覆盖ToString（）的方法，以获取字符串中ABC类的所有字段值。

作为解决方案，这对我有用：

**Here is an other solution if we use static fields and fieldsInfo:** 

class ReflectionTest
{
    public static int Height = 2;
    public static int Width = 10;
    public static int Weight = 12;
    public static string Name = "Got It";

    public override string ToString()
    {
        string result = string.Empty;
        Type type = typeof(ReflectionTest); 
        FieldInfo[] fields = type.GetFields();
        foreach (var field in fields)
        {
            string name = field.Name; 
            object temp = field.GetValue(null);
            result += "Name:" + name + ":" + temp.ToString() + System.Environment.NewLine;
        }
        return result;
    }

}

Answer 1

public override string ToString()
{
    Dictionary<string, string> fieldValues = new Dictionary<string, string>();
    var fields = this.GetType().GetFields();

    foreach (var field in fields)
    {
        fieldValues[field.Name] = field.GetValue(this).ToString();
    }

    return string.Join(", ", fieldValues.Select(x => string.Format("{0}: {1}", x.Key, x.Value)));
}

Answer 2

不确定这是不是你的意思;

public override ToString() 
{
    return string.Format("one: {1}{0}two: {2}", Environment.NewLine(), one, two);
}

Answer 3

您可以使用属性来检索字符串，也可以覆盖ToString()，两者都显示出来：

public class ABC
{
    private Int32 _one = 10;
    public Int32 One { get { return _one; } }
    private String _two = "123";
    public String Two { get { return _two; } }

    protected override ToString()
    {
        return _two;
    }
}

Answer 4

这应该这样做：

public override string ToString() {
    string s = "";
    foreach(FieldInfo f in this.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public)) {
        s += f.Name + "=" + f.GetValue(this).ToString() + "\r\n";
    }
    return s;
}

BindingFlags.Public仅反映公众成员。如果您也想要私人会员，请同时使用BindingFlags.Private标志您可以在对象初始化时使用this.GetType().GetFields()，只调用一次。

这也适用于框架2 根据您的需要改变它。

Answer 5

所以，这是：

public class ABC
    {
        public int one;
        public string two;
        public int three;

        public override string ToString()
        {
            string names = String.Empty;
            System.Reflection.FieldInfo[] infos = this.GetType().GetFields();

            foreach (System.Reflection.MemberInfo inf in infos)
            {
                if (names == String.Empty)
                {
                    names = inf.Name;
                }
                else
                {
                    names += ';' + inf.Name;
                }
            }

            return names;
        }
    }

享受！

Answer 6

您可以使用以下两种方法中的任何一种来代替使用Reflection：

1：在这里，您可以将类对象序列化为更易读的JSON对象：

    public override string ToString()
    {

        DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(ABC));
        string str;
        using (MemoryStream stream = new MemoryStream())
        {
            serializer.WriteObject(stream, this);
            stream.Position = 0;
            using (StreamReader streamReader = new StreamReader(stream, Encoding.UTF8))
            {

                str = streamReader.ReadToEnd();
            }
        }

        return str;
}

2：在这里，您可以将类对象序列化为XML，这可以利用其他地方：

    public override string ToString()
    {

        XmlSerializer s = new XmlSerializer(typeof(ABC));
        StringBuilder sb = new StringBuilder();
        var xtw = XmlTextWriter.Create(sb);
        s.Serialize
            (xtw, this);

        return sb.ToString();
}

Answer 7

最后解决我的问题：）

using System;
using System.Reflection;
using System.IO;
using System.Collections.Generic;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        MyClass mC= new MyClass();
        string result = mC.ToString();
    }
}

class MyClass
{
    string someValue = "One";
    int someValue1 = -1;
    bool someValue2 = false;
    float someValue3 = 2.2f;

    public string SomeValue
    {
        get{ return this.someValue;}
    }

    public int SomeValue1
    {
        get { return this.someValue1; }
    }

    public bool SomeValue2
    {
        get { return this.someValue2; }
    }

    public float SomeValue3
    {
        get { return this.someValue3; }
    }

    public override string ToString()
    {
        string result = string.Empty;
        Type type = this.GetType();
        PropertyInfo [] pInfo = type.GetProperties();

        for (int i = 0; i <= pInfo.Length-1; i++)
        {
            Type internalType = this.GetType();
            PropertyInfo pInfoObject = internalType.GetProperty(pInfo[i].Name);
            object value = pInfoObject.GetValue(this,null);
            result += pInfo[i].Name + " : " + value.ToString() + System.Environment.NewLine;
        }
        return result;
    }
}

Answer 8

如果我们使用静态字段和fieldsInfo：

，这是另一种解决方案

    class ReflectionTest
{
    public static int Height = 2;
    public static int Width = 10;
    public static int Weight = 12;
    public static string Name = "Got It";

    public override string ToString()
    {
        string result = string.Empty;
        Type type = typeof(ReflectionTest); 
        FieldInfo[] fields = type.GetFields();
        foreach (var field in fields)
        {
            string name = field.Name; 
            object temp = field.GetValue(null);
            result += "Name:" + name + ":" + temp.ToString() + System.Environment.NewLine;
        }
        return result;
    }

}

System.Reflection用法

8 个答案: