Student data in a database I am working on an ASP.NET MVC 5 project, using the code-first approach for database design. I have a question about my code design.

I have an Entity in my database schema called Student:

public partial class Student
{
  public int Id { get; set; }
  public string RollNumber { get; set; }
  public string Name { get; set; }
  public string Address { get; set; }
  public string Mobile { get; set; }
  public string Email { get; set; }
}


Notice that I have declared this as partial because I extend it and include all the data access and processing functions for a student, like this:

public partial class Student
{
   [NotMapped]
   private MyDbContext context = new MyDbContext();

   public static Student Get(int id)
   {
     Student student;
     using(MyDbContext context = new MyDbContext())
     {
       student = context.Students.SingleOrDefault(s =&gt; s.Id == id)
     }
     return student;
   }

   public void Student Create()
   {
     context.Students.Add(this);
     context.SaveChanges();
   }

   //....
   //and similarly many other
}


Notice that I have declared a static Get function which takes an id and returns a Student object if it exists, otherwise null. I have declared this static because it already returns a Student object, so calling it on an object seems unreasonable to me (please correct me if I am wrong). 

The second thing to notice is the NotMapped attribute which I've used to exclude this property from mapping to database when running migrations.

I am using the above mentioned design with my all entities (i.e. wrapping data and function processing over that data into a single object).

Is this design approach good? Is there any other better approach exist, or am I on the wrong path?
I'm no big fan of using partial classes because I find it less readable. Like the other commenter I think you should look at the repository pattern for a cleaner solution.
It seems a bit odd that you give Student the responsibility to save itself to the context. 

Something in the same neighbourhood is the UnitOfWorkPattern. That said the DbContext is an implementation of UnitOfWork and Repository Pattern. You could use the DbContext directly or with a wrapper of your own, but if your wrapper doesn't add value to the DbContext you could skip it.

You are initializing your DbContext multiple times which seems redundant. Most likely you get the same instance since it implements the UnitOfWork pattern, but the "new" and private variables combined with static methods will make it very hard to write unit-tests. For testability you should avoid having MyDbContext in a private variable. You can use constructor injection to make it available to the class, or keep it in a property that you can substitute in tests later.