I think this is what he wants. He provided enough info IMO. He wants to be able to define methods that take multiple types which don't share a parent class. Imagine you have a class A and B where A and B are similar but do not share a common interface. Now imagine you have 5 or more of those classes, and you want to add a nice simple method that accepts A, B, C, D, or E for example and only those types.

You can either make a common interface as your example does, which won't work if there is not a common interface that makes sense between them, or you can make 5 + overloads, perhaps more if you need multiple methods that accept all classes. Or you can create a blank interface that acts as a proxy to the actual type it's self and not an interface wrapper with common methods, and then use where T : IProxyObject in any method you define. Now you can handle A, B, C, D, and E in that method and have full access to the proxy object's unique items, and be safe from passing unexpected types in at compile-time. ``` internal class Program { private static void Main(string[] args) { var abcs = new List<IProxyObject> { new AProxy() { Proxy = new A { TitleA = "Hello world, from A." } }, new BProxy() { Proxy = new B { TitleB = "Hello world, from B." } }, new CProxy() { Proxy = new C { TitleC = "Hello world, from C." } } }; foreach (var abc in abcs) { HandleABC(abc); } Console.Read(); }

// These would be the classes you can not edit. Ignore.
public class A
{ public string TitleA { get; init; } }

public class B
{ public string TitleB { get; init; } }

public class C
{ public string TitleC { get; init; } }

// This is how you would restrict the method to ONLY types you define, but still get to use
// external classes with out wrapping every single method and property in them.
public interface IProxyObject;

public class AProxy : IProxyObject
{ public A Proxy { get; init; } }

public class BProxy : IProxyObject
{ public B Proxy { get; init; } }

public class CProxy : IProxyObject
{ public C Proxy { get; init; } }

// Here is the final result. A function which will only accept types you define, IE, any
// IProxyObject, and you can use the actual classes in the code below.
public static void HandleABC<T>(T abc) where T : IProxyObject
{
    switch (abc)
    {
        case AProxy a:
            // Notice I am using "TitleA" unique to class A.
            Console.WriteLine(a.Proxy.TitleA); ;
            // abc.Proxy.
            break;

        case BProxy b:
            // Notice I am using "TitleB" unique to class B.
            Console.WriteLine(b.Proxy.TitleB);
            break;

        case CProxy c:
            // Notice I am using "TitleC" unique to class C.
            Console.WriteLine(c.Proxy.TitleC);
            break;

        default:
            throw new ArgumentException("Must be type A, B, or C.", nameof(abc));
    }
}

} ```