जावा टाइप क्लास <> के लिए नेट समकक्ष?

Question

मैं एक .NET लड़का हूं, इसलिए मुझे पहले कुछ जावा अवधारणाओं की मेरी समझ पर जोर देना चाहिए - अगर मैं गलत हूं तो मुझे सही करें।

class GenericClass< ? extends IInterface> { ... } 

... जो नेट where प्रतिबंध के समान है::

class GenericClass<T> where T: IInterface { ... } 

जावा के Class वर्ग एक प्रकार का वर्णन करता है, और

जावा जेनेरिक्स घिरे वाइल्डकार्ड की अवधारणा का समर्थन लगभग .NET Type वर्ग

0 के समतुल्य है

अब तक, बहुत अच्छा है। लेकिन मुझे सामान्य रूप से Class<T> टाइप किए गए जावा के करीब पर्याप्त समकक्ष नहीं मिल सकता है, जहां टी एक बाध्य वाइल्डकार्ड है। यह मूल रूप से उन प्रकारों पर प्रतिबंध लगाता है जो Class दर्शाते हैं।

मुझे जावा में एक उदाहरण दें।

String custSortclassName = GetClassName(); //only known at runtime, 
              // e.g. it can come from a config file 

Assembly assy = GetAssembly();    //unimportant 

Type customClass = assy.GetType(custSortclassName); 
if(!customClass.IsSubclassOf(typeof(IExternalSort))){ 
    throw new InvalidOperationException(...); 
} 
IExternalSort impl = (IExternalSort)Activator.CreateInstance(customClass); 

जावा संस्करण मेरे लिए क्लीनर दिखता है:

String custSortclassName = GetClassName(); //only known at runtime, 
              // e.g. it can come from a config file 
Class<? extends IExternalSort> customClass 
    = Class.forName("MyExternalSort") 
     .asSubclass(IExternalSort.class); //this checks for correctness 

IExternalSort impl = customClass.newInstance(); //look ma', no casting! 

निकटतम मैं नेट में मिल सकता है कुछ इस तरह है। क्या .NET समकक्ष को बेहतर बनाने का कोई तरीका है?

Answer 1

विस्तार तरीकों & के लिए एक कस्टम आवरण वर्ग का उपयोग करना System.Type, आप जावा वाक्यविन्यास के बहुत करीब हो सकते हैं।

नोट:Type.IsSubclassOf एक प्रकार एक अंतरफलक को लागू करता है, तो परीक्षण करने के लिए इस्तेमाल नहीं किया जा सकता है - MSDN पर जुड़ा हुआ दस्तावेज़ देखें। इसके बजाय Type.IsAssignableFrom का उपयोग कर सकते हैं - नीचे दिए गए कोड को देखें।

using System; 

class Type<T> 
{ 
    readonly Type type; 

    public Type(Type type) 
    { 
     // Check for the subtyping relation 
     if (!typeof(T).IsAssignableFrom(type)) 
      throw new ArgumentException("The passed type must be a subtype of " + typeof(T).Name, "type"); 

     this.type = type; 
    } 

    public Type UnderlyingType 
    { 
     get { return this.type; } 
    } 
} 

static class TypeExtensions 
{ 
    public static Type<T> AsSubclass<T>(this System.Type type) 
    { 
     return new Type<T>(type); 
    } 
} 

// This class can be expanded if needed 
static class TypeWrapperExtensions 
{ 
    public static T CreateInstance<T>(this Type<T> type) 
    { 
     return (T)Activator.CreateInstance(type.UnderlyingType); 
    } 
} 

इसके अलावा इंटरफ़ेस विचरण का उपयोग कर सुधार

(केवल उत्पादन कोड में उपयोग किया जाना चाहिए के बाद प्रदर्शन का मूल्यांकन किया गया है। एक (समवर्ती!) कैश शब्दकोश ConcurrentDictionary<System.Type, IType<object> का उपयोग करके सुधार किया जा सकता है)

Covariant type parameters का उपयोग करके, सी # 4.0 के साथ पेश की गई एक विशेषता, और एक अतिरिक्त प्रकार interface IType<out T>, जो Type<T> लागू करता है, कोई भी निम्न संभव चीज़ों को बना सकता है:

// IExternalSortExtended is a fictional interface derived from IExternalSort 
IType<IExternalSortExtended> extendedSort = ... 
IType<IExternalSort> externalSort = extendedSort; // No casting here, too. 

एक भी कर सकता है:

using System; 

interface IType<out T> 
{ 
    Type UnderlyingType { get; } 
} 

static class TypeExtensions 
{ 
    private class Type<T> : IType<T> 
    { 
     public Type UnderlyingType 
     { 
      get { return typeof(T); } 
     } 
    } 

    public static IType<T> AsSubclass<T>(this System.Type type) 
    { 
     return (IType<T>)Activator.CreateInstance(
      typeof(Type<>).MakeGenericType(type) 
     ); 
    } 
} 

static class TypeWrapperExtensions 
{ 
    public static T CreateInstance<T>(this IType<T> type) 
    { 
     return (T)Activator.CreateInstance(type.UnderlyingType); 
    } 
} 

ताकि कोई भी कर सकते हैं (स्पष्ट) असंबंधित इंटरफेस InterfaceA और InterfaceB तरह के बीच डाली:

var x = typeof(ConcreteAB).AsSubclass<InterfaceA>(); 
var y = (IType<InterfaceB>)x; 

लेकिन है कि थोड़े अभ्यास का उद्देश्य धरा ।

Answer 2

आप "के रूप में" ऑपरेटर का उपयोग एक से थोड़ा खूबसूरत संस्करण प्राप्त कर सकते हैं:

String custSortclassName = GetClassName(); 
Assembly assy = GetAssembly(); 
Type customClass = assy.GetType(custSortclassName); 

IExternalSort impl = Activator.CreateInstance(customClass) as IExternalSort; 
if(impl==null) throw new InvalidOperationException(...); 

लेकिन यहाँ मैं अपने प्रकार है, जो आप के लिए एक मुद्दा हो सकता जाँच से पहले उदाहरण बना रहा हूं।

Answer 3

सी # जेनेरिक घोषणा-साइट भिन्नता है, एक प्रकार पैरामीटर का भिन्नता तय किया गया है।

जावा, उपयोग साइट भिन्नता है तो एक बार हम एक घोषणा List<E> है, हम इसे 3 तरीके

List<Number>   // invariant, read/write 
List<+Number>   // covariant, read only 
List<-NUmber>   // contravariant, write only 

वहाँ पेशेवरों और दोनों दृष्टिकोण करने के लिए विपक्ष का उपयोग कर सकते हैं। उपयोग-साइट दृष्टिकोण स्पष्ट रूप से अधिक शक्तिशाली है, हालांकि इसे प्रतिष्ठित करने वालों के लिए बहुत मुश्किल माना जाता है। मुझे लगता है कि यह वास्तव में बहुत

List<Integer> integers = ...; 
List<+Number> numbers = integers; // covariant 

दुर्भाग्य से, जावा एक बिल्कुल घृणित वाक्य रचना का आविष्कार किया काबू करने के लिए आसान है,

List<? extends Number> // i.e. List<+Number> 

एक बार अपने कोड इनमें से कई है यह वास्तव में बदसूरत हो जाता है। आपको इसे प्राप्त करना सीखना है।

अब, घोषणा साइट शिविर में, हम एक ही कक्षा में 3 भिन्नताओं को कैसे प्राप्त करते हैं? अधिक प्रकार के साथ - ReadOnlyList<out E>, WriteOnlyList<in E>, और List<E> दोनों को विस्तारित करना। यह बहुत बुरा नहीं है, और कोई कह सकता है कि यह एक बेहतर डिजाइन है। लेकिन अगर अधिक प्रकार के पैरामीटर हैं तो यह बदसूरत हो सकता है। और यदि किसी वर्ग के डिजाइनर ने यह अनुमान नहीं लगाया कि इसे अलग-अलग इस्तेमाल किया जा रहा है, तो वर्ग के उपयोगकर्ताओं के पास इसका उपयोग करने का कोई तरीका नहीं है।

Answer 4

आप निम्न जैसा कोई एक्सटेंशन विधि लिखने का प्रयास कर सकते हैं:

static class TypeExtension 
    { 
     public static I NewInstanceOf<I>(this Type t) 
      where I: class 
     { 
      I instance = Activator.CreateInstance(t) as I; 
      if (instance == null) 
       throw new InvalidOperationException(); 
      return instance; 
     } 
    } 

कौन सा तो निम्नलिखित तरीके से इस्तेमाल किया जा सकता:

String custSortclassName = GetClassName(); //only known at runtime, 
              // e.g. it can come from a config file 

Assembly assy = GetAssembly(); 
Type customClass = assy.GetType(custSortclassName);    

IExternalSort impl = customClass.NewInstanceOf<IExternalSort>();