Описать класс "здание", содержащий сведения о количестве подъездов и этажей, и количестве квартир на этаже

using System;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            House[] houses = new House[] 
            {
                new House(3, 5, 4, 1000),
                new House(4, 9, 5, 2000),
                new House(5, 3, 2, 700),
                new House(1, 2, 3, 500),
                new House(6, 9, 5, 2500),
            };
 
            foreach (House house in houses)
                Console.WriteLine(house.ToString());
            Console.ReadKey();
        }
    }
 
    class House
    {
        //Поля
        public int porchCount;
        public int floorCount;
        private int roomsOnFloor;
        private double meterCost;
 
        //Свойства
        public int Porchs
        {
            get { return porchCount; }
            set { porchCount = value; }
        }
 
        public int Floors
        {
            get { return floorCount; }
            set { floorCount = value; }
        }
 
        public int RoomsOnFloor
        {
            get { return roomsOnFloor; }
            set { roomsOnFloor = value; }
        }
 
        public double Cost
        {
            get { return meterCost; }
            set { meterCost = value; }
        }
 
        //Конструкторы
        public House()
        {
        }
 
        public House(int porchCount, int floorCount, int roomsOnFloor, double cost)
        {
            this.porchCount = porchCount;
            this.floorCount = floorCount;
            this.roomsOnFloor = roomsOnFloor;
            this.meterCost = cost;
        }
        //Методы
 
        public int GetRoomsCountInPorch()
        {
            return roomsOnFloor * floorCount;
        }
 
        public int GetRoomsCountInHouse()
        {
            return GetRoomsCountInPorch() * porchCount;
        }
 
        public double HouseCost()
        {
            return (double)GetRoomsCountInHouse() * Cost;
        }
 
        public override string ToString()
        {
            return string.Format("Количество этажей: {0} \nКоличество подъездов: {1} \nЦена за квадратный метр: {2}", Floors, Porchs, Cost);
        }
    }
}

namespace ConsoleApplication1
{
    class Program
    {
        class Zdanie
        {
            private double MetrPrice; // Поле Цена одного метра
            public double FlatMetr; // Поле Количество метров в квартире
            
            Zdanie porch = new Zdanie(); //Создание объекта подъезд
            Zdanie floor = new Zdanie(); //Создание объекта этаж
            Zdanie flat = new Zdanie(); //Создание объекта квартира
 
            static public double FlatInPorch(int flat, int floor) // Метод подсчета количества квартир в подъезде
            {
                int c = flat * floor;
                return (c);
            }
            static public double FlatInHouse(double p, int porch) // Метод подсчета количества квартир в доме
            {
                double c = p * porch;
                return (c);
            }
            static public double FlatPrices(double h, double FlatMetr, double MetrPrice) // Метод подсчета общей стоимости квартир в доме
            {
                double c = (h * FlatMetr) * MetrPrice;
                return (c);
            }
 
 
        }
        static void Main(string[] args)
        {
 
            double a = Zdanie.FlatInPorch(10, 9);
            double b = Zdanie.FlatInHouse(a, 3);
            double price = Zdanie.FlatPrices(b, 100, 1100);
            Console.WriteLine("Количество квартир в подъезде = " + a);
            Console.WriteLine("Количество квартир в доме = " + b);
            Console.WriteLine("Общая стоимость квартир в доме = " + price + "$");
        }
    }
}

using System;
using System.Collections.Generic;
 
namespace ConsoleApplication1
{
    class Room
    {
        int size;
        public Room()
        {
            size = 10;
        }
        public Room(int size)
        {
            this.size = size;
        }
        public int Size
        {
            get
            {
                return size;
            }
            set
            {
                if (value > 0)
                    size = value;
                else
                    throw new Exception("HAHAHA! you can't live in this appartment!");
            }
        }
    }
    class Apartment
    {
        public static int RoomSize = 10;
 
        List<Room> rooms;
        public Apartment(int CountRooms)
        {
            rooms = new List<Room>();
            for (int i = 0; i < CountRooms; i++)
                rooms.Add(new Room(RoomSize));
        }
 
        public int ApartmentSize()
        {
            int apartmentSize = 0;
            foreach (Room r in rooms)
                apartmentSize += r.Size;
 
            return apartmentSize;
        }
        public List<Room> Rooms
        {
            get { return rooms; }
        }
    }
    class Floor
    {
 
        List<Apartment> apartments;
        public Floor(int[] ApartmentSizes)
        {
            apartments = new List<Apartment>();
            foreach (int i in ApartmentSizes)
 
                apartments.Add(new Apartment(i));
 
 
 
        }
 
        public int FloorInPorchSize()
        {
            int FullSize = 0;
            foreach (Apartment a in apartments)
                FullSize += a.ApartmentSize();
 
            return FullSize;
        }
        public List<Apartment> Apartments
        {
            get { return apartments; }
        }
    }
    class Porch
    {
 
        List<Floor> floors;
        public Porch(int floors, int[] ApartmentSizes)
        {
            this.floors = new List<Floor>();
            for (int i = 0; i < floors; i++)
                this.floors.Add(new Floor(ApartmentSizes));
 
 
        }
        public int PorchSize()
        {
            int PorchSize = 0;
            foreach (Floor f in floors)
                PorchSize += f.FloorInPorchSize();
 
            return PorchSize;
        }
        public List<Floor> Floors
        {
            get { return floors; }
        }
 
 
 
    }
    class Zdanie
    {
        public static int MetrPrice = 100;
 
        public static bool notnull(int a)
        {
            if (a > 0)
                return true;
            else
            {
                return false;
                throw new Exception("It is not a house!");
               
            }
        }
        public int Price(int Size)
        {
            return Size * MetrPrice;
        }
 
        List<Porch> porchs;
        public Zdanie(int porchs, int floors, int[] ApartmentSizes)
        {
            this.porchs = new List<Porch>();
            if (notnull(porchs) && notnull(floors))
                for (int i = 0; i < porchs; i++)
                    this.porchs.Add(new Porch(floors, ApartmentSizes));
        }
 
        public int ZdanieSize()
        {
            int zdanieSize = 0;
            foreach (Porch p in porchs)
                zdanieSize += p.PorchSize();
 
            return zdanieSize;
        }
 
        public List<Porch> Porches
        {
            get { return porchs; }
        }
 
 
 
 
    }
     
 
        class Program
        {
        static void Main(string[] args)
        {
 
            Zdanie building = new Zdanie(5, 5, new int [] {1,2,3});
     
            Console.WriteLine("Porch Size = "+building.Porches[0].PorchSize());
            Console.WriteLine("Count apartments in the house = "+building.Porches.Count*building.Porches[0].Floors.Count*building.Porches[0].Floors[0].Apartments.Count);
            Console.WriteLine("Общая стоимость квартир в доме ="+ building.Price(building.ZdanieSize())+"$");
            Console.ReadKey();
        }
    }
}