I am using await Task.Delay(10); in unity C# for delay .After build and run in Web-GL format .The execution stops at this line that has delay .When I remove the delay it executes. This is function where delay is to be used.

 public async Task ObjSupport_PositionArrivedAsync(string Coordinate, double Value)
{
    XAxis = GameObject.Find("X-Axis");
    ZAxis = GameObject.Find("Z-Axis");
   switch (Coordinate)
    {
        case "X-":
            {
               //code for case X-
            }
            break;
        case "X ":
            {
                   Value = Value - 100; //Total cube - x value
                    float izvalue = (float)Value;
                    izvalue = izvalue * 0.001f;
                    Debug.Log(izvalue);
                    Vector3 XAxisposition = XAxis.transform.localPosition; //get head position
                    float XAxiscurrentXpos = XAxisposition.x;
                    if (XAxiscurrentXpos <= -izvalue)
                    {

                        Debug.Log("XAxisSmaller");


                        while (XAxiscurrentXpos <= -izvalue)
                        {
                            await Task.Delay(1);
                            XAxiscurrentXpos  = 0.001f;
                            Vector3 posx = new Vector3(XAxiscurrentXpos, XAxisposition.y, XAxisposition.z);
                        XAxis.transform.localPosition = posx;
                     
                    }

                    }
                    else
                    {
                        if (XAxiscurrentXpos > -izvalue)
                        {
                            Debug.Log("XAxisGreater");
                            while (XAxiscurrentXpos >= -izvalue)
                            {

                                await Task.Delay(0);
                                XAxiscurrentXpos -= 0.001f;
                                Vector3 posX = new Vector3(XAxiscurrentXpos, XAxisposition.y, XAxisposition.z);
                             XAxis.transform.localPosition = posX;
                           
                        }
                        }
                    }
                }
         break;
case "Z ":
            { //code for Z  axis }
break;
}
}

And the following is code from where the above function is called.

  public async void ExecuteFile()
   {          
    string lGMCode;
    /// aList is a ArrayList object and fill in
    /// ValidateFile function.
    for (int i = 0; i < aList.Count; i  )
    {
          lGMCode = aList[i].ToString();
            if (lGMCode.StartsWith("X"))
            {
              XValue = Convert.ToDouble(lGMCode.Substring(1, lGMCode.Length - 1));
              if (XValue<0)
                    {
                      await arr.ObjSupport_PositionArrivedAsync("X-",  XValue); 
                    }
                    else
                    {
                       
                            await arr.ObjSupport_PositionArrivedAsync("X ", XValue );
                      
                    } 
          if (lGMCode.StartsWith("Z"))
            { //code for Z
      }}

Now this is all I am doing .I work fine in windows but when i build it in WEbGl format then it causes problem and stops execution on delay line. Now Kindly suggest me solution.

CodePudding user response：

So now knowing what you are actually trying to do instead of your task at all you rather want to use e.g.

public class MoveObject : MonoBehaviour
{
    public Transform XAxis;
    public float desiredUnitsPerSecond;

    // This is called once a frame by Unity
    private void Update()
    {
        if(XAxis.localPosition.x <= -izvalue)
        { 
            XAxis.localPosition  = Vector3.right * desiredUnitsPerSecond * Time.deltaTime;
        }
    }
}

this moves your object with the linear speed of desiredUnitsPerSecond in its local right direction as long as it is left of -izvalue.

CodePudding user response：

Abstract
Task.delay involves threads. WebGl doesn't really support threading in that manner. Although the DOM interface contains many async features which are used by websites constantly which can be seen as a form of multithreading, WebGl doesn't support that. So anything regarding multithreading should not be used within WebGl.

Explanation
WebGl runs on a single thread mainly because threads in JavaScript generally have a lack of support which means that they can't be a stable feature within WebGl.

Link to unity overview of why webGl doesn't support multithreading