Exemple #1
0
 private static void BindReferences()
 {
     _classA = _classC.A;
     _classB = _classA.B;
 }
        static void Main(string[] args)
        {
            string choice;

            do
            {
                Console.Clear();
                Console.WriteLine("Insert \"xml\" or \"own\"\n(press any key to exit)");
                choice = Console.ReadLine();
                if (choice == "xml")
                {
                    #region "XmlSerialization"
                    Console.WriteLine("Insert \"s\" - serialize or \"d\" - deserialize");
                    string choice2 = Console.ReadLine();
                    switch (choice2)
                    {
                    case "s":
                        ClassAPrim classAPrim = new ClassAPrim(1.2f, new DateTime(1997, 1, 1, 0, 0, 0), "TestA", null);
                        ClassBPrim classBPrim = new ClassBPrim(2.2f, new DateTime(1997, 2, 1, 0, 0, 0), "testB", null);
                        ClassCPrim classCPrim = new ClassCPrim(3.2f, new DateTime(1997, 3, 1, 0, 0, 0), "testC", null);

                        classAPrim.ClassBProperty = classBPrim;
                        classBPrim.ClassCProperty = classCPrim;
                        classCPrim.ClassAProperty = classAPrim;

                        Console.WriteLine("Insert \"A\" - serialize ClassA, \"B\" - serialize ClassB or \"C\" - serialize ClassC");
                        choice2 = Console.ReadLine();
                        switch (choice2)
                        {
                        case "A":
                            XmlSerialization <ClassAPrim> xmlClassA = new XmlSerialization <ClassAPrim>("xml-a.xml", classAPrim);
                            xmlClassA.serialize();
                            break;

                        case "B":
                            XmlSerialization <ClassBPrim> xmlClassB = new XmlSerialization <ClassBPrim>("xml-b.xml", classBPrim);
                            xmlClassB.serialize();
                            break;

                        case "C":
                            XmlSerialization <ClassCPrim> xmlClassC = new XmlSerialization <ClassCPrim>("xml-c.xml", classCPrim);
                            xmlClassC.serialize();
                            break;

                        default:
                            Console.WriteLine("Invalid input!");
                            break;
                        }
                        break;

                    case "d":
                        Console.WriteLine("Insert \"A\" - deserialize ClassA, \"B\" - deserialize ClassB or \"C\" - deserialize ClassC");
                        choice2 = Console.ReadLine();
                        switch (choice2)
                        {
                        case "A":
                            XmlSerialization <ClassAPrim> xmlClassA = new XmlSerialization <ClassAPrim>("xml-a.xml", new ClassAPrim());
                            ClassAPrim deserializedClassA           = xmlClassA.deserialize();
                            if (deserializedClassA.ClassBProperty.ClassCProperty.ClassAProperty == deserializedClassA)
                            {
                                Console.WriteLine("Deserialization is completed!");
                            }
                            else
                            {
                                Console.WriteLine("Deserialization is failed!");
                            }
                            break;

                        case "B":
                            XmlSerialization <ClassBPrim> xmlClassB = new XmlSerialization <ClassBPrim>("xml-b.xml", new ClassBPrim());
                            ClassBPrim deserializedClassB           = xmlClassB.deserialize();
                            if (deserializedClassB.ClassCProperty.ClassAProperty.ClassBProperty == deserializedClassB)
                            {
                                Console.WriteLine("Deserialization is completed!");
                            }
                            else
                            {
                                Console.WriteLine("Deserialization is failed!");
                            }
                            break;

                        case "C":
                            XmlSerialization <ClassCPrim> xmlClassC = new XmlSerialization <ClassCPrim>("xml-c.xml", new ClassCPrim());
                            ClassCPrim deserializedClassC           = xmlClassC.deserialize();
                            if (deserializedClassC.ClassAProperty.ClassBProperty.ClassCProperty == deserializedClassC)
                            {
                                Console.WriteLine("Deserialization is completed!");
                            }
                            else
                            {
                                Console.WriteLine("Deserialization is failed!");
                            }
                            break;

                        default:
                            Console.WriteLine("Invalid input!");
                            break;
                        }
                        break;

                    default:
                        Console.WriteLine("Invalid input!");
                        break;
                    }
                    #endregion
                }
                else if (choice == "own")
                {
                    #region "OwnSerialization"
                    Console.WriteLine("Insert \"s\" - serialize or \"d\" - deserialize");
                    string choice2 = Console.ReadLine();
                    switch (choice2)
                    {
                    case "s":
                        ClassA classA = new ClassA(1.2f, new DateTime(1997, 1, 1, 0, 0, 0), "TestA", null);
                        ClassB classB = new ClassB(2.2f, new DateTime(1997, 2, 1, 0, 0, 0), "testB", null);
                        ClassC classC = new ClassC(3.2f, new DateTime(1997, 3, 1, 0, 0, 0), "testC", null);

                        classA.ClassBProperty = classB;
                        classB.ClassCProperty = classC;
                        classC.ClassAProperty = classA;

                        Console.WriteLine("Insert \"A\" - serialize ClassA, \"B\" - serialize ClassB or \"C\" - serialize ClassC");
                        choice2 = Console.ReadLine();
                        switch (choice2)
                        {
                        case "A":
                            using (FileStream s = new FileStream("own-a.txt", FileMode.Create))
                            {
                                IFormatter f = new OwnFormatter();
                                f.Serialize(s, classA);
                            }
                            break;

                        case "B":
                            using (FileStream s = new FileStream("own-b.txt", FileMode.Create))
                            {
                                IFormatter f = new OwnFormatter();
                                f.Serialize(s, classB);
                            }
                            break;

                        case "C":
                            using (FileStream s = new FileStream("own-c.txt", FileMode.Create))
                            {
                                IFormatter f = new OwnFormatter();
                                f.Serialize(s, classC);
                            }
                            break;

                        default:
                            Console.WriteLine("Invalid input!");
                            break;
                        }
                        break;

                    case "d":
                        Console.WriteLine("Insert \"A\" - deserialize ClassA, \"B\" - deserialize ClassB or \"C\" - deserialize ClassC");
                        choice2 = Console.ReadLine();
                        switch (choice2)
                        {
                        case "A":
                            using (FileStream s = new FileStream("own-a.txt", FileMode.Open))
                            {
                                IFormatter f         = new OwnFormatter();
                                ClassA     testClass = (ClassA)f.Deserialize(s);
                                if (testClass.ClassBProperty.ClassCProperty.ClassAProperty == testClass)
                                {
                                    Console.WriteLine("Deserialization is completed!");
                                    Console.WriteLine(testClass);
                                    Console.WriteLine(testClass.ClassBProperty);
                                    Console.WriteLine(testClass.ClassBProperty.ClassCProperty);
                                    Console.WriteLine(testClass.ClassBProperty.ClassCProperty.ClassAProperty);
                                }
                                else
                                {
                                    Console.WriteLine("Deserialization is failed!");
                                }
                            }
                            break;

                        case "B":
                            using (FileStream s = new FileStream("own-b.txt", FileMode.Open))
                            {
                                IFormatter f         = new OwnFormatter();
                                ClassB     testClass = (ClassB)f.Deserialize(s);
                                if (testClass.ClassCProperty.ClassAProperty.ClassBProperty == testClass)
                                {
                                    Console.WriteLine("Deserialization is completed!");
                                    Console.WriteLine(testClass);
                                    Console.WriteLine(testClass.ClassCProperty);
                                    Console.WriteLine(testClass.ClassCProperty.ClassAProperty);
                                    Console.WriteLine(testClass.ClassCProperty.ClassAProperty.ClassBProperty);
                                }
                                else
                                {
                                    Console.WriteLine("Deserialization is failed!");
                                }
                            }
                            break;

                        case "C":
                            using (FileStream s = new FileStream("own-c.txt", FileMode.Open))
                            {
                                IFormatter f         = new OwnFormatter();
                                ClassC     testClass = (ClassC)f.Deserialize(s);
                                if (testClass.ClassAProperty.ClassBProperty.ClassCProperty == testClass)
                                {
                                    Console.WriteLine("Deserialization is completed!");
                                    Console.WriteLine(testClass);
                                    Console.WriteLine(testClass.ClassAProperty);
                                    Console.WriteLine(testClass.ClassAProperty.ClassBProperty);
                                    Console.WriteLine(testClass.ClassAProperty.ClassBProperty.ClassCProperty);
                                }
                                else
                                {
                                    Console.WriteLine("Deserialization is failed!");
                                }
                            }
                            break;

                        default:
                            Console.WriteLine("Invalid input!");
                            break;
                        }
                        break;

                    default:
                        Console.WriteLine("Invalid input!");
                        break;
                    }
                    #endregion
                }
                Console.WriteLine("Click any to continue");
                Console.ReadLine();
            } while (choice == "xml" || choice == "own");
        }
Exemple #3
0
 private static void InitEmptyModel()
 {
     _classA = new ClassA();
     _classB = new ClassB();
     _classC = new ClassC();
 }
Exemple #4
0
        static void Main(string[] args)
        {
            ClassA classA = new ClassA("classA", 789654, true);
            ClassB classB = new ClassB("classB", 123456897, 777);
            ClassC classC = new ClassC("classC", 98765188);

            classA.ClassB = classB;
            classA.ClassC = classC;
            classB.ClassA = classA;
            classB.ClassC = classC;
            classC.ClassA = classA;
            classC.ClassB = classB;

            Bookshelf bookshelf = new Bookshelf(
                new List <Book> {
                new Book("123-456", 9.9), new Book("987-654", 1.1)
            },
                new BookGenres[] {
                new BookGenres("Drama"), new BookGenres("Action"), new BookGenres("Poetry")
            }
                );

            CustomFormatter customFormatter;


            Console.WriteLine("Wciśnij:");
            Console.WriteLine("1 - by zapisać stan programu w pliku JSON - ClassA");
            Console.WriteLine("2 - by zapisać stan programu w pliku JSON - Bookshelf");
            Console.WriteLine("3 - by zapisać stan programu własną metodą - ClassA");
            Console.WriteLine("4 - by zapisać stan programu własną metodą - Bookshelf");
            Console.WriteLine("5 - by wczytać stan programu z pliku JSON - ClassA");
            Console.WriteLine("6 - by wczytać stan programu z pliku JSON - Bookshelf");
            Console.WriteLine("7 - by wczytać stan programu własną metodą - ClassA");
            Console.WriteLine("8 - by wczytać stan programu własną metodą - Bookshelf");
            Console.WriteLine("9 - by wyłączyć program");
            string option = "10";
            string filePath;

            while (option != "9")
            {
                customFormatter = new CustomFormatter();
                option          = Console.ReadLine();
                switch (option)
                {
                case "1":
                    filePath = "..\\..\\..\\..\\TestResults\\jsonFileClassA.json";
                    JsonSerializer.Serialize(classA, filePath);
                    break;

                case "2":
                    filePath = "..\\..\\..\\..\\TestResults\\jsonFileBookshelf.json";
                    JsonSerializer.Serialize(bookshelf, filePath);
                    break;

                case "3":
                    filePath = "..\\..\\..\\..\\TestResults\\CustomSerializationClassA.txt";
                    using (Stream stream = new FileStream(filePath, FileMode.Create))
                    {
                        customFormatter.Serialize(stream, classA);
                    }
                    break;

                case "4":
                    filePath = "..\\..\\..\\..\\TestResults\\CustomSerializationBookshelf.txt";
                    using (Stream stream = new FileStream(filePath, FileMode.Create))
                    {
                        customFormatter.Serialize(stream, bookshelf);
                    }
                    break;

                case "5":
                    filePath = "..\\..\\..\\..\\TestResults\\jsonFileClassA.json";
                    ClassA classADeserialized = JsonSerializer.Deserialize <ClassA>(filePath);
                    break;

                case "6":
                    filePath = "..\\..\\..\\..\\TestResults\\jsonFileBookshelf.json";
                    Bookshelf bookshelfDeserialized = JsonSerializer.Deserialize <Bookshelf>(filePath);
                    break;

                case "7":
                    filePath = "..\\..\\..\\..\\TestResults\\CustomSerializationClassA.txt";
                    using (Stream stream = new FileStream(filePath, FileMode.Open))
                    {
                        ClassA deserialized = (ClassA)customFormatter.Deserialize(stream);
                    }
                    break;

                case "8":
                    filePath = "..\\..\\..\\..\\TestResults\\CustomSerializationBookshelf.txt";
                    using (Stream stream = new FileStream(filePath, FileMode.Open))
                    {
                        Bookshelf deserialized = (Bookshelf)customFormatter.Deserialize(stream);
                    }
                    break;

                default:
                    break;
                }
            }
        }