C# Component.GetType方法代码示例

		private static void RemovedComponent(Entity e,Component c) 
      	{
        	 Console.WriteLine("This was the component removed: "+(c.GetType()));
			 Bag<Component> tempBag;
			 componentPool.TryGetValue(c.GetType(),out tempBag);
			 Console.WriteLine("Health Component Pool has "+tempBag.Size()+" objects");
			 tempBag.Add(c);
			 componentPool.TryGetValue(c.GetType(),out tempBag);
			 Console.WriteLine("Health Component Pool now has "+tempBag.Size()+" objects");
      	}

    public static Component copyComponent(GameObject target, Component prefabComponent)
    {
        Component c = target.AddComponent(prefabComponent.GetType());
        foreach (FieldInfo info in prefabComponent.GetType().GetFields())
        {
          info.SetValue(c, info.GetValue(prefabComponent));
        }

        return c;
    }

	protected int index; // if the property is multi-valued (e.g., Color, Vector3, ...), index of the value to change 

	// Use this for initialization
	void Start () {

		comp = this.GetComponent (componentName);
		if (!propertyName.Contains ("[")) {  // i.e. the property is a single value, not an array
			property = comp.GetType ().GetProperty (propertyName);
		} else { // we mean to change a single value inside an array-type value
			property = comp.GetType ().GetProperty (propertyName.Substring (0, propertyName.IndexOf ('[')));
			index = System.Int32.Parse (propertyName.Substring (propertyName.IndexOf ('[')+1, 1));
			isMultiValue = true;

		}

	}

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        /// 

        private void RemovedComponent(Entity e,Component c)
        {
            if (c != null)
            {
                pool.AddComponent(c.GetType(), c);
            }
        }

    /// <summary>
    /// Bind the source event to the target event handler
    /// </summary>
    public void Bind()
    {
        if( isBound || DataSource == null )
            return;

        if( !DataSource.IsValid || !DataTarget.IsValid )
        {
            Debug.LogError( string.Format( "Invalid event binding configuration - Source:{0}, Target:{1}", DataSource, DataTarget ) );
            return;
        }

        sourceComponent = DataSource.Component;
        targetComponent = DataTarget.Component;

        var eventHandler = DataTarget.GetMethod();
        if( eventHandler == null )
        {
            Debug.LogError( "Event handler not found: " + targetComponent.GetType().Name + "." + DataTarget.MemberName );
            return;
        }

        if( bindToEventProperty( eventHandler ) )
        {
            isBound = true;
            return;
        }

        if( bindToEventField( eventHandler ) )
        {
            isBound = true;
            return;
        }
    }

        public void Add(Component T)
        {
            bool exists = false;

            for (int i = 0; i < Count; i++)
            {
                if (T.GetType() == this[i].GetType())
                {
                    exists = true;
                    break;
                }
            }

            if (exists == false)
            {
                T.gameObject = gameObject;
                this.List.Add(T);
            }
            else if (T.multiple() == true)
            {
                T.gameObject = gameObject;
                this.List.Add(T);
            }

            gameObject.setComponents();
        }

 private Component copyComponent(Component original, GameObject destination)
 {
     System.Type type = original.GetType();
     Component copy = destination.AddComponent(type);
     if(copy!=null){
         EditorUtility.CopySerialized(original, copy);
     }
     return copy;
 }

	//use the component that contains the RPC function!
	public static void RPC(Component comp, string func, NetRPCMode mode, params object[] paras){
		/*if (UseNet)
			comp.networkView.RPC(func, mode==NetRPCMode.All?RPCMode.All:RPCMode.AllBuffered, paras);
		else*/
		{
			comp.GetType().GetMethod(func).Invoke(comp, paras);
			//gameObject.SendMessage(func, paras);
		}
	}

    // ------------------------------------------------------------------ 
    // Desc: 
    // ------------------------------------------------------------------ 

    static public bool Copy ( Component _src, Component _dest ) {
        if ( _src.GetType() != _dest.GetType() ) {
            Debug.LogWarning ( "the type of src component and dest component are different" );
            return false;
        }

        // Animation
        if ( _src.GetType() == typeof(Animation) ) {
            return CopyAnimation ( _src as Animation, _dest as Animation );
        } 
        // Rigidbody
        else if ( _src.GetType() == typeof(Rigidbody) ) {
            return CopyRigidbody ( _src as Rigidbody, _dest as Rigidbody );
        }
        // BoxCollider
        else if ( _src.GetType() == typeof(BoxCollider) ) {
            return CopyBoxCollider ( _src as BoxCollider, _dest as BoxCollider );
        }
        // CapsuleCollider
        else if ( _src.GetType() == typeof(CapsuleCollider) ) {
            return CopyCapsuleCollider ( _src as CapsuleCollider, _dest as CapsuleCollider );
        }
        // CharacterController
        else if ( _src.GetType() == typeof(CharacterController) ) {
            return CopyCharacterController ( _src as CharacterController, _dest as CharacterController );
        }
        // CharacterJoint
        else if ( _src.GetType() == typeof(CharacterJoint) ) {
            return CopyCharacterJoint ( _src as CharacterJoint, _dest as CharacterJoint );
        }
        // MeshCollider
        else if ( _src.GetType() == typeof(MeshCollider) ) {
            return CopyMeshCollider ( _src as MeshCollider, _dest as MeshCollider );
        }
        // SphereCollider
        else if ( _src.GetType() == typeof(SphereCollider) ) {
            return CopySphereCollider ( _src as SphereCollider, _dest as SphereCollider );
        }
        // SkinnedMeshRenderer
        else if ( _src.GetType() == typeof(SkinnedMeshRenderer) ) {
            return CopySkinnedMeshRenderer ( _src as SkinnedMeshRenderer, _dest as SkinnedMeshRenderer );
        }
        // Transform NOTE: I don't think we need to copy this in most of the time.
        else if ( _src.GetType() == typeof(Transform) ) {
            // return CopyTransform ( _src as Transform, _dest as Transform );
            return true;
        }
        // WheelCollider
        else if ( _src.GetType() == typeof(WheelCollider) ) {
            return CopyWheelCollider ( _src as WheelCollider, _dest as WheelCollider );
        }

        // if the component is not the type above.
        CopyCommon ( _src, _dest );
        return true;
    }

 public static void LogComponentEvents(Component component)
 {
     var componentType = component.GetType();
     foreach (var eventInfo in componentType.GetEvents())
     {
         var handler = (Delegate)GetHandler(componentType, eventInfo)
             .DynamicInvoke(component.gameObject.name);
         eventInfo.AddEventHandler(component, handler);
     }
 }

 //turn off the light 
 public void TurnOffHighLight()
 {
     halo = GetComponent("Halo");
     halo.GetType().GetProperty("enabled").SetValue(halo, false, null);
     particle = GetComponentInChildren<ParticleRenderer>();
     ;
     if (particle != null)
         particle.GetType().GetProperty("enabled").SetValue(particle, false, null);
     lightOn = false;
 }

 Component CopyComponent(Component original, GameObject g)
 {
     System.Type type = original.GetType();
     Component copy = g.AddComponent(type);
     System.Reflection.FieldInfo[] fields = type.GetFields();
     foreach(System.Reflection.FieldInfo f in fields){
         f.SetValue(copy,f.GetValue(original));
     }
     return copy;
 }

 //turn on the light in this cell
 public void TurnOnHighLight()
 {
     if (gameManager.hintMode && !gameManager.players[gameManager.currentPlayer].IsAI()) {
         halo = GetComponent("Halo");
         halo.GetType().GetProperty("enabled").SetValue(halo, true, null);
         particle = GetComponentInChildren<ParticleRenderer>();
         if (particle != null)
             particle.GetType().GetProperty("enabled").SetValue(particle, true, null);
     }
     lightOn = true;
 }

 // Copy a component to another GameObject
 Component CopyComponent(Component original, GameObject destination)
 {
     System.Type type = original.GetType();
     Component copy = destination.AddComponent(type);
     // Copied fields can be restricted with BindingFlags
     System.Reflection.FieldInfo[] fields = type.GetFields();
     foreach (System.Reflection.FieldInfo field in fields)
     {
         field.SetValue(copy, field.GetValue(original));
     }
     return copy;
 }

    public static Component AddComponent(GameObject tarObject, Component srcCom)
    {
        if (srcCom.ToString().Contains("EllipsoidParticleEmitter"))
            return tarObject.AddComponent("EllipsoidParticleEmitter");
        if (srcCom.ToString().Contains("MeshParticleEmitter"))
            return tarObject.AddComponent("MeshParticleEmitter");
        if (srcCom.ToString().Contains("WorldParticleCollider"))
            return tarObject.AddComponent("WorldParticleCollider");
        Component com = tarObject.AddComponent(srcCom.GetType());

        return com;
    }