सी # में मेटाप्रोग्रामिंग संभव है?

Question

विशेष रूप से, कोड होना चाहिए जो इस सी ++ कोड के समान है जो संकलन समय पर C# में निष्पादित किया गया है?

template <int N> 
struct Factorial 
{ 
    enum { value = N * Factorial<N - 1>::value }; 
}; 

template <> 
struct Factorial<0> 
{ 
    enum { value = 1 }; 
}; 

// Factorial<4>::value == 24 
// Factorial<0>::value == 1 
void foo() 
{ 
    int x = Factorial<4>::value; // == 24 
    int y = Factorial<0>::value; // == 1 
} 

Answer 1

नहीं, इस जटिलता का मेटाप्रोग्रामिंग सीधे सी # भाषा द्वारा समर्थित नहीं है। हालांकि, @littlegeek की तरह, Text Template Transformation Toolkit विजुअल स्टूडियो के साथ शामिल होने से आपको किसी भी जटिलता की कोड जनरेशन प्राप्त करने की अनुमति मिल जाएगी।

Answer 2

नहीं, सी # में मेटाप्रोग्रामिंग संभव नहीं है।

Answer 3

बहुत सीमित सीमा, सी # कुछ जिसे मेटा प्रोग्रामिंग के रूप में व्याख्या किया जा सकता है। लेकिन वास्तव में यह अधिभार संकल्प से अधिक कुछ नहीं है। यह मेटा प्रोग्रामिंग को कॉल करने के लिए एक वास्तविक खिंचाव है।

उदाहरण: टी -4 टेम्पलेट्स

iphone पर क्षमा और संसाधन को इंगित नहीं कर सकते हैं के लिए देखो की

static string SomeFunc<T>(T value) { 
    return "Generic"; 
} 
static string SomeFunc(int value) { 
    return "Non-Generic"; 
} 

static void Example() { 
    SomeFunc(42);   // Non-Generic 
    SomeFunc((object)42); // Generic 
} 

Answer 4

तरह।

स्कॉट हंसलेमैन ने पिछले हफ्ते इसके बारे में पोस्ट किया था।

Answer 5

.NET जेनेरिक और सी ++ टेम्पलेट्स के बीच आवश्यक अंतर यह है कि जेनेरिक रनटाइम पर विशिष्ट होते हैं। संकलन समय पर टेम्पलेट का विस्तार किया जाता है। जेनेरिकों का गतिशील व्यवहार लिंक, अभिव्यक्ति पेड़, टाइप.मेक जेनरिक टाइप(), भाषा स्वतंत्रता और कोड पुनः उपयोग करने जैसी चीजें बनाता है।

लेकिन एक कीमत है, उदाहरण के लिए आप जेनेरिक प्रकार तर्क के मूल्यों पर ऑपरेटर का उपयोग नहीं कर सकते हैं। आप सी # में एक std :: जटिल कक्षा नहीं लिख सकते हैं। और कोई संकलन समय मेटाप्रोग्रामिंग नहीं है।

Answer 6

जावा या नेट भाषाओं से निपटने के दौरान संकलन-समय के बारे में बात करते समय आपको सावधान रहना चाहिए। उन भाषाओं में आप सी ++ की तुलना में अधिक शक्तिशाली मेटाप्रोगैमिंग (व्यापक अर्थ में - प्रतिबिंब-) कर सकते हैं क्योंकि "संकलन समय" (जेआईटी) को "रन टाइम" के बाद स्थगित कर दिया जा सकता है;)

Answer 7

यह जा रहा है संभव होना एंडर्स हेजल्सबर्ग की The Future of C# बात देखें।

Answer 8

अधिकांश लोग अपनी पसंदीदा भाषा के अंदर से मेट्रैप्रोग्राम करने का प्रयास करने पर जोर देते हैं। यह काम नहीं करता है अगर भाषा मेटाप्रोग्रामिंग का समर्थन नहीं करती है; अन्य उत्तरों ने देखा है कि सी # नहीं है।

इस के चारों ओर एक रास्ता भाषा बाहर से metaprogramming करना है, program transformation tools का उपयोग कर रहा है। ऐसे उपकरण स्रोत कोड को पार्स कर सकते हैं, और उस पर मनमाने ढंग से परिवर्तन कर सकते हैं (यही मेटाप्रोग्रामिंग वैसे भी करता है) और फिर संशोधित प्रोग्राम को थूक दें।

यदि आपके पास एक सामान्य उद्देश्य प्रोग्राम परिवर्तन प्रणाली है, जो मनमाने ढंग से भाषाओं का विश्लेषण कर सकती है, तो आप अपनी पसंद की किसी भी भाषा के साथ मेटाप्रोग्रामिंग कर सकते हैं। ऐसे उपकरण के लिए हमारे DMS Software Reengineering Toolkit देखें, जिनके पास सी, सी ++, जावा, सी #, कोबोल, पीएचपी और कई अन्य प्रोग्रामिंग लैंगुग के लिए मजबूत फ्रंट सिरों हैं, और इनमें से सभी पर मेटाप्रोग्रामिंग के लिए उपयोग किया गया है।

डीएमएस सफल होता है क्योंकि यह एएसटी के रूप में प्रोग्राम संरचना तक पूर्ण पहुंच के लिए एक नियमित विधि और समर्थन आधारभूत संरचना प्रदान करता है, और ज्यादातर मामलों में अतिरिक्त डेटा जैसे प्रतीक प्रतीक, प्रकार की जानकारी, नियंत्रण और डेटा प्रवाह विश्लेषण, परिष्कृत करने के लिए आवश्यक सभी कार्यक्रम हेरफेर।

संपादित करें (टिप्पणी के जवाब में): सी # पर ओपी के कार्य को लागू करने के लिए डीएमएस लागू कर सकता है।

Answer 9

script.net पर एक नज़र डालने का प्रयास करें; अधिक जानकारी पर - http://www.orbifold.net/default/?p=2457

Answer 10

Metaprogramming .NET में संभव है (संकलक compilers, नियमित अभिव्यक्ति, कोड डोम, प्रतिबिंब आदि देखें) लेकिन क्योंकि यह उस भाषा सुविधा नहीं है सी # टेम्पलेट metaprogramming में सक्षम नहीं है।

Answer 11

जिस तरह से आप पूछ रहे हैं में

नहीं है, लेकिन आप पुराने सी ++ चाल से कुछ का उपयोग वर्गों जिसका लक्षण स्थिर निर्दिष्ट कर रहे हैं उत्पन्न करने के लिए कर सकते हैं:

abstract class Integer 
{ 
    public abstract int Get { get; } 
} 

public class One : Integer { public override int Get { return 1; } } } 
public class Two : Integer { public override int Get { return 2; } } } 
public class Three : Integer { public override int Get { return 3; } } } 

public class FixedStorage<T, N> where N : Integer, new() 
{ 
    T[] storage; 
    public FixedStorage() 
    { 
     storage = new T[new N().Get]; 
    } 
    public T Get(int i) 
    { 
     return storage[i]; 
    } 
} 

इस का उपयोग करना, आप स्थानिक वर्गों को परिभाषित कर सकते हैं:

public class Vector3 : FixedStorage<float, Three> {} 
public class Vector2 : FixedStorage<float, Two> {} 
public class GridCell : FixedStorage<int, Two> {} 

मैं इस तकनीक का उपयोग उस पुस्तकालय में करता हूं जिसमें बहुत से उप-वर्ग हैं, जहां एक नए डेटा सदस्य को जोड़ने के लिए बहुत सारे बॉयलरप्लेट की आवश्यकता होती है।