2

こんにちは:) winFormに他のオブジェクトとリストを含むオブジェクトのクローンを作成するときに問題が発生しました。タイプ構造のオブジェクトの クローンを作成したいクラスを以下に示します まず、ShallowCloneを試しました

public Structure Clone()
{
    return this.MemberwiseClone() as Structure;
}

それが機能しなかったので、https://stackoverflow.com/を検索し、ディープクローンを作成しました

オブジェクトのクローン作成 とこれ .NET(具体的にはC#)でオブジェクトのディープコピーをどのように実行しますか?

public static T DeepClone<T>(T obj)
{
 using (var ms = new MemoryStream())
 {
   var formatter = new BinaryFormatter();
   formatter.Serialize(ms, obj);
   ms.Position = 0;

   return (T) formatter.Deserialize(ms);
 }
}

私が抱えている問題は、オブジェクトのバックアップコピーを取っていることです

var backup=DeepClone<Structure>(this.sched); //sched is Structure Object

その後this.sched、バックアップの変更が変更されます:(

私のクラスの構造は次のとおりです。

[Serializable]
public class Sub
{
    string name;

    int studentsNumber;

    int unassaignedStudent;

    public Sub(string name, int number)
    {
        this.name = name;
        this.studentsNumber = number;
        this.unassaignedStudent = number;
    }

public Subject()
        {
            this.name = "";
            this.studentsNumber = 0;
            this.unassaignedStudent = 0;
        }

    public bool Assigne(int count)
    {
        //stuff
    }

    public Sub Clone()
    {
        return this.MemberwiseClone() as Sub;
    }
}

[Serializable]
class Room
{

    string name;
    int studentsNumber;
    int full;
    private int freeSeats;
    List<Sub> subjects;

    /// <summary>
    /// the list of subjects
    /// </summary>
    internal List<Sub> Subjects
    {
        get { return subjects; }
        set { subjects = value; }
    }

    Dictionary<Subject, int> variations;


    public Room(string name, int number)
    {
        this.name = name;
        this.studentsNumber = number;
        this.full = 0;
        this.subjects = new List<Subject>();
        this.variations = new Dictionary<Subject, int>();
        this.freeSeats = number;
    }

    public Room(int number)
    {
        this.studentsNumber = number;
        this.full = 0;
        this.subjects = new List<Subject>();
        this.variations = new Dictionary<Subject, int>();
        this.freeSeats = number;
    }

     public Room()
    {
        this.name = "R" + count.ToString();
        count++;
        this.studentsNumber = 0;
        this.full = 0;
        this.subjects = new List<Sub>();
        this.variation= new Dictionary<Sub, int>();
        this.freeSeats = 0;
    }


    public bool addSubject(Sub sbj)
    {
         //also stuff
    }

    public bool addPartialSubject(Sub sbj)
    {
           //stuff
           // return false;
    }

    public Room Clone()
    {
        return this.MemberwiseClone() as Room;
    }


}

[Serializable]
class Period
{
    List<Room> rooms;


    int conflicts;


    List<Sub> subjects;
    internal List<Sub> Subjects
    {
        get { return subjects; }
        set { subjects = value; }
    }


    /// <summary>
    /// Create an instance of class Period
    /// </summary>
    /// <param name="rooms">the rooms in this Period</param>
    public Period(List<Room> rooms)
    {
        this.conflicts = 0;
        this.rooms = rooms;
        subjects = new List<Subject>();
        fillSubjects(ref rooms, ref subjects);
    }
     public Period()
    {
        this.conflicts = 0;
        this.rooms = null;
        subjects = new List<Subt>();
        freeSeats = 0;
    }

    /// <summary>
    /// Fill the subjects in the rooms to the list of subjects
    /// </summary>
    /// <param name="rooms">referance to the list of the rooms</param>
    /// <param name="subjects">referance to the list of the subjects</param>
    private void fillSubjects(ref List<Room> rooms, ref List<Sub> subjects)
    {
        foreach (var room in rooms)
        {
            foreach (var subject in room.Subjects)
            {
                if (!subjects.Exists(s => s.Name == subject.Name))
                    subjects.Add(subject);
            }
        }
    }

    /// <summary>
    /// Adds the given subject to the period if there is a place in any room
    /// </summary>
    /// <param name="s">the subject to add</param>
    /// <returns>true if there is space for this subject and added, otherwise false</returns>
    public bool AddSubject(Sub s)
    {
        foreach (var room in rooms)
        {
            if (room.addSubject(s))
            {
                //stuff
            }
            else
                if (room.addPartialSubject(s))
                {
                    //stuff
                }
        }
        return false;
    }

    private int CalculateConflictions(Sub s)
    {
        //also a lot of stuff 
    }
}

[Serializable]
class Structure:IDisposable
{
    int days;

    /// <summary>
    /// the number of days in the Schedual
    /// </summary>
    public int Days
    {
        get { return days; }
        set { days = value; }
    }

    int periods;


    Period[,] schedualArray;

    List<Room> rooms;

    internal List<Room> Rooms
    {
        get { return rooms; }
        set { rooms = value; }
    }

    /// <summary>
    /// Creates an instance of the Structure object
    /// </summary>
    /// <param name="rooms">a list of the rooms in the Schedual</param>
    public Structure(int days, int periods,List<Room> rooms)
    {
        this.days = days;
        this.periods = periods;
        this.rooms=rooms;
        this.schedualArray = new Period[days, periods];
        this.subjectCount = 0;
        for (int i = 0; i < days; i++)
        {
            for (int j = 0; j < periods; j++)
            {
                schedualArray[i, j] = new Period(CloneList(ref rooms)); //here i cloned the list to be in the safe side and it didn't work also
            }
        }
    }

    public Structure()
    {
        this.days = 0;
        this.totalEval = Int32.MaxValue;
        this.periods = 0;
        this.rooms = null;
        this.subjectCount = 0;
        this.schedualArray = null;
    }

    internal bool AddSubject(Sub subject, int day, int period)
    {
        //add the subject into inner lists (room)
    }

    public void PrintStruct()
    {
        for (int i = 0; i < days; i++)
        {
            for (int j = 0; j < periods; j++)
            {
                foreach (var subject in schedualArray[i, j].Subjects)
                {
                    Console.Write("\t\t");
                }
                Console.Write("\t\t");
            }
            Console.WriteLine();
        }
    }

    public Structure Clone()
    {
        return this.MemberwiseClone() as Structure;
    }

    public List<Room> CloneList(ref List<Room> rooms)
    {
        var lst = new List<Room>();
        foreach (var room in rooms)
        {
            lst.Add(DeepClone<Room>(room));
        }
        return lst;
    }

    internal void RemoveSubject(Sub subject)
    {
        //..................
    }

    #region IDisposable Members

    public void Dispose()
    {

        GC.Collect(g, GCCollectionMode.Forced);
    }

    #endregion
}

クローン作成プロセスの詳細はわかりませんが、オブジェクトの構造と階層内の連続するオブジェクトと、リストが参照しているだけでなく、リストが指す完全なアイテムを使用して、オブジェクト全体をクローンする必要があり ます。誰かが私を助けてください私は本当に迷っています:(、私を助けてくれることに興味を持っているすべての人に事前に感謝します:) Yaser

メソッド@WiiMaxxを使用する場合は編集

Structure backup=XamlClone(this.sched);

private Structure XamlClone(Structure s)
{
   //First Step
            // create a XAML string
            string stCopie = XamlWriter.Save(s);

            //Secound Step
            // convert him back to an Object of YourTyp
            return XamlReader.Load(XmlReader.Create(new StringReader(stCopie))) as Structure;
}

しかし、内部period[,]は次のように複製されます。 @WiiMaxxnull を助けてください。

Edit 2.0 私は3つのメソッドでのディープクローンについてもこの記事をチェックしましたが、コードに循環参照があると思います。そのため、これは機能しません http://blog.nuclex-games.com/mono-dotnet/ fast-deep-cloning / End Edit

4

2 に答える 2

2

さて、それは本当に機能するはず
です(あなたのニーズに完全に間違っていたので、古いソリューションも削除しました)

Sub.cs

public class Sub: ICloneable
{
    struct datenStruct
    {
        internal int studentsNumber;
        internal int unassaignedStudent;
        internal string name;
    }

    private datenStruct USE;

    int studentsNumber;

    public string Name
    {
        get { return USE.name; }
        set { USE.name = value; }
    }

    private Sub(datenStruct struc)
    {
        this.USE = struc;
    }

    public Sub(string name, int number)
    {
        this.USE = new datenStruct();
        this.USE.name = name;
        this.USE.studentsNumber = number;
        this.USE.unassaignedStudent = number;
    }

    public bool Assigne(int count)
    {
        //stuff
        return true;
    }

    public object Clone()
    {
        var copie = new datenStruct();

        copie.name = USE.name;
        copie.unassaignedStudent = USE.unassaignedStudent;
        copie.studentsNumber = USE.studentsNumber;

        return new Sub(copie);
    }
}

Room.cs

public class Room: ICloneable
{
    struct datenStruct
    {
        internal int studentsNumber;
        internal int full;
        internal string name;
        internal int freeSeats;
        internal List<Sub> subjects;
        internal Dictionary<Sub, int> variations;
    }

    private datenStruct USE;

    /// <summary>
    /// the list of subjects
    /// </summary>
    internal List<Sub> Subjects
    {
        get { return USE.subjects; }
        set { USE.subjects = value; }
    }

    public Room(string name, int number)
    {
        this.USE = new datenStruct();

        this.USE.name = name;
        this.USE.studentsNumber = number;
        this.USE.full = 0;
        this.USE.subjects = new List<Sub>();
        this.USE.variations = new Dictionary<Sub, int>();
        this.USE.freeSeats = number;
    }

    public Room(int number)
    {
        this.USE = new datenStruct();

        this.USE.studentsNumber = number;
        this.USE.full = 0;
        this.USE.subjects = new List<Sub>();
        this.USE.variations = new Dictionary<Sub, int>();
        this.USE.freeSeats = number;
    }

    private Room(datenStruct struc)
    {
        USE = struc;
    }

    public bool addSubject(Sub sbj)
    {
        //also stuff
        return false;
    }

    public bool addPartialSubject(Sub sbj)
    {
        //stuff
        return false;
    }

    public object Clone()
    {
        var copie = new datenStruct();

        copie.studentsNumber = USE.studentsNumber;
        copie.full = USE.full;
        copie.freeSeats = USE.freeSeats;
        var SubListCopie = new List<Sub>();

        foreach (Sub origSub in USE.subjects)
            SubListCopie.Add((Sub)origSub.Clone());

        copie.subjects = SubListCopie;

        var SubDictCopie = new Dictionary<Sub, int>();

        foreach (KeyValuePair<Sub, int> KvP in USE.variations)
            SubDictCopie.Add((Sub)KvP.Key.Clone(),KvP.Value);

        copie.variations = SubDictCopie;

        return new Room(copie);
    }
}

Period.cs

public class Period: ICloneable
{
    struct datenStruct
    {
        internal List<Room> rooms;
        internal List<Sub> subjects;
        internal string name;
        internal int conflicts;
    }

    private datenStruct USE;


    internal List<Sub> Subjects
    {
        get { return USE.subjects; }
        set { USE.subjects = value; }
    }


    /// <summary>
    /// Create an instance of class Period
    /// </summary>
    /// <param name="rooms">the rooms in this Period</param>
    public Period(List<Room> rooms)
    {
        this.USE.conflicts = 0;
        this.USE.rooms = rooms;
        this.USE.subjects = new List<Sub>();
        fillSubjects(ref USE.rooms, ref USE.subjects);
    }

    private Period(datenStruct struc)
    {
        USE = struc;
    }


    /// <summary>
    /// Fill the subjects in the rooms to the list of subjects
    /// </summary>
    /// <param name="rooms">referance to the list of the rooms</param>
    /// <param name="subjects">referance to the list of the subjects</param>
    private void fillSubjects(ref List<Room> rooms, ref List<Sub> subjects)
    {
        foreach (var room in rooms)
        {
            foreach (var subject in room.Subjects)
            {
                if (!subjects.Exists(s => s.Name == subject.Name))
                    subjects.Add(subject);
            }
        }
    }

    /// <summary>
    /// Adds the given subject to the period if there is a place in any room
    /// </summary>
    /// <param name="s">the subject to add</param>
    /// <returns>true if there is space for this subject and added, otherwise false</returns>
    public bool AddSubject(Sub s)
    {
        foreach (var room in USE.rooms)
        {
            if (room.addSubject(s))
            {
                //stuff
            }
            else
                if (room.addPartialSubject(s))
                {
                    //stuff
                }
        }
        return false;
    }

    private int CalculateConflictions(Sub s)
    {
        //also a lot of stuff 
        return 1;
    }

    public object Clone()
    {
        var copie = new datenStruct();

        copie.name = USE.name;
        copie.conflicts = USE.conflicts;

        var RoomListCopie = new List<Room>();

        foreach (Room origSub in USE.rooms)
            RoomListCopie.Add((Room)origSub.Clone());

        copie.rooms = RoomListCopie;


        var SubListCopie = new List<Sub>();

        foreach (Sub origSub in USE.subjects)
            SubListCopie.Add((Sub)origSub.Clone());

        copie.subjects = SubListCopie;

        return new Period(copie);
    }
}

Structure.cs

public class Structure : IDisposable,ICloneable
{
    struct datenStruct
    {
        internal int days;
        internal int subjectCount;
        internal int periods;
        internal Period[,] schedualArray;
        internal List<Room> rooms;
    }

    private datenStruct USE;



    /// <summary>
    /// the number of days in the Schedual
    /// </summary>
    public int Days
    {
        get { return USE.days; }
        set { USE.days = value; }
    }


    internal List<Room> Rooms
    {
        get { return USE.rooms; }
        set { USE.rooms = value; }
    }



    /// <summary>
    /// Creates an instance of the Structure object
    /// </summary>
    /// <param name="rooms">a list of the rooms in the Schedual</param>
    public Structure(int days, int periods, List<Room> rooms)
    {
        this.USE.days = days;
        this.USE.periods = periods;
        this.USE.rooms = rooms;
        this.USE.schedualArray = new Period[days, periods];
        this.USE.subjectCount = 0;
        for (int i = 0; i < days; i++)
        {
            for (int j = 0; j < periods; j++)
            {
                USE.schedualArray[i, j] = new Period(CloneList(ref rooms)); //here i cloned the list to be in the safe side and it didn't work also
            }
        }
    }

    private Structure(datenStruct struc) 
    {
        this.USE = struc;
    }

    internal bool AddSubject(Sub subject, int day, int period)
    {
        //add the subject into inner lists (room)
        return true;
    }

    public void PrintStruct()
    {
        for (int i = 0; i < USE.days; i++)
        {
            for (int j = 0; j < USE.periods; j++)
            {
                foreach (var subject in USE.schedualArray[i, j].Subjects)
                {
                    Console.Write("\t\t");
                }
                Console.Write("\t\t");
            }
            Console.WriteLine();
        }
    }

    public List<Room> CloneList(ref List<Room> rooms)
    {
        var lst = new List<Room>();
        foreach (var room in rooms)
        {
            lst.Add((Room)room.Clone());
        }
        return lst;
    }

    internal void RemoveSubject(Sub subject)
    {
        //..................
    }

    #region IDisposable Members

    public void Dispose()
    {
       // GC.Collect(g, GCCollectionMode.Forced);
    }

    #endregion

    public object Clone()
    {
        var copie =new datenStruct();

        copie.days = USE.days;
        copie.subjectCount = USE.subjectCount;
        copie.periods = USE.periods;


        var RoomListCopie = new List<Room>();

        foreach (Room origSub in USE.rooms)
            RoomListCopie.Add((Room)origSub.Clone());

        copie.rooms = RoomListCopie;


        copie.schedualArray = new Period[copie.days, copie.periods];
        for (int i = 0; i < copie.days; i++)
        {
            for (int j = 0; j < copie.periods; j++)
            {
                copie.schedualArray[i, j] = new Period(CloneList(ref copie.rooms));
            }
        }

        return new Structure(copie);
    }
}
于 2013-03-16T20:07:20.927 に答える
0

私はこのコードを書いて私の問題を解決すると思いますが、他に答えがある場合はお知らせください。

private Structure SpecialClone(Structure s)
        {
            var rooms = Cloner.DeepClone<List<Room>>(s.Rooms);
            var perds = Cloner.DeepClone<Period[,]>(s.SchedualArray);
            var days = s.Days;
            var periods = s.Periods;
            return new Structure(days, periods, rooms, perds, s.SubjectCount);
        }

そして、これを行うために構造コンストラクチャにオーバーロードを追加しました:

public Structure(int days, int periods, List<Room> rooms, Period[,] _periods,int subjectCount)
        {
            this.days = days;
            this.periods = periods;
            this.rooms = rooms.DeepClone();
            this.subjectCount = subjectCount;
            this.schedualArray = _periods.Clone() as Period[,];
        }
于 2013-03-17T14:29:18.790 に答える