C# object oriented programming - using ArrayList

I would not create AllApartments but use a List and then create a search method :

        private List<Aapartment> _appartements;

    public Aapartment Search(int price, int roomN, Type type)
    {
        var founded = _appartements.SingleOrDefault(x => x.GetType() == type && x.price == price && x.roomN == roomN);
        return founded;

    }

More on lambdas with linq queries : https://msdn.microsoft.com/fr-fr/library/bb397675.aspx

For the program, I would ask to the user 0 for penthouse and 1 for private, it's bad design to map the user input to the type name.

     static void Main(string[] args)
    {
        AllApartments all = new AllApartments();
        all.Add(new Private(200000000, 5));
        all.Add(new penthouse(125000000, 4));
        all.Add(new penthouse(125000000, 2));
        all.Add(new penthouse(125000000, 7));
        all.Add(new penthouse(125000000, 1));

        int roomN;
        int price;
        int type1;

        type1 = int.Parse(Console.ReadLine());
        //Type type = Type.GetType("ConsoleApplication48.Aapartment");
        roomN = Convert.ToInt32(Console.ReadLine());
        price = Convert.ToInt32(Console.ReadLine());
        Type type;
        switch (type1)
        {
            case 0 :
                type = typeof (penthouse);
                break;
            case 1:
                type = typeof (Private);
                break;
            default:
                throw new Exception("Appartment type unknown");
        }

        Aapartment temp = all.Search(price, roomN, type);
        Console.WriteLine(temp.GetType().ToString());
    }

I used an int but you could use an enum;

You could have a readonly property that returns that.

public string TypeName { get { return GetType().Name; } }

This isn't Code Review and this looks like an XY problem incited by homework requirements, but here goes.

You're trying to apply inheritance, a strong object-oriented design principle, to a problem where it doesn't fit. You should only use inheritance to add behavior that derives from the base class behavior.

If I may try to extract the original requirements from your question:

I want to create an apartment reservation system, where a user can search for an apartment type.

You don't need inheritance for this. Just as you wouldn't create a Novel : Book class, a ScienceFiction : Book class and a Dictionary : Book class when you're building a library checkout system (not in the first place because a book can have many genres), so shouldn't you when building this apartment reservation system.

The type of an apartment for rent is just a propery of the non-abstract Apartment class. It doesn't add new behavior, it's not something that makes the Apartment class suddenly not fit to hold a "Cardboard Box" nor a "Castle" type of apartment.

So for the sake of simplicity, keep it a string property:

public class Apartment
{
    public int NumberOfRooms { get; set; }
    public int Price { get; set; }  
    public string Type { get; set; }
}

And then the entire need for this question goes away. Of course you could also make Type an enum, for type-safety (or typo-safety).

Furthermore, you don't use ArrayList and you don't inherit from a List (again, you don't add behavior to the list, so don't inherit from it), but just use a List<T>:

var apartmentData = new List<Apartment>
{
    new Apartment { NumberOfRooms = 4, Price = 42000, Type = "Private" },
    new Apartment { NumberOfRooms = 40, Price = 420000, Type = "Penthouse" },
    new Apartment { NumberOfRooms = 400, Price = 4200000, Type = "Castle" },
};

Then you can use a "repository"-like pattern to create your unique logic:

public class ApartmentRepository
{
    private readonly List<Apartment> _apartmentData;

    public ApartmentRepository(List<Apartment> apartmentData)
    {
        _apartmentData = apartmentData;
    }

    public Apartment Search(int price, int numberOfRooms, string type)
    {
        return _apartmentData.FirstOrDefault(a => a.Price == price 
                                               && a.NumberOfRooms == numberOfRooms
                                               && a.Type == type);
    }
}

Besides all that, you should in general favor composition over inheritance. You might say "But my occupants will enter the building in a different way!" (if that's even relevant to the system).

Then you simply add a IWayOfEntry WayOfEntry property to the Apartment (or maybe Residency is a better class name anyway), to which you then assign a DrawBridge, Elevator or FrontDoor instance, while Residency.Enter() simply relays the call to WayOfEntry.Enter().