怎样使两个对象一样？

Question

比如说有个Job类他有成员Name、State现在有两个Job对象job1：
Name ： Test
State： Wait
job2：
Name ： Test
State： Running我怎样使job1 的内容和job2的内容一样？除了自己写函数逐一复制成员之外，有没有更快捷的方法？

Answer 1

把name和state做成属性，遍历并赋值

Answer 2

job2=job1行不？
你试试，我猜的！

Answer 3

楼主说的是深拷贝吧，以下通过序列化实现static T DeepCopy<T>(T arg) where T:class
        {
            T deepcopy;
            MemoryStream memoryStream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(memoryStream, arg);
            memoryStream.Position = 0;
            deepcopy = (T)formatter.Deserialize(memoryStream);
            return deepcopy;
        }
类型T要加[Serializable]可序列化

Answer 4

这是JOB类    public class Job
    {
        private string name;
        private int state;        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }        public int State
        {
            get
            {
                return state;
            }
            set
            {
                state = value;
            }
        }
    }
调用的代码        private Job job1;
        private Job job2;
        private void propertyForm_Load(object sender, EventArgs e)
        {
            job1 = new Job();
            job1.Name = "cs";
            job1.State = 1;            job2 = new Job();
        }        private void button1_Click(object sender, EventArgs e)
        {
            funPro();            textBox1.Text = "name:" + job2.Name.ToString() + "----" +"state:"+ job2.State.ToString();
        }        private void funPro()
        {
            Type type = job1.GetType();
            PropertyInfo[] propertyList = type.GetProperties();
            for (int i = 0; i < propertyList.Length; i++)
            {
                string perName = propertyList[i].Name;
                PropertyInfo property = type.GetProperty(perName);
                object value = property.GetValue(job1, null);
                property.SetValue(job2, value, null);
               
            }
        }

Answer 5

可以重写Equal()  ,这在List.Contains也可以用。  在其中比较name 和state 相同则为true；如果不需要使用dictionary和sortList等比较，可以不用改写GetHashTable

Answer 6

浅拷贝和浅拷贝可以实现
浅拷贝用.NET自带的MemberwiseClone()可以实现，深拷贝有两种实现方式：一种是new后一一赋值，第二种就是序列化与反序列化
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;namespace CSDN
{
    public class Job
    {
        public Job Clone()//浅拷贝，适合成员只有值类型和string类型的时候
        {
            return (Job)this.MemberwiseClone();
        }
        //序列化和反序列化实现深拷贝
        public Job DeepClone()////深拷贝，适合所有情况
        {
            IFormatter format = new BinaryFormatter();
            using (Stream stream = new MemoryStream())
            {
                format.Serialize(stream, this);
                stream.Seek(0, SeekOrigin.Begin);
                return (Job)format.Deserialize(stream);
            }
        }
        //深拷贝还有一种方式就是您不需要的那种new对象后一一赋值
    }
}

Answer 7

/// <summary>
        /// Copy对象间相同属性名的属性数据
        /// </summary>
        /// <param name="orgObject">源对象</param>
        /// <param name="targetObject">目标对象</param>
        /// <param name="forepartPropertyName">目标对象属性名前缀</param>
        public static void CopyTo(object orgObject, object targetObject, string forepartPropertyName)
        {
            try
            {
                foreach (MemberInfo targetObjectMemberInfo in targetObject.GetType().GetMembers())
                {
                    if (targetObjectMemberInfo.MemberType == MemberTypes.Field)
                    {
                        if (((FieldInfo)targetObjectMemberInfo).Name == "TableName")
                        {
                            continue;
                        }                        foreach (MemberInfo orgObjectMemberInfo in orgObject.GetType().GetMembers())
                        {
                            if (orgObjectMemberInfo.MemberType == MemberTypes.Field)
                            {
                                if (((FieldInfo)targetObjectMemberInfo).Name == forepartPropertyName + ((FieldInfo)orgObjectMemberInfo).Name)
                                {
                                    if (((FieldInfo)orgObjectMemberInfo).GetValue(orgObject) != null)
                                    {
                                        ((FieldInfo)targetObjectMemberInfo).SetValue(targetObject, ((FieldInfo)orgObjectMemberInfo).GetValue(orgObject));
                                    }
                                    break;
                                }
                            }
                        }
                    }                    if (targetObjectMemberInfo.MemberType == MemberTypes.Property)
                    {
                        foreach (MemberInfo orgObjectMemberInfo in orgObject.GetType().GetMembers())
                        {
                            if (orgObjectMemberInfo.MemberType == MemberTypes.Property)
                            {
                                if (((PropertyInfo)targetObjectMemberInfo).Name == forepartPropertyName + ((PropertyInfo)orgObjectMemberInfo).Name)
                                {
                                    if (((PropertyInfo)orgObjectMemberInfo).GetValue(orgObject, null) != null)
                                    {
                                        ((PropertyInfo)targetObjectMemberInfo).SetValue(targetObject, ((PropertyInfo)orgObjectMemberInfo).GetValue(orgObject, null), null);
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Copy属性数据出错：" + ex.Message);
            }
        }

Answer 8

谢谢各位不过我说的不是拷贝，因为两个对象都已经存在了，我现在就是想让两个对象的成员一样，可以说是同步类似于浅拷贝，只需要考虑自身的成员，不用考虑深层的变量遍历的做法就不考虑了，如果我给Job成员添加属性，那这个函数还得修改11楼做法不错，不过能再简单点不？