Android 从尚未从AsyncTask调用的回调调用PublishProgress（）

经过三年的阅读，这是我在这里的第一篇文章。从来没有必要写一本。这是一个非常好的网站

---

我想扩展本机的

AsyncTask

类，以支持从

RunInBackground（）

、

OnProgressUpdate（）

、

OnPreExecute（）

和

OnPostExecute（）

调用的回调。因此，我不需要为每个任务实现一个新的

AsyncTask

子体

（我必须提到，在

Java

中有一个名为

DoInBackground（）

的方法，它也存在于Xamarin端口中。但是文档中说要重写

RunInBackground（）

）

目标是安装

AsyncTask

子体，设置所需的回调并执行

AsyncTask

现在的问题是，我需要从活动中的回调内部调用

PublishProgress（）

，以对进度状态的变化做出反应。因此，我必须将此方法的单独回调传递到

RunInBackground（）

的回调中。但当我这样做时，会抛出一个异常

System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. ---> System.Exception: Object reference not set to an instance of an object System.Reflection.TargetInvocationException： 调用的目标已引发异常。 --->系统。例外情况： 对象引用未设置为对象的实例 但我不能处理这个问题，因为我不知道应该使用哪一个引用。调试表明回调正确传递

活动：Main.cs

使用AsyncSpecial=AsyncTaskEnhanced；
[活动（Label=“FooBar”，MainLauncher=true）]
公共课主要内容：活动
{
受保护的Int32 RunInBackground（AsyncSpecial.PublishProgressDelegate publishProgressCallback，参数字符串[]参数）
{
for（Int32 n=0；n（Resource.Id.btnOne）；
按钮。单击+=（对象发送者，事件参数EventArgs）=>
{
AsyncSpecial asyncTask=新的AsyncSpecial（）；
asyncTask.RunInBackgroundCallback=this.RunInBackground；
asyncTask.OnProgressUpdateCallback=this.OnProgressUpdate；
asyncTask.OnPreExecuteCallback=this.OnPreExecute；
asyncTask.OnPostExecuteCallback=this.OnPostExecute；
asyncTask.Execute（“ItemOne”、“ItemTwo”）；
};
}
}

类：AsyncTaskEnhanced.cs

公共类AsyncTaskEnhanced：AsyncTask
{
public delegate void PublishProgressDelegate（参数TProgress[]progress）；
公共委托TResult RunInBackgroundDelegate（PublishProgressDelegate publishProgressCallback，参数target[]参数）；
public delegate void OnProgressUpdateDelegate（TProgress progress）；
public delegate void OnPreExecuteDelegate（）；
PostExecutedElegate上的公共委托无效（TResult结果）；
private PublishProgressDelegate publishProgressCallback=null；
公共PublishProgressDelegate PublishProgressCallback
{ 
得到
{
返回此.publishProgressCallback；
}
设置
{
this.publishProgressCallback=值；
}
}
私有RunInBackgroundDelegate runInBackgroundCallback=null；
公共RunInBackgroundDelegate RunInBackgroundCallback
{ 
得到
{
返回此.runInBackgroundCallback；
}
设置
{
this.runInBackgroundCallback=值；
}
}
private OnProgressUpdateLegate onProgressUpdateCallback=null；
公共OnProgressUpdateLegate OnProgressUpdateCallback
{ 
得到
{
返回此.onProgressUpdateCallback；
}
设置
{
this.onProgressUpdateCallback=值；
}
}
private OnPreExecuteDelegate onPreExecuteCallback=null；
公共OnPreExecuteDelegate OnPreExecuteCallback
{ 
得到
{
返回此.onPreExecuteCallback；
}
设置
{
this.onPreExecuteCallback=值；
}
}
private OnPostExecuteElegate onPostExecuteCallback=null；
public OnPostExecuteElegate OnPostExecuteCallback
{ 
得到
{
返回此.onPostExecuteCallback；
}
设置
{
this.onPostExecuteCallback=值；
}
}
public AsyncTaskEnhanced（IntPtr doNotUse，JniHandleOwnership transfer）：基本（doNotUse，transfer）
{
this.PublishProgressCallback=this.PublishProgress；
}
公共AsyncTaskEnhanced（）：基（）
{
}
受保护的重写TResult RunInBackground（参数targetment[]参数）
{
TResult result=DelegateHelper.Invoke（this.RunInBackgroundCallback，this.PublishProgressCallback，arguments）；
返回结果；
}
受保护的void OnProgressUpdate（TProgress progress）
{
DelegateHelper.Invoke（this.OnProgressUpdateCallback，progress）；
}
受保护的覆盖无效OnPreExecute（）
{
DelegateHelper.Invoke（this.OnPreExecuteCallback）；
}
受保护的重写void OnPostExecute（TResult结果）
{
DelegateHelper.Invoke（this.OnPostExecuteCallback，result）；
}
}

类：DelegateHelper.cs

静态公共类DelegateHelper
{
静态公共void调用（委托回调，参数对象[]参数）
{
if（null！=回调）
{
回电，发电机
System.Exception:
Failed to convert parameters.
using System;

namespace Library
{
  static public class HDelegate
  {
    #region Methods

    static public void Invoke( Delegate callback, params Object[ ] arguments )
    {
      if ( null != callback )
      {
        callback.DynamicInvoke( arguments );
      }
    }

    static public TResult Invoke< TResult >( Delegate callback, params Object[ ] arguments )
    {
      TResult result = default( TResult );
      if ( null != callback )
      {
        result = ( TResult ) callback.DynamicInvoke( arguments );
      }
      return result;
    }

    #endregion
  }
}

using System;
using System.Threading;

namespace Library.Threading
{
  public class CallbackThread< TArgument, TProgress, TResult >
  {
    #region Delegates

    public delegate void PublishProgressDelegate( params TProgress[ ] progresses );
    public delegate TResult DoInBackgroundDelegate( PublishProgressDelegate publishProgressCallback, params TArgument[ ] arguments );
    public delegate void ProgressUpdateDelegate( TProgress progress );
    public delegate void PreExecuteDelegate( );
    public delegate void PostExecuteDelegate( TResult result );

    #endregion

    #region Properties

    private PublishProgressDelegate publishProgressCallback = null;
    protected virtual PublishProgressDelegate PublishProgressCallback
    { 
      get
      {
        return this.publishProgressCallback; 
      }
      set
      {
        this.publishProgressCallback = value; 
      }
    }

    private DoInBackgroundDelegate doInBackgroundCallback = null;
    public virtual DoInBackgroundDelegate DoInBackgroundCallback
    { 
      get
      {
        return this.doInBackgroundCallback; 
      }
      set
      {
        this.doInBackgroundCallback = value; 
      }
    }

    private ProgressUpdateDelegate progressUpdateCallback = null;
    public virtual ProgressUpdateDelegate ProgressUpdateCallback
    { 
      get
      {
        return this.progressUpdateCallback; 
      }
      set
      {
        this.progressUpdateCallback = value; 
      }
    }

    private PreExecuteDelegate preExecuteCallback = null;
    public virtual PreExecuteDelegate PreExecuteCallback
    { 
      get
      {
        return this.preExecuteCallback; 
      }
      set
      {
        this.preExecuteCallback = value; 
      }
    }

    private PostExecuteDelegate postExecuteCallback = null;
    public virtual PostExecuteDelegate PostExecuteCallback
    { 
      get
      {
        return this.postExecuteCallback; 
      }
      set
      {
        this.postExecuteCallback = value; 
      }
    }

    #endregion

    #region Constructors

    public CallbackThread( )
    {
      this.PublishProgressCallback = this.PublishProgress;
    }

    #endregion

    #region Methods

    protected virtual void PreExecute( )
    {
      HDelegate.Invoke( this.PreExecuteCallback );
    }

    protected virtual TResult DoInBackground( params TArgument[ ] arguments )
    {
      TResult result = HDelegate.Invoke< TResult >( this.DoInBackgroundCallback, this.PublishProgressCallback, arguments );
      return result;
    }

    protected virtual void PublishProgress( params TProgress[ ] progresses )
    {
      foreach ( TProgress progress in progresses )
      {
        this.ProgressUpdate( progress );
      }
    }

    protected virtual void ProgressUpdate( TProgress progress )
    {
      HDelegate.Invoke( this.ProgressUpdateCallback, progress );
    }

    protected virtual void PostExecute( TResult result )
    {
      HDelegate.Invoke( this.PostExecuteCallback, result );
    }

    public virtual void Execute( params TArgument[ ] arguments )
    {
      Thread thread = new Thread(( ) =>
      {
        this.PreExecute( );
        TResult result = this.DoInBackground( arguments );
        this.PostExecute( result );
      } );
      thread.Start( );
    }

    #endregion
  }
}