In this course, Using Visual Studio Code for ASP.NET Core Projects, you'll learn how to install, create, and debug ASP.NET Core projects using Visual Studio Code. After watching this course, you'll be able to write your applications using this small, fast tool across multiple different platforms. I used the prebuilt Azure VM for VS 15.8 Preview, installed ASP.NET Core 2.1 RC1 and created a new web project using the ASP.NET Core MVC template. The example project created lacks the bundleconfig.json and any example of client-side library package management. Complete the New ASP.NET Core Web Application (.NET Core) - MvcMovie dialog: Visual Studio used a default template for the MVC project you just created. You have a working app right now by entering a project name and selecting a few options. This is a basic starter project, and it's a good place to.
- Visual Studio Web Application Tutorial
- Using Visual Studio For Mac Asp Net Core Mvc Tutorial
- Download Microsoft Visual Studio For Mac
- Complete the New ASP.NET Core Web Application (.NET Core) - MvcMovie dialog: Visual Studio used a default template for the MVC project you just created. You have a working app right now by entering a project name and selecting a few options. This is a basic starter project, and it's a good place to.
- Since I am planning to buy a new MacBook Pro (2017) and currently working on a Windows 10-device on a ASP.NET MVC (Not ASP.NET Core MVC) project for my internship, I was wondering if it is possible to continue developing the same project in Visual Studio for Mac.
- ASP.NET Core - Write Apps with Visual Studio Code and Entity Framework This article explains how developers working on any platform can write data-oriented Web applications that run on Linux, Mac OS X, and Windows leveraging the new ASP.NET Core 1.0 and the Entity Framework, using Visual Studio Code as the development e.
By Mike Wasson and Rick Anderson
HTTP is not just for serving up web pages. It’s also a powerful platform for building APIs that expose services and data. HTTP is simple, flexible, and ubiquitous. Almost any platform that you can think of has an HTTP library, so HTTP services can reach a broad range of clients, including browsers, mobile devices, and traditional desktop apps.
In this tutorial, you’ll build a simple web API for managing a list of “to-do” items. You won’t build any UI in this tutorial.
ASP.NET Core has built-in support for MVC building Web APIs. Unifying the two frameworks makes it simpler to build apps that include both UI (HTML) and APIs, because now they share the same code base and pipeline.
Note
If you are porting an existing Web API app to ASP.NET Core, see Migrating from ASP.NET Web API
Sections:
Here is the API that you’ll create:
API | Description | Request body | Response body |
---|---|---|---|
GET /api/todo | Get all to-do items | None | Array of to-do items |
GET /api/todo/{id} | Get an item by ID | None | To-do item |
POST /api/todo | Add a new item | To-do item | To-do item |
PUT /api/todo/{id} | Update an existing item | To-do item | None |
DELETE /api/todo/{id} | Delete an item. | None | None |
The following diagram show the basic design of the app.
- The client is whatever consumes the web API (browser, mobile app, and so forth). We aren’t writing a client in this tutorial.
- A model is an object that represents the data in your application. In this case, the only model is a to-do item. Models are represented as simple C# classes (POCOs).
- A controller is an object that handles HTTP requests and creates the HTTP response. This app will have a single controller.
- To keep the tutorial simple the app doesn’t use a database. Instead, it just keeps to-do items in memory. But we’ll still include a (trivial) data access layer, to illustrate the separation between the web API and the data layer. For a tutorial that uses a database, see Building your first ASP.NET Core MVC app with Visual Studio.
We’re not building a client, we’ll use Fiddler to test the API. Fiddler is a web debugging tool that lets you compose HTTP requests and view the raw HTTP responses.
Start Visual Studio. From the File menu, select New > Project.
Select the ASP.NET Core Web Application project template. Name the project
TodoApi
and tap OK.In the New ASP.NET Core Web Application (.NET Core) - TodoApi dialog, select the Web API template. Tap OK.
A model is an object that represents the data in your application. In this case, the only model is a to-do item.
Add a folder named “Models”. In Solution Explorer, right-click the project. Select Add > New Folder. Name the folder Models.
Note
You can put model classes anywhere in your project, but the Models folder is used by convention.
Next, add a
TodoItem
class. Right-click the Models folder and select Add > New Item.In the Add New Item dialog, select the Class template. Name the class
TodoItem
and click OK.Replace the generated code with:
A repository is an object that encapsulates the data layer, and contains logic for retrieving data and mapping it to an entity model. Even though the example app doesn’t use a database, it’s useful to see how you can inject a repository into your controllers. Create the repository code in the Models folder.
Start by defining a repository interface named
ITodoRepository
. Use the class template (Add New Item > Class).This interface defines basic CRUD operations.
Next, add a
TodoRepository
class that implements ITodoRepository
:Build the app to verify you don’t have any compiler errors.
By defining a repository interface, we can decouple the repository class from the MVC controller that uses it. Instead of instantiating a
TodoRepository
inside the controller we will inject an ITodoRepository
the built-in support in ASP.NET Core for dependency injection.This approach makes it easier to unit test your controllers. Unit tests should inject a mock or stub version of
ITodoRepository
. That way, the test narrowly targets the controller logic and not the data access layer.In order to inject the repository into the controller, we need to register it with the DI container. Open the Startup.cs file. Add the following using directive:
In the
ConfigureServices
method, add the highlighted code:In Solution Explorer, right-click the Controllers folder. Select Add > New Item. In the Add New Item dialog, select the Web API Controller Class template. Name the class
TodoController
.Replace the generated code with the following:
![Studio Studio](/uploads/1/2/6/0/126096885/457274504.png)
This defines an empty controller class. In the next sections, we’ll add methods to implement the API.
To get to-do items, add the following methods to the
TodoController
class.These methods implement the two GET methods:
GET/api/todo
GET/api/todo/{id}
Here is an example HTTP response for the
GetAll
method:Later in the tutorial I’ll show how you can view the HTTP response using the Fiddler tool.
Routing and URL paths¶
The [HttpGet] attribute specifies that these are HTTP GET methods. The URL path for each method is constructed as follows:
- Take the template string in the controller’s route attribute,
[Route('api/[controller]')]
- Replace “[Controller]” with the name of the controller, which is the controller class name minus the “Controller” suffix. For this sample the name of the controller is “todo” (case insensitive). For this sample, the controller class name is TodoController and the root name is “todo”. ASP.NET MVC Core is not case sensitive.
- If the
[HttpGet]
attribute also has a template string, append that to the path. This sample doesn’t use a template string.
For the
GetById
method, “{id}” is a placeholder variable. In the actual HTTP request, the client will use the ID of the todo
item. At runtime, when MVC invokes GetById
, it assigns the value of “{id}” in the URL the method’s id
parameter.Return values¶
The
GetAll
method returns a CLR object. MVC automatically serializes the object to JSON and writes the JSON into the body of the response message. The response code for this method is 200, assuming there are no unhandled exceptions. (Unhandled exceptions are translated into 5xx errors.)In contrast, the
GetById
method returns the more general IActionResult
type, which represents a generic result type. That’s because GetById
has two different return types:- If no item matches the requested ID, the method returns a 404 error. This is done by returning
NotFound
. - Otherwise, the method returns 200 with a JSON response body. This is done by returning an ObjectResult.
This step is optional, but it’s useful to see the raw HTTP responses from the web API.In Visual Studio, press ^F5 to launch the app. Visual Studio launches a browser and navigates to
http://localhost:port/api/todo
, where port is a randomly chosen port number. If you’re using Chrome, Edge or Firefox, the todo data will be displayed. If you’re using IE, IE will prompt to you open or save the todo.json file.Launch Fiddler. From the File menu, uncheck the Capture Traffic option. This turns off capturing HTTP traffic.
Select the Composer page. In the Parsed tab, type
http://localhost:port/api/todo
, where port is the port number. Click Execute to send the request.The result appears in the sessions list. The response code should be 200. Use the Inspectors tab to view the content of the response, including the response body.
The last step is to add
Create
, Update
, and Delete
methods to the controller. These methods are variations on a theme, so I’ll just show the code and highlight the main differences.Create¶
This is an HTTP POST method, indicated by the [HttpPost] attribute. The [FromBody] attribute tells MVC to get the value of the to-do item from the body of the HTTP request.
The CreatedAtRoute method returns a 201 response, which is the standard response for an HTTP POST method that creates a new resource on the server.
CreateAtRoute
also adds a Location header to the response. Is fl studio 20 for mac. The Location header specifies the URI of the newly created to-do item. See 10.2.2 201 Created.We can use Fiddler to send a Create request:
- In the Composer page, select POST from the drop-down.
- In the request headers text box, add
Content-Type:application/json
, which is aContent-Type
header with the valueapplication/json
. Fiddler automatically adds the Content-Length header. - In the request body text box, enter the following:
{'Name':'<yourto-doitem>'}
- Click Execute.
Here is an example HTTP session. Use the Raw tab to see the session data in this format.
Request:
Response:
Update¶
Update
is similar to Create
, but uses HTTP PUT. The response is 204 (No Content).According to the HTTP spec, a PUT request requires the client to send the entire updated entity, not just the deltas. To support partial updates, use HTTP PATCH.Delete¶
The void return type returns a 204 (No Content) response. That means the client receives a 204 even if the item has already been deleted, or never existed. There are two ways to think about a request to delete a non-existent resource:
- “Delete” means “delete an existing item”, and the item doesn’t exist, so return 404.
- “Delete” means “ensure the item is not in the collection.” The item is already not in the collection, so return a 204.
Either approach is reasonable. If you return 404, the client will need to handle that case.
- To learn about creating a backend for a native mobile app, see 🔧 Creating Backend Services for Native Mobile Applications.
- For information about deploying your API, see Publishing and Deployment.
By Rick Anderson
This tutorial will teach you the basics of building an ASP.NET Core MVC web app using Visual Studio 2015.
Note
For the tutorial using .NET Core on a Mac see Your First ASP.NET Core Application on a Mac Using Visual Studio Code.
Install Visual Studio and .NET Core¶
- Install Visual Studio Community 2015. Select the Community download and the default installation. Skip this step if you have Visual Studio 2015 installed.
- Install .NET Core + Visual Studio tooling
Create a web app¶
From the Visual Studio Start page, tap New Project.
Alternatively, you can use the menus to create a new project. Tap File > New > Project.
Complete the New Project dialog:
- In the left pane, tap Web
- In the center pane, tap ASP.NET Core Web Application (.NET Core)
- Name the project “MvcMovie” (It’s important to name the project “MvcMovie” so when you copy code, the namespace will match. )
- Tap OK
Complete the New ASP.NET Core Web Application - MvcMovie dialog:
- Tap Web Application
- Clear Host in the cloud
- Tap OK.
Visual Studio used a default template for the MVC project you just created, so you have a working app right now by entering a project name and selecting a few options. This is a simple “Hello World!” project, and it’s a good place to start,
Tap F5 to run the app in debug mode or Ctl-F5 in non-debug mode.
- Visual Studio starts IIS Express and runs your app. Notice that the address bar shows
localhost:port#
and not something likeexample.com
. That’s becauselocalhost
always points to your own local computer, which in this case is running the app you just created. When Visual Studio creates a web project, a random port is used for the web server. In the image above, the port number is 1234. When you run the app, you’ll see a different port number. - Launching the app with Ctrl+F5 (non-debug mode) allows you to make code changes, save the file, refresh the browser, and see the code changes. Many developers prefer to use non-debug mode to quickly launch the app and view changes.
- You can launch the app in debug or non-debug mode from the Debug menu item:
Visual Studio Web Application Tutorial
- You can debug the app by tapping the IIS Express button
Using Visual Studio For Mac Asp Net Core Mvc Tutorial
The default template gives you working Home, Contact, About, Register and Log in links. The browser image above doesn’t show these links. Depending on the size of your browser, you might need to click the navigation icon to show them.
Download Microsoft Visual Studio For Mac
How to download r on mac. In the next part of this tutorial, we’ll learn about MVC and start writing some code.