Is this a sensible way to implement a model? I've created the following model for an academic project, and I'm wondering if this is a sensible way to manage a model:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Collections.ObjectModel;
using System.Windows.Forms;

namespace IceCreamShop
{
    [Serializable]
    public class Customer : ISerializable 
    {
        private const string SAVE_FILE_NAME = @".\Customers.bin";

        #region static model accessors

        private static List&lt;Customer&gt; customers = new List&lt;Customer&gt;();

        public static ReadOnlyCollection&lt;Customer&gt; Customers
        {
            get
            { 
                return customers.AsReadOnly(); 
            }
        }

        public static int Cardinality { get; private set; }

        public static void saveCustomers(List&lt;Customer&gt; customers)
        {
            IFormatter formatter = new BinaryFormatter();

            Stream stream = File.Open(SAVE_FILE_NAME, FileMode.Create);

            formatter.Serialize(stream, customers);

            formatter.Serialize(stream, Customer.Cardinality);

            stream.Close();
        }

        public static void loadAllCustomers()
        {
            IFormatter formatter = new BinaryFormatter();

            List&lt;Customer&gt; customers = new List&lt;Customer&gt;();

            try
            {
                Stream stream = File.Open(SAVE_FILE_NAME, FileMode.OpenOrCreate);

                if (stream.Length &gt; 0)
                {
                    customers = (List&lt;Customer&gt;)formatter.Deserialize(stream);

                    Customer.Cardinality = (int)formatter.Deserialize(stream);
                }

                stream.Close();
            }
            // Shouldn't happen during normal operation, pending any permissions/file write issues
            catch (Exception ex)
            {
                throw ex;
            }

            if(customers.Count == 0)
            {
                // Dummy customer for patrons who don't want their data tracked
                customers.Add(new Customer("nobody", "nobody"));

                Customer.Cardinality = 1;
            }

            Customer.customers = customers;
        }
        #endregion

        #region individual model data

        private string firstName;
        public string FirstName { get { return firstName; } }

        private string lastName;
        public string LastName { get { return lastName; } }

        private int id;
        public int ID { get { return id; } }

        //Used externally to generate a new customer
        public Customer(string firstName, string lastName)
        {
            this.id = Customer.Cardinality++;
            this.firstName = firstName;
            this.lastName = lastName;
        }

        #endregion

        #region serialization

        Customer(SerializationInfo info, StreamingContext context)
        {
            this.id = info.GetInt32("i");
            this.firstName = info.GetString("j");
            this.lastName = info.GetString("k");
        }

        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("i", this.id);
            info.AddValue("j", this.firstName);
            info.AddValue("k", this.lastName);
        }

        #endregion
    }
}


An individual Customer consists of an id, first name and a last name. I realize there are still some issues to be ironed out, but I'm primarily wondering if it makes sense to use statics in this way.

This is part of an MVP-based project, which focuses on putting application logic in the controllers and data-based operations in the model with dumb views.
This smells slightly odd to me. Why would the class of customers know about what customers are actually participating in the model at the moment? Is there a need to even have knowledge of all the customers in the model overall? (Even in a simulation, you'd have that knowledge as part of the harness, not the customers themselves.)

No, I'd instead model the collection of all potential customers as an instance of another class (the catchment? the clientele?) and would avoid having public static methods in any class at all. That collection might well just be a simple wrapper around a core collection class instance, but I'd be making it a proper member of the model simply because the collection of customers is a model participant. (Well, if it isn't then you have no reason to keep a list of all customers at all.) The other advantage of working this way is that you  can then easily adapt to a growing business that opens a second shop far enough away from the first that virtually nobody goes to both shops…