HttpWebRequest.BeginGetRequestStream(AsyncCallback, Object) Metoda

Definicja

Rozpoczyna asynchroniczne żądanie dla obiektu Stream, który będzie używany do zapisywania danych.Begins an asynchronous request for a Stream object to use to write data.

public:
 override IAsyncResult ^ BeginGetRequestStream(AsyncCallback ^ callback, System::Object ^ state);
public override IAsyncResult BeginGetRequestStream (AsyncCallback callback, object state);
override this.BeginGetRequestStream : AsyncCallback * obj -> IAsyncResult
Public Overrides Function BeginGetRequestStream (callback As AsyncCallback, state As Object) As IAsyncResult

Parametry

callback
AsyncCallback

Delegat AsyncCallback.The AsyncCallback delegate.

state
Object

Obiekt stanu dla tego żądania.The state object for this request.

Zwraca

IAsyncResult, który odwołuje się do żądania asynchronicznego.An IAsyncResult that references the asynchronous request.

Wyjątki

Właściwość Method ma wartość GET lub $.The Method property is GET or HEAD.

lub-or- KeepAlive jest true, AllowWriteStreamBuffering false, ContentLength to-1, SendChunked to false, a Method to POST lub PUT.KeepAlive is true, AllowWriteStreamBuffering is false, ContentLength is -1, SendChunked is false, and Method is POST or PUT.

Strumień jest używany przez poprzednie wywołanie do BeginGetRequestStream(AsyncCallback, Object)The stream is being used by a previous call to BeginGetRequestStream(AsyncCallback, Object)

lub-or- TransferEncoding jest ustawiona na wartość i SendChunked jest false.TransferEncoding is set to a value and SendChunked is false.

lub-or- Pula wątków działa poza wątkiem.The thread pool is running out of threads.

Moduł sprawdzania poprawności pamięci podręcznej żądań wskazywał, że odpowiedź na to żądanie może być obsługiwana z pamięci podręcznej; Jednak żądania, które zapisują dane, nie mogą korzystać z pamięci podręcznej.The request cache validator indicated that the response for this request can be served from the cache; however, requests that write data must not use the cache. Ten wyjątek może wystąpić, jeśli używasz niestandardowego modułu sprawdzania pamięci podręcznej, który jest niepoprawnie zaimplementowany.This exception can occur if you are using a custom cache validator that is incorrectly implemented.

Abort() została wcześniej wywołana.Abort() was previously called.

W aplikacji .NET Compact Framework strumień żądania o zerowej długości zawartości nie został pobrany i poprawnie zamknięty.In a .NET Compact Framework application, a request stream with zero content length was not obtained and closed correctly. Aby uzyskać więcej informacji na temat obsługi żądań o zerowej długości zawartości, zobacz programowanie sieci w .NET Compact Framework.For more information about handling zero content length requests, see Network Programming in the .NET Compact Framework.

Przykłady

Poniższy przykład kodu używa metody BeginGetRequestStream, aby wykonać asynchroniczne żądanie dla wystąpienia strumienia.The following code example uses the BeginGetRequestStream method to make an asynchronous request for a stream instance.

#using <System.dll>

using namespace System;
using namespace System::Net;
using namespace System::IO;
using namespace System::Text;
using namespace System::Threading;
ref class HttpWebRequestBeginGetRequest
{
public:
   static ManualResetEvent^ allDone = gcnew ManualResetEvent( false );
   static void Main()
   {
      
      // Create a new HttpWebRequest object.
      HttpWebRequest^ request = dynamic_cast<HttpWebRequest^>(WebRequest::Create( "http://www.contoso.com/example.aspx" ));
      
      // Set the ContentType property.
      request->ContentType = "application/x-www-form-urlencoded";
      
      // Set the Method property to 'POST' to post data to the Uri.
      request->Method = "POST";
      
      // Start the asynchronous operation.    
      AsyncCallback^ del = gcnew AsyncCallback(GetRequestStreamCallback);
      request->BeginGetRequestStream( del, request );
      
      // Keep the main thread from continuing while the asynchronous
      // operation completes. A real world application
      // could do something useful such as updating its user interface. 
      allDone->WaitOne();
    }
      

private:
    static void GetRequestStreamCallback(IAsyncResult^ asynchronousResult)
    {
        HttpWebRequest^ request = dynamic_cast<HttpWebRequest^>(asynchronousResult->AsyncState);
        
        // End the operation
        Stream^ postStream = request->EndGetRequestStream(asynchronousResult);

        Console::WriteLine("Please enter the input data to be posted:");
        String^ postData = Console::ReadLine();

        // Convert the string into a byte array.
        array<Byte>^ByteArray = Encoding::UTF8->GetBytes(postData);

        // Write to the request stream.
        postStream->Write(ByteArray, 0, postData->Length);
        postStream->Close();

        // Start the asynchronous operation to get the response
        AsyncCallback^ del = gcnew AsyncCallback(GetResponseCallback);
        request->BeginGetResponse(del, request);
    }

   static void GetResponseCallback(IAsyncResult^ asynchronousResult)
   {
      HttpWebRequest^ request = dynamic_cast<HttpWebRequest^>(asynchronousResult->AsyncState);

      // End the operation
      HttpWebResponse^ response = dynamic_cast<HttpWebResponse^>(request->EndGetResponse(asynchronousResult));
      Stream^ streamResponse = response->GetResponseStream();
      StreamReader^ streamRead = gcnew StreamReader(streamResponse);
      String^ responseString = streamRead->ReadToEnd();
      Console::WriteLine(responseString);
      // Close the stream object
      streamResponse->Close();
      streamRead->Close();

      // Release the HttpWebResponse
      response->Close();
      allDone->Set();
   }
};

void main()
{
   HttpWebRequestBeginGetRequest::Main();
}

using System;
using System.Net;
using System.IO;
using System.Text;
using System.Threading;

class HttpWebRequestBeginGetRequest
{
    private static ManualResetEvent allDone = new ManualResetEvent(false);

    public static void Main(string[] args)
    {


        // Create a new HttpWebRequest object.
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://www.contoso.com/example.aspx");

        request.ContentType = "application/x-www-form-urlencoded";

        // Set the Method property to 'POST' to post data to the URI.
        request.Method = "POST";

        // start the asynchronous operation
        request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback), request);

        // Keep the main thread from continuing while the asynchronous
        // operation completes. A real world application
        // could do something useful such as updating its user interface. 
        allDone.WaitOne();
    }

    private static void GetRequestStreamCallback(IAsyncResult asynchronousResult)
    {
        HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState;
        
        // End the operation
        Stream postStream = request.EndGetRequestStream(asynchronousResult);

        Console.WriteLine("Please enter the input data to be posted:");
        string postData = Console.ReadLine();

        // Convert the string into a byte array.
        byte[] byteArray = Encoding.UTF8.GetBytes(postData);

        // Write to the request stream.
        postStream.Write(byteArray, 0, postData.Length);
        postStream.Close();

        // Start the asynchronous operation to get the response
        request.BeginGetResponse(new AsyncCallback(GetResponseCallback), request);
    }

    private static void GetResponseCallback(IAsyncResult asynchronousResult)
    {
        HttpWebRequest request = (HttpWebRequest)asynchronousResult.AsyncState;

        // End the operation
        HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(asynchronousResult);
        Stream streamResponse = response.GetResponseStream();
        StreamReader streamRead = new StreamReader(streamResponse);
        string responseString = streamRead.ReadToEnd();
        Console.WriteLine(responseString);
        // Close the stream object
        streamResponse.Close();
        streamRead.Close();

        // Release the HttpWebResponse
        response.Close();
        allDone.Set();
    }
}
Imports System.Net
Imports System.IO
Imports System.Text
Imports System.Threading

Class HttpWebRequestBeginGetRequest
    Public Shared allDone As New ManualResetEvent(False)

    Shared Sub Main()


        ' Create a new HttpWebRequest object.
        Dim request As HttpWebRequest = CType(WebRequest.Create("http://www.contoso.com/example.aspx"), _
                 HttpWebRequest)

        ' Set the ContentType property.
        request.ContentType = "application/x-www-form-urlencoded"

        '  Set the Method property to 'POST' to post data to the URI.
        request.Method = "POST"

        ' Start the asynchronous operation.		
        Dim result As IAsyncResult = _
            CType(request.BeginGetRequestStream(AddressOf GetRequestStreamCallback, request), _
            IAsyncResult)

        ' Keep the main thread from continuing while the asynchronous
        ' operation completes. A real world application
        ' could do something useful such as updating its user interface. 
        allDone.WaitOne()
    End Sub

    Private Shared Sub GetRequestStreamCallback(ByVal asynchronousResult As IAsyncResult)
        Dim request As HttpWebRequest = CType(asynchronousResult.AsyncState, HttpWebRequest)
        
        ' End the operation
        Dim postStream As Stream = request.EndGetRequestStream(asynchronousResult)
        Console.WriteLine("Please enter the input data to be posted:")
        Dim postData As [String] = Console.ReadLine()
        
        '  Convert the string into byte array.
        Dim byteArray As Byte() = Encoding.UTF8.GetBytes(postData)

        ' Write to the stream.
        postStream.Write(byteArray, 0, postData.Length)
        postStream.Close()

        ' Start the asynchronous operation to get the response
        Dim result As IAsyncResult = _
            CType(request.BeginGetResponse(AddressOf GetResponseCallback, request), _
            IAsyncResult)
    End Sub

    Private Shared Sub GetResponseCallback(ByVal asynchronousResult As IAsyncResult)
        Dim request As HttpWebRequest = CType(asynchronousResult.AsyncState, HttpWebRequest)
        
        '  Get the response.
        Dim response As HttpWebResponse = CType(request.EndGetResponse(asynchronousResult), _
           HttpWebResponse)
        
        Dim streamResponse As Stream = response.GetResponseStream()
        Dim streamRead As New StreamReader(streamResponse)
        Dim responseString As String = streamRead.ReadToEnd()
        
        Console.WriteLine(responseString)
        
        ' Close Stream object.
        streamResponse.Close()
        streamRead.Close()

        ' Release the HttpWebResponse.
        allDone.Set()
        response.Close()
    End Sub
            
End Class

Uwagi

Metoda BeginGetRequestStream uruchamia asynchroniczne żądanie dla strumienia użytego do wysłania danych dla HttpWebRequest.The BeginGetRequestStream method starts an asynchronous request for a stream used to send data for the HttpWebRequest. Asynchroniczna Metoda wywołania zwrotnego używa metody EndGetRequestStream, aby zwrócić rzeczywisty strumień.The asynchronous callback method uses the EndGetRequestStream method to return the actual stream.

Metoda BeginGetRequestStream wymaga wykonania pewnych synchronicznych zadań konfiguracyjnych (na przykład rozpoznawania nazw DNS, wykrywania serwera proxy i połączenia gniazda TCP) przed rozpoczęciem tej metody.The BeginGetRequestStream method requires some synchronous setup tasks to complete (DNS resolution, proxy detection, and TCP socket connection, for example) before this method becomes asynchronous. W związku z tym ta metoda nigdy nie powinna być wywoływana w wątku interfejsu użytkownika, ponieważ może to potrwać pewien czas (aż do kilku minut w zależności od ustawień sieciowych), aby wykonać wstępne zadania konfiguracji synchronicznej przed wystąpieniem błędu lub Metoda powiedzie się.As a result, this method should never be called on a user interface (UI) thread because it might take considerable time (up to several minutes depending on network settings) to complete the initial synchronous setup tasks before an exception for an error is thrown or the method succeeds.

Aby dowiedzieć się więcej na temat puli wątków, zobacz Zarządzana pula wątków.To learn more about the thread pool, see The managed thread pool.

Uwaga

Aplikacja nie może mieszać metod synchronicznych i asynchronicznych dla określonego żądania.Your application cannot mix synchronous and asynchronous methods for a particular request. Jeśli wywołasz metodę BeginGetRequestStream, musisz użyć metody BeginGetResponse, aby pobrać odpowiedź.If you call the BeginGetRequestStream method, you must use the BeginGetResponse method to retrieve the response.

Uwaga

Ten element członkowski generuje informacje ze śledzenia pod warunkiem włączenia funkcji śledzenia sieci w aplikacji.This member outputs trace information when you enable network tracing in your application. Aby uzyskać więcej informacji, zobacz Śledzenie sieci w .NET Framework.For more information, see Network Tracing in the .NET Framework.

Dotyczy

Zobacz też