public StreamCopyOperation(
            LiveConnectClient client, 
            ApiMethod method, 
            Stream inputStream, 
            Stream outputStream, 
            long contentLength, 
            object progress,
            SynchronizationContextWrapper syncContext, 
            Action<bool, Exception> onCopyCompleted)
            : base(syncContext)
        {
            Debug.Assert(client != null, "client must not be null.");
            Debug.Assert(
                method == ApiMethod.Download || method == ApiMethod.Upload,
                "Only Download and Upload methods are allowed.");
            Debug.Assert(inputStream.CanRead, "Input stream is not readable.");
            Debug.Assert(outputStream.CanWrite, "Output stream is not writable.");

            this.LiveClient = client;
            this.Method = method;
            this.InputStream = inputStream;
            this.OutputStream = outputStream;
            this.ContentLength = contentLength;
            this.buffer = new byte[StreamCopyOperation.BufferSize];
            this.copyCompletedCallback = onCopyCompleted;
            this.progress = progress;
        }

        private void btnUploadDirectory_Click(object sender, RoutedEventArgs e)
        {
            //Show folder picker...
            var dialog = new System.Windows.Forms.FolderBrowserDialog();
            dialog.ShowDialog();
            //END Show folder picker...

            //Get a recusive list of all files...
            if (dialog.SelectedPath == "")
            {
                System.Windows.MessageBox.Show("No folder selected.");
                return;
            }
            string[] files = Directory.GetFiles(dialog.SelectedPath, "*.*", SearchOption.AllDirectories);

            foreach (string file in files)
            {
                txtRaw.Text += file + "\r\n";
                LiveConnectClient client = new LiveConnectClient(Properties.session);

                client.UploadCompleted += this.ConnectClient_UploadCompleted;
                var stream = default(Stream);
                stream = File.OpenRead(file);
                client.UploadAsync(Properties.UltiDriveFolderID + "/files", file, stream, stream);
                stream.Close();
                //System.Windows.MessageBox.Show(file);
            }
            //END Get a recursive list of all files...
        }

 public ForegroundUploadOperation(LiveConnectClient client, Uri url, string filename, IFileSource inputFile, OverwriteOption option, IProgress<LiveOperationProgress> progress, SynchronizationContextWrapper syncContext)
     : base(client, url, ApiMethod.Upload, null, syncContext)
 {
     this.Filename = filename;
     this.Progress = progress;
     this.OverwriteOption = option;
     this.FileSource = inputFile;
 }

 /// <summary>
 /// Creates a new TailoredDownloadOperation instance.
 /// </summary>
 public CreateBackgroundDownloadOperation(
     LiveConnectClient client, 
     Uri url, 
     IStorageFile outputFile)
     : base(client, url, ApiMethod.Download, null, null)
 {
     this.OutputFile = outputFile;
 }

 public DownloadOperation(
     LiveConnectClient client, 
     Uri url, 
     object progress, 
     SynchronizationContextWrapper syncContext)
     : base(client, url, ApiMethod.Download, null, syncContext)
 {
     this.progress = progress;
 }

 public ApiWriteOperation(
     LiveConnectClient client, 
     Uri url, 
     ApiMethod method, 
     string body, 
     SynchronizationContextWrapper syncContext)
     : base(client, url, method, body, syncContext)
 {
 }

 public GetUploadLinkOperation(
     LiveConnectClient client, 
     Uri url, 
     string fileName, 
     OverwriteOption option, 
     SynchronizationContextWrapper syncContext)
     : base(client, url, ApiMethod.Get, null, syncContext)
 {
     this.FileName = fileName;
     this.OverwriteOption = option;
 }

 /// <summary>
 /// Creates a new TailoredDownloadOperation instance.
 /// </summary>
 public TailoredDownloadOperation(
     LiveConnectClient client, 
     Uri url, 
     IStorageFile outputFile, 
     IProgress<LiveOperationProgress> progress,
     SynchronizationContextWrapper syncContext)
     : base(client, url, ApiMethod.Download, null, syncContext)
 {
     this.OutputFile = outputFile;
     this.Progress = progress;
 }

 /// <summary>
 /// Constructs a new ApiOperation object.
 /// </summary>
 public ApiOperation(
     LiveConnectClient client, 
     Uri url, 
     ApiMethod method, 
     string body, 
     SynchronizationContextWrapper syncContext)
     : base(url, body, syncContext)
 {
     this.Method = method;
     this.LiveClient = client;
 }

        public void TestExecute()
        {
            WebRequestFactory.Current = new TestWebRequestFactory();
            LiveConnectClient connectClient = new LiveConnectClient(new LiveConnectSession());
            Uri requestUri = new Uri("http://foo.com");
            string fileName = string.Empty;
            OverwriteOption overwriteOption = OverwriteOption.Overwrite;
            SynchronizationContextWrapper syncContextWrapper = SynchronizationContextWrapper.Current;

            var apiOperation =
                new GetUploadLinkOperation(connectClient, requestUri, fileName, overwriteOption, syncContextWrapper);
        }

        public void TestExecute()
        {
            WebRequestFactory.Current = new TestWebRequestFactory();
            LiveConnectClient connectClient = new LiveConnectClient(new LiveConnectSession());
            Uri requestUri = new Uri("http://foo.com");
            ApiMethod apiMethod = ApiMethod.Copy;
            string body = string.Empty;
            SynchronizationContextWrapper syncContextWrapper = SynchronizationContextWrapper.Current;

            var apiOperation =
                new ApiWriteOperation(connectClient, requestUri, apiMethod, body, syncContextWrapper);
        }

 public static void checkSkyDriveInitiatedStart(object sender, RoutedEventArgs e)
 {
     //Check to see if user is logged in
     if (SkyDrive.Properties.LoggedIn)
     {
         //Check to see if SkyDrive is initiated for UltiDrive
         LiveConnectClient client = new LiveConnectClient(SkyDrive.Properties.session);
         client.GetCompleted += skydrive_checkInitiated;
         client.GetAsync("me/skydrive/files"); //Get list of files in root directory of SkyDrive.
         //END Check to see if SkyDrive is initiated for UltiDrive
     }
 }

 public void TestDeleteNullPath()
 {
     var connectClient = new LiveConnectClient(new LiveConnectSession());
     try
     {
         connectClient.DeleteAsync(null);
         Assert.Fail("Expected ArguementNullException to be thrown.");
     }
     catch (ArgumentNullException)
     {
     }
 }

 public void TestGetWhiteSpaceStringPath()
 {
     var connectClient = new LiveConnectClient(new LiveConnectSession());
     try
     {
         connectClient.GetAsync("\t\n ");
         Assert.Fail("Expected ArguementException to be thrown.");
     }
     catch (ArgumentException)
     {
     }
 }

        public void TestExecute()
        {
            WebRequestFactory.Current = new TestWebRequestFactory();
            var connectClient = new LiveConnectClient(new LiveConnectSession());
            var requestUrl = new Uri("http://foo.com");
            IStorageFile outputFile = new StorageFileStub();
            IProgress<LiveOperationProgress> progress = new Progress<LiveOperationProgress>();
            SynchronizationContextWrapper syncContext = SynchronizationContextWrapper.Current;

            var tailoredDownloadOperation =
                new TailoredDownloadOperation(connectClient, requestUrl, outputFile, progress, syncContext);
        }

 /// <summary>
 /// This class implements the upload operation on Windows 8 using the background uploader.
 /// </summary>
 /// <remarks>This constructor is used when uploading a stream created by the application.</remarks>
 internal TailoredUploadOperation(
     LiveConnectClient client,
     Uri url,
     string fileName,
     OverwriteOption option,
     IProgress<LiveOperationProgress> progress,
     SynchronizationContextWrapper syncContext)
     : base(client, url, ApiMethod.Upload, null, syncContext)
 {
     this.FileName = fileName;
     this.Progress = progress;
     this.OverwriteOption = option;
 }

 private void btnListAllFiles_Click(object sender, RoutedEventArgs e)
 {
     try
     {
         LiveConnectClient liveClient = new LiveConnectClient(Properties.session);
         liveClient.GetCompleted += this.ConnectClient_GetCompleted;
         liveClient.GetAsync("me/skydrive/files");
     }
     catch (LiveConnectException exception)
     {
         txtTestBox.Text = "Error getting folder info: " + exception.Message;
     }
 }

 /// <summary>
 /// This class implements the upload operation on Windows 8 using the background uploader.
 /// </summary>
 /// <remarks>This constructor is used when uploading a stream created by the application.</remarks>
 public TailoredUploadOperation(
     LiveConnectClient client,
     Uri url,
     string fileName,
     IInputStream inputStream,
     OverwriteOption option,
     IProgress<LiveOperationProgress> progress,
     SynchronizationContextWrapper syncContext)
     : this(client, url, fileName, option, progress, syncContext)
 {
     Debug.Assert(inputStream != null, "inputStream is null.");
     this.InputStream = inputStream;
 }

        /// <summary>
        /// This class implements the upload operation on Windows 8 using the background uploader.
        /// </summary>
        /// <remarks>This constructor is used when uploading a stream created by the application.</remarks>
        public CreateBackgroundUploadOperation(
            LiveConnectClient client,
            Uri url,
            string fileName,
            IInputStream inputStream,
            OverwriteOption option)
            : base(client, url, ApiMethod.Upload, null, null)
        {
            Debug.Assert(inputStream != null, "inputStream is null.");

            this.InputStream = inputStream;
            this.FileName = fileName;
            this.OverwriteOption = option;
        }

        public static bool DeleteFile(string guid)
        {
            validateSession();
            try
            {
                guidToDeleteQueue.Enqueue(guid);
                LiveConnectClient client = new LiveConnectClient(Properties.session);
                client.GetCompleted += DeleteFileHelper;
                client.GetAsync(SkyDrive.Properties.UltiDriveFolderID + "/files");

                return true;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return false;
            }
        }