How to approach refactoring this code (C #, Types)

Question

Firstly, my apologies for the title of the question. I'm not quite sure what he called what I'm trying to accomplish, so I just go to him.

I am currently developing a game engine in C # using GDI + and have implemented a component class. The idea is that any game object can have several components to it (like Unity3D), and I want to find any component of any type by looking for what class it is.

In this note, I would like to modify this piece of code:

Rigidbody r = obj.GetComponentOfType(typeof(Rigidbody)) as Rigidbody;

To look like this:

Rigidbody r = obj.GetComponentOfType<Rigidbody>();

How should I do it?

Sorry if my question seems vague, any light on this topic will be wonderful!

Answer 1

. , :

public T GetComponentOfType<T>()
{
    return (T) GetComponentOfType(typeof(T));
}

Answer 2

, List<Component> obj. Linq:

// assuming
public class GameObject
{
    List<Component> m_Components; // all components attached to this GameObject
    public TComponent GetComponentOfType<TComponent>()
        where TComponent : Component
    {
        // Select only the ones of type TComponent and return first one
        return m_Components.OfType<TComponent>().FirstOrDefault();
    }
}

: obj.GetComponentOfType<Rigidbody>();

Answer 3

, :

public static T GetComponentOfType<T>(this [objType] obj)
where T : class
{
    return obj.GetComponentOfType(typeof(T)) as T;
}

Answer 4

, :

using System.Linq;
using System.Collections.Generic;

/// <summary>
/// Base-Class
/// </summary>
public abstract class Thing
{
    private ICollection<Thing> _things;

    public Thing()
    {
        _things = new List<Thing>();
    }

    public void AddSomething(Thing toAdd)
    {
        _things.Add(toAdd);
    }

    /// <summary>
    /// Assuming that every type can only appear once
    /// </summary>
    /// <param name="t"></param>
    /// <returns></returns>
    public T GetComonentOfType<T>() where T : Thing
    {
        return this.GetComonentOfType(typeof(T)) as T;
    }

    public Thing GetComonentOfType(Type t)
    {
        return _things.Where(x => x.GetType() == t).Single();
    }

}

/// <summary>
/// One possible implementation
/// </summary>
public class SpecialThing : Thing
{

}

Answer 5

GetComponentOfType, ( , ), . Rigidbody < > .

.

: , .

, .

Answer 6

. GetComponentofType , , , , .

:

 public T GetComponentOfType<T>(){

      //code goes here to locate the object.
      you can get the type via typeof(T) 

      return theObject;
 }

Answer 7

   public class Rigidbody{
        public int Size{ get; set; }
        public string fourgroundColor{ get; set; }
        public string backgroundColor{ get; set; }
        public int fingerammount{ get; set; }
        public int arms{ get; set; }
    }

Hide result

Rigidbody. , . Olso , , .

, : var r = obj.GetComponentOfType(); datat var. var , - oldscool ( # 1 C2.0). . , var ( , )

Answer 8

, ( ):

public abstract class IComponent
{
    protected IList<object> objComponents;

    public object GetComponentOfType(Type type)
    {
        if (objComponents == null)
            return null;

        return objComponents.Where(obj => obj.GetType() == type).FirstOrDefault();
    }
}

, :

public abstract class BaseComponent : IComponent
{
    public object GetComponentOfType<T>()
    {
        return GetComponentOfType(typeof(T));
    }
}

, , .