angularjs - AngularJs $http.post() verzendt geen gegevens

Kan iemand mij vertellen waarom de volgende verklaring de postgegevens niet naar de aangewezen url stuurt? De url wordt aangeroepen, maar op de server wanneer ik $_POST afdruk – krijg ik een lege array. Als ik een bericht in de console afdruk voordat ik het aan de gegevens toevoeg, wordt de juiste inhoud weergegeven.

$http.post('request-url',  { 'message' : message });

Ik heb het ook geprobeerd met de data als string (met hetzelfde resultaat):

$http.post('request-url',  "message=" + message);

Het lijkt te werken als ik het in het volgende formaat gebruik:

$http({
    method: 'POST',
    url: 'request-url',
    data: "message=" + message,
    headers: {'Content-Type': 'application/x-www-form-urlencoded'}
});

maar is er een manier om dit te doen met $http.post() – en moet ik altijd de header toevoegen om het te laten werken? Ik geloof dat het bovenstaande inhoudstype het formaat van de verzonden gegevens specificeert, maar kan ik het als javascript-object verzenden?

Antwoord 1, autoriteit 100%

Ik had hetzelfde probleem met asp.net MVC en vond hier de oplossing

Er is veel verwarring onder nieuwkomers op AngularJSover waarom de
$httpservice stenofuncties ($http.post(), etc.) lijken niet te
verwisselbaar zijn met de jQueryequivalenten (jQuery.post(), etc.)

Het verschil zit in hoe jQueryen AngularJSde gegevens serialiseren en verzenden. Het probleem ligt in het feit dat uw servertaal naar keuze de transmissie van AngularJS niet kan begrijpen … Standaard verzendt jQuerygegevens met
Content-Type: x-www-form-urlencoded
en de bekende foo=bar&baz=moeserialisatie.

AngularJSverzendt echter gegevens met
Content-Type: application/json 
en { "foo": "bar", "baz": "moe" }

JSON-serialisatie, die helaas in sommige webservertalen voorkomt, met name
PHP: verwijder de serialisatie niet van nature.

Werkt als een tierelier.

CODE

// Your app's root module...
angular.module('MyModule', [], function($httpProvider) {
  // Use x-www-form-urlencoded Content-Type
  $httpProvider.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=utf-8';
  /**
   * The workhorse; converts an object to x-www-form-urlencoded serialization.
   * @param {Object} obj
   * @return {String}
   */ 
  var param = function(obj) {
    var query = '', name, value, fullSubName, subName, subValue, innerObj, i;
    for(name in obj) {
      value = obj[name];
      if(value instanceof Array) {
        for(i=0; i<value.length; ++i) {
          subValue = value[i];
          fullSubName = name + '[' + i + ']';
          innerObj = {};
          innerObj[fullSubName] = subValue;
          query += param(innerObj) + '&';
        }
      }
      else if(value instanceof Object) {
        for(subName in value) {
          subValue = value[subName];
          fullSubName = name + '[' + subName + ']';
          innerObj = {};
          innerObj[fullSubName] = subValue;
          query += param(innerObj) + '&';
        }
      }
      else if(value !== undefined && value !== null)
        query += encodeURIComponent(name) + '=' + encodeURIComponent(value) + '&';
    }
    return query.length ? query.substr(0, query.length - 1) : query;
  };
  // Override $http service's default transformRequest
  $httpProvider.defaults.transformRequest = [function(data) {
    return angular.isObject(data) && String(data) !== '[object File]' ? param(data) : data;
  }];
});

Antwoord 2, Autoriteit 34%

Het is niet super duidelijk hierboven, maar als u het verzoek in PHP ontvangt, kunt u gebruiken:

$params = json_decode(file_get_contents('php://input'),true);

Om toegang te krijgen tot een array in PHP vanuit een Angularjs-bericht.

Antwoord 3, Autoriteit 23%

U kunt het standaard “content-type” als volgt instellen:

$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded";

Over de dataFormaat:

De $ http.post en $ http.put-methoden accepteren elk JavaScript-object (of een string) -waarde als hun gegevensparameter. Als gegevens een JavaScript-object zijn, wordt standaard geconverteerd naar een JSON-string.

Probeer deze variatie

te gebruiken

function sendData($scope) {
    $http({
        url: 'request-url',
        method: "POST",
        data: { 'message' : message }
    })
    .then(function(response) {
            // success
    }, 
    function(response) { // optional
            // failed
    });
}

Antwoord 4, autoriteit 17%

Ik heb een soortgelijk probleem gehad en ik vraag me af of dit ook nuttig kan zijn: https://stackoverflow.com/a/11443066

var xsrf = $.param({fkey: "key"});
$http({
    method: 'POST',
    url: url,
    data: xsrf,
    headers: {'Content-Type': 'application/x-www-form-urlencoded'}
})

Met vriendelijke groet,

Antwoord 5, autoriteit 10%

Ik gebruik graag een functie om objecten om te zetten in postparameters.

myobject = {'one':'1','two':'2','three':'3'}
Object.toparams = function ObjecttoParams(obj) {
    var p = [];
    for (var key in obj) {
        p.push(key + '=' + encodeURIComponent(obj[key]));
    }
    return p.join('&');
};
$http({
    method: 'POST',
    url: url,
    data: Object.toparams(myobject),
    headers: {'Content-Type': 'application/x-www-form-urlencoded'}
})

Antwoord 6, autoriteit 9%

Dit is eindelijk opgelost in hoekige 1.4 met behulp van $httpParamSerializerJQLike

Zie https://github.com/angular/angular.js/issues/6039

.controller('myCtrl', function($http, $httpParamSerializerJQLike) {
$http({
  method: 'POST',
  url: baseUrl,
  data: $httpParamSerializerJQLike({
    "user":{
      "email":"[email protected]",
      "password":"123456"
    }
  }),
  headers:
    'Content-Type': 'application/x-www-form-urlencoded'
})})

Antwoord 7, autoriteit 5%

Ik gebruik jQuery-parammet AngularJS-berichtvereist. Hier is een voorbeeld … maak een AngularJS-toepassingsmodule, waarbij myappis gedefinieerd met ng-appin uw HTML-code.

var app = angular.module('myapp', []);

Laten we nu een Login-controller en POST-e-mailadres en wachtwoord maken.

app.controller('LoginController', ['$scope', '$http', function ($scope, $http) {
    // default post header
    $http.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=utf-8';
    // send login data
    $http({
        method: 'POST',
        url: 'https://example.com/user/login',
        data: $.param({
            email: $scope.email,
            password: $scope.password
        }),
        headers: {'Content-Type': 'application/x-www-form-urlencoded'}
    }).success(function (data, status, headers, config) {
        // handle success things
    }).error(function (data, status, headers, config) {
        // handle error things
    });
}]);

Ik hou er niet van om de code uit te leggen, het is eenvoudig genoeg om te begrijpen 🙂 Merk op dat paramvan jQuery is, dus je moet zowel jQuery als AngularJS installeren om het te laten werken. Hier is een screenshot.

Ik hoop dat dit nuttig is. Bedankt!

Antwoord 8, autoriteit 3%

Ik had hetzelfde probleem met AngularJS en Node.js + Express 4 + Router

Router verwacht de gegevens van het verzoek van de post in de body. Deze body was altijd leeg als ik het voorbeeld van Angular Docs volgde

Notatie 1

$http.post('/someUrl', {msg:'hello word!'})

Maar als ik het in de gegevens heb gebruikt

Notatie 2

$http({
       withCredentials: false,
       method: 'post',
       url: yourUrl,
       headers: {'Content-Type': 'application/x-www-form-urlencoded'},
       data: postData
 });

Bewerken 1:

Anders verwacht de node.js-router de gegevens in req.body als notatie 1 wordt gebruikt:

req.body.msg

Die de informatie ook als JSON-payload verzendt. Dit is beter in sommige gevallen waar je arrays in je json hebt en x-www-form-urlencoded wat problemen geeft.

het werkte. Ik hoop dat het helpt.

Antwoord 9, autoriteit 3%

In tegenstelling tot JQuery en omwille van pedanterie, gebruikt Angular het JSON-formaat voor POST
gegevens overdrachtvan een client naar de server (JQuery past vermoedelijk x-www-form-urlencoded toe, hoewel JQuery en Angular JSON gebruiken voor gegevensinvoer). Daarom zijn er twee delen van het probleem: in het js-clientgedeelte en in uw servergedeelte. Dus je hebt nodig:

zet het js Angular-clientgedeelte als volgt:

$http({
method: 'POST',
url: 'request-url',
data: {'message': 'Hello world'}
});

schrijf in uw servergedeelte om gegevens van een client te ontvangen (als het php is).

       $data               = file_get_contents("php://input");
        $dataJsonDecode     = json_decode($data);
        $message            = $dataJsonDecode->message;
        echo $message;     //'Hello world'

Opmerking: $_POST werkt niet!

De oplossing werkt voor mij prima, hopelijk, en voor jou.

Antwoord 10, autoriteit 2%

Om voort te bouwen op het antwoord van @felipe-miosso:

Download het als een AngularJS-module van hier,
Installeer het

Voeg het toe aan uw aanvraag:

var app = angular.module('my_app', [ ... , 'httpPostFix']);

Antwoord 11, autoriteit 2%

Om gegevens te verzenden via Post-methode met $httpvan angularjs moet je

wijzigen

data: "message=" + message, met data: $.param({message:message})

Antwoord 12, autoriteit 2%

Ik heb niet de reputatie om commentaar te geven, maar als reactie op/aanvulling op het antwoord van Don F:

$params = json_decode(file_get_contents('php://input'));

Een tweede parameter van truemoet worden toegevoegd aan de functie json_decodeom een associatieve array correct te retourneren:

$params = json_decode(file_get_contents('php://input'), true);

Antwoord 13, autoriteit 2%

Hoekig

 var payload = $.param({ jobId: 2 });
                this.$http({
                    method: 'POST',
                    url: 'web/api/ResourceAction/processfile',
                    data: payload,
                    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
                });

WebAPI 2

public class AcceptJobParams
        {
            public int jobId { get; set; }
        }
        public IHttpActionResult ProcessFile([FromBody]AcceptJobParams thing)
        {
            // do something with fileName parameter
            return Ok();
        }

Antwoord 14

Deze code heeft het probleem voor mij opgelost. Het is een oplossing op toepassingsniveau:

moduleName.config(['$httpProvider',
  function($httpProvider) {
    $httpProvider.defaults.transformRequest.push(function(data) {
        var requestStr;
        if (data) {
            data = JSON.parse(data);
            for (var key in data) {
                if (requestStr) {
                    requestStr += "&" + key + "=" + data[key];
                } else {
                    requestStr = key + "=" + data[key];
                }
            }
        }
        return requestStr;
    });
    $httpProvider.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded";
  }
]);

Antwoord 15

Voeg dit toe in uw JS-bestand:

$http.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded";

en voeg dit toe aan uw serverbestand:

$params = json_decode(file_get_contents('php://input'), true);

die moeten werken.

Antwoord 16

Ik heb ook een soortgelijk probleem geconfronteerd en ik deed zoiets en dat heeft niet gewerkt. Mijn veercontroller was niet in staat om gegevensparameter te lezen.

var paramsVal={data:'"id":"1"'};
  $http.post("Request URL",  {params: paramsVal});

Maar toen ik dit forum en API Doc las, probeerde ik de volgende manier en dat werkte voor mij.
Als iemand ook een soortgelijk probleem heeft, kun je het ook hieronder proberen.

$http({
      method: 'POST',
      url: "Request URL",           
      params: paramsVal,
      headers: {'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8'}
            });

Controleer https://docs.angularjs.org/api/ng/service/$http#post voor wat param config doet.
{data:'”id”:”1″‘} – Kaart van strings of objecten die worden omgezet in URL?data=”id:1″

Antwoord 17

dit is waarschijnlijk een laat antwoord, maar ik denk dat de meest juiste manier is om hetzelfde stuk code hoekig gebruik te gebruiken bij het doen van een “get”-verzoek waarbij u $httpParamSerializerhet moet injecteren in je controller
dus u kunt eenvoudig het volgende doen zonder dat u JQuery hoeft te gebruiken,
$http.post(url,$httpParamSerializer({param:val}))

app.controller('ctrl',function($scope,$http,$httpParamSerializer){
    $http.post(url,$httpParamSerializer({param:val,secondParam:secondVal}));
}

Antwoord 18

In mijn geval los ik het probleem als volgt op:

var deferred = $q.defer();
$http({
    method: 'POST',
    url: 'myUri', 
    data: $.param({ param1: 'blablabla', param2: JSON.stringify(objJSON) }),
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
}).then(
    function(res) {
        console.log('succes !', res.data);
        deferred.resolve(res.data);
    },
    function(err) {
        console.log('error...', err);
        deferred.resolve(err);
    }
);
return deferred.promise;

Je moet JSON.stringify gebruiken voor elke param die een JSON-object bevat, en dan je data-object bouwen met “$.param” 🙂

NB : Mijn “objJSON” is een JSON-object dat array-, integer-, string- en html-inhoud bevat. Zijn totale grootte is >3500 tekens.

Antwoord 19

Ik weet dat het antwoord geaccepteerdheeft. Maar het volgende kan toekomstige lezers helpen, als het antwoord om welke reden dan ook niet bij hen past.

Angular doet niet hetzelfde als jQuery. Terwijl ik probeerde de gids te volgen om hoekige $httpprovideraan te passen, kwam ik andere problemen tegen. bijv. Ik gebruik codeigniter waarin de functie $this->input->is_ajax_request()altijd faalde (die is geschreven door een andere programmeur en wereldwijd wordt gebruikt, dus kan niet worden gewijzigd) om te zeggen dat dit geen echt ajax-verzoek was.

Om het op te lossen heb ik de hulp ingeroepen van uitgestelde belofte . Ik heb het getest in Firefox en ie9 en het werkte.

Ik heb de volgende functie gedefinieerd buiteneen van de hoekcodes. Deze functie maakt een normale jQuery ajax-aanroep en retourneert een uitgesteld/belofte (ik ben nog aan het leren) object.

function getjQueryAjax(url, obj){
    return $.ajax({
        type: 'post',
        url: url,
        cache: true,
        data: obj
    });
}

Dan noem ik het hoekcode met de volgende code. Houd er rekening mee dat we de $scopehandmatig moeten bijwerken met $scope.$apply().

   var data = {
        media: "video",
        scope: "movies"
    };
    var rPromise = getjQueryAjax("myController/getMeTypes" , data);
    rPromise.success(function(response){
        console.log(response);
        $scope.$apply(function(){
            $scope.testData = JSON.parse(response);
            console.log($scope.testData);
        });
    }).error(function(){
        console.log("AJAX failed!");
    });

Dit is misschien niet het perfecte antwoord, maar het stelde me in staat om jQuery ajax-aanroepen met angular te gebruiken en stelde me in staat om de $scopebij te werken.

Antwoord 20

Ik had hetzelfde probleem in express .. om op te lossen moet je bodyparser gebruiken om json-objecten te parseren voordat je http-verzoeken verzendt ..

app.use(bodyParser.json());

Antwoord 21

Ik gebruik asp.net WCF-webservices met hoekige js en onderstaande code
werkte:

$http({
        contentType: "application/json; charset=utf-8",//required
        method: "POST",
        url: '../../operation/Service.svc/user_forget',
        dataType: "json",//optional
        data:{ "uid_or_phone": $scope.forgettel, "user_email": $scope.forgetemail },
        async: "isAsync"//optional
       }).success( function (response) {
         $scope.userforgeterror = response.d;                    
       })

Hopelijk helpt het.

Antwoord 22

Kon geen volledig codefragment vinden over het gebruik van de $http.post-methode om gegevens naar de server te verzenden en waarom het in dit geval niet werkte.

Uitleg van onderstaand codefragment…

Ik gebruik de functie jQuery $.param om de JSON-gegevens te serialiseren naar www-postgegevens
Instellen van het inhoudstype in de configuratie-variabele die wordt doorgegeven met het verzoek van Angularjs $ http.post die de server instrueert die we gegevens in WWW-postformaat verzenden.
Let op de $ HTTTPTP.POST-methode, waarbij ik de 1e parameter verzend als URL, 2e parameter als gegevens (serialized) en 3e parameter als config.

Resterende code is zelfbegrepen.

$scope.SendData = function () {
           // use $.param jQuery function to serialize data from JSON 
            var data = $.param({
                fName: $scope.firstName,
                lName: $scope.lastName
            });
            var config = {
                headers : {
                    'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8;'
                }
            }
            $http.post('/ServerRequest/PostDataResponse', data, config)
            .success(function (data, status, headers, config) {
                $scope.PostDataResponse = data;
            })
            .error(function (data, status, header, config) {
                $scope.ResponseDetails = "Data: " + data +
                    "<hr />status: " + status +
                    "<hr />headers: " + header +
                    "<hr />config: " + config;
            });
        };

Kijk naar het CODE-voorbeeld van $ http.post methode hier .

Antwoord 23

Als u PHP gebruikt, is dit een eenvoudige manier om toegang te krijgen tot een array in PHP vanuit een Angularjs-post.

$params = json_decode(file_get_contents('php://input'), true);

Antwoord 24

Als u Angular >= 1.4gebruikt, is dit de schoonste oplossing met de serializer geleverd door Angular:

angular.module('yourModule')
  .config(function ($httpProvider, $httpParamSerializerJQLikeProvider){
    $httpProvider.defaults.transformRequest.unshift($httpParamSerializerJQLikeProvider.$get());
    $httpProvider.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
});

En dan kun je dit gewoon overal in je app doen:

$http({
  method: 'POST',
  url: '/requesturl',
  data: {
    param1: 'value1',
    param2: 'value2'
  }
});

En het zal de gegevens correct serialiseren als param1=value1&param2=value2en het naar /requesturlsturen met de application/x-www-form-urlencoded; charset=utf-8Content-Type header zoals het normaal wordt verwacht bij POST-verzoeken op eindpunten.

TL;DR

Tijdens mijn onderzoek ontdekte ik dat het antwoord op dit probleem in veel verschillende smaken verkrijgbaar is; sommige zijn erg ingewikkeld en zijn afhankelijk van aangepaste functies, sommige zijn afhankelijk van jQuery en sommige zijn onvolledig door te suggereren dat u alleen de header hoeft in te stellen.

Als je gewoon de Content-Typeheader instelt, zal het eindpunt de POST-gegevens zien, maar het zal niet in het standaardformaat zijn, want tenzij je een string opgeeft als je dataof uw data-object handmatig serialiseren, het wordt allemaal standaard geserialiseerd als JSON en kan op het eindpunt onjuist worden geïnterpreteerd.

bijv. als de juiste serializer niet was ingesteld in het bovenstaande voorbeeld, zou deze in het eindpunt worden gezien als:

{"param1":"value1","param2":"value2"}

En dat kan leiden tot onverwachte parsing, b.v. ASP.NET behandelt het als een nullparameternaam, met {"param1":"value1","param2":"value2"}als waarde; of Fiddler interpreteert het andersom, met {"param1":"value1","param2":"value2"}als de parameternaam en nullals de waarde .

Antwoord 25

Vergelijkbaar met het door het OP voorgestelde werkformaat & Denison’s antwoord, behalve het gebruik van $http.postin plaats van alleen $httpen is nog steeds afhankelijk van jQuery.

Het goede aan het gebruik van jQuery hier is dat complexe objecten correct worden doorgegeven; tegen handmatig converteren naar URL-parameters die de gegevens kunnen vervormen.

$http.post( 'request-url', jQuery.param( { 'message': message } ), {
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
});

Antwoord 26

Geef gewoon de gegevens die u wilt verzenden als tweede parameter:

$http.post('request-url',  message);

Een andere vorm die ook werkt is:

$http.post('request-url',  { params: { paramName: value } });

Zorg ervoor dat paramNameexact overeenkomt met de naam van de parameter van de functie die u aanroept.

Bron: AngularJS-snelkoppelingsmethode voor posts

Antwoord 27

Toen ik dit probleem had, bleek de parameter die ik postte een array van objecten te zijn in plaats van een eenvoudig object.

Antwoord 28

Zojuist bijgewerkt van hoekige 1.2 naar 1.3, er is een probleem in de code gevonden. Het transformeren van een resource zal leiden tot een eindeloze lus omdat (denk ik) van de $promise hetzelfde object opnieuw vasthoudt. Misschien helpt het iemand…

Ik zou dat kunnen oplossen door:

[...]
  /**
 * The workhorse; converts an object to x-www-form-urlencoded serialization.
 * @param {Object} obj
 * @return {String}
 */
var param = function (obj) {
var query = '', name, value, fullSubName, subName, subValue, innerObj, i;
angular.forEach(obj, function(value, name) {
+    if(name.indexOf("$promise") != -1) {
+        return;
+    }
    value = obj[name];
    if (value instanceof Array) {
        for (i = 0; i < value.length; ++i) {
[...]

Antwoord 29

Ik gebruik de code van het geaccepteerde antwoord (Felipe’s code) al een tijdje en het werkt prima (bedankt, Felipe!).

Onlangs ontdekte ik echter dat het problemen heeft met lege objecten of arrays.
Bijvoorbeeld bij het indienen van dit object:

{
    A: 1,
    B: {
        a: [ ],
    },
    C: [ ],
    D: "2"
}

PHP lijkt B en C helemaal niet te zien. Het krijgt dit:

[
    "A" => "1",
    "B" => "2"
]

Een blik op het daadwerkelijke verzoek in Chrome laat dit zien:

A: 1
:
D: 2

Ik heb een alternatief codefragment geschreven. Het lijkt goed te werken met mijn gebruiksscenario’s, maar ik heb het niet uitgebreid getest, dus wees voorzichtig.

Ik heb typescript gebruikt omdat ik van sterke typen houd, maar het zou gemakkelijk zijn om te converteren naar Pure JS:

angular.module("MyModule").config([ "$httpProvider", function($httpProvider: ng.IHttpProvider) {
    // Use x-www-form-urlencoded Content-Type
    $httpProvider.defaults.headers.post["Content-Type"] = "application/x-www-form-urlencoded;charset=utf-8";
    function phpize(obj: Object | any[], depth: number = 1): string[] {
        var arr: string[] = [ ];
        angular.forEach(obj, (value: any, key: string) => {
            if (angular.isObject(value) || angular.isArray(value)) {
                var arrInner: string[] = phpize(value, depth + 1);
                var tmpKey: string;
                var encodedKey = encodeURIComponent(key);
                if (depth == 1) tmpKey = encodedKey;
                else tmpKey = `[${encodedKey}]`;
                if (arrInner.length == 0) {
                    arr.push(`${tmpKey}=`);
                }
                else {
                    arr = arr.concat(arrInner.map(inner => `${tmpKey}${inner}`));
                }
            }
            else {
                var encodedKey = encodeURIComponent(key);
                var encodedValue;
                if (angular.isUndefined(value) || value === null) encodedValue = "";
                else encodedValue = encodeURIComponent(value);
                if (depth == 1) {
                    arr.push(`${encodedKey}=${encodedValue}`);
                }
                else {
                    arr.push(`[${encodedKey}]=${encodedValue}`);
                }
            }
        });
        return arr;
    }
    // Override $http service's default transformRequest
    (<any>$httpProvider.defaults).transformRequest = [ function(data: any) {
        if (!angular.isObject(data) || data.toString() == "[object File]") return data;
        return phpize(data).join("&");
    } ];
} ]);

Het is minder efficiënt dan de code van Felipe, maar ik denk niet dat het veel belangrijk is, omdat het onmiddellijk moet zijn in vergelijking met het totale overhead van het HTTP-verzoek zelf.

Nu PHP-shows:

[
    "A" => "1",
    "B" => [
        "a" => ""
    ],
    "C" => "",
    "D" => "2"
]

Voor zover ik weet, is het niet mogelijk om PHP te krijgen om te erkennen dat BA en C lege arrays zijn, maar tenminste de sleutels verschijnen, wat belangrijk is wanneer er een code is op de een bepaalde structuur .

Houd er ook rekening mee dat het undefined s en null s omzet aan lege strings.

ANTWOORD 30

Ik heb dit met onderstaande codes opgelost:

Klantzijde (JS):

    $http({
                url: me.serverPath,
                method: 'POST',
                data: data,
                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
            }).
                success(function (serverData) {
                    console.log("ServerData:", serverData);
    ......

Merk op dat gegevens een object zijn.

op de server (ASP.NET MVC):

[AllowCrossSiteJson]
        public string Api()
        {
            var data = JsonConvert.DeserializeObject<AgentRequest>(Request.Form[0]);
            if (data == null) return "Null Request";
            var bl = Page.Bl = new Core(this);
            return data.methodName;
        }

en ‘AllowCrossSiteJsonAttribute’ is nodig voor aanvragen voor meerdere domeinen:

public class AllowCrossSiteJsonAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            filterContext.RequestContext.HttpContext.Response.AddHeader("Access-Control-Allow-Origin", "*");
            base.OnActionExecuting(filterContext);
        }
    }

Ik hoop dat dit nuttig was.

AngularJs $http.post() verzendt geen gegevens