Cast<Transform>()は何をしているか。

Question

前提・実現したいこと

子オブジェクトの一括削除を調べていて、こちらのサイトを見たのですが、

 go.transform.Cast<Transform>().ToList().ForEach(x => { x.parent = null; GameObject.Destroy(x.gameObject);} 

このコードのCast<Transform>()って何をしているかご教示いただけませんか？

試したこと

キャストが型変換なのはわかっています。
例えば、int型の数をキャストして文字列に変換できるという使い方があることを知っています。

ただ、「transform.Cast<Transform>()」は、「transformをtransformにキャスト？」しているのでしょうか？
「何をしているかわかっていない」ので、「何故、この処理が必要か」ということもわかりません。

また、「unity cast」で検索すると、Collider2Dのキャストしか引っ掛かってこないのですが、Cast<Transform>()のCastのリファレンスってあるのでしょうか？

余談ですが、ForEach内の「x.parent = null;」の処理って必要ですか？
ゲームを実行したら、なくても子オブジェクトが破棄できているような挙動をしました。

Answer 1

リファレンスには...

また、以下のようにループを使って子の Transform を使用する列挙体をサポートしています。

としか書かれていませんが、Transformは...

using System;
using System.Collections;
using System.Runtime.CompilerServices;
using UnityEngine.Bindings;
using UnityEngine.Internal;
using UnityEngine.Scripting;

namespace UnityEngine
{
  /// <summary>
  ///   <para>Position, rotation and scale of an object.</para>
  /// </summary>
  [NativeHeader("Configuration/UnityConfigure.h")]
  [NativeHeader("Runtime/Transform/Transform.h")]
  [NativeHeader("Runtime/Transform/ScriptBindings/TransformScriptBindings.h")]
  [RequiredByNativeCode]
  public class Transform : Component, IEnumerable
  {
    // 省略

    public IEnumerator GetEnumerator()
    {
      return (IEnumerator) new Transform.Enumerator(this);
    }

    // 省略

    private class Enumerator : IEnumerator
    {
      private int currentIndex = -1;
      private Transform outer;

      public object Current
      {
        get
        {
          return (object) this.outer.GetChild(this.currentIndex);
        }
      }

      internal Enumerator(Transform outer)
      {
        this.outer = outer;
      }

      public bool MoveNext()
      {
        return ++this.currentIndex < this.outer.childCount;
      }

      public void Reset()
      {
        this.currentIndex = -1;
      }
    }
  }
}

となっており、IEnumerableインターフェイスを実装しています。
ただしこれはジェネリック版のIEnumerable<Transform>ではないため、そのままではLINQの各種メソッドが使えません。
そこでCast<Transform>を使うとIEnumerable<Transform>に変わり、LINQが使えるようになります。もしここで、何らかの条件によって削除するTransformをふるい分けたい...などといった場合には、この後にLINQのメソッドをつなげてやることができるでしょう。
さらにToListでList<Transform>に変えることで、ForEachが使えるようになります。

x.parent = null;については私も最初は不必要じゃないかと思いましたが、ちょっと違いの出てくる状況を思いつきました。
下記のようなコードで、親の切り離しがある場合とない場合を比較してみると...

using System.Collections;
using System.Linq;
using UnityEngine;

public class DeleteChildrenTest : MonoBehaviour
{
    public GameObject TargetA;
    public GameObject TargetB;

    private IEnumerator Start()
    {
        // x.parent = null;がある場合
        Debug.Log("--------Detach parent--------");
        Debug.LogFormat("Child count:{0}", this.TargetA.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetA.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }
        Debug.Log("Destroy!");
        UnityUtil.DestroyChildren_LinQ(this.TargetA);
        Debug.LogFormat("Child count:{0}", this.TargetA.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetA.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }

        // x.parent = null;がない場合
        Debug.Log("--------Keep parent--------");
        Debug.LogFormat("Child count:{0}", this.TargetB.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetB.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }
        Debug.Log("Destroy!");
        DestroyChildrenKeepParent(this.TargetB);
        Debug.LogFormat("Child count:{0}", this.TargetB.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetB.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }

        // 1フレーム待って...
        yield return null;

        // x.parent = null;がある場合
        Debug.Log("--------Detach parent--------");
        Debug.LogFormat("Child count:{0}", this.TargetA.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetA.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }

        // x.parent = null;がない場合
        Debug.Log("--------Keep parent--------");
        Debug.LogFormat("Child count:{0}", this.TargetB.transform.childCount);
        Debug.Log("Children:");
        foreach (Transform t in this.TargetB.transform)
        {
            Debug.LogFormat("\t{0}", t.name);
        }
    }

    private static void DestroyChildrenKeepParent(GameObject go)
    {

        if (go.transform.childCount > 0)
        {
            go.transform.Cast<Transform>().ToList().ForEach(x => { GameObject.Destroy(x.gameObject); });
        }
    }
}

親を切り離さない場合は、1フレーム経ってオブジェクトが削除されるまでは、子のDestroy後でも子を列挙することができました。

Comments

[退会済みユーザー]

ご回答ありがとうございます。
ご提示のドキュメントを拝見しました。
「A.Cast<b>()とすると、AがIEnumerable<b>型に変換される。AがCastを呼び出すには、Aの基底クラスがEnumerableである必要がある。」という認識で合っていますか？

なるほど、そのフレーム内ならば列挙可能ということですね。
Destroy後に、そのフレーム内で取得しようとしない限りは全く問題なさそうですね。
Destroyの次の直後にInstantiateで別のオブジェクトを子として吊るすという処理をしてみましたが、問題なく切り替わっているように見えました。
ただ、万全を期すならば、子オブジェクトは親の切り離しをしてから破棄すると覚えたほうがよいみたいですね。

[Bongo]

だいたいそのような感じでいいと思いますが、「Aの基底クラスがEnumerableである必要がある」という部分に関しては、厳密さを求める人でしたら「『クラスの継承』と『インターフェイスの実装』は区別せよ」と言うかもしれません（参考1）。「AがIEnumerableを実装している必要がある」の方がよさそうな気がします。

実際のところ、Enumerableクラス（参考2）というのはLINQ用のさまざまな拡張メソッド（参考3）を提供するための静的クラス（参考4）でして、Enumerableクラス自体を継承して独自のクラスを作ろうとしてもエラーが出るかと思います。

参考1: https://docs.microsoft.com/ja-jp/dotnet/csharp/programming-guide/interfaces/
参考2: https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable?view=netframework-4.7.2
参考3: https://ufcpp.net/study/csharp/sp3_extension.html
参考4: https://docs.microsoft.com/ja-jp/dotnet/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members

[退会済みユーザー]

ご回答ありがとうございます。
ご提示いただいたURL全て拝見しました。
「拡張メソッド」という言葉は見覚えがありましたが、意味を勘違いしていたので、ご提示いただいたURLでとても勉強になりました。
また、ご指摘ありがとうございます。
「A.Cast<b>()とすると、AがIEnumerable<b>型に変換される。AがCastを呼び出すには、AがIEnumerableを実装している必要がある。AがIEnumerable<b>型に変換されることによって、LINQが使えるようになる」という一連の流れを理解することができました。
ありがとうございました。