So sánh Loại Nhanh nhất?

Question

Sự kiện sau có thể được gọi là hàng trăm lần khung.

public bool OnCollision(Body body1, Body body2) 
{ 
if(body2.Tag is Dog) 
     ((Dog)body2.Tag).Bark(); 
} 

Tôi hiểu rằng việc sử dụng "is" sẽ tạo ra một dàn diễn viên và sau đó khi tôi muốn làm gì đó, hãy truyền lại lần thứ hai. Có cách nào hiệu quả hơn để kiểm tra loại không? Tôi đã thực hiện một ứng dụng giao diện điều khiển cố gắng "if (body2.Tag.GetType() == typeOf (Dog))" nhưng nó dường như thậm chí còn chậm hơn so với việc sử dụng "is".

Cảm ơn.

Answer 1

if(body2.Tag is Dog) 

là thực sự biên soạn như

Dog Temp = body2.Tag as Dog; 
if (temp != null) 

Trong code của bạn, bạn đang sau đó làm các diễn viên một lần nữa. Tốt hơn sẽ là:

Dog dog = body2.Tag as Dog; 
if (dog != null) 
{ 
    dog.Bark(); 
} 

Answer 2

Tôi chỉ có thể làm cho một phương pháp trừu tượng trên đối tượng Body gọi là va chạm:

abstract class Body 
{ 
    abstract void Collision(Body other); 
} 

class Dog : Body 
{ 
    public override void Collision(Body other) { 
     this.Bark(); 
    } 

    public void Bark() { ... } 
} 

Sau đó, trong chức năng va chạm của bạn chỉ cần gọi Collision trên các cơ quan tham gia.

public bool OnCollision(Body body1, Body body2) 
{ 
    body2.Collision(body2); 
} 

Bằng cách này bất kỳ loại hình cơ thể có thể làm bất cứ điều gì nó cần khi một vụ va chạm xảy ra, thậm chí bạn có thể tối ưu hóa này để theo dõi trong đó các cơ quan đã được thông báo về vụ va chạm với eachother và giảm số lượng các chức năng cuộc gọi mà bạn phải thực hiện:

public bool OnCollision(Body body1, Body body2) 
{ 
    // Record that these two objects have been notified of a collision 
    // then when these same objects are the only two operands in subsequent calls 
    // you can just short circuit the calls. 
    if(!AlreadyNotifiedOfCollision(body1, body2)) 
    { 
     body1.Collision(body2); 
     body2.Collision(body1); 
     NotifiedOfCollision(body1, body2); 
    } 
} 

Tất nhiên thử nghiệm thực nghiệm sẽ phải được thực hiện để xác nhận rằng việc kiểm tra này là nhanh hơn so với thực tế chỉ làm cuộc gọi hai lần ...

Answer 3

có một cách tiếp cận như thế này có khả thi hay hữu ích ?

public interface ICollidable 
{ 
    void OnCollision(); 
} 

public abstract class Body : ICollidable 
{ 
    public abstract void OnCollision(); 
} 

public class Dog : Body 
{ 
    public override void OnCollision(); 
    { 
     Bark(); 
    } 
} 

public Boolean OnCollision(ICollidable a, ICollidable b) 
{ 
    b.OnCollision(); 
} 

Answer 4

Phương pháp xung đột chung như thế nào? Thế thì không cần thừa kế. Chỉ là một giao diện.

public bool OnCollision<TA,TB>(TA a, TB b) 
    where TA : ICollidable 
    where TB : ICollidable { 
    a.Collision(b); 
}