Dieses Beispiel zeigt die Nutzung des Streamens von großen Dateien mit Windows Communication Foundation (WCF) und WebHttpBinding.

[Der Original-Code kommt von diesem Forum-Post: http://social.msdn.microsoft.com/Forums/en-US/wcf/thread/fb9efac5-8b57-417e-9f71-35d48d421eb4]
Für mehr Informationen über Streaming, siehe http://msdn.microsoft.com/de-de/library/ms733742.aspx.

public class Post_fb9efac5_8b57_417e_9f71_35d48d421eb4
{
  [ServiceContract]
  public interface ITest
  {
    [OperationContract]
    [WebGet]
    Stream DownloadFile(string fileName);
  
    [OperationContract]
    [WebInvoke(UriTemplate = "/UploadFile/{fileName}")]
    void UploadFile(string fileName, Stream fileContents);
  }
  
  static long CountBytes(Stream stream)
  {
    byte[] buffer = new byte[100000];
    int bytesRead;
    long totalBytesRead = 0;
  
    do
    {
      bytesRead = stream.Read(buffer, 0, buffer.Length);
      totalBytesRead += bytesRead;
    } while (bytesRead > 0);
  
    return totalBytesRead;
  }
  
  class MyReadonlyStream : Stream
  {
    long length;
    long leftToRead;
  
    public MyReadonlyStream(long length)
    {
      this.length = length;
      this.leftToRead = length;
    }
  
    public override bool CanRead
    {
      get { return true; }
    }
  
    public override bool CanSeek
    {
      get { return false; }
    }
  
    public override bool CanWrite
    {
      get { return false; }
    }
  
    public override void Flush()
    {
    }
  
    public override long Length
    {
      get { return this.length; }
    }
  
    public override long Position
    {
      get { throw new NotSupportedException(); }
      set { throw new NotSupportedException(); }
    }
  
    public override int Read(byte[] buffer, int offset, int count)
    {
      int toReturn = (int)Math.Min(this.leftToRead, (long)count);
      this.leftToRead -= toReturn;
  
      return toReturn;
    }
  
    public override long Seek(long offset, SeekOrigin origin)
    {
      throw new NotSupportedException();
    }
  
    public override void SetLength(long value)
    {
      throw new NotSupportedException();
    }
  
    public override void Write(byte[] buffer, int offset, int count)
    {
      throw new NotSupportedException();
    }
  }
  
  public class Service : ITest
  {
    public Stream DownloadFile(string fileName)
    {
      WebOperationContext.Current.OutgoingResponse.Headers["Content-Disposition"] = "attachment; filename=" + fileName;
  
      return new MyReadonlyStream(200000000); //200MB
    }
  
    public void UploadFile(string fileName, Stream fileContents)
    {
      long totalBytesRead = CountBytes(fileContents);
  
      Console.WriteLine("Total bytes read for file {0}: {1}", fileName, totalBytesRead);
    }
  
    public static void Test()
    {
      string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
      ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
        
      WebHttpBinding binding = new WebHttpBinding
      {
        TransferMode = TransferMode.Streamed,
        MaxReceivedMessageSize = int.MaxValue,
      };
  
      binding.ReaderQuotas.MaxArrayLength = int.MaxValue;
      host.AddServiceEndpoint(typeof(ITest), binding, "").Behaviors.Add(new WebHttpBehavior());
      host.Open();
      Console.WriteLine("Host opened");
  
      HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(baseAddress + "/DownloadFile?fileName=test.txt");
      req.Method = "GET";
      HttpWebResponse resp;
  
      try
      {
        resp = (HttpWebResponse)req.GetResponse();
      }
      catch (WebException e)
      {
        resp = (HttpWebResponse)e.Response;
      }
  
      Console.WriteLine("HTTP/{0} {1} {2}", resp.ProtocolVersion, (int)resp.StatusCode, resp.StatusDescription);
  
      foreach (string header in resp.Headers.AllKeys)
      {
        Console.WriteLine("{0}: {1}", header, resp.Headers[header]);
      }
  
      Stream respStream = resp.GetResponseStream();
      long size = CountBytes(respStream);
      Console.WriteLine("Response size: {0}", size);
  
      req = (HttpWebRequest)HttpWebRequest.Create(baseAddress + "/UploadFile/test.txt");
      req.Method = "POST";
      req.SendChunked = true;
      req.AllowWriteStreamBuffering = false;
      req.ContentType = "application/octet-stream";
      Stream reqStream = req.GetRequestStream();
      byte[] buffer = new byte[10000000];
      long bytesWritten = 0;
  
      for (int i = 0; i < 50; i++)
      {
        reqStream.Write(buffer, 0, buffer.Length);
        bytesWritten += buffer.Length;
  
        if ((i % 10) == 0)
        {
          Console.WriteLine("Wrote {0} bytes", bytesWritten);
        }
      }
  
      reqStream.Close();
      resp = (HttpWebResponse)req.GetResponse();
      Console.WriteLine(resp.StatusCode);
    }
  }
}

Siehe auch


Andere Sprachen


Dieser Artikel ist auch in den folgenden Sprachen verfügbar:

English (en-US)

Brazilian Portuguese (pt-BR)