Question

What does a syntax like this mean in C#?

public abstract class HostFactory<TApp> : ServiceHostFactory
        where TApp : IFoo

Answer 1

Alot going on here and I wonder if this is homework because of the “IFoo”, or maybe you made that replacement to simplify the example.

–: ServiceHostFactory, HostFactory inherits from ServiceHostFactory.

–HostFactory<TApp>, HostFactory is a generic type as it has a type parameter of TApp. Whenever someone uses the HostFactory class, they can specify a type for TApp which will cause that type to be used everywhere TApp appears int he code. So if the class has a function TApp GetApp() and they specify <int> for TApp, then GetApp is actually int GetApp()

–where TApp : IFoo, TApp must implement the IFoo interface(this could have been a class as well, indicating it must inherit from that class, not necesarily directly).

–abstract, HostFactory is an abstract class, meaning other classes can inherit from it, but no code can instantiate the HostFactory itself. This would be like me giving you the frame of a car, and saying, you’re not legally allowed to drive this on the road, but you’re welcome to make a car of your own out of it.

–public HostFactory is public, meaning it is visible to code outside of the assembly in which it was declared.

Edit: More on generics
I will start with a pretty significant quote from MSDN: “Generics are the most powerful feature of C# 2.0.”

You would use generics when you write something that could conceivably work with many types. For example, before we had generics in 2.0, we had to cast everything to an Object before we could place it in a collection, which was really dangerous because the copmpiler couldn’t verify that you were casting to the correct type whenever you later got an item out of the collection. With generics we can do ArrayList<bool> to create an ArrayList of bool’s and now there is no need to cast. The compiler can verify that we are putting bool’s into the collection.

For example, in the above class we can write algorithms that work with things that implement IFoo, knowing only that the object will be able to do things that an IFoo interface has. So I can write an algorithm that calls methods on the IFoo interface, and then my algorithm can be reused in the future by anyone who implements the IFoo interface.