Могу ли я ограничить общий метод более чем одним интерфейсом?

Это прекрасно компилируется для меня:

interface I1 { int NumberOne { get; set; } }
interface I2 { int NumberTwo { get; set; } }

static void DoSomething<T>(T item) where T:I1,I2
{
    Console.WriteLine(item.NumberOne);
    Console.WriteLine(item.NumberTwo);
}

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

Пусть Interface1 и Interface2 происходят от одного и того же базового интерфейса. Бывший:

    public static void DoSomething<T>() where T : ICommon
    {
        //...
    }

    public interface IInterface1 : ICommon
    {}

    public interface IInterface2 : ICommon
    { }

    public interface ICommon
    { }

Преимущество этого способа заключается в том, что вам не нужно постоянно обновлять определение DoSomething() каждый раз, когда вы добавляете новый интерфейс, наследуемый от ICommon.

Изменить: если у вас нет контроля над интерфейсами, у вас есть несколько вариантов. Вот одна вещь, которую вы могли бы сделать...

    protected static class DoSomethingServer<T1> where T1 : class
    {

        //Define your allowed types here
        private static List<Type> AllowedTypes = new List<Type> {
            typeof(IInterface1),
            typeof(IInterface2)
        };

        public static MethodInvoker DoSomething()
        {
            //Perform type check
            if (AllowedTypes.Contains(typeof(T1)))
            {
                return DoSomethingImplementation;
            }
            else
            {
                throw new ApplicationException("Wrong Type");
            }
        }

        private static void DoSomethingImplementation()
        {
            //Actual DoSomething work here
            //This is guaranteed to only be called if <T> is in the allowed type list
        }
    }

Использовать как таковой:

DoSomethingServer<IInterface1>.DoSomething();

К сожалению, это лишает безопасности тип во время компиляции, и он взорвется только во время выполнения, если вы попытаетесь ввести неправильный тип. Очевидно, что это далеко от идеала.

Если вы имеете в виду, что параметр может быть либо реализацией I1, либо реализацией I2, и они являются несвязанными типами, то вы не можете написать одну группу методов (т. е. перегрузки с одинаковым именем метода) для обработки обоих типов.

Вы даже не можете сказать (заимствуя у надера!):

    interface I1 { int NumberOne { get; set; } }
    interface I2 { int NumberTwo { get; set; } }

    static void DoSomething<T>(T item) where T : I1
    {
        Console.WriteLine(item.NumberOne);
    }

    static void DoSomething<T>(T item) where T : I2
    {
        Console.WriteLine(item.NumberTwo);
    }

    static void DoSomething<T>(T item) where T : I1, I2
    {
        Console.WriteLine(item.NumberOne);
        Console.WriteLine(item.NumberTwo);
    }

Это дало бы компилятору возможность обрабатывать все возможности без двусмысленности. Но чтобы помочь с управлением версиями, C# старается избегать ситуаций, когда добавление/удаление метода меняет применимость другого метода.

Вам нужно написать два метода с разными именами для обработки двух интерфейсов.

один из способов - создать дополнительный интерфейс, который расширяет оба интерфейса, Interface1 и 2. Затем вы помещаете этот интерфейс вместо двух других.

это один из способов сделать это в java; если я правильно помню, это должно работать и в С#

надеюсь, это поможет.

привет, тоби тоже :P

    public interface IInterfaceBase
    {

    }
    public interface IInterface1 : IInterfaceBase
    {
      ...
    }
    public interface IInterface2 : IInterfaceBase
    {
      ...
    } 

    public static void DoSomething<T>() where T: IInterfaceBase
    {
    }

Если вы хотите, чтобы T был IInterface1 или IInterface2, используйте приведенный выше код.

Опираясь на то, что сказал Эрвикер... имена - не единственный путь. Вы также можете изменить сигнатуры методов...

public interface I1 { int NumberOne { get; set; } }
public interface I2 { int NumberTwo { get; set; } }

public static class EitherInterface
{
    public static void DoSomething<T>(I1 item) where T : I1
    {
        Console.WriteLine("I1 : {0}", item.NumberOne);
    }

    public static void DoSomething<T>(I2 item) where T : I2
    {
        Console.WriteLine("I2 : {0}", item.NumberTwo);
    }
}

Что при проверке следующим образом:

public class Class12 : I1, I2
{
    public int NumberOne { get; set; }
    public int NumberTwo { get; set; }
}

public class TestClass
{
    public void Test1()
    {
        Class12 z = new Class12();
        EitherInterface.DoSomething<Class12>((I1)z);
        EitherInterface.DoSomething<Class12>((I2)z);
    }
}

Дает этот вывод:

I1 : 0
I2 : 0

Это соответствует цели предоставления вызывающей стороне одного имени метода, но не помогает вам, поскольку вы не используете параметры.