Tutoriel : Upload de fichiers en Silverlight 2 en C# sur un serveur PHP

<?php
require_once('nusoap/nusoap.php');

$server = new soap_server();
// Initialize WSDL support
$server->configureWSDL('uploadwsdl', 'urn:uploadwsdl');
// Register the method to expose
$server->register('upload',                // method name
    array('mode' => 'xsd:int', 'filename' => 'xsd:string', 'filecontent' => 'xsd:string'),        // input parameters
    array('return' => 'xsd:string'),        // output parameters
    'urn:uploadwsdl',                // namespace
    'urn:uploadwsdl#upload',            // soapaction
    'rpc',                    // style
    'literal',                // use
    'Upload un fichier'            // documentation
);
// Define the method as a PHP function
function upload($mode, $filename, $filecontent)
{
    if ($mode == 0)
    {
        $fh = fopen($filename, 'w') or die("can't open file");
    }
    if ($mode == 1)
    {
        $fh = fopen($filename, 'a') or die("can't open file");
    }
    $stringData = base64_decode($filecontent);
    fwrite($fh, $stringData);
    fclose($fh);

    return 'OK';
}
// Use the request to (try to) invoke the service
$HTTP_RAW_POST_DATA = isset($HTTP_RAW_POST_DATA) ? $HTTP_RAW_POST_DATA : '';
$server->service($HTTP_RAW_POST_DATA);

?>

<Canvas>
    <TextBlock x:Name="textEnvoyer" Text="Choisir un fichier : " Canvas.Top="5" />
    <Button x:Name="btnParcourir" Content="Parcourir ..." 
        Canvas.Left="120" Width="90" Height="30" Click="Upload_Click" />
    <TextBlock x:Name="result" Canvas.Top="50" />
</Canvas>

public partial class Page : UserControl
{
    private const int _packetSize = 32768;
    private FileStream _fileStream;
    private string _fileName;

    public Page()
    {
        InitializeComponent();
    }

    private void Upload_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            OpenFileDialog dialog = new OpenFileDialog
            {
                Filter = "Image files (*.gif;*.jpg;*.png)|*.gif;*.jpg;*.png",
                Multiselect = false
            };
            if (dialog.ShowDialog() == true)
            {
                FileInfo fichier = dialog.File;
                _fileName = fichier.Name;
                _fileStream = fichier.OpenRead();
                btnParcourir.IsEnabled = false;
                Dispatcher.BeginInvoke(() => { result.Text = "Envoi en cours ..."; });

                uploadwsdlPortTypeClient client = new uploadwsdlPortTypeClient();
                client.uploadCompleted += client_uploadCompleted;
                string toUpload = GetNextPacket();
                client.uploadAsync(0, _fileName, toUpload);
            }
        }
        catch (Exception ex)
        {
            Dispatcher.BeginInvoke(() => { 
                result.Text = string.Format("Erreur d'envoi : {0}", ex.InnerException.Message); });
        }
    }

    private string GetNextPacket()
    {
        int lengthToRead = (int)(_fileStream.Length > _packetSize ? _packetSize : _fileStream.Length);
        byte[] buffer = new byte[lengthToRead];

        for (int i = 0; i < lengthToRead; i++)
        {
            int value = _fileStream.ReadByte();
            if (value == -1)
            {
                return GetEncodedValue(buffer, i);
            }
            buffer[i] = (byte)value;
        }
        return GetEncodedValue(buffer, lengthToRead);
    }

    private static string GetEncodedValue(byte[] buffer, int i)
    {
        byte[] newBuffer = new byte[i];
        Array.Copy(buffer, newBuffer, i);
        return Convert.ToBase64String(newBuffer);
    }

    void client_uploadCompleted(object sender, uploadCompletedEventArgs e)
    {
        try
        {
            if (e.Result != "OK")
            {
                Dispatcher.BeginInvoke(() => { result.Text = "Erreur d'envoi !"; });
            }
            else
            {
                uploadwsdlPortTypeClient client = new uploadwsdlPortTypeClient();
                client.uploadCompleted += client_uploadCompleted;
                string toUpload = GetNextPacket();
                if (!string.IsNullOrEmpty(toUpload))
                    client.uploadAsync(1, _fileName, toUpload);
                else
                {
                    Dispatcher.BeginInvoke(() => { btnParcourir.IsEnabled = true; });
                    Dispatcher.BeginInvoke(() => { result.Text = "Envoi terminé"; });
                }
            }
        }
        catch (Exception ex)
        {
            Dispatcher.BeginInvoke(() => 
            { result.Text = string.Format("Erreur d'envoi : {0}", ex.InnerException.Message); });
        }
    }
}

namespace DemoUpload
{
    public class WSUploader
    {
        private enum UploadType
        {
            CREATE = 0,
            APPEND = 1
        }

        private static AutoResetEvent autoEvent;
        private static UploadType _uploadType;
        private string _currentFileName;
        private Stream _currentFileStream;
        private long _currentFileSize;
        private long _totalSizeToUpload;
        private long _currentSizeUploaded;
        private long _totalSizeUploaded;
        private string _toReUploadIfError;
        private int _nbTry;
        private bool _hasError;
        private List<string> _successfullFiles;
        private List<string> _errorFiles;

        #region current file handler

        public delegate void CurrentFileErrorUploadHanlder(CurrentFileErrorUploadEventArgs args, ref bool DeleteFileOnServer);
        private event CurrentFileErrorUploadHanlder _currentFileUploadError;
        public event CurrentFileErrorUploadHanlder OnCurrentFileUploadError
        {
            add { _currentFileUploadError += value; }
            remove { _currentFileUploadError -= value; }
        }

        public delegate void CurrentFileUploadProgressHanlder(CurrentFileProgressEventArgs args);
        private event CurrentFileUploadProgressHanlder _currentFileUploadProgress;
        public event CurrentFileUploadProgressHanlder OnCurrentFileUploadProgress
        {
            add { _currentFileUploadProgress += value; }
            remove { _currentFileUploadProgress -= value; }
        }

        public delegate void CurrentFileUploadCompletedHanlder(CurrentFileUploadCompletedEventArgs args, ref bool verifyUpload);
        private event CurrentFileUploadCompletedHanlder _currentFileUploadCompleted;
        public event CurrentFileUploadCompletedHanlder OnCurrentFileUploadCompleted
        {
            add { _currentFileUploadCompleted += value; }
            remove { _currentFileUploadCompleted -= value; }
        }

        public delegate void CurrentFileVerifyUploadHanlder(VerifyUploadEventArgs args);
        private event CurrentFileVerifyUploadHanlder _currentFileVerifyUpload;
        public event CurrentFileVerifyUploadHanlder OnCurrentFileVerifyUpload
        {
            add { _currentFileVerifyUpload += value; }
            remove { _currentFileVerifyUpload -= value; }
        }

        #endregion

        #region all files handler
        public delegate void ErrorUploadHanlder(ErrorUploadEventArgs args);
        private event ErrorUploadHanlder _uploadError;
        public event ErrorUploadHanlder OnUploadError
        {
            add { _uploadError += value; }
            remove { _uploadError -= value; }
        }

        public delegate void UploadProgressHanlder(ProgressEventArgs args);
        private event UploadProgressHanlder _uploadProgress;
        public event UploadProgressHanlder OnUploadProgress
        {
            add { _uploadProgress += value; }
            remove { _uploadProgress -= value; }
        }

        public delegate void UploadCompletedHanlder(UploadCompletedEventArgs args);
        private event UploadCompletedHanlder _uploadCompleted;
        public event UploadCompletedHanlder OnUploadCompleted
        {
            add { _uploadCompleted += value; }
            remove { _uploadCompleted -= value; }
        }

        #endregion

        public WSUploader()
        {
            MaxTryPerPacket = 5;
            PacketSize = 32768;
        }

        private static uploadwsdlPortTypeClient Client
        {
            get { return new uploadwsdlPortTypeClient(
        new BasicHttpBinding(BasicHttpSecurityMode.None), new EndpointAddress(Config.UPLOAD_WEB_SERVICE_PATH)); }
        }

        public int PacketSize { get; set; }
        public int MaxTryPerPacket { get; set; }

        public void Upload(Dictionary<FileStream, string> fileDico)
        {
            _successfullFiles = new List<string>();
            _errorFiles = new List<string>();
            _totalSizeToUpload = fileDico.Sum(kp => kp.Key.Length);
            Thread thread = new Thread(delegate()
            {
                foreach (KeyValuePair<FileStream, string> element in fileDico)
                {
                    _uploadType = UploadType.CREATE;
                    autoEvent = new AutoResetEvent(false);
                    KeyValuePair<FileStream, string> currentElement = element;
                    _currentSizeUploaded = 0;
                    _currentFileStream = currentElement.Key;
                    _currentFileName = currentElement.Value;
                    _currentFileSize = _currentFileStream.Length;

                    UploadPacket();

                    autoEvent.WaitOne();
                }
                // tous les envois sont terminés
                if (_hasError)
                {
                    if (_uploadError != null)
                        _uploadError(new ErrorUploadEventArgs 
                    { FileNameWithError = _errorFiles, SuccessFullFileName = _successfullFiles });
                }
                else
                {
                    if (_uploadCompleted != null)
                        _uploadCompleted(new UploadCompletedEventArgs 
                    { UploadedFiles = _successfullFiles, TotalUploadedSize = _totalSizeToUpload });
                }
            });
            thread.Start();
        }

        void uploadCompleted(object sender, uploadCompletedEventArgs e)
        {
            try
            {
                if (e.Result != "OK")
                    ManageError(e, null);
                else
                    ContinueUpload();
            }
            catch (TargetInvocationException ex)
            {
                if (ex.InnerException != null && ex.InnerException is ProtocolException)
                    ContinueUpload();
                else
                    ManageError(null, ex);
            }
            catch (Exception ex)
            {
                ManageError(null, ex);
            }
        }

        private void ContinueUpload()
        {
            _uploadType = UploadType.APPEND;
            if (_currentFileUploadProgress != null)
                _currentFileUploadProgress(new CurrentFileProgressEventArgs 
            { ProgressPercentage = ((double)_currentSizeUploaded * 100) / _currentFileStream.Length, 
            FileName = _currentFileName });
            if (_uploadProgress != null)
                _uploadProgress(new ProgressEventArgs 
            { ProgressPercentage = ((double)_totalSizeUploaded * 100) / _totalSizeToUpload });

            UploadPacket();
        }

        private void UploadPacket()
        {
            string toUpload = GetNextPacket();
            _toReUploadIfError = toUpload;
            _nbTry = 0;
            UploadPacket(toUpload);
        }

        private void UploadPacket(string toUpload)
        {
            if (!string.IsNullOrEmpty(toUpload))
            {
                try
                {
                    uploadwsdlPortTypeClient service = Client;
                    service.uploadCompleted += uploadCompleted;
                    string checkSum = GetChecksum(new MemoryStream(Convert.FromBase64String(toUpload)));
                    service.uploadAsync((int)_uploadType, _currentFileName, toUpload, checkSum);
                }
                catch (Exception ex)
                {
                    UploadError(ex);
                }
            }
            else
            {
                // envoi du fichier courant terminé
                if (_currentFileUploadCompleted != null)
                {
                    bool verifyUpload = false;
                    _currentFileUploadCompleted(new CurrentFileUploadCompletedEventArgs 
                { FileName = _currentFileName, FileSize = _currentFileSize }, ref verifyUpload);
                    if (verifyUpload)
                    {
                        _nbTry = 0;
                        DoCheckSum();
                    }
                    else
                    {
                        _successfullFiles.Add(_currentFileName);
                        autoEvent.Set();
                    }
                }
                else
                {
                    _successfullFiles.Add(_currentFileName);
                    autoEvent.Set();
                }
            }
        }

        private void DoCheckSum()
        {
            uploadwsdlPortTypeClient service = Client;
            service.getshaCompleted += service_getshaCompleted;
            service.getshaAsync(_currentFileName);
        }

        private static string GetChecksum(Stream fileStream)
        {
            fileStream.Seek(0, SeekOrigin.Begin);
            SHA1 sha = new SHA1Managed();
            byte[] checksum = sha.ComputeHash(fileStream);
            return BitConverter.ToString(checksum).Replace("-", String.Empty);
        }

        void service_getshaCompleted(object sender, getshaCompletedEventArgs e)
        {
            Stream currentFileStream = _currentFileStream;
            string currentFileName = _currentFileName;
            if (_currentFileVerifyUpload != null)
            {
                try
                {
                    string sha = GetChecksum(currentFileStream);
                    bool resultOK = string.Compare(e.Result, sha, StringComparison.InvariantCultureIgnoreCase) == 0;
                    _currentFileVerifyUpload(new VerifyUploadEventArgs
                                                 {
                                                     ResultOK = resultOK,
                                                     FileName = currentFileName
                                                 });
                    if (resultOK)
                        _successfullFiles.Add(currentFileName);
                    else
                    {
                        _hasError = true;
                        _errorFiles.Add(currentFileName);
                    }
                    autoEvent.Set();
                }
                catch (Exception)
                {
                    _nbTry++;
                    if (_nbTry <= MaxTryPerPacket)
                        DoCheckSum();
                    else
                    {
                        _currentFileVerifyUpload(new VerifyUploadEventArgs 
                    { ResultOK = false, FileName = currentFileName });
                        _errorFiles.Add(currentFileName);
                        _hasError = true;
                        autoEvent.Set();
                    }
                }
            }
            else
            {
                _successfullFiles.Add(currentFileName);
                autoEvent.Set();
            }
        }

        private void ManageError(uploadCompletedEventArgs e, Exception ex)
        {
            _nbTry++;
            if (_nbTry <= MaxTryPerPacket)
                UploadPacket(_toReUploadIfError);
            else
            {
                if (ex != null)
                    UploadError(ex);
                else
                    UploadError(new Exception(string.Format("Nombre maxi de tentatives atteintes : {0}", e.Result)));
            }
        }

        private void UploadError(Exception exception)
        {
            if (_currentFileUploadError != null)
            {
                bool deleteFile = false;
                _currentFileUploadError(new CurrentFileErrorUploadEventArgs 
            { InnerException = exception, FileName = _currentFileName }, ref deleteFile);
                if (deleteFile)
                    DeleteFile();
            }
            _errorFiles.Add(_currentFileName);
            _hasError = true;
            autoEvent.Set();
        }

        private void DeleteFile()
        {
            uploadwsdlPortTypeClient service = Client;
            service.deleteAsync(_currentFileName);
        }

        private string GetNextPacket()
        {
            int lengthToRead = (int)(_currentFileStream.Length > PacketSize ? PacketSize : _currentFileStream.Length);
            byte[] buffer = new byte[lengthToRead];

            for (int i = 0; i < lengthToRead; i++)
            {
                int value = -1;
                int nbTry = 0;
                bool notok = true;
                while (notok && nbTry < 5)
                {
                    try
                    {
                        value = _currentFileStream.ReadByte();
                        notok = false;
                    }
                    catch (IndexOutOfRangeException)
                    {
                        nbTry++;
                        Thread.Sleep(300);
                    }
                }
                if (nbTry == 5)
                    value = -1;
                
                if (value == -1)
                {
                    _currentSizeUploaded += i;
                    _totalSizeUploaded += i;
                    return GetEncodedValue(buffer, i);
                }
                buffer[i] = (byte)value;
            }
            _currentSizeUploaded += lengthToRead;
            _totalSizeUploaded += lengthToRead;
            return GetEncodedValue(buffer, lengthToRead);
        }

        private static string GetEncodedValue(byte[] buffer, int i)
        {
            byte[] newBuffer = new byte[i];
            Array.Copy(buffer, newBuffer, i);
            return Convert.ToBase64String(newBuffer);
        }
    }

    public class VerifyUploadEventArgs
    {
        public bool ResultOK { get; set; }
        public string FileName { get; set; }
    }

    public class UploadCompletedEventArgs
    {
        public List<string> UploadedFiles { get; set; }
        public long TotalUploadedSize { get; set; }
    }

    public class CurrentFileUploadCompletedEventArgs
    {
        public string FileName { get; set; }
        public long FileSize { get; set; }
    }

    public class CurrentFileProgressEventArgs
    {
        public double ProgressPercentage { get; set; }
        public string FileName { get; set; }
    }

    public class ProgressEventArgs
    {
        public double ProgressPercentage { get; set; }
    }

    public class ErrorUploadEventArgs
    {
        public List<string> SuccessFullFileName { get; set; }
        public List<string> FileNameWithError { get; set; }
    }

    public class CurrentFileErrorUploadEventArgs
    {
        public string FileName { get; set; }
        public Exception InnerException { get; set; }
    }
}

<UserControl x:Class="DemoUpload.Page"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
        <Canvas>
            <TextBlock x:Name="textEnvoyer" Text="Choisir un fichier : " Canvas.Top="5" />
            <Button x:Name="btnParcourir" Content="Parcourir ..." Canvas.Left="120" Width="90" Height="30" Click="Upload_Click" />
            <TextBlock x:Name="result" Canvas.Top="5" Canvas.Left="250" />
            <ProgressBar x:Name="GlobalProgressBar" Width="200" Height="20" Canvas.Top="50" Minimum="0" Maximum="100" />
            <ProgressBar x:Name="IndividualProgressBar" Width="200" Height="20" Canvas.Top="90" Minimum="0" Maximum="100" />
            <TextBlock x:Name="verif" Canvas.Top="130" />
        </Canvas>
</UserControl>

public partial class Page : UserControl
{
    private readonly List<FrameworkElement> controlProgressBar;
    public Page()
    {
        InitializeComponent();
        controlProgressBar = new List<FrameworkElement> { GlobalProgressBar, IndividualProgressBar, verif };
        SetVisibilityOnControls(controlProgressBar, false);
    }

    private void SetVisibilityOnControls(IEnumerable<FrameworkElement> elements, bool visible)
    {
        Dispatcher.BeginInvoke(() =>
        {
            foreach (FrameworkElement element in elements)
                element.Visibility = visible ? Visibility.Visible : Visibility.Collapsed;
        });
    }

    private void Upload_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            OpenFileDialog dialog = new OpenFileDialog
            {
                Filter = "Image files (*.gif;*.jpg;*.png)|*.gif;*.jpg;*.png",
                Multiselect = true
            };
            if (dialog.ShowDialog() == true)
            {
                var fichiers = dialog.Files;
                GlobalProgressBar.Value = 0;
                IndividualProgressBar.Value = 0;
                SetVisibilityOnControls(controlProgressBar, true);
                btnParcourir.IsEnabled = false;
                Dispatcher.BeginInvoke(() => { verif.Text = ""; });
                Dispatcher.BeginInvoke(() => { result.Text = "Envoi en cours ..."; });

                WSUploader wsUploader = new WSUploader { MaxTryPerPacket = 10 };
                wsUploader.OnCurrentFileUploadCompleted += wsUploader_OnCurrentFileUploadCompleted;
                wsUploader.OnCurrentFileUploadError += wsUploader_OnCurrentFileUploadError;
                wsUploader.OnCurrentFileUploadProgress += wsUploader_OnCurrentFileUploadProgress;
                wsUploader.OnCurrentFileVerifyUpload += wsUploader_OnCurrentFileVerifyUpload;

                wsUploader.OnUploadCompleted += wsUploader_OnUploadCompleted;
                wsUploader.OnUploadError += wsUploader_OnUploadError;
                wsUploader.OnUploadProgress += wsUploader_OnUploadProgress;
                wsUploader.Upload(fichiers.Select(f => f).ToDictionary(f => f.OpenRead(), f => f.Name));
            }
        }
        catch (Exception ex)
        {
            Dispatcher.BeginInvoke(() => { result.Text = ex.InnerException.Message; });
        }
    }

    void wsUploader_OnCurrentFileVerifyUpload(VerifyUploadEventArgs args)
    {
        Dispatcher.BeginInvoke(() => { verif.Text = args.ResultOK ? "Vérification OK" : "Vérification KO"; });
    }

    void wsUploader_OnCurrentFileUploadProgress(CurrentFileProgressEventArgs args)
    {
        Dispatcher.BeginInvoke(() => { IndividualProgressBar.Value = args.ProgressPercentage; });
    }

    void wsUploader_OnCurrentFileUploadError(CurrentFileErrorUploadEventArgs args, ref bool DeleteFileOnServer)
    {
        DeleteFileOnServer = true;
        Dispatcher.BeginInvoke(() => { result.Text = 
            string.Format("Erreur dans l'envoi du fichier {0} => {1}", 
            args.FileName, args.InnerException.Message); });
    }

    void wsUploader_OnCurrentFileUploadCompleted(CurrentFileUploadCompletedEventArgs args, ref bool verifyUpload)
    {
        Dispatcher.BeginInvoke(() => { IndividualProgressBar.Value = 100; });
        verifyUpload = true;
    }

    void wsUploader_OnUploadProgress(ProgressEventArgs args)
    {
        Dispatcher.BeginInvoke(() => { GlobalProgressBar.Value = args.ProgressPercentage; });
    }

    void wsUploader_OnUploadError(ErrorUploadEventArgs args)
    {
        StringBuilder stringBuilder = new StringBuilder();
        foreach (string file in args.FileNameWithError)
        {
            if (stringBuilder.Length != 0)
                stringBuilder.Append(", ");
            stringBuilder.Append(file);
        }
        Dispatcher.BeginInvoke(() => 
            { result.Text = string.Format("Erreur dans l'envoi des fichiers : {0}", stringBuilder); });
    }

    void wsUploader_OnUploadCompleted(UploadCompletedEventArgs args)
    {
        Dispatcher.BeginInvoke(() => { GlobalProgressBar.Value = 100; });
        Dispatcher.BeginInvoke(() => { IndividualProgressBar.Value = 100; });
        Dispatcher.BeginInvoke(() => { btnParcourir.IsEnabled = true; });
        Dispatcher.BeginInvoke(() => { result.Text = "Envoi terminé"; });
    }
}

<cross-domain-policy>
    <allow-access-from domain="*"/>
</cross-domain-policy>