ASP.NET MVC 4 Anwendung Aufruf von Remote-WebAPI

Question

Ich habe ein paar ASP.NET MVC-Anwendungen in der Vergangenheit erstellt, aber ich habe noch nie zuvor WebAPIs verwendet. Ich frage mich, wie ich eine einfache MVC 4-App erstellen könnte, die einfache CRUD-Sachen über WebAPI statt über einen normalen MVC-Controller macht. Der Trick besteht darin, dass die WebAPI eine separate Lösung sein sollte (und tatsächlich auf einem anderen Server/einer anderen Domäne sein könnte).

Wie mache ich das? Was vermisse ich? Ist es nur eine Frage der Einrichtung von Routen, die auf den WebAPI-Server verweisen? Alle Beispiele, die ich gefunden habe, wie WebAPIs mit einer MVC-Anwendung konsumiert werden, scheinen anzunehmen, dass die WebAPI in die MVC-Anwendung "eingebacken" ist oder zumindest auf demselben Server ist.

Oh, und um zu verdeutlichen, ich spreche nicht über Ajax Anrufe mit jQuery ... Ich meine, dass der Controller der MVC-Anwendung die WebAPI verwenden sollte, um Daten zu bekommen/setzen.

Answer 1

Sie sollten neue HttpClient verwenden, um Ihre HTTP-APIs zu verbrauchen. Was ich Ihnen zusätzlich raten kann, Ihre Anrufe komplett asynchron zu machen. Da ASP.NET MVC-Controller-Aktionen Task-based Asynchronous Programming-Modell unterstützen, ist es ziemlich mächtig und einfach.

Hier ist ein übermäßig vereinfachtes Beispiel. Der folgende Code ist die Hilfsklasse für eine Probe Anfrage:

public class CarRESTService { 

    readonly string uri = "http://localhost:2236/api/cars"; 

    public async Task<List<Car>> GetCarsAsync() { 

     using (HttpClient httpClient = new HttpClient()) { 

      return JsonConvert.DeserializeObject<List<Car>>(
       await httpClient.GetStringAsync(uri)  
      ); 
     } 
    } 
} 

Dann habe ich das durch meine MVC-Controller asynchron wie unten verbrauchen kann: zu

public class HomeController : Controller { 

    private CarRESTService service = new CarRESTService(); 

    public async Task<ActionResult> Index() { 

     return View("index", 
      await service.GetCarsAsync() 
     ); 
    } 
} 

Sie haben einen Blick auf die unten Post sehen die Auswirkungen der asynchronen I/O-Operationen mit ASP.NET MVC:

My Take on Task-based Asynchronous Programming in C# 5.0 and ASP.NET MVC Web Applications

Answer 2

http://restsharp.org/ ist die Antwort auf Ihre Fragen. Ich benutze es derzeit in einer Anwendung, die eine ähnliche Struktur hat.

Aber im Allgemeinen mit WebAPI ist nur Buchung und Anforderung von Daten, wie Sie zu verarbeiten ist an Ihnen. Sie können sogar Standard WebRequest und JavascriptSerializer verwenden.

Prost.

Answer 3

In diesem Fall können Sie HttpClient verwenden, um Web-API von Ihrem Controller zu konsumieren.

Answer 4

Sie WCF verwenden, den Dienst zu verbrauchen. Wie so:

[ServiceContract] 
public interface IDogService 
{ 
    [OperationContract] 
    [WebGet(UriTemplate = "/api/dog")] 
    IEnumerable<Dog> List(); 
} 

public class DogServiceClient : ClientBase<IDogService>, IDogService 
{ 
    public DogServiceClient(string endpointConfigurationName) : base(endpointConfigurationName) 
    { 
    } 

    public IEnumerable<Dog> List() 
    { 
     return Channel.List(); 
    } 
} 

Und dann können Sie es in Ihrem Controller verbrauchen:

public class HomeController : Controller 
{ 
    public HomeController() 
    { 
    } 

    public ActionResult List() 
    { 
     var service = new DogServiceClient("YourEndpoint"); 
     var dogs = service.List(); 
     return View(dogs); 
    } 
} 

Und in Ihrer web.config legen Sie die Konfiguration für Ihren Endpunkt:

<system.serviceModel> 
    <client> 
    <endpoint address="http://localhost/DogService" binding="webHttpBinding" 
    bindingConfiguration="" behaviorConfiguration="DogServiceConfig" 
    contract="IDogService" name="YourEndpoint" /> 
    </client> 
    <behaviors> 
    <endpointBehaviors> 
     <behavior name="DogServiceConfig"> 
     <webHttp/> 
     </behavior> 
    </endpointBehaviors> 
    </behaviors> 
</system.serviceModel> 

Answer 5

Vielen Dank allen für die Antworten. @tugberk hat mich auf den richtigen Weg gebracht, denke ich. Dieser arbeitete für mich ...

Für meine CarsRESTService Helfer:

public class CarsRESTService 
{ 
    readonly string baseUri = "http://localhost:9661/api/cars/"; 

    public List<Car> GetCars() 
    { 
     string uri = baseUri; 
     using (HttpClient httpClient = new HttpClient()) 
     { 
      Task<String> response = httpClient.GetStringAsync(uri); 
      return JsonConvert.DeserializeObjectAsync<List<Car>>(response.Result).Result; 
     } 
    } 

    public Car GetCarById(int id) 
    { 
     string uri = baseUri + id; 
     using (HttpClient httpClient = new HttpClient()) 
     { 
      Task<String> response = httpClient.GetStringAsync(uri); 
      return JsonConvert.DeserializeObjectAsync<Car>(response.Result).Result; 
     } 
    } 
} 

Und dann für CarsController.cs:

public class CarsController : Controller 
{ 
    private CarsRESTService carsService = new CarsRESTService(); 

    // 
    // GET: /Cars/ 

    public ActionResult Index() 
    { 
     return View(carsService.GetCars()); 
    } 

    // 
    // GET: /Cars/Details/5 

    public ActionResult Details(int id = 0) 
    { 
     Car car = carsService.GetCarById(id); 

     if (car == null) 
     { 
      return HttpNotFound(); 
     } 
     return View(car); 
    } 
}