如何从ASP.NET AJAX调用本地WCF服务？附临时服务代码

Alright, let's break down how to make this work. You've got a local WCF service using NetTcpBinding running inside a WinForms app, and you want to call it from ASP.NET AJAX. The core hurdle here is that NetTcpBinding is a binary, TCP-only protocol, while AJAX relies on HTTP/JSON—they can't communicate directly. Here are three practical, actionable solutions depending on whether you can modify the original WCF service or not:

Solution 1: Add an AJAX-Compatible WebHttpBinding Endpoint (If You Can Modify the WCF Service) #

If you have access to modify the TestService code and configuration, this is the most direct approach. WCF lets you expose multiple endpoints for the same service, so you can keep your existing NetTcp endpoint while adding an HTTP/JSON endpoint for AJAX calls.

Steps: #

1. Update the Service Contract
   Add [WebInvoke] or [WebGet] attributes to your service interface methods to enable JSON formatting for HTTP requests/responses:

   using System.ServiceModel;
   using System.ServiceModel.Web;
   
   namespace TestService
   {
       [ServiceContract]
       public interface IService1
       {
           [WebInvoke(
               Method = "POST",
               ResponseFormat = WebMessageFormat.Json,
               RequestFormat = WebMessageFormat.Json,
               UriTemplate = "GetPatient"
           )]
           Patient GetPatient(int patientId); // Replace with your actual service method
       }
   }
   

2. Configure the New Endpoint
   Edit your WinForms app's App.config to add a webHttpBinding endpoint alongside the existing NetTcp endpoint:

   <system.serviceModel>
       <services>
           <service name="TestService.Service1">
               <!-- Existing NetTcp endpoint -->
               <endpoint 
                   address="net.tcp://localhost:2202/PatientService"
                   binding="netTcpBinding"
                   contract="TestService.IService1"
               />
               <!-- New AJAX-compatible endpoint -->
               <endpoint 
                   address="http://localhost:2203/PatientServiceAjax"
                   binding="webHttpBinding"
                   behaviorConfiguration="webHttpBehavior"
                   contract="TestService.IService1"
               />
               <host>
                   <baseAddresses>
                       <add baseAddress="http://localhost:2203/" />
                   </baseAddresses>
               </host>
           </service>
       </services>
       <behaviors>
           <endpointBehaviors>
               <behavior name="webHttpBehavior">
                   <webHttp /> <!-- Enables AJAX-friendly behavior -->
               </behavior>
           </endpointBehaviors>
       </behaviors>
   </system.serviceModel>
   

3. Call the Service from ASP.NET AJAX
   Use jQuery (or vanilla JS) to send an HTTP request to the new endpoint:

   $.ajax({
       url: "http://localhost:2203/PatientServiceAjax/GetPatient",
       type: "POST",
       contentType: "application/json",
       data: JSON.stringify({ patientId: 123 }),
       success: function(response) {
           console.log("Patient data loaded:", response);
           // Handle the JSON response here
       },
       error: function(xhr, status, error) {
           console.error("Failed to call service:", error);
       }
   });
   

   Note: If your ASP.NET site runs on a different port/domain, you'll need to enable CORS on the WCF service.

Solution 2: Build an ASP.NET Web API Proxy Layer (No Changes to Original WCF Service) #

If you can't modify the original NetTcp WCF service, create a middleman Web API project that acts as a bridge. It will receive AJAX requests, call the local WCF service via NetTcp, and return JSON responses to the client.

Steps: #

1. Create a Web API Project
   Spin up a new ASP.NET Web API (or ASP.NET Core Web API, recommended for modern apps) project.

2. Add a WCF Service Reference
   Right-click the Web API project → Add → Service Reference, then enter your WCF service address (net.tcp://localhost:2202/PatientService) to generate a client proxy.

3. Write a Proxy Controller
   Create an API controller that uses the WCF proxy to forward requests:

   using Microsoft.AspNetCore.Mvc; // For ASP.NET Core
   // Or using System.Web.Http; for traditional Web API
   
   [ApiController]
   [Route("api/[controller]")]
   public class PatientController : ControllerBase
   {
       [HttpGet("{id}")]
       public IActionResult GetPatient(int id)
       {
           // Initialize WCF client using NetTcpBinding
           var binding = new NetTcpBinding();
           var endpoint = new EndpointAddress("net.tcp://localhost:2202/PatientService");
           
           using (var client = new Service1Client(binding, endpoint))
           {
               var patient = client.GetPatient(id);
               return Ok(patient); // Automatically serializes to JSON
           }
       }
   }
   

4. Call the Web API from ASP.NET AJAX
   Point your AJAX call to the Web API endpoint instead of the WCF service directly:

   $.ajax({
       url: "/api/Patient/123",
       type: "GET",
       success: function(response) {
           console.log("Patient data loaded:", response);
       },
       error: function(xhr, status, error) {
           console.error("Failed to call API:", error);
       }
   });
   

   This approach lets you add extra logic like authentication, logging, or rate limiting without touching the original WCF service.

Solution 3: Use ASP.NET ScriptManager (Traditional WebForms) #

If you're working with classic ASP.NET WebForms, you can use the ScriptManager control to call an AJAX-enabled WCF service (requires setting up the WebHttp endpoint as in Solution 1).

Steps: #

1. Enable ASP.NET Compatibility Mode
   Add this attribute to your WCF service class:

   using System.ServiceModel.Activation;
   
   [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
   public class Service1 : IService1
   {
       // Your service implementation code
   }
   

2. Add ScriptManager to Your WebForms Page
   Register the WCF service with the ScriptManager control:

   <asp:ScriptManager ID="ScriptManager1" runat="server">
       <Services>
           <asp:ServiceReference Path="http://localhost:2203/PatientServiceAjax" />
       </Services>
   </asp:ScriptManager>
   

3. Call the Service from JavaScript
   Use the auto-generated client proxy to invoke service methods:

   TestService.IService1.GetPatient(123, 
       function(response) {
           console.log("Patient data loaded:", response);
       },
       function(error) {
           console.error("Error calling service:", error.get_message());
       }
   );
   

Key Notes for All Solutions #

• Cross-Origin Requests: If your ASP.NET site and WCF service run on different ports/domains, enable CORS (either on the WCF service for Solution 1, or on the Web API proxy for Solution 2).
• Service Availability: Ensure your WinForms WCF service is running when AJAX calls are made. For reliability, consider converting the WCF service to a Windows Service instead of relying on a WinForms app.
• Security: Add authentication (e.g., Windows auth for NetTcp, JWT tokens for HTTP endpoints) if your service handles sensitive data.

内容的提问来源于stack exchange，提问作者StealthRT