What is the point of defining "shadow properties" in Entities?

This question may seem silly,
but what is the point of defining "shadow properties" in Entities since the corresponding column would be created in Database/Tables?
Plus, we can simply solve this issue by inheritance so imagine "shadows properties" has NOT been introduced by EF, then what?

What could not I implement by other things that I have had in my hands?

let's look at some code:

public class Student
{
   public int StudentID { get; set; }
   public string StudentName { get; set; }
   public DateTime? DateOfBirth { get; set; }
   public decimal Height { get; set; }
   public float Weight { get; set; }
}

public class SchoolContext : DbContext
{
   public SchoolContext() : base()
   {		
   }

   protected override void OnModelCreating(ModelBuilder modelBuilder)
   {
	  modelBuilder.Entity<Student>().Property<DateTime>("CreatedDate");
	  modelBuilder.Entity<Student>().Property<DateTime>("UpdatedDate");
   }

   public DbSet<Student> Students { get; set; }
}

VS

public class BaseEntity
{
   public DateTime CreatedDate
   public DateTime UpdatedDate
}

public class Student : BaseEntity
{
   public int StudentID { get; set; }
   public string StudentName { get; set; }
   public DateTime? DateOfBirth { get; set; }
   public decimal Height { get; set; }
   public float Weight { get; set; }
}

doesn't it make the implementation more complicated?

The key is that shadow properties don't exist on the entity class. Instead they are defined in the entity model. You don't access those kind of properties via a class instance. You use the DbContext model manager (same way as shadow properties are created).

private DateTime GetCreatedDate(Student student)
{
  using dbContext = new MyDbContext();
  var createdDate = (DateTime)dbContext
    .Entry(student)
    .Property("CreatedDate")
    .CurrentValue; 
}

It's up to you to decide whether you want model related meta properties (for example relation properties like foreign key IDs and other meta data) in your entity class. If you don't, you can define shadow properties in the model.
Meta data in this case means data (table columns) about the actual data records (table rows). This could be a timestamp, a read/write counter or data relation related data like foreign keys. Usually the application is not interested in such meta information. You don't want to pollute your data entity with meta data. Hence you would define them as shadow properties, that only exist in the entity model (managed by DbContext).

Shadow and Indexer Properties

The concept of "shadow properties" in entities is used in Object-Relational Mapping (ORM) frameworks like Entity Framework to add additional properties to an entity without modifying the database schema. In other words, these properties are not mapped to any column in the database table, but can be used to store information that is not persisted.

In the first example you provided, the two shadow properties:

"CreatedDate" and "UpdatedDate"

They are added to the "Student" entity using the
"modelBuilder.Entity<Student>().Property<DateTime>("PropertyName")"
method. These properties can be used to track when a student record was created and last updated, without having to add these columns to the underlying database table.

In the second example, the "BaseEntity" class is used to define common properties that are shared by multiple entities. In this case, the "CreatedDate" and "UpdatedDate" properties are defined in the base class, and the "Student" class inherits from the "BaseEntity" class. This approach eliminates the need to define these properties for every entity class and ensures that they are consistently implemented across all entities.

I hope this helps