Exemplo n.º 1
0
        static void Main(string[] args)
        {
            RootDescriptor <Person> rootDesc = GetPersonDescriptor();

            var czechRepublic = new Country {
                Name = "Czech Republic", AreaCode = 420
            };
            var person = new Person
            {
                FirstName   = "Pavel",
                LastName    = "Jezek",
                HomeAddress = new Address {
                    Street = "Patkova", City = "Prague"
                },
                WorkAddress = new Address {
                    Street = "Malostranske namesti", City = "Prague"
                },
                CitizenOf   = czechRepublic,
                MobilePhone = new PhoneNumber {
                    Country = czechRepublic, Number = 123456789
                }
            };

            rootDesc.Serialize(Console.Out, person);
        }
Exemplo n.º 2
0
        static RootDescriptor <Person> GetPersonDescriptor()
        {
            //Address
            var addressDes = new RootDescriptor <Address>("Address");

            addressDes.AddNewDescriptor(new SimpleTypeDescriptor <Address, string>("Street", a => a.Street));
            addressDes.AddNewDescriptor(new SimpleTypeDescriptor <Address, string>("City", a => a.City));

            //Country
            var countryDes = new RootDescriptor <Country>("Country");

            countryDes.AddNewDescriptor(new SimpleTypeDescriptor <Country, string>("Name", c => c.Name));
            countryDes.AddNewDescriptor(new SimpleTypeDescriptor <Country, int>("AreaCode", c => c.AreaCode));

            //PhoneNumber
            var phoneNumberDesc = new RootDescriptor <PhoneNumber>("PhoneNumber");

            phoneNumberDesc.AddNewDescriptor(new SimpleTypeDescriptor <PhoneNumber, int>("Number", pn => pn.Number));
            phoneNumberDesc.AddNewDescriptor(new ComplexPropertyDescriptor <PhoneNumber, Country>("Country", countryDes, pn => pn.Country));

            //Person
            var personDesc = new RootDescriptor <Person>("Person");

            personDesc.AddNewDescriptor(new SimpleTypeDescriptor <Person, string>("FirstName", p => p.FirstName));
            personDesc.AddNewDescriptor(new SimpleTypeDescriptor <Person, string>("LastName", p => p.LastName));
            personDesc.AddNewDescriptor(new ComplexPropertyDescriptor <Person, Address>("HomeAddress", addressDes, p => p.HomeAddress));
            personDesc.AddNewDescriptor(new ComplexPropertyDescriptor <Person, Address>("WorkAddress", addressDes, p => p.WorkAddress));
            personDesc.AddNewDescriptor(new ComplexPropertyDescriptor <Person, Country>("CitizenOf", countryDes, p => p.CitizenOf));
            personDesc.AddNewDescriptor(new ComplexPropertyDescriptor <Person, PhoneNumber>("MobilePhone", phoneNumberDesc, p => p.MobilePhone));

            return(personDesc);
        }
Exemplo n.º 3
0
        //Follow a set of methods serving as a configuration for a serializer

        /// <summary>
        /// returns a description of Person
        /// </summary>
        /// <returns></returns>
        static RootDescriptor <Person> GetPersonDescriptor()
        {
            //Create delegates to functions describing Person fields
            //functions are to be called from the Serialize function
            //descritors for each field nested anywhere in Person object is recursivelly created and .Serialize() is called on each descriptor
            GetStringRepresentation <Person> FirstName = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                              { GetStringDescriptor().Serialize(person.FirstName, nameof(person.FirstName), builder); });
            GetStringRepresentation <Person> LastName = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                             { GetStringDescriptor().Serialize(person.LastName, nameof(person.LastName), builder); });
            GetStringRepresentation <Person> HomeAddress = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                                { GetAddressDescriptor().Serialize(person.HomeAddress, nameof(person.HomeAddress), builder); });
            GetStringRepresentation <Person> WorkAddress = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                                { GetAddressDescriptor().Serialize(person.WorkAddress, nameof(person.WorkAddress), builder); });
            GetStringRepresentation <Person> CitizenOf = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                              { GetCountryDescriptor().Serialize(person.CitizenOf, nameof(person.CitizenOf), builder); });
            GetStringRepresentation <Person> MobilePhone = new GetStringRepresentation <Person>((Person person, StringBuilder builder) =>
                                                                                                { GetPhoneNumberDescriptor().Serialize(person.MobilePhone, nameof(person.MobilePhone), builder); });

            //create new person descriptor with coresponding array of delegates
            RootDescriptor <Person> rootDesc = new RootDescriptor <Person>(new GetStringRepresentation <Person>[]
                                                                           { FirstName, LastName, HomeAddress, WorkAddress, CitizenOf, MobilePhone });

            return(rootDesc);
            //no Person instance is passed directly to GetDescriptor() functions - Descriptors can be created independentally of a particular instance
            //Person instance is passed to Serialize function when called, then propageted thru corresponding delegates to recursive serialize calls
        }
Exemplo n.º 4
0
        static RootDescriptor <Person> GetPersonDescriptor()
        {
            string ownName = nameof(Person);

            RootDescriptor <String>      stringDesc      = GetStringDescriptor();
            RootDescriptor <Int32>       int32Desc       = GetInt32Descriptor();
            RootDescriptor <Address>     adressDesc      = GetAdressDescriptor();
            RootDescriptor <Country>     countryDesc     = GetCountryDescriptor();
            RootDescriptor <PhoneNumber> phoneNumberDesc = GetPhoneNumberDescriptor();

            SerializerHelperPointingToVariableValue <Person>[] variables = new SerializerHelperPointingToVariableValue <Person>[]
            {
                new SerializerHelperPointingToVariableValue <Person>(FirstName),
                new SerializerHelperPointingToVariableValue <Person>(LastName),
                new SerializerHelperPointingToVariableValue <Person>(HomeAddress),
                new SerializerHelperPointingToVariableValue <Person>(WorkAddress),
                new SerializerHelperPointingToVariableValue <Person>(CitizenOf),
                new SerializerHelperPointingToVariableValue <Person>(MobilePhone),
            };

            string FirstName(Person person) => stringDesc.Serialize(nameof(FirstName), person.FirstName);
            string LastName(Person person) => stringDesc.Serialize(nameof(LastName), person.LastName);
            string HomeAddress(Person person) => adressDesc.Serialize(nameof(HomeAddress), person.HomeAddress);
            string WorkAddress(Person person) => adressDesc.Serialize(nameof(WorkAddress), person.WorkAddress);
            string CitizenOf(Person person) => countryDesc.Serialize(nameof(CitizenOf), person.CitizenOf);
            string MobilePhone(Person person) => phoneNumberDesc.Serialize(nameof(MobilePhone), person.MobilePhone);

            return(new RootDescriptor <Person>(ownName, variables));
        }
Exemplo n.º 5
0
        static void Main(string[] args)
        {
            RootDescriptor <Person> rootDesc = GetPersonDescriptor();

            var czechRepublic = new Country {
                Name = "Czech Republic", AreaCode = 420
            };
            var person = new Person
            {
                FirstName   = "David",
                LastName    = "Napravnik",
                HomeAddress = new Address {
                    Street = "Vetrna", City = "Predboj"
                },
                WorkAddress = new Address {
                    Street = "U kastanu", City = "Prague"
                },
                CitizenOf   = czechRepublic,
                MobilePhone = new PhoneNumber {
                    Country = czechRepublic, Number = 987654321
                }
            };

            rootDesc.Serialize(Console.Out, person);
            Console.ReadKey();
        }
Exemplo n.º 6
0
        static RootDescriptor <Int32> GetInt32Descriptor()
        {
            string ownName = nameof(Int32);

            SerializerHelperPointingToVariableValue <Int32>[] variables = new SerializerHelperPointingToVariableValue <Int32>[] { };

            var rootDesc = new RootDescriptor <Int32>(ownName, variables);

            return(rootDesc);
        }
Exemplo n.º 7
0
        static RootDescriptor <String> GetStringDescriptor()
        {
            string ownName = nameof(String);

            SerializerHelperPointingToVariableValue <String>[] variables = new SerializerHelperPointingToVariableValue <String>[] { };

            var rootDesc = new RootDescriptor <String>(ownName, variables);

            return(rootDesc);
        }
Exemplo n.º 8
0
        static RootDescriptor <Address> GetAdressDescriptor()
        {
            string ownName = nameof(Address);

            RootDescriptor <String> stringDesc = GetStringDescriptor();

            SerializerHelperPointingToVariableValue <Address>[] variables = new SerializerHelperPointingToVariableValue <Address>[]
            {
                new SerializerHelperPointingToVariableValue <Address>(Street),
                new SerializerHelperPointingToVariableValue <Address>(City),
            };

            string Street(Address address) => stringDesc.Serialize(nameof(Street), address.Street);
            string City(Address address) => stringDesc.Serialize(nameof(City), address.City);

            return(new RootDescriptor <Address>(ownName, variables));
        }
Exemplo n.º 9
0
        static RootDescriptor <Country> GetCountryDescriptor()
        {
            string ownName = nameof(Country);

            RootDescriptor <String> stringDesc = GetStringDescriptor();
            RootDescriptor <Int32>  int32Desc  = GetInt32Descriptor();

            SerializerHelperPointingToVariableValue <Country>[] variables = new SerializerHelperPointingToVariableValue <Country>[]
            {
                new SerializerHelperPointingToVariableValue <Country>(Name),
                new SerializerHelperPointingToVariableValue <Country>(AreaCode),
            };

            string Name(Country country) => stringDesc.Serialize(nameof(Name), country.Name);
            string AreaCode(Country country) => int32Desc.Serialize(nameof(AreaCode), country.AreaCode);

            return(new RootDescriptor <Country>(ownName, variables));
        }
Exemplo n.º 10
0
        static RootDescriptor <PhoneNumber> GetPhoneNumberDescriptor()
        {
            string ownName = nameof(PhoneNumber);

            RootDescriptor <Country> adressDesc = GetCountryDescriptor();
            RootDescriptor <Int32>   int32Desc  = GetInt32Descriptor();

            SerializerHelperPointingToVariableValue <PhoneNumber>[] variables = new SerializerHelperPointingToVariableValue <PhoneNumber>[]
            {
                new SerializerHelperPointingToVariableValue <PhoneNumber>(Country),
                new SerializerHelperPointingToVariableValue <PhoneNumber>(Number),
            };

            string Country(PhoneNumber phoneNumber) => adressDesc.Serialize(nameof(Country), phoneNumber.Country);
            string Number(PhoneNumber phoneNumber) => int32Desc.Serialize(nameof(Number), phoneNumber.Number);

            return(new RootDescriptor <PhoneNumber>(ownName, variables));
        }
Exemplo n.º 11
0
        static RootDescriptor <Person> GetPersonDescriptor()
        {
            var rootDesc = new RootDescriptor <Person>();

            return(rootDesc);
        }