වර්ගය පරීක්ෂා කිරීම: typeof, GetType, හෝ?

බොහෝ අය පහත කේතය භාවිතා කරන බව මම දැක ඇත්තෙමි:

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

නමුත් මම දන්නවා ඔබටත් මෙය කළ හැකි බව:

if (obj1.GetType() == typeof(int))
    // Some code here

හෝ මෙය:

if (obj1 is int)
    // Some code here

පුද්ගලිකව, මට දැනෙන්නේ අන්තිම එක පිරිසිදුයි, නමුත් මට නැති වූ දෙයක් තිබේද? භාවිතා කිරීමට වඩාත්ම සුදුසු වන්නේ කුමක්ද, නැතහොත් එය පුද්ගලික මනාපයද?

සියල්ල වෙනස් ය.

• typeof වර්ග නාමයක් ගනී (ඔබ සම්පාදනය කරන වේලාවේදී සඳහන් කරයි).
• GetType උදාහරණයක ධාවන කාල වර්ගය ලබා ගනී.
• is උරුමය ගසෙහි නිදසුනක් තිබේ නම් එය සත්‍ය වේ.

උදාහරණයක්

class Animal { } 
class Dog : Animal { }

void PrintTypes(Animal a) { 
    Console.WriteLine(a.GetType() == typeof(Animal)); // false 
    Console.WriteLine(a is Animal);                   // true 
    Console.WriteLine(a.GetType() == typeof(Dog));    // true
    Console.WriteLine(a is Dog);                      // true 
}

Dog spot = new Dog(); 
PrintTypes(spot);

කුමක් ගැනද typeof(T)? එය සම්පාදනය කරන වේලාවේදී ද විසඳා තිබේද?

ඔව්. T යනු සැමවිටම ප්‍රකාශනයේ වර්ගයයි. මතක තබා ගන්න, සාමාන්‍ය ක්‍රමයක් යනු මූලික වශයෙන් සුදුසු වර්ගයක් සහිත ක්‍රම සමූහයකි. උදාහරණයක්:

string Foo<T>(T parameter) { return typeof(T).Name; }

Animal probably_a_dog = new Dog();
Dog    definitely_a_dog = new Dog();

Foo(probably_a_dog); // this calls Foo<Animal> and returns "Animal"
Foo<Animal>(probably_a_dog); // this is exactly the same as above
Foo<Dog>(probably_a_dog); // !!! This will not compile. The parameter expects a Dog, you cannot pass in an Animal.

Foo(definitely_a_dog); // this calls Foo<Dog> and returns "Dog"
Foo<Dog>(definitely_a_dog); // this is exactly the same as above.
Foo<Animal>(definitely_a_dog); // this calls Foo<Animal> and returns "Animal". 
Foo((Animal)definitely_a_dog); // this does the same as above, returns "Animal"

සම්පාදනය කරන වේලාවේදීtypeof වර්ගය ලබා ගැනීමට ඔබට අවශ්‍ය විට භාවිතා කරන්න . ක්‍රියාත්මක කිරීමේ වේලාවේදී වර්ගය ලබා ගැනීමට ඔබට අවශ්‍ය විට භාවිතා කරන්න . වාත්තු කිරීමක් ලෙස භාවිතා කිරීමට ඕනෑම අවස්ථාවක් කලාතුරකින් ඇති අතර බොහෝ විට ඔබ කෙසේ හෝ විචල්‍යය වාත්තු කිරීම අවසන් කරයි.GetTypeis

ඔබ නොසැලකූ සිව්වන විකල්පයක් ඇත (විශේෂයෙන් ඔබ සොයා ගන්නා වර්ගයට ඔබ වස්තුවක් දැමීමට යන්නේ නම්); එනම් භාවිතා කිරීමයි as.

Foo foo = obj as Foo;

if (foo != null)
    // your code here

මෙය භාවිතා කරන්නේ එක් වාත්තු කිරීමක් පමණක් වන අතර මෙම ප්‍රවේශය:

if (obj is Foo)
    Foo foo = (Foo)obj;

දෙකක් අවශ්‍යයි .

යාවත්කාලීන කිරීම (2020 ජනවාරි):

• C # 7+ වන විට , ඔබට දැන් පේළිගත කළ හැකිය, එබැවින් 'is' ප්‍රවේශය දැන් එක් කාස්ට් එකක ද කළ හැකිය.

උදාහරණයක්:

if(obj is Foo newLocalFoo)
{
    // For example, you can now reference 'newLocalFoo' in this local scope
    Console.WriteLine(newLocalFoo);
}

1.

Type t = typeof(obj1);
if (t == typeof(int))

මෙය නීති විරෝධී ය, මන්ද typeofක්‍රියා කරන්නේ විචල්‍යයන් මත නොව වර්ග මත පමණි. මම හිතන්නේ obj1 විචල්යයක්. ඉතින්, මේ ආකාරයෙන් typeofස්ථිතික වන අතර, එහි ක්‍රියාකාරීත්වය ධාවන කාලය වෙනුවට සම්පාදනය කරන වේලාවේදී සිදු කරයි.

2.

if (obj1.GetType() == typeof(int))

මේ trueනම් obj1හරියටම ආකාරයේ වන int. obj1ව්‍යුත්පන්න නම් int, if කොන්දේසිය වනු ඇත false.

3.

if (obj1 is int)

මේ trueනම් obj1යනු int, හෝ එය නමින් පන්ති උපද්දවා නම් int, හෝ එය හැඳින්වූයේ අතුරු මුහුණතක් ක්රියාත්මක නම් int.

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

මෙය දෝෂයකි. C # හි යතුරු ලියන ක්‍රියාකරුට ගත හැක්කේ වස්තු නොව වර්ග නාම පමණි.

if (obj1.GetType() == typeof(int))
    // Some code here

මෙය ක්‍රියාත්මක වනු ඇත, නමුත් සමහර විට ඔබ බලාපොරොත්තු වන පරිදි නොවේ. වටිනාකම් වර්ග සඳහා, ඔබ මෙහි පෙන්වා ඇති පරිදි, එය පිළිගත හැකි නමුත් යොමු වර්ග සඳහා, එය සත්‍ය බවට පත්වන්නේ එම වර්ගය හරියටම එකම වර්ගයේ නම් මිස උරුම ධූරාවලියේ වෙනත් දෙයක් නොවේ. උදාහරණයක් වශයෙන්:

class Animal{}
class Dog : Animal{}

static void Foo(){
    object o = new Dog();

    if(o.GetType() == typeof(Animal))
        Console.WriteLine("o is an animal");
    Console.WriteLine("o is something else");
}

මෙම මුද්රණය කරන "o is something else"වර්ගය නිසා oය Dog, නැත Animal. කෙසේ වෙතත්, ඔබ පන්තියේ IsAssignableFromක්‍රමය භාවිතා කරන්නේ නම් ඔබට මෙම කාර්යය කළ හැකිය Type.

if(typeof(Animal).IsAssignableFrom(o.GetType())) // note use of tested type
    Console.WriteLine("o is an animal");

මෙම තාක්ෂණය තවමත් විශාල ගැටලුවක්ව පවතී. ඔබගේ විචල්‍යය ශුන්‍ය නම්, ඇමතුම GetType()NullReferenceException එකක් දමනු ඇත. එබැවින් එය නිවැරදිව ක්‍රියාත්මක කිරීම සඳහා, ඔබ කරන්නේ:

if(o != null && typeof(Animal).IsAssignableFrom(o.GetType()))
    Console.WriteLine("o is an animal");

මේ සමඟ, ඔබට යතුරුපදයේ සමාන හැසිරීමක් ඇත is. එබැවින්, ඔබට අවශ්‍ය හැසිරීම මෙය නම්, ඔබ isකියවිය යුතු හා වඩා කාර්යක්ෂම වන යතුරු පදය භාවිතා කළ යුතුය .

if(o is Animal)
    Console.WriteLine("o is an animal");

බොහෝ අවස්ථාවන්හීදී, isමූලික පදය තවමත් ඔබට සැබවින්ම අවශ්‍ය දේ නොවේ, මන්ද සාමාන්‍යයෙන් වස්තුවක් එක්තරා ආකාරයක බව දැන ගැනීම පමණක් ප්‍රමාණවත් නොවේ. සාමාන්‍යයෙන්, ඔබට ඇත්ත වශයෙන්ම එම වස්තුව එම වර්ගයේ නිදසුනක් ලෙස භාවිතා කිරීමට අවශ්‍ය වන අතර, එය ද වාත්තු කිරීම අවශ්‍ය වේ. ඒ නිසා ඔබ මේ වගේ කේත ලිවීම සොයාගත හැකිය:

if(o is Animal)
    ((Animal)o).Speak();

නමුත් එමඟින් සීඑල්ආර් වස්තුවේ වර්ගය දෙවරක් පරීක්ෂා කරයි. එය isක්‍රියාකරු තෘප්තිමත් කිරීම සඳහා වරක් එය පරික්ෂා කරනු ඇති අතර , oඇත්ත වශයෙන්ම එය නම් Animal, වාත්තු කිරීම වලංගු කිරීම සඳහා අපි එය නැවත පරීක්ෂා කරමු.

ඒ වෙනුවට මෙය කිරීම වඩාත් කාර්යක්ෂම වේ:

Animal a = o as Animal;
if(a != null)
    a.Speak();

මෙම asක්රියාකරු වෙනුවට නැවත, එය අපොහොසත් වන්නේ නම්, ව්යතිරේකයක් විසි නොවන බව ඉතා අයගේ ක්රමය null. මේ ආකාරයෙන්, සීඑල්ආර් වස්තුවේ වර්ගය එක් වරක් පමණක් පරීක්ෂා කරන අතර, ඉන් පසුව, අප විසින් ශුන්‍ය පරීක්‍ෂණයක් කළ යුතු අතර එය වඩාත් කාර්යක්ෂම වේ.

නමුත් පරෙස්සම් වන්න: බොහෝ අය උගුලකට හසු වේ as. එය ව්‍යතිරේකයන් නොදක්වන නිසා, සමහර අය එය "ආරක්ෂිත" කාස්ට් එකක් ලෙස සිතන අතර, ඔවුන් එය තනිකරම භාවිතා කරයි. මෙය මෙවැනි දෝෂ වලට තුඩු දෙයි:

(o as Animal).Speak();

මෙම අවස්ථාවේ දී, සංවර්ධකයා පැහැදිලිවම උපකල්පනය කරන්නේ oඑය සැමවිටම එකක් වනු ඇති Animalඅතර ඔවුන්ගේ උපකල්පනය නිවැරදිව පවතින තාක් කල් සියල්ල හොඳින් ක්‍රියාත්මක වන බවයි. නමුත් ඔවුන් වැරදියි නම්, ඔවුන් මෙහි අවසන් වන්නේ අ NullReferenceException. නිතිපතා වාත්තු කිරීමක් සමඟ, ඔවුන් ඒ InvalidCastExceptionවෙනුවට ලබා ගනු ඇත, එමඟින් ගැටළුව වඩාත් නිවැරදිව හඳුනා ගනු ඇත.

සමහර විට, මෙම දෝෂය සොයා ගැනීම දුෂ්කර විය හැකිය:

class Foo{
    readonly Animal animal;

    public Foo(object o){
        animal = o as Animal;
    }

    public void Interact(){
        animal.Speak();
    }
}

මෙය සෑම අවස්ථාවකදීම සංවර්ධකයා පැහැදිලිවම අපේක්ෂා oකරන තවත් Animalඅවස්ථාවකි, නමුත් asවාත්තු භාවිතා කරන ඉදිකිරීම්කරු තුළ මෙය පැහැදිලිව පෙනෙන්නට නැත . ක්ෂේත්‍රය ධනාත්මකව පවරනු ඇතැයි අපේක්ෂා කරන Interactක්‍රමයට ඔබ පිවිසෙන තුරු එය පැහැදිලිව පෙනෙන්නට නැත animal. මෙම අවස්ථාවේ දී, ඔබ නොමඟ යවන ව්‍යතිරේකයකින් අවසන් වනවා පමණක් නොව, සත්‍ය දෝෂය සිදුවූ කාලයට වඩා බොහෝ කලකට පසුව එය විසි නොකරයි.

සාරාංශයකින්:

• වස්තුවක් කිසියම් වර්ගයකද නැද්ද යන්න ඔබට දැන ගැනීමට අවශ්‍ය නම් භාවිතා කරන්න is.

• ඔබට යම් වස්තුවක් එක්තරා ආකාරයක නිදසුනක් ලෙස සැලකීමට අවශ්‍ය නම්, නමුත් එම වස්තුව එම වර්ගයට අයත් වනු ඇතැයි ඔබ නිශ්චිතව නොදන්නේ නම්, භාවිතා asකර පරීක්ෂා කරන්න null.

• ඔබට යම් වස්තුවක් එක්තරා ආකාරයක නිදසුනක් ලෙස සැලකීමට අවශ්‍ය නම් සහ එම වස්තුව එම වර්ගයට අයත් යැයි සිතිය හැකි නම්, සාමාන්‍ය වාත්තු කිරීමක් භාවිතා කරන්න.

ඔබ C # 7 භාවිතා කරන්නේ නම්, ඇන්ඩ rew හාරේගේ විශිෂ්ට පිළිතුර යාවත්කාලීන කිරීමට කාලයයි. රටා ගැලපීම මඟින් කදිම කෙටිමඟක් හඳුන්වා දී ඇති අතර එය වෙනම ප්‍රකාශයක් / වාත්තු කිරීමක් අවශ්‍ය නොවී if ප්‍රකාශයේ සන්දර්භය තුළ ටයිප් කළ විචල්‍යයක් ලබා දෙයි:

if (obj1 is int integerValue)
{
    integerValue++;
}

මේ වගේ තනි නළු නිළියන්ට මෙය බෙහෙවින් අවතක්සේරු වන බවක් පෙනේ, නමුත් ඔබේ දෛනික වැඩකටයුතු සඳහා විවිධ වර්ග ඇති විට එය සැබවින්ම බබළයි. දෙවරක් වාත්තු නොකිරීමට පැරණි ක්‍රමය පහත දැක්වේ:

Button button = obj1 as Button;
if (button != null)
{
    // do stuff...
    return;
}
TextBox text = obj1 as TextBox;
if (text != null)
{
    // do stuff...
    return;
}
Label label = obj1 as Label;
if (label != null)
{
    // do stuff...
    return;
}
// ... and so on

මෙම කේතය හැකිතාක් හැකිලීම වටා වැඩ කිරීම මෙන්ම එකම වස්තුවක අනුපිටපත් වළක්වා ගැනීම මට නිතරම කරදරයක් විය. ඉහත කරුණු පහත දැක්වෙන රටාවන්ට ගැලපෙන පරිදි සම්පීඩිත වේ:

switch (obj1)
{
    case Button button:
        // do stuff...
        break;
    case TextBox text:
        // do stuff...
        break;
    case Label label:
        // do stuff...
        break;
    // and so on...
}

සංස්කරණය කරන්න: පැලෙක්ගේ අදහස් අනුව ස්විචයක් භාවිතා කිරීම සඳහා දීර් new නව ක්‍රමය යාවත්කාලීන කරන ලදි.

මට Typeසංසන්දනය කිරීමට -ප්‍රතිලාභයක් ඇති අතර is(වැනි my_type is _BaseTypetoLookFor) භාවිතා කිරීමට නොහැකි විය, නමුත් මට මේවා භාවිතා කළ හැකිය:

base_type.IsInstanceOfType(derived_object);
base_type.IsAssignableFrom(derived_type);
derived_type.IsSubClassOf(base_type);

සිටින බව දැනුම් IsInstanceOfTypeසහ IsAssignableFromනැවත trueIsSubClassOf ආපසු වන අතර එහිදී එම වර්ග, සාපේක්ෂව false. හා IsSubclassOfඅනෙක් දෙක කරන්න එහිදී අතුරු මුහුණත් මත වැඩ කරන්නේ නැහැ. ( මෙම ප්‍රශ්නය සහ පිළිතුරද බලන්න .)

public class Animal {}
public interface ITrainable {}
public class Dog : Animal, ITrainable{}

Animal dog = new Dog();

typeof(Animal).IsInstanceOfType(dog);     // true
typeof(Dog).IsInstanceOfType(dog);        // true
typeof(ITrainable).IsInstanceOfType(dog); // true

typeof(Animal).IsAssignableFrom(dog.GetType());      // true
typeof(Dog).IsAssignableFrom(dog.GetType());         // true
typeof(ITrainable).IsAssignableFrom(dog.GetType()); // true

dog.GetType().IsSubclassOf(typeof(Animal));            // true
dog.GetType().IsSubclassOf(typeof(Dog));               // false
dog.GetType().IsSubclassOf(typeof(ITrainable)); // false

මම කැමති කියන්නේ

එයින් කියැවෙන්නේ ඔබ භාවිතා කරන්නේ නම් , ඔබ උරුමය නිසි ලෙස භාවිතා නොකරන බවයි.

එම පුද්ගලයා උපකල්පනය කරන්න: ආයතනය, සහ එම සත්වයා: වස්තුව. සංග්‍රහය යනු ආයතනයේ අතථ්‍ය ක්‍රමයකි (නීල් සතුටු කිරීමට)

class Person
{
  // A Person should be able to Feed
  // another Entity, but they way he feeds
  // each is different
  public override void Feed( Entity e )
  {
    if( e is Person )
    {
      // feed me
    }
    else if( e is Animal )
    {
      // ruff
    }
  }
}

ඒ වෙනුවට

class Person
{
  public override void Feed( Person p )
  {
    // feed the person
  }
  public override void Feed( Animal a )
  {
    // feed the animal
  }
}

මම විශ්වාස කරන්නේ අන්තිමයා උරුමය දෙස බලන බවයි (උදා: බල්ලා යනු සත්ව == සත්‍යය), එය බොහෝ අවස්ථාවන්හිදී වඩා හොඳය.

එය මා කරන දේ මත රඳා පවතී. මට bool අගයක් අවශ්‍ය නම් (කියන්න, මම int එකකට දමන්නේද යන්න තීරණය කිරීම සඳහා), මම භාවිතා කරමි is. කිසියම් හේතුවක් නිසා මට ඇත්ත වශයෙන්ම වර්ගය අවශ්‍ය නම් (කියන්න, වෙනත් ක්‍රමයකට යොමු වීමට) මම භාවිතා කරමි GetType().

අන්තිම එක පිරිසිදුයි, වඩා පැහැදිලිව පෙනෙන අතර උප වර්ග සඳහාද පරික්ෂා කරයි. අනෙක් අය බහුමාපකය පරීක්ෂා නොකරයි.

System.Type වස්තුව ලබා ගැනීම සඳහා භාවිතා වේ. යතුරු ලියනයක ප්‍රකාශනය පහත දැක්වෙන ස්වරූපය ගනී:

System.Type type = typeof(int);

Example:

    public class ExampleClass
    {
       public int sampleMember;
       public void SampleMethod() {}

       static void Main()
       {
          Type t = typeof(ExampleClass);
          // Alternatively, you could use
          // ExampleClass obj = new ExampleClass();
          // Type t = obj.GetType();

          Console.WriteLine("Methods:");
          System.Reflection.MethodInfo[] methodInfo = t.GetMethods();

          foreach (System.Reflection.MethodInfo mInfo in methodInfo)
             Console.WriteLine(mInfo.ToString());

          Console.WriteLine("Members:");
          System.Reflection.MemberInfo[] memberInfo = t.GetMembers();

          foreach (System.Reflection.MemberInfo mInfo in memberInfo)
             Console.WriteLine(mInfo.ToString());
       }
    }
    /*
     Output:
        Methods:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Members:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Void .ctor()
        Int32 sampleMember
    */

සංඛ්‍යාත්මක ගණනය කිරීමේ ප්‍රති result ල අඩංගු කිරීම සඳහා භාවිතා කරන වර්ගය තීරණය කිරීම සඳහා මෙම නියැදිය GetType ක්‍රමය භාවිතා කරයි. මෙය ප්‍රති ing ලයක් ලෙස ලැබෙන අංකයේ ගබඩා අවශ්‍යතා මත රඳා පවතී.

    class GetTypeTest
    {
        static void Main()
        {
            int radius = 3;
            Console.WriteLine("Area = {0}", radius * radius * Math.PI);
            Console.WriteLine("The type is {0}",
                              (radius * radius * Math.PI).GetType()
            );
        }
    }
    /*
    Output:
    Area = 28.2743338823081
    The type is System.Double
    */

if (c is UserControl) c.Enabled = enable;

ඔබට C # හි "typeof ()" ක්‍රියාකරු භාවිතා කළ හැකි නමුත් ඔබට System.IO භාවිතා කර නාම අවකාශය ඇමතිය යුතුය; ඔබට වර්ගයක් පරීක්ෂා කිරීමට අවශ්‍ය නම් "is" යතුර භාවිතා කළ යුතුය.

GetType () එදිරිව කාර්ය සාධන පරීක්ෂණ වර්ගය ():

using System;
namespace ConsoleApplication1
    {
    class Program
    {
        enum TestEnum { E1, E2, E3 }
        static void Main(string[] args)
        {
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test1(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test2(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            Console.ReadLine();
        }
        static Type Test1<T>(T value) => typeof(T);
        static Type Test2(object value) => value.GetType();
    }
}

නිදොස් කිරීමේ මාදිලියේ ප්‍රති Results ල:

00:00:08.4096636
00:00:10.8570657

මුදා හැරීමේ මාදිලියේ ප්‍රති Results ල:

00:00:02.3799048
00:00:07.1797128