C# 移动服务中的Azure Blob服务在未从Visual Studio运行应用程序时停止工作

我正在使用Azure移动服务开发一个应用程序，它可以在不同的设备上上传和下载blob

我使用的是SAS模型，我删除它是因为我根本不关心安全性，只对“粗略地”做事感兴趣（我相信我会因此受到很多批评，但希望你仍然能理解我的其余问题）

因此，我基本上是直接使用帐户名和密钥设置一个

CloudBlobClient

。然后我设置容器（在上载blob时，我会执行

CreateIfNotExists

），并最终运行

UploadFromStreamAsync

或

DownloadToStreamAsync

）

现在，在我从PC上拔下USB电缆之前，一切都很好。如果我从Visual Studio（发行版和调试版）运行它，它运行得很好。如果我拔下电缆并试着运行它，它不会。如果我首先使用XapDeply（Debug和Release-Xap）部署它也不起作用

经过大量调试（因为它在调试器上运行良好，我不得不将所有内容打印到日志文件中），我意识到Azure上的

InsertAsync

和其他类似操作（使用表）运行良好。但这三种方法提到：

CreateIfNotExists

，

uploadfromstreeamasync

和

DownloadToStreamAsync

这些措施不起作用，并导致：

Exception.Type : System.ArgumentOutOfRangeException
Exception.InnerException : 
Exception.Exception Message : The argument 'ParallelOperationThreadCount' is larger than maximum of '64'
Parameter name: ParallelOperationThreadCount
at Microsoft.WindowsAzure.Storage.Core.Util.CommonUtility.AssertInBounds[T](String paramName, T val, T min, T max)
   at Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions.set_ParallelOperationThreadCount(Nullable`1 value)
   at Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions.ApplyDefaults(BlobRequestOptions options, BlobType blobType, CloudBlobClient serviceClient, Boolean applyExpiry)
   at Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.BeginCreateIfNotExists(BlobContainerPublicAccessType accessType, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, Object state)
   at Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.BeginCreateIfNotExists(AsyncCallback callback, Object state)
   at Microsoft.WindowsAzure.Storage.Core.Util.AsyncExtensions.TaskFromApm[TResult](Func`3 beginMethod, Func`2 endMethod, CancellationToken cancellationToken)
   at Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.CreateIfNotExistsAsync(CancellationToken cancellationToken)
   at Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.CreateIfNotExistsAsync()
   at AzureLink.AzureServices.BlobUpload.<SetContainer>d__1.MoveNext()

Exception.Type:System.ArgumentOutOfRangeException
Exception.InnerException：
异常。异常消息：参数“ParallelOperationThreadCount”大于最大值“64”
参数名称：ParallelOperationThreadCount
在Microsoft.WindowsAzure.Storage.Core.Util.CommonUtility.AssertInBounds[T]（字符串参数名，T val，T min，T max）
在Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions.set_ParallelOperationThreadCount上（可为null的`1值）
位于Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions.ApplyDefaults（BlobRequestOptions选项、BlobType BlobType、CloudBlobClient服务客户端、布尔applyExpiry）
位于Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.BegIncremateIfNotExists（BlobContainerPublicAccessType访问类型、BlobRequestStoptions选项、OperationContext操作上下文、异步回调、对象状态）
位于Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.BegIncremateIfNotexists（异步回调，对象状态）
在Microsoft.WindowsAzure.Storage.Core.Util.AsyncExtensions.TaskFromApm[TResult]（Func`3 beginMethod，Func`2 endMethod，CancellationToken CancellationToken）
在Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.CreateIfNotExistsAsSync（CancellationToken CancellationToken）
在Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer.CreateIfNotExistsAsync（）上
在AzureLink.AzureServices.BlobUpload.d_u1.MoveNext（）中

在过去的几个小时里，我一直被这个问题困扰着，我非常非常不明白，我唯一想到的是，也许它绝对需要SAS认证。这意味着我做事的方式有了很大的改变，也许这是唯一的解决办法。但我仍然很好奇，为什么它在连接到VisualStudio时会工作，一旦它没有从VisualStudio运行，就会立即停止

我肯定我遗漏了一些东西，我真的很想理解这一点，谢谢你的耐心，如果你想要更多的日志文件或代码或其他东西，请告诉我。我没有粘贴所有的代码，因为问题似乎更多的是连接到VS与否的区别，以及为什么这些Azure函数在一种情况下工作得很好，而不是在另一种情况下

编辑：添加我的BlobUpload类（很抱歉，它的长度有点太长，但我试图隔离问题）也很抱歉延迟，在低连接区域工作：

class BlobUpload
{
    private String ResourceName;
    private String ContainerName;

    private const string endpoint = "https://[svname].blob.core.windows.net";
    private const string accountKey = "key==";
    private const string accountName = "[svname]";

    public FarmerBlobUpload(String resourceName, String containerName)
    {
        ResourceName = resourceName;
        ContainerName = containerName;
    }

    private CloudBlobClient blobClient = null;
    private CloudBlobContainer container = null;
    private CloudBlockBlob blob = null;

    private bool SetClient()
    {
        try
        {
            blobClient = new CloudBlobClient(
                new Uri(string.Format(endpoint)),
                new StorageCredentials(accountName, accountKey));
            return true;
        }
        catch (Exception e)
        {
            PersonalLogger.WriteLine("Upload: SetClient - Exception : " + e.StackTrace);
            return false;
        }
    }

    private async Task<bool> SetContainer()
    {
        if (blobClient == null)
            if (!SetClient())
                return false;

        try
        {
            container = blobClient.GetContainerReference(ContainerName.ToLower());
            PersonalLogger.WriteLine("Upload: CreateIfNotExistsAsync");
            await container.CreateIfNotExistsAsync();
            PersonalLogger.WriteLine("Upload: SetPermissionsAsync");
            await container.SetPermissionsAsync(new BlobContainerPermissions
            {
                PublicAccess = BlobContainerPublicAccessType.Container
            });
            return true;
        }
        catch (Exception e)
        {
            PersonalLogger.WriteLine("Upload: SetContainer - Exception TYPE : " + e.GetType());
            PersonalLogger.WriteLine("Upload: SetContainer - Exception InnerException : " + e.InnerException);
            PersonalLogger.WriteLine("Upload: SetContainer - Exception Message : " + e.Message);
            PersonalLogger.WriteLine("Upload: SetContainer - Exception StackTrace : " + e.StackTrace);
            return false;
        }
    }

    private async Task<bool> SetBlockBlob()
    {
        if (container == null)
            if (!(await SetContainer()))
                return false;

        try
        {
            blob = container.GetBlockBlobReference(ResourceName);
            return true;
        }
        catch (Exception e)
        {
            PersonalLogger.WriteLine("Upload: SetBlockBlob - Exception : " + e.StackTrace);
            return false;
        }
    }

    private async Task<bool> UploadFile(IsolatedStorageFile isoStore)
    {
        if (blob == null)
            if (!(await SetBlockBlob()))
                return false;

        try
        {
            IsolatedStorageFileStream isfs = isoStore.OpenFile(ResourceName, FileMode.Open, FileAccess.Read);
            bool xx = await blob.ExistsAsync();
            if (!xx)
            {
                await blob.UploadFromStreamAsync(isfs);
            }
            return true;
        }
        catch (Exception e)
        {
            PersonalLogger.WriteLine("Upload: UploadFile - Exception TYPE : " + e.GetType());
            PersonalLogger.WriteLine("Upload: UploadFile - Exception InnerException : " + e.InnerException);
            PersonalLogger.WriteLine("Upload: UploadFile - Exception Message : " + e.Message);
            PersonalLogger.WriteLine("Upload: UploadFile - Exception StackTrace : " + e.StackTrace);
            return false;
        }
    }

    public async Task<bool> UploadBlob()
    {
        try
        {
            using (var isoStore = IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (isoStore.FileExists(ResourceName))
                {
                    bool res = await UploadFile(isoStore);
                    return res;
                }
                else
                {
                    return true;
                }
            }
        }
        catch (Exception e)
        {
            PersonalLogger.WriteLine("Upload: UploadBlob - Failure : " + ResourceName + " - " + e.StackTrace);
            return false;
        }
    }
}

class BlobUpload
{
私有字符串ResourceName；
私有字符串容器名称；
private const string endpoint=“https://[svname].blob.core.windows.net”；
私有常量字符串accountKey=“key==”；
私有常量字符串accountName=“[svname]”；
公共FarmerBlobUpload（字符串resourceName、字符串containerName）
{
ResourceName=ResourceName；
容器名称=容器名称；
}
私有CloudBlobClient blobClient=null；
私有CloudBlobContainer容器=null；
私有CloudBlockBlob blob=null；
私有boolsetclient（）
{
尝试
{
blobClient=新的CloudBlobClient(
新Uri（string.Format（endpoint）），
新的存储凭据（accountName、accountKey））；
返回true；
}
捕获（例外e）
{
WriteLine（“上传：SetClient-异常：+e.StackTrace”）；
返回false；
}
}
专用异步任务SetContainer（）
{
if（blobClient==null）
如果（！SetClient（））
返回false；
尝试
{
container=blobClient.GetContainerReference（ContainerName.ToLower（））；
WriteLine（“上传：CreateIfNotExistsAsync”）；
wait container.CreateIfNotExistsAsync（）；
WriteLine（“上传：SetPermissionsAsync”）；
等待容器.SetPermissionsAsync（新BlobContainerPermissions
{
PublicAccess=BlobContainerPublicAccessType.Container
});
返回true；
}
捕获（例外e）
{
WriteLine（“上传：SetContainer-异常类型：+e.GetType（））；
WriteLine（“上传：SetContainer-Exception-InnerException:+e.InnerException”）；
WriteLine（“上传：SetContainer-异常消息：”+e.Message）；
WriteLine（“上传：SetContainer-异常堆栈