Encapsulation - PizzaCalories | C# Online Compiler

Encapsulation - PizzaCalories by lduduman

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PizzaCalories
{
    public class Dough
    {
        private string flour;
        private string technique;
        private double weight;

        public Dough(string flour, string technique, double weight)
        {
            Flour = flour;
            Technique = technique;
            Weight = weight;
        }

        private string Flour
        {
            get
            {
                return flour;
            }
            set
            {
                if (value.ToLower() != "white" && value.ToLower() != "wholegrain")
                {
                    throw new ArgumentException("Invalid type of dough!");
                }

                flour = value;
            }
        }
        private string Technique
        {
            get
            {
                return technique;
            }
            set
            {
                if (value.ToLower() != "cripsy" && 
                    value.ToLower() != "chewy" &&
                    value.ToLower() != "homemade")
                {
                    throw new ArgumentException("Invalid type of dough!");
                }

                technique = value;
            }
        }
        private double Weight
        {
            get
            {
                return weight;
            }
            set
            {
                if (value < 1 || value > 200)
                {
                    throw new ArgumentException("Dough weight should be in the range [1...200].");
                }

                weight = value;
            }
        }

        public double Calories()
        {
            double flourModifier = 0.0;
            double techniqueModifier = 0.0;

            switch (flour.ToLower())
            {
                case "white":
                    flourModifier = 1.5;
                    break;
                case "wholegrain":
                    flourModifier = 1.0;
                    break;
            }

            switch (Technique.ToLower())
            {
                case "cripsy":
                    techniqueModifier = 0.9;
                    break;
                case "chewy":
                    techniqueModifier = 1.1;
                    break;
                case "homemade":
                    techniqueModifier = 1.0;
                    break;
            }

            return (2 * Weight * flourModifier * techniqueModifier);
        }
    }
	
	public class Topping
    {
        private string toppingType;
        private double weigth;

        public Topping(string toppingType, double weigth)
        {
            ToppingType = toppingType;
            Weigth = weigth;
        }

        private string ToppingType
        {
            get
            {
                return toppingType;
            }
            set
            {
                if (value.ToLower() != "meat" && value.ToLower() != "veggies" && 
                    value.ToLower() != "cheese" && value.ToLower() != "sauce")
                {
                    throw new ArgumentException(string.Format("Cannot place {0} on top of your pizza.", value));
                }

                toppingType = value;
            }
        }
        private double Weigth
        {
            get
            {
                return weigth;
            }
            set
            {
                if (value < 1 || value > 50)
                {
                    throw new ArgumentException(string.Format("{0} weight should be in the range [1...50].", toppingType));
                }

                weigth = value;
            }
        }

        public double Calories()
        {
            double toppingTypeModifier = 0.0;

            switch (ToppingType.ToLower())
            {
                case "meat":
                    toppingTypeModifier = 1.2;
                    break;
                case "veggies":
                    toppingTypeModifier = 0.8;
                    break;
                case "cheese":
                    toppingTypeModifier = 1.1;
                    break;
                case "sauce":
                    toppingTypeModifier = 0.9;
                    break;
            }

            return (2 * Weigth * toppingTypeModifier);
        }
    }
	
	public class Pizza
    {
        private string name;
        private int numbTopping;

        public Pizza()
        {
        }

        public Pizza(string name, int numbTopping)
        {
            Name = name;
            NumbTopping = numbTopping;
            Toppings = new List<Topping>();
        }

        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                if (value.Length < 1 || value.Length > 15)
                {
                    throw new ArgumentException("Pizza name should be between 1 and 15 symbols.");
                }

                name = value;
            }
        }

        public double Calories { get; set; }

        public int NumbTopping
        {
            get
            {
                return numbTopping;
            }
            set
            {
                if (value < 0 || value > 10)
                {
                    throw new ArgumentException("Number of toppings should be in range [0...10].");
                }

                numbTopping = value;
            }
        }

        public List<Topping> Toppings { get; set; }

        public Dough Dough { get; set; }

        public double TotalCalories()
        {
            return this.Dough.Calories() + this.Toppings.Sum(t => t.Calories());
        }
    }
	
	public class Program
    {
        public static void Main()
        {
            var pizza = new Pizza();

            string order = Console.ReadLine();

            while (order != "END")
            {
                string[] input = order.Split();

                if (input[0] == "Dough")
                {
                    try
                    {
                        var dough = new Dough(input[1], input[2], double.Parse(input[3]));
                        pizza.Dough = dough;
                        Console.WriteLine("{0:F2}", dough.Calories());
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }

                else if (input[0] == "Topping")
                {
                    try
                    {
                        var topping = new Topping(input[1], double.Parse(input[2]));
                        pizza.Toppings.Add(topping);
                        Console.WriteLine("{0:F2}", topping.Calories());
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }

                else if (input[0] == "Pizza")
                {
                    string pizzaName = input[1];
                    int numbTopping = int.Parse(input[2]);

                    try
                    {
                        pizza = new Pizza(pizzaName, numbTopping);
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }

                order = Console.ReadLine();
            }

            Console.WriteLine("\n{0} –> {1:F2} calories.", pizza.Name, pizza.TotalCalories());
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace PizzaCalories
{
    public class Dough
    {
        private string flour;
        private string technique;
        private double weight;
​
        public Dough(string flour, string technique, double weight)
        {
            Flour = flour;
            Technique = technique;
            Weight = weight;
        }
​
        private string Flour
        {
            get
            {
                return flour;
            }
            set
            {
                if (value.ToLower() != "white" && value.ToLower() != "wholegrain")
                {
                    throw new ArgumentException("Invalid type of dough!");
                }
​
                flour = value;
            }
        }
        private string Technique
        {
            get
            {
                return technique;
            }
            set
            {
                if (value.ToLower() != "cripsy" && 
                    value.ToLower() != "chewy" &&
                    value.ToLower() != "homemade")
                {
                    throw new ArgumentException("Invalid type of dough!");
                }
​
                technique = value;
            }
        }
        private double Weight
        {
            get
            {
                return weight;
            }
            set
            {
                if (value < 1 || value > 200)
                {
                    throw new ArgumentException("Dough weight should be in the range [1...200].");
                }
​
                weight = value;
            }
        }
​
        public double Calories()
        {
            double flourModifier = 0.0;
            double techniqueModifier = 0.0;
​
            switch (flour.ToLower())
            {
                case "white":
                    flourModifier = 1.5;
                    break;
                case "wholegrain":
                    flourModifier = 1.0;
                    break;
            }
​
            switch (Technique.ToLower())
            {
                case "cripsy":
                    techniqueModifier = 0.9;
                    break;
                case "chewy":
                    techniqueModifier = 1.1;
                    break;
                case "homemade":
                    techniqueModifier = 1.0;
                    break;
            }
​
            return (2 * Weight * flourModifier * techniqueModifier);
        }
    }
    
    public class Topping
    {
        private string toppingType;
        private double weigth;
​
        public Topping(string toppingType, double weigth)
        {
            ToppingType = toppingType;
            Weigth = weigth;
        }
​
        private string ToppingType
        {
            get
            {
                return toppingType;
            }
            set
            {
                if (value.ToLower() != "meat" && value.ToLower() != "veggies" && 
                    value.ToLower() != "cheese" && value.ToLower() != "sauce")
                {
                    throw new ArgumentException(string.Format("Cannot place {0} on top of your pizza.", value));
                }
​
                toppingType = value;
            }
        }
        private double Weigth
        {
            get
            {
                return weigth;
            }
            set
            {
                if (value < 1 || value > 50)
                {
                    throw new ArgumentException(string.Format("{0} weight should be in the range [1...50].", toppingType));
                }
​
                weigth = value;
            }
        }
​
        public double Calories()
        {
            double toppingTypeModifier = 0.0;
​
            switch (ToppingType.ToLower())
            {
                case "meat":
                    toppingTypeModifier = 1.2;
                    break;
                case "veggies":
                    toppingTypeModifier = 0.8;
                    break;
                case "cheese":
                    toppingTypeModifier = 1.1;
                    break;
                case "sauce":
                    toppingTypeModifier = 0.9;
                    break;
            }
​
            return (2 * Weigth * toppingTypeModifier);
        }
    }
    
    public class Pizza
    {
        private string name;
        private int numbTopping;
​
        public Pizza()
        {
        }
​
        public Pizza(string name, int numbTopping)
        {
            Name = name;
            NumbTopping = numbTopping;
            Toppings = new List<Topping>();
        }
​
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                if (value.Length < 1 || value.Length > 15)
                {
                    throw new ArgumentException("Pizza name should be between 1 and 15 symbols.");
                }
​
                name = value;
            }
        }
​
        public double Calories { get; set; }
​
        public int NumbTopping
        {
            get
            {
                return numbTopping;
            }
            set
            {
                if (value < 0 || value > 10)
                {
                    throw new ArgumentException("Number of toppings should be in range [0...10].");
                }
​
                numbTopping = value;
            }
        }
​
        public List<Topping> Toppings { get; set; }
​
        public Dough Dough { get; set; }
​
        public double TotalCalories()
        {
            return this.Dough.Calories() + this.Toppings.Sum(t => t.Calories());
        }
    }
    
    public class Program
    {
        public static void Main()
        {
            var pizza = new Pizza();
​
            string order = Console.ReadLine();
​
            while (order != "END")
            {
                string[] input = order.Split();
​
                if (input[0] == "Dough")
                {
                    try
                    {
                        var dough = new Dough(input[1], input[2], double.Parse(input[3]));
                        pizza.Dough = dough;
                        Console.WriteLine("{0:F2}", dough.Calories());
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }
​
                else if (input[0] == "Topping")
                {
                    try
                    {
                        var topping = new Topping(input[1], double.Parse(input[2]));
                        pizza.Toppings.Add(topping);
                        Console.WriteLine("{0:F2}", topping.Calories());
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }
​
                else if (input[0] == "Pizza")
                {
                    string pizzaName = input[1];
                    int numbTopping = int.Parse(input[2]);
​
                    try
                    {
                        pizza = new Pizza(pizzaName, numbTopping);
                    }
                    catch (Exception fe)
                    {
                        Console.WriteLine(fe.Message);
                        return;
                    }
                }
​
                order = Console.ReadLine();
            }
​
            Console.WriteLine("\n{0} –> {1:F2} calories.", pizza.Name, pizza.TotalCalories());
        }
    }
}
​

Compilation error (line 3, col 9): A namespace cannot directly contain members such as fields or methods
Compilation error (line 7, col 20): Identifier expected
Compilation error (line 7, col 22): Expected class, delegate, enum, interface, or struct
Compilation error (line 7, col 35): Expected class, delegate, enum, interface, or struct
Compilation error (line 7, col 45): Expected class, delegate, enum, interface, or struct
Compilation error (line 9, col 30): Expected class, delegate, enum, interface, or struct
Compilation error (line 9, col 65): Type or namespace definition, or end-of-file expected

Last Run:	1:03:43 am
Compile:	0s
Execute:	0.086s
Memory:	0b
CPU:	0s

View IL Code