सबसे तेज़ प्रकार तुलना?

Question

निम्नलिखित घटना संभवतः एक फ्रेम को सैकड़ों बार बुलाया जा सकता है।

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

मैं समझता हूँ "है" का कारण बनता है कि का उपयोग कर एक डाली किए जाने के लिए और उसके बाद जब मैं इसके साथ कुछ करना चाहता हूँ, यह एक दूसरी बार डाली। क्या इस प्रकार की जांच करने का एक और अधिक प्रभावी तरीका है? मैंने एक कंसोल ऐप बनाया "अगर (body2.Tag.GetType() == टाइपऑफ (कुत्ता))" लेकिन यह "है" का उपयोग करने से भी धीमा प्रतीत होता है।

धन्यवाद।

Answer 1

if(body2.Tag is Dog) 

वास्तव में के रूप में

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

अपने कोड में संकलित किया गया है, तो आप फिर से डाली कर रहे हैं। बेहतर होगा:

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

Answer 2

मैं बस टकरा गई बुलाया शरीर वस्तु पर एक सार विधि बनाना होगा:

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

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

    public void Bark() { ... } 
} 

फिर अपने टक्कर समारोह में सिर्फ शामिल शरीर पर टकराव कहते हैं।

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

इस तरह शरीर के किसी भी प्रकार के जो भी इसकी आवश्यकता है जब एक टक्कर होता है क्या कर सकते हैं, तो आप भी ट्रैक जिनमें से शरीर eachother के साथ टकराव के बारे में सूचित कर दिया गया है रखने के लिए और संख्या को कम करने के लिए इस का अनुकूलन कर सकता फ़ंक्शन को कॉल करने की है कि आप निष्पादित करने के लिए है:

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); 
    } 
} 

बेशक अनुभवजन्य परीक्षण मान्य करने के लिए है कि इस चेक वास्तव में सिर्फ कॉल दो बार कर रही है की तुलना में तेजी है किया जा करने के लिए होगा ...

Answer 3

इस तरह एक दृष्टिकोण संभव या उपयोगी हो सकते हैं ?

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

एक सामान्य टकराव विधि के बारे में कैसे? फिर विरासत की कोई आवश्यकता नहीं है। बस एक इंटरफ़ेस।

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