Constructor car calculator program

Question

I am trying to write a program with the instructions below. The program does work currently, but it does not fully meet the specs.

I think I'm very close, but I'm having trouble understanding the constructor setup and how to do the current year.

Coding Instructions

Create a class called Car.

This class should have 3 member variables:

• a string called Make
• a string called Model
• an integer called Year
• The class should have a function that returns the age of the car by subtracting the member variable "year" from the current year (2021).
• The class should have a constructor that takes 3 parameters: make, model, year.

This is my code:

using System;
                    
public class Program
{
    public static void Main()
    {
        
        Console.WriteLine("Welcome to Historic Car Calculator");
        Console.WriteLine("Please enter the make of your car");
        var _Make = Console.ReadLine();
        
        Console.WriteLine("Please enter the model of your car.");
        var _Model = Console.ReadLine();
        
        Console.WriteLine("Please enter the year your car was made.");
        int _Year = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine("Your " + _Make + " " + _Model+ " is " + (2021 - _Year) + " years old");  

    }
    
    public class Car
    {
        public string Make;
        public string Model;
        public int Year;
        public int currentYear;
        
        //Overloaded Constructor
        public Car(string _Make, string _Model, int _Year)
        {
            Make = _Make;
            Model = _Model;
            Year = _Year;   
        }
        public void display()
        {
            var Car = new Car(Make, Model, Year);
        }

        public void CarAge(int Year)
        {
            this.currentYear = 2021 - this.Year;
        }
                
    }

    
}

Answer 1

1.You need to declare those 3 member variables as private, if they are public it can be accessed (for both getting and setting values), and that's what we don't want. In your case constructor should be the only means of setting their values:

 private string Make;
 private string Model;
 private int Year;

2.There is no need for an extra variable, you can just return the car age directly:

public int GetCarAge()
{
  return 2021 - Year;
}

3.The Display method creates another instance of the car class, which is wrong. you may want to return some string value about current car, or something like that:

public string display()
{
    return "Make: " + Make + ", Model: " + Model + ", Year:" + Year.ToString();
    //return $"Make: {Make}, Model:{Model}, Year:{Year}"; //can be written like this too
}

Answer 2

You have a class, but you are not using it. Lets make it a bit more meaningfull, construct an instance of a car and use it for writing:

public class Car
{
    public readonly string Make;
    public readonly string Model;
    public readonly int Year;

    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;
    }
  
    public int CarAge()
    {
        return DateTime.Now.Year - Year;
    }
}

static void Main(string[] args)
{
    Console.WriteLine("Welcome to Historic Car Calculator");
    Console.WriteLine("Please enter the make of your car");
    var make = Console.ReadLine();

    Console.WriteLine("Please enter the model of your car.");
    var model = Console.ReadLine();

    Console.WriteLine("Please enter the year your car was made.");
    int year = Convert.ToInt32(Console.ReadLine());

    var car = new Car(make, model, year);

    Console.WriteLine("Your " + car.Make + " " + car.Model + " is " + car.CarAge() + " years old");
    Console.ReadKey();
}

Answer 3

I see you have a variable for currentYear which is not needed. The current year isn't information that relates to the car. Also your function needs to return a value. So look at the sample code below for inspiration.

public class Car
{
    // private fields
    string make;
    string model;
    int year;
    
    //Overloaded Constructor
    public Car(string make, string model, int year)
    {
        this.make = make;
        this.model = model;
        this.year = year;   
    }
    // public properties
    public string Make { get { return make; } }
    public string Model { get { return model; } }
    public int Year { get { return year; } }

    // function to calculate age
    public int CarAge(int currentYear)
    {
        return currentYear - year;
    }

    // convert class to string for dsplay
    public string ToString()
    {
        return $"{year} {make} {model} is {CarAge(DateTime.Now.Year))} years old.";
    }                
}

Additional functionality I included below by overriding ToString() which allows you to write things like Console.WriteLine(car) and it will display the specific information about the car. This method tells the computer how to convert the data in a class to a string representation for display or processing.

Answer 4

You need to be aware that Program and Car are two separate classes, even though you have declared Car inside the Program class.

In your static Main method, you need to instantiate (create) an instance (object) of the Car class with the parameters captured from your calls to Console.ReadLine():

public static void Main()
{
    
    Console.WriteLine("Welcome to Historic Car Calculator");
    Console.WriteLine("Please enter the make of your car");
    var make = Console.ReadLine();
    
    Console.WriteLine("Please enter the model of your car.");
    var model = Console.ReadLine();
    
    Console.WriteLine("Please enter the year your car was made.");
    int year = Convert.ToInt32(Console.ReadLine());

    // Create a Car Object using the above parameters:
    // This is the proof that:
    //    The class should have a constructor that takes 3 parameters: make, model, year.
    Car car = new Car(make, model, year);

    // Deliberately demonstrate you have an Age function by
    // calling the Age function on the car:
    Console.WriteLine("Your car's age is {0} years old", car.Age());  

    // Override standard Object.ToString() to create a string representation
    // Instead of creating a new method called display().
    Console.WriteLine("Your Car: {0}", car);
}

You should should get into the habit of using Properties to represent the meta-data of the car, the following code will use the auto-properties syntax to declare these properties as readonly:

    public string Make { get; }
    public string Model { get; }
    public int Year { get; }

remove currentYear... that is not needed at all.

There is a comment about an overloaded constructor... But you have not overloaded anything. At the very least you should remove that comment.

If your class needs to support serilization, then it will be important to create an additional default constructor that takes no parameters, but then the backing properties will also need to be settable from external contexts. Serilization is an important consideration for all classes in modern programming as we commonly use serilization techniques to transfer data between APIs and files, in a real world application you would want your Car instance to be saved to a database or disk, a user does not re-enter their car details, for every car, every time they use your app. This is where serialization becomes very useful, I'll include an example of this at the end of this post.

4 things about your CarAge function:

1. You are not using the value of Year argument at all, so remove it.
2. The name is redundant, we already know it is a Car Car.CarAge() is just a silly, make your code easier to read by renaming to something that includes a verb to describe what it does like CalculateAge() or perhaps just simply Age().
3. You do not need to create a new instance of a Car, this method is already part of a car definition, so it has access to the member variables.
4. This is contraversial... at least from a homework point of view, the value of 2021 should NOT be hardcoded, even though the requirement suggests this. In real world software design hardcoding time, system or environment based variables is a serious red flag

• In .NET DateTime.Now will give you the current time and date, from there you can access the current year.

  public int Age()
  {
      return DateTime.Now.Year - this.Year;
  }
  

Finally, replace your display method with an override of the standard Object.ToString(). That is the whole purpose of the ToString() to create the standard display representation of your class.

    public override string ToString()
    {
        return String.Format("Make: {0}, Model: {1}, Year: {2}, Age: {3}", this.Make, this.Model, this.Year, this.Age();
        // You could also use string interpolation:
        // return $"Make: {this.Make}, Model: {this.Model}, Year: {this.Year}, Age: {this.Age()}";
    }

Overall this makes your Car class look something like this:

public class Car
{
    public string Make { get; }
    public string Model { get; }
    public int Year { get; }
    

    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;   
    }

    /// <summary>Override ToString to return the standard display format for a car</summary>
    public override string ToString()
    {
        return String.Format("Make: {0}, Model: {1}, Year: {2}, Age: {3}", this.Make, this.Model, this.Year, this.Age();
        // You could also use string interpolation:
        // return $"Make: {this.Make}, Model: {this.Model}, Year: {this.Year}, Age: {this.Age()}";
    }

    /// <summary>Caculate and return the Current Age of this Car based on the current System Year and stamp Year of this car.</summary>
    public int Age()
    {
        return DateTime.Now.Year - this.Year;
    }
            
}

---

Serialization Support

As explained above, if is a good habit to get into supporting serialization, this will enable the instances of your class to be saved to text based files or to be transferred via text based protocols like HTTP. In an increasingly cloud oriented industry, you will come across this requirement very soon.

To support Serialization in a generic sense a class needs to have the following:

1. A parameter-less constructor, this is known as the default constructor.
2. The meta-data that you want to be saved and restored MUST be declared as public Properties.

This is because the default string based serialization processors will create an instance of the target class using the default constructor and will then set each of the properties one by one.

We can add the default serialization support to your Car class by making the auto-properties settable by external contexts and by adding the default constructor:

public class Car
{
    public string Make { get;set; }
    public string Model { get;set; }
    public int Year { get;set; }
    
    /// <summary>Create a default Car representation, meta-data will need to be set explicitly </summary>
    public Car()
    {
    }

    /// <summary>Overload to Create a Car Instance with the specified meta-data</summary>
    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;   
    }

    /// <summary>Override ToString to return the standard display format for a car</summary>
    public override string ToString()
    {
        return String.Format("Make: {0}, Model: {1}, Year: {2}, Age: {3}", this.Make, this.Model, this.Year, this.Age();
        // You could also use string interpolation:
        // return $"Make: {this.Make}, Model: {this.Model}, Year: {this.Year}, Age: {this.Age()}";
    }

    /// <summary>Caculate and return the Current Age of this Car based on the current System Year and stamp Year of this car.</summary>
    public int Age()
    {
        return DateTime.Now.Year - this.Year;
    }                
}

There are other benefits to this Serialization ready implementation, we can now avoid overloaded constructors altogether with the following class instantiation syntax:

var car = new Car { Make = make, Model = model, Year = year };