C # generics - можно создать метод с n универсальных типов ..?

Question

Я не думаю, что это возможно, но здесь идет ...

Я хочу добавить метод, который может обрабатывать n числовых выражений. например:

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

C # Вывод интерактивного окна:

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

Таким образом, вы можете взять ваши типы, которые вы хотите (которые соответствуют универсальному), пройти через них и вызвать ваш код, как вы указали. Вы также не можете использовать дженерики и просто взять в params object [] что-то; но я бы настоятельно рекомендовал напечатать его, если можете.

Если кто-нибудь увидит это, пожалуйста, дайте мне знать, если я далеко от базы или неправильно понял вопрос ... Спасибо!

Answer 3

На самом деле я только что заметил эту ссылку - я должен идти домой сейчас, но я мог бы попробовать что-то вроде этого позже, если это сработает:

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

Я думаю, если я прошел вмассив типов и перебрал типы с отражением, это будет работать.

Answer 4

вы, кажется, повторяете ту же ошибку, что, возможно, когда-то делал Ньютон.У него две кошки, одна была больше, а другая меньше.Он сделал два отверстия в двери, большее отверстие для большего и меньшее для маленького кота.Где на самом деле ему нужна была одна большая дыра, чтобы помочь обеим кошкам.

Почему бы вам не создать один единственный метод, который может обрабатывать столько типов, сколько вы хотите ..

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