This is the admincontroller class:

namespace Project.Controllers
{ 
    public class AdminController : Controller
    {
        
        IAdminService _adminService;
        
        public AdminController(IAdminService adminService)
        {
            _adminService = adminService;
        }
        [Authorize(Roles ="Admin")]
        public ActionResult Create() {
            
            return View();
        }
        [Authorize(Roles = "Admin")]
        public IActionResult Index( )
        {
            var courses =  _adminService.GetAllCourses( ); /* Bringing all the table from database and drop into your table */

            return View(courses);
        }
        [HttpPost]
        public async Task<IActionResult> Create(CourseToAddDto course)
        {
            //var id = HttpContext.User.Claims("id")[0];
           // course.InstructorID = Guid.Parse(id);
            await _adminService.CreateCourse(course);
            return RedirectToAction("Index");
        }
        
        public async Task<IActionResult> Detail(Guid id)
        {
            Course course = _adminService.GetCourseById(id);
            return View(course);
        }
        
        public async Task<IActionResult> Edit(Guid id)
        {
            var course = _adminService.GetCourseById(id);
            if(course == null) return View("Error");
            var courseDTO = new CourseToAddDto
            {
                Title = course.Title,
                Description = course.Description,
                Category = course.Category,
            };
            return View(courseDTO);
        }
        
        [HttpPost]
        public async Task<IActionResult> Edit(Guid id, CourseToAddDto _courseDto)
        {
            if(!ModelState.IsValid)
            {
                ModelState.AddModelError("","Failed to edit club");
                return RedirectToAction("Index");
            }
            var _course = _adminService.GetCourseById(id);
            if(_course != null)
            {
                //var photoResult = await _photoService.AddPhotoAsync(clubVM.Image);
                var editedCourse = new Course
                {
                    ID = id,
                    Title = _courseDto.Title,
                    Description = _courseDto.Description,
                    InstructorID = _course.InstructorID,
                    Category = _courseDto.Category,
                    EnrollmentCount = _course.EnrollmentCount,
                    ImageUrl = _course.ImageUrl, 
                    /* courseDto image ile Course image data type farklı */
                };
                _adminService.UpdateCourse(editedCourse);
                return  RedirectToAction("Index");
            }
            else
            {
                var courseDTO = new CourseToAddDto
                {
                    Title = _course.Title,
                    Description = _course.Description,
                    InstructorID = _course.InstructorID,
                    Category = _course.Category,
                };
                
                return View(courseDTO);
            }
        }    
        public async Task<IActionResult> Delete(Guid ID)
        {
            var courseDetails = _adminService.GetCourseById(ID);
            if(courseDetails == null) return View("Error");
            return View(courseDetails);
        }

        [HttpPost, ActionName("Delete")]
        public async Task<IActionResult> DeleteClub(Guid id)
        {   
            var courseDetails = _adminService.GetCourseById(id);
            if(courseDetails == null) return View("Error");

            _adminService.DeleteCourse(id);
            return RedirectToAction("Index");
        }

        [Authorize(Roles = "Admin")]
        public IActionResult UserManager()
        {
            var users = _adminService.GetAllUsers( );
            return View(users);
        }
    }
}

you gave me those explanations:

1. AdminController(IAdminService adminService): This is the constructor of the AdminController class. It takes an IAdminService parameter and assigns it to the _adminService field.

2. Create(): This method is decorated with the [Authorize(Roles ="Admin")] attribute, which means that only users with the “Admin” role can access this method. It returns a view for creating a new course.

3. Index(): This method is also decorated with the [Authorize(Roles ="Admin")] attribute. It retrieves all courses from the _adminService and passes them to the view. The courses are then displayed in the view.

4. Create(CourseToAddDto course): This method is decorated with the [HttpPost] attribute, which means it handles the HTTP POST requests. It takes a CourseToAddDto object as a parameter, which represents the data for creating a new course. It awaits the _adminService.CreateCourse(course) method, which creates a new course using the provided data.

5. Detail(Guid id): This method takes a Guid (unique identifier) parameter id representing the course ID. It retrieves the course with the matching ID from the _adminService and passes it to the view for displaying course details.

6. Edit(Guid id): This method takes a Guid parameter id representing the course ID. It retrieves the course with the matching ID from the _adminService and creates a CourseToAddDto object containing the course details. It returns the view for editing the course, passing the CourseToAddDto object.

7. Edit(Guid id, CourseToAddDto _courseDto): This method handles the HTTP POST requests for editing a course. It takes the course ID (id) and the updated course details (_courseDto). It checks if the model state is valid and then retrieves the course with the matching ID from the _adminService. If the course exists, it creates a new Course object with the updated details and calls the _adminService.UpdateCourse(editedCourse) method to update the course. If the course does not exist, it returns the view.

8. Delete(Guid ID): This method takes a Guid parameter ID representing the course ID. It retrieves the course with the matching ID from the _adminService and passes it to the view for confirming the course deletion.

9. DeleteClub(Guid id): This method handles the HTTP POST requests for deleting a course. It takes the course ID (id) and retrieves the course details from the _adminService. If the course exists, it calls the _adminService.DeleteCourse(id) method to delete the course.

10. UserManager(): This method is decorated with the [Authorize(Roles = "Admin")] attribute, which means that only users with the “Admin” role can access this method. It retrieves all users from the _adminService and passes them to the view for managing user accounts.

myquestions: 

I will give multiple answers based on your numerization please do the same

2. It returns a view for creating a new course. what does this mean? what view? it says return View() is this something default we created it?
3. It retrieves all courses from the _adminService and passes them to the view. what does this mean? which view? and what is the datatype all courses? what the view accepts?
4. The reason it doesnt take Course but CourseToAddDto instead is we need a specific version of the Course model? and by using dto we dont provide the object directly to course controller, what advantages this has? what does return RedirectToAction("Index"); do?
5. why we use guid? is this standard for unique identifiers in dotnet? what else we could use? passes it to the view for displaying course details, which view and where it shows the details? 
6. I dont get how this returns a view for editing? doesnt it create a CourseToAddDto by specific paramteres and pass it to view?
7. I dont understand why this handleds post requests for course isnt that admincontroller?
8. passes it to the view for confirming the course deletion. what does tha mean? why we need this doesnt deleteclub handle everything?
9.This method handles the HTTP POST requests for deleting a course. post request from where like when an admin is in a course page there will be a delete button that triggers this?
10. It retrieves all users from the _adminService and passes them to the view for managing user accounts. Again which view? like how do we use this class?