如何在具有返回类型的方法中调用异步方法？

Question

This is windows phone 8.1 silverlight app. I have a file association. For that I have a class as

class AssociationUriMapper : UriMapperBase
{
    public override Uri MapUri(Uri uri)
    {
       //here I'm getting file ID etc..
    }

    // here I want to read the file content & determine the file type because,
    // the case is, even same file extension can contain different type of data

    switch (fileType)
    {
       //here I'm calling appropriate page according to type
    }
}

Now the problem is MapUri is overridden method so it must have a return type. while, OpenStreamForReadAsync() is a async method. I tried Wait() method, creating new task & then calling Start(), Wait() in it but no success. Currently my code is,

class AssociationUriMapper : UriMapperBase
{
    string strData = "";
    public override Uri MapUri(Uri uri)
    {
        strUri = uri.ToString();

        // File association launch
        if (strUri.Contains("/FileTypeAssociation"))
        {
            // Get the file ID (after "fileToken=").
            int nFileIDIndex = strUri.IndexOf("fileToken=") + 10;
            string strFileID = strUri.Substring(nFileIDIndex);

            string strFileName = SharedStorageAccessManager.GetSharedFileName(strFileID);
            string strIncomingFileType = Path.GetExtension(strFileName);

            fnCopyToLocalFolderAndReadContents(strFileID);

            switch (fileType)
            {
                case ".gmm":
                       //determine if gmm is text
                       if (objGMM.fnGetGMMType() == GMMFILETYPE.TXT)
                       {
                           return new Uri("/PageReadText.xaml?data=" + strData, UriKind.Relative);
                       }
                       break;
             }
        }
  }

  async void fnCopyToLocalFolderAndReadContents(string strIncomingFileId)
  {
     StorageFolder objLocalFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
     objFile = await SharedStorageAccessManager.CopySharedFileAsync(objLocalFolder, TEMP.gmm, NameCollisionOption.ReplaceExisting, strIncomingFileId);

     using (StreamReader streamReader = new StreamReader(objFile))
     {
        strData = streamReader.ReadToEnd();
     }
  }
}

Answer 1

The first thing I'd do is change the logic. When the OS asks your app whether it supports a Uri mapping, it's expecting an immediate answer; it's not expecting the app to copy and read files. Usually, Uri mappings are very constant; an app either always supports one or it does not.

So, the first thing I would try to do is load all the mapping files at startup and then create the AssociationUriMapper with all the results. If this isn't possible, then you're almost certainly using Uri mappings for the wrong thing. They're not supposed to be dynamic, and it is quite possible that the OS will assume that they're not dynamic.

That said, if you want to get it working, I think the cleanest solution would be to push the asynchronous file operations to another thread and then block on that:

public override Uri MapUri(Uri uri)
{
  strUri = uri.ToString();

  // File association launch
  if (strUri.Contains("/FileTypeAssociation"))
  {
    // Get the file ID (after "fileToken=").
    int nFileIDIndex = strUri.IndexOf("fileToken=") + 10;
    string strFileID = strUri.Substring(nFileIDIndex);

    string strFileName = SharedStorageAccessManager.GetSharedFileName(strFileID);
    string strIncomingFileType = Path.GetExtension(strFileName);

    var strData = Task.Run(() => CopyToLocalFolderAndReadContents(strFileID)).GetAwaiter().GetResult();

    switch (fileType)
    {
      case ".gmm":
        //determine if gmm is text
        if (objGMM.fnGetGMMType() == GMMFILETYPE.TXT)
        {
          return new Uri("/PageReadText.xaml?data=" + strData, UriKind.Relative);
        }
        break;
    }
  }
}

async Task<string> CopyToLocalFolderAndReadContentsAsync(string strIncomingFileId)
{
  StorageFolder objLocalFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
  objFile = await SharedStorageAccessManager.CopySharedFileAsync(objLocalFolder, TEMP.gmm, NameCollisionOption.ReplaceExisting, strIncomingFileId);

  using (StreamReader streamReader = new StreamReader(objFile))
  {
    return streamReader.ReadToEnd();
  }
}

Answer 2

I don't like it much, because it involves code that calls an async method synchronously. But the following should work:

class AssociationUriMapper : UriMapperBase
{
    public override Uri MapUri(Uri uri)
    {
        strUri = uri.ToString();

        // File association launch
        if (strUri.Contains("/FileTypeAssociation"))
        {
            // Get the file ID (after "fileToken=").
            int nFileIDIndex = strUri.IndexOf("fileToken=") + 10;
            string strFileID = strUri.Substring(nFileIDIndex);

            string strFileName = SharedStorageAccessManager.GetSharedFileName(strFileID);
            string strIncomingFileType = Path.GetExtension(strFileName);

            string strData = fnCopyToLocalFolderAndReadContents(strFileID).Result;

            switch (fileType)
            {
                case ".gmm":
                       //determine if gmm is text
                       if (objGMM.fnGetGMMType() == GMMFILETYPE.TXT)
                       {
                           return new Uri("/PageReadText.xaml?data=" + strData, UriKind.Relative);
                       }
                       break;
             }
        }
  }

  async Task<string> fnCopyToLocalFolderAndReadContents(string strIncomingFileId)
  {
     StorageFolder objLocalFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
     objFile = await SharedStorageAccessManager.CopySharedFileAsync(objLocalFolder, TEMP.gmm, NameCollisionOption.ReplaceExisting, strIncomingFileId).ConfigureAwait(false);

     using (StreamReader streamReader = new StreamReader(objFile))
     {
        return streamReader.ReadToEnd();
     }
  }
}

For me, a bigger question is why would you implement a method like MapUri() such that it requires calls to asynchronous methods, and involves this kind of potentially time-consuming I/O. I mean, maybe that is in fact required here, but it just seems a bit off. Unfortunately, there's not enough context in the question for me to feel like I can offer other alternatives.

Answer 3

Unfortunately, there is no "pretty way" of overriding non-async methods.

The best you can do is make sure you add ConfigureAwait(false) to your async calls to make sure the SynchronizationContext doesn't flow and deadlock, and then access the Result property of the returned Task .

What i would do is change the method that reads the file to return a Task<string> :

async Task<string> CopyToLocalFolderAndReadContents(string strIncomingFileId)
{
    StorageFolder objLocalFolder = Windows.Storage.ApplicationData.Current
                                                                  .LocalFolder;
    objFile = await SharedStorageAccessManager
                   .CopySharedFileAsync(objLocalFolder, TEMP.gmm, 
                                        NameCollisionOption.ReplaceExisting, 
                                        strIncomingFileId)
                   .AsTask().ConfigureAwait(false);

    using (StreamReader streamReader = new StreamReader
          (await objFile.OpenStreamForReadAsync().ConfigureAwait(false)))
    {
        return await streamReader.ReadToEndAsync().ConfigureAwait(false);
    }
}

And then change the call site to:

string data = CopyToLocalFolderAndReadContents(strFileID).Result;