Pobieranie strumieniowe w usłudze IIF Hosted WCF do pracy
Trochę tu utknąłem ...
Mój cel jest dość prosty: chcę udostępnić usługę WCF hostowaną przez IIS (a następnie Windows Azure), za pomocą której mogę przesyłać pliki, używając transmisji strumieniowej i dodawać dane META o pliku, który chcę przesłać (nazwa pliku, MD5-hash all zwykłe rzeczy ...) i aby móc wyświetlać dokładne informacje o postępie w przesyłaniu.
Przede wszystkim stworzyłem klasę pochodnąStreamWithProgress który dziedziczy zFileStream, gdzie zastąpiłemCzytać metoda wywołania zdarzenia z każdym odczytem, przez który przekazuję informacje o postępie.
Po drugie stworzyłem usługę WCF przy użyciu aMessageContract ( http://msdn.microsoft.com/en-us/library/ms730255.aspx ) aby zawinąć dane META i obiekt strumienia w jedną kopertę SOAP. Ta usługa jest naprawdę prosta, ponieważ udostępnia tylko jedną metodę przesyłania.
Ustawiłem wszystkie rozmiary buforów, aby akceptować duże ilości danych, zgodnie z:
http://msdn.microsoft.com/en-us/library/ms733742.aspx i
http://msdn.microsoft.com/en-us/library/ms731325.aspx
oraz ustawienia httpRuntime według:
http://msdn.microsoft.com/en-us/library/e1f13641(v=vs.71).aspx i
http://kjellsj.blogspot.com/2007/02/wcf-streaming-upload-files-over-http.html
ustawienia zgodności IIS ASP według:
http://weblogs.asp.net/jclarknet/archive/2008/02/14/wcf-streaming-issue-under-iis.aspx i
WCF Streaming File Transfer ON .NET 4
I wyłączanie grupowania według:
http://msdn.microsoft.com/en-us/library/system.servicemodel.icontextchannel.allowoutputbatching.aspxStworzyłemusługa hostowana samodzielnie przez które przesyłanie się powiodło. Następnie „zaktualizowałem” go doUsługa hostowana IIS (na mojej lokalnej maszynie), która działała. Potem stworzyłemlokalnie obsługiwana usługa Windows Azure z webrolem WCF, które działało.
Problem polega jednak na tym, że w żadnym z przypadków nie nastąpiło rzeczywiste przesyłanie strumieniowe… Wszystkie z nich buforowały dane przed wysłaniem.
Natknąłem się na ten problem, gdy zobaczyłem, że mój klient zgłasza postęp, ale serwer nie zaczyna pisać pliku, dopóki cały plik nie zostanie buforowany.
Mój rzeczywisty kod jest następujący.
Jakieś pomysły? Wszystko będzie mile widziane…
Dzięki!
Serwer web.config:
<code><?xml version="1.0"?>
<configuration>
<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding name="uploadBasicHttpBinding"
maxReceivedMessageSize="2147483647"
transferMode="Streamed"
messageEncoding="Mtom"
maxBufferPoolSize="2147483647"
maxBufferSize="2147483647">
<readerQuotas maxArrayLength="2147483647"
maxBytesPerRead="2147483647"
maxDepth="2147483647"
maxNameTableCharCount="2147483647"
maxStringContentLength="2147483647"/>
</binding>
</basicHttpBinding>
</bindings>
<behaviors>
<serviceBehaviors>
<behavior name="defaultBehavior">
<serviceMetadata httpGetEnabled="true"/>
<serviceDebug includeExceptionDetailInFaults="false"/>
<dataContractSerializer maxItemsInObjectGraph="2147483647"/>
</behavior>
</serviceBehaviors>
</behaviors>
<!-- Add this for BufferOutput setting -->
<serviceHostingEnvironment multipleSiteBindingsEnabled="true" aspNetCompatibilityEnabled="true"/>
<services>
<service name="WcfService1.Service1" behaviorConfiguration="defaultBehavior">
<endpoint binding="basicHttpBinding" contract="WcfService1.IService1" bindingConfiguration="uploadBasicHttpBinding"/>
<endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
</service>
</services>
</system.serviceModel>
<system.webServer>
<modules runAllManagedModulesForAllRequests="true"/>
</system.webServer>
<system.web>
<compilation debug="true"/>
<httpRuntime maxRequestLength="2147483647" />
</system.web>
</configuration>
</code>Umowa o świadczenie usług:
<code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using System.IO;
namespace WcfService1
{
[ServiceContract]
public interface IService1
{
[OperationContract(IsOneWay=true)]
void UploadStream(Encapsulator data);
}
}
</code>Rzeczywista usługa:
<code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
using System.IO;
using System.Web;
using System.ServiceModel.Activation;
namespace WcfService1
{
[MessageContract]
public class Encapsulator
{
[MessageHeader(MustUnderstand = true)]
public string fileName;
[MessageBodyMember(Order = 1)]
public Stream requestStream;
}
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class Service1 : IService1
{
public Service1()
{
HttpContext context = HttpContext.Current;
if (context != null)
{
context.Response.BufferOutput = false;
}
}
public void UploadStream(Encapsulator data)
{
const int BUFFER_SIZE = 1024;
int bytesRead = 0;
byte[] dataRead = new byte[BUFFER_SIZE];
string filePath = Path.Combine(@"C:\MiscTestFolder", data.fileName);
string logPath = Path.Combine(@"C:\MiscTestFolder", string.Concat(data.fileName, ".log"));
bytesRead = data.requestStream.Read(dataRead, 0, BUFFER_SIZE);
StreamWriter logStreamWriter = new StreamWriter(logPath);
using (System.IO.FileStream fileStream = new System.IO.FileStream(filePath, FileMode.Create))
{
while (bytesRead > 0)
{
fileStream.Write(dataRead, 0, bytesRead);
fileStream.Flush();
logStreamWriter.WriteLine("Flushed {0} bytes", bytesRead.ToString());
logStreamWriter.Flush();
bytesRead = data.requestStream.Read(dataRead, 0, BUFFER_SIZE);
}
fileStream.Close();
}
logStreamWriter.Close();
}
}
}
</code>Klient app.config:
<code><?xml version="1.0"?>
<configuration>
<system.serviceModel>
<bindings>
<basicHttpBinding>
<binding name="BasicHttpBinding_IService1" closeTimeout="00:01:00"
openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
allowCookies="false" bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
messageEncoding="Mtom" textEncoding="utf-8" transferMode="Streamed"
useDefaultWebProxy="true">
<readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
maxBytesPerRead="4096" maxNameTableCharCount="16384" />
<security mode="None">
<transport clientCredentialType="None" proxyCredentialType="None"
realm="" />
<message clientCredentialType="UserName" algorithmSuite="Default" />
</security>
</binding>
</basicHttpBinding>
</bindings>
<client>
<endpoint address="http://localhost/WcfService1/Service1.svc"
binding="basicHttpBinding" bindingConfiguration="BasicHttpBinding_IService1"
contract="UploadService.IService1" name="BasicHttpBinding_IService1" />
</client>
</system.serviceModel>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/>
</startup>
</configuration>
</code>Główny kod klienta:
<code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CustomFileUploaderTester.UploadService;
using System.ServiceModel;
using System.IO;
namespace CustomFileUploaderTester
{
class Program
{
private static long bytesRead = 0;
static void Main(string[] args)
{
Service1Client client = new Service1Client();
using (StreamWithProgress fstream = new StreamWithProgress(@"C:\BladieBla\someFile.wmv", FileMode.Open))
{
client.InnerChannel.AllowOutputBatching = false;
fstream.ProgressChange += new EventHandler<StreamReadProgress>(fstream_ProgressChange);
client.UploadStream("someFile.wmv", fstream);
fstream.Close();
}
Console.ReadKey();
}
static void fstream_ProgressChange(object sender, StreamReadProgress e)
{
bytesRead += e.BytesRead;
Console.WriteLine(bytesRead.ToString());
}
}
}
</code>Pochodząca klasa FileStream (StreamWithProgress)
<code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
namespace CustomFileUploaderTester
{
public class StreamReadProgress : EventArgs
{
#region Public Properties
public long BytesRead
{
get;
set;
}
public long Length
{
get;
set;
}
#endregion
#region Constructor
public StreamReadProgress(long bytesRead, long fileLength)
: base()
{
this.BytesRead = bytesRead;
this.Length = fileLength;
}
#endregion
}
public sealed class StreamWithProgress : FileStream
{
#region Public Events
public event EventHandler<StreamReadProgress> ProgressChange;
#endregion
#region Constructor
public StreamWithProgress(string filePath, FileMode fileMode)
: base(filePath, fileMode)
{
}
#endregion
#region Overrides
public override int Read(byte[] array, int offset, int count)
{
int bytesRead = base.Read(array, offset, count);
this.RaiseProgressChanged(bytesRead);
return bytesRead;
}
#endregion
#region Private Worker Methods
private void RaiseProgressChanged(long bytesRead)
{
EventHandler<StreamReadProgress> progressChange = this.ProgressChange;
if (progressChange != null)
{
progressChange(this, new StreamReadProgress(bytesRead, this.Length));
}
}
#endregion
}
}
</code>- Aktualizacja: 2012-04-20
Po zainstalowaniu adaptera pętli zwrotnej prześledziłem połączenia za pomocą RawCap i zobaczyłem, że dane są faktycznie przesyłane strumieniowo, ale serwer IIS buforuje wszystkie dane przed wywołaniem metody WWW!
Zgodnie z tym postem:
http://social.msdn.microsoft.com/Forums/is/wcf/thread/cfe625b2-1890-471b-a4bd-94373daedd39
to zachowanie ASP.Net, które WCF dziedziczy ... Ale mówią o poprawkach do tego w .Net 4.5: |
Jeśli ktoś ma jakieś inne sugestie, będzie świetnie!
Dzięki!!