सी # जेनेरिक - एन सामान्य प्रकार के साथ एक विधि बनाने के लिए संभव ..?

Question

मुझे नहीं लगता कि यह संभव है लेकिन यहां जाता है ...

मैं जेनरिक्स के एन संख्या को संभाल सकता हूं जो विधि जोड़ना चाहता हूं। उदाहरण के लिए:

bool<T> MyMethod() where T: Isomething 
{ 
} 

एक प्रकार के लिए काम करेंगे

bool<T,K> MyMethod() where T: Isomething 
{ 
} 

दो प्रकार

के लिए काम करेंगे वहाँ n प्रकार के साथ काम करने के लिए एक रास्ता है - जैसे अभी यह एक विधानसभा के लिए महान काम करता है -

bool<T[]> MyMethod() where T: Isomething 
{ 
} 

कारण मैं ऐसा करना चाहते हैं एक स्थिर nhibernate सहायक विधि है जो कई विधानसभाओं से लोड कर सकते हैं लागू करने के लिए है। मेरे वर्तमान पद्धति के रूप में नीचे दिखाया गया है:

 public static ISessionFactory GetMySqlSessionFactory<T>(string connectionString, bool BuildSchema) 
    { 
     //configuring is meant to be costly so just do it once for each db and store statically 
     if (!AllFactories.ContainsKey(connectionString)) 
     { 
      var configuration = 
      Fluently.Configure() 
      .Database(MySQLConfiguration.Standard 
         .ConnectionString(connectionString) 
         .ShowSql() //for development/debug only.. 
         .UseOuterJoin() 
         .QuerySubstitutions("true 1, false 0, yes 'Y', no 'N'")) 
      .Mappings(m => 
         { 
          m.FluentMappings.AddFromAssemblyOf<T>(); 
          m.AutoMappings.Add(AutoMap.AssemblyOf<T>().Conventions.Add<CascadeAll>); 
         }) 
      .ExposeConfiguration(cfg => 
           { 
            new SchemaExport(cfg) 
            .Create(BuildSchema, BuildSchema); 
           }); 
      AllFactories[connectionString] = configuration.BuildSessionFactory(); 
     } 

     return AllFactories[connectionString]; 
    } 

कहाँ पंक्ति: m.FluentMappings.AddFromAssemblyOf(), मैं कई प्रकार के उदाहरण के लिए जोड़ना चाहते हैं

foreach(T in T[]){ 
    m.FluentMappings.AddFromAssemblyOf<T>() 

}

जाहिर है यह काम नहीं कर सकता है मैं पूरी तरह से बेवकूफ नहीं हूँ, लेकिन मैं जेनरिक पर इतना गर्म नहीं कर रहा हूँ - किसी की पुष्टि कर सकते कि यह संभव नहीं है :-) ..? आपकी राय में इस प्रभाव को प्राप्त करने का सबसे शानदार तरीका क्या होगा ..?

Answer 1

नहीं - सामान्य प्रकार और विधियों की धर्मा प्रति-प्रकार/विधि आधार पर तय की गई है।

यही कारण है कि सभी अलग-अलग Action<...>, Func<...> और Tuple<...> ढांचे में प्रकार हैं।

कभी-कभी यह शर्म की बात है, लेकिन यह अपेक्षाकृत शायद ही कभी हो, और मुझे संदेह है कि सभी प्रकार की चीजें परिवर्तनीय धैर्य के साथ बहुत अधिक जटिल होंगी।

Answer 2

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

क्यों आप इस लिंक

bool<T[]> MyMethod() where T: Isomething 
{ 
} 

Answer 3

असल में मैं सिर्फ देखा एक ही विधि .. जो आप चाहते प्रकार के रूप में कई के साथ सौदा कर सकते हैं बनाने नहीं है - मैं अब घर जाना है, लेकिन मैं कुछ कोशिश कर सकते हैं यह बाद में की तरह अगर यह काम करता है:

http://geekswithblogs.net/marcel/archive/2007/03/24/109722.aspx

मुझे लगता है कि अगर मैं प्रकार की एक सरणी में पारित कर दिया और प्रतिबिंब इस काम करेगा साथ प्रकार के माध्यम से लूप में चलाया।

Answer 4

दूसरों के रूप में निर्दिष्ट किया है आप नहीं कर सकते:

bool MyMethod<T[]>() where T: ISomething 

लेकिन आप कर सकते हैं:

bool MyMethod<T>(params T[] somethings) where T : ISomething 

उदाहरण के लिए:

public interface ISomething { string Name { get; set; } } 

public class SomethingA : ISomething { public string Name { get; set; } = nameof(SomethingA); } 
public class SomethingB : ISomething { public string Name { get; set; } = nameof(SomethingB); } 

void MyMethod<T>(params T[] somethings) where T : ISomething 
{ 
    foreach (var something in somethings) 
    { 
     if (something != null) 
      Console.WriteLine(something); 
    } 
} 

// Use it! 
ISomething a = new SomethingA(); 
ISomething b = new SomethingB(); 

// You don't need to specify the type in this call since it can determine it itself. 
MyMethod(a, b); 

// If calling it like this though you do: 
MyMethod<ISomething>(new SomethingA(), new SomethingB()); 

सी # इंटरएक्टिव विंडो आउटपुट:

> MyMethod(a, b); 
Submission#0+SomethingA 
Submission#0+SomethingB 
> 
> MyMethod<ISomething>(new SomethingA(), new SomethingB()); 
Submission#0+SomethingA 
Submission#0+SomethingB 

तो, आप अपने प्रकारों को ले सकते हैं जो आप चाहते हैं (जो जेनेरिक के अनुरूप हैं) और उनके माध्यम से लूप करें और आपके कोड को निर्दिष्ट करें। आप जेनेरिक का भी उपयोग नहीं कर सकते हैं और केवल पैराम्स ऑब्जेक्ट [] somethings ले सकते हैं; लेकिन अगर आप कर सकते हैं तो मैं दृढ़ता से टाइपिंग की अनुशंसा करता हूं।

यदि कोई इसे देखता है तो कृपया मुझे बताएं कि क्या मैं आधार से बाहर हूं या प्रश्न को गलत समझा रहा हूं ... धन्यवाद!