Tasks on the other hand are a higher-level .NET abstraction that basically represents a promise of a separate work, that’ll be completed in future. For example, a Task<T> is nothing but a task that comes with the promise of returning a value of type T when the task completes. They are compositional in nature, capable of returning values and being chained (at any amount) by using task continuations. They are also capable of using the Thread Pool and extremely handy for being used for I/O bound operations. 

Tasks on the other hand are a higher-level .NET abstraction that basically represents a promise of a separate work, that’ll be completed in future. For example, a Task<T> is nothing but a task that comes with the promise of returning a value of type T when the task completes. They are compositional in nature, capable of returning values and being chained (at any amount) by using task continuations. They are also capable of using the Thread Pool and extremely handy for being used for I/O bound operations. 

        private struct Rigidbody2DData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            public Rigidbody2D Rigidbody2d;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector2 Velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public float AngularVelocity;

        private struct Rigidbody2DData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            public Rigidbody2D Rigidbody2d;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector2 Velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public float AngularVelocity;

        private struct RigidbodyData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            public Rigidbody Rigidbody;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector3 Velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector3 AngularVelocity;

            public RigidbodyData(Rigidbody rigidbody)
            {
                Rigidbody = rigidbody;
                Rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
                Velocity = Vector3.zero;
                AngularVelocity = Vector3.zero;
            }
        }

        private struct RigidbodyData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            public Rigidbody Rigidbody;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector3 Velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            public Vector3 AngularVelocity;

            public RigidbodyData(Rigidbody rigidbody)
            {
                Rigidbody = rigidbody;
                Rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
                Velocity = Vector3.zero;
                AngularVelocity = Vector3.zero;
            }
        }

               for (int i = 0; i < _rigidbodyDatas.Count; i++)
                {
                    if (!SetIsKinematic(isKinematic, i))
                    {
                        _rigidbodyDatas.RemoveAt(i);
                        i--;
                    }
                }

                //Sets isKinematic status and returns if successful.
                bool SetIsKinematic(bool isZKinematic, int index)
                {
                    RigidbodyData rbData = _rigidbodyDatas[index];
                    Rigidbody rb = rbData.Rigidbody;
                    if (rb == null)
                        return false;

                    if (isZKinematic)
                    {
                        rbData.Velocity = rb.velocity;
                        rbData.AngularVelocity = rb.angularVelocity;
                        rb.isKinematic = true;

                        //Update data.
                        _rigidbodyDatas[index] = rbData;
                    }
                    else
                    {
                        rb.isKinematic = false;
                        rb.AddForce(rbData.Velocity, ForceMode.Impulse);
                        rb.AddTorque(rbData.AngularVelocity, ForceMode.Impulse);
                    }

                    return true;
                }

               for (int i = 0; i < _rigidbodyDatas.Count; i++)
                {
                    if (!SetIsKinematic(isKinematic, i))
                    {
                        _rigidbodyDatas.RemoveAt(i);
                        i--;
                    }
                }

                //Sets isKinematic status and returns if successful.
                bool SetIsKinematic(bool isZKinematic, int index)
                {
                    RigidbodyData rbData = _rigidbodyDatas[index];
                    Rigidbody rb = rbData.Rigidbody;
                    if (rb == null)
                        return false;

                    if (isZKinematic)
                    {
                        rbData.Velocity = rb.velocity;
                        rbData.AngularVelocity = rb.angularVelocity;
                        rb.isKinematic = true;

                        //Update data.
                        _rigidbodyDatas[index] = rbData;
                    }
                    else
                    {
                        rb.isKinematic = false;
                        rb.AddForce(rbData.Velocity, ForceMode.Impulse);
                        rb.AddTorque(rbData.AngularVelocity, ForceMode.Impulse);
                    }

                    return true;
                }

    public class RigidbodyPauser
    {
        #region Types.
        /// <summary>
        /// Data for a rigidbody before being set kinematic.
        /// </summary>
        private struct RigidbodyData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            private Rigidbody _rigidbody;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            private Vector3 _velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            private Vector3 _angularVelocity;

            public RigidbodyData(Rigidbody rigidbody)
            {
                _rigidbody = rigidbody;
                _rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
                _velocity = Vector3.zero;
                _angularVelocity = Vector3.zero;
            }

            /// <summary>
            /// Sets isKinematic status and returns if successful.
            /// </summary>
            public bool SetIsKinematic(bool isKinematic)
            {
                if (_rigidbody == null)
                    return false;

                if (isKinematic)
                {
                    _velocity = _rigidbody.velocity;
                    //_VELOCITY was being set to the wrong object hashcode if it contained anything other than Vector3.zero.
                    _angularVelocity = _rigidbody.angularVelocity;
                    _rigidbody.isKinematic = true;
                }
                else
                {
                    _rigidbody.isKinematic = false;
                    _rigidbody.AddForce(_velocity, ForceMode.Impulse);
                    _rigidbody.AddTorque(_angularVelocity, ForceMode.Impulse);
                }

                return true;
            }
        }

    public class RigidbodyPauser
    {
        #region Types.
        /// <summary>
        /// Data for a rigidbody before being set kinematic.
        /// </summary>
        private struct RigidbodyData
        {
            /// <summary>
            /// Rigidbody for data.
            /// </summary>
            private Rigidbody _rigidbody;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            private Vector3 _velocity;
            /// <summary>
            /// Cached velocity when being set kinematic.
            /// </summary>
            private Vector3 _angularVelocity;

            public RigidbodyData(Rigidbody rigidbody)
            {
                _rigidbody = rigidbody;
                _rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
                _velocity = Vector3.zero;
                _angularVelocity = Vector3.zero;
            }

            /// <summary>
            /// Sets isKinematic status and returns if successful.
            /// </summary>
            public bool SetIsKinematic(bool isKinematic)
            {
                if (_rigidbody == null)
                    return false;

                if (isKinematic)
                {
                    _velocity = _rigidbody.velocity;
                    //_VELOCITY was being set to the wrong object hashcode if it contained anything other than Vector3.zero.
                    _angularVelocity = _rigidbody.angularVelocity;
                    _rigidbody.isKinematic = true;
                }
                else
                {
                    _rigidbody.isKinematic = false;
                    _rigidbody.AddForce(_velocity, ForceMode.Impulse);
                    _rigidbody.AddTorque(_angularVelocity, ForceMode.Impulse);
                }

                return true;
            }
        }