We Keep Coding

Using the name of a generic type in a class attribute

I have a generic class which needs to use the name of one of its type arguments in a class attribute. I don't know how to access the class name in that context
I've tried using typeof(TMsg).Name but VS shows an error saying
An attribute argument must be a constant expression, typeof expression or array creation expression of an attribute parameter type
Currently my code looks like this:
[MessageBase(typeof(TMsg).Name)]
public abstract class DDSMessageAbstract<TMsg/*, TReader, TWriter, TMsgBase, TSupport*/> : MessageBaseForDDS
where TMsg : new()
...
My question is, is there a way for me to use the actual name of TMsg or must I define this attribute for each inheriting class?

The short answer might be you could not do that.
First, the generics is for your class instead of your attribute. so you can't use
MessageBase(typeof(TMsg)
The values into attributes are limited to simple types; for example, basic constants (including strings) and typeof.
From ECMA 334v4:
§24.1.3 Attribute parameter types
The types of positional and named
parameters for an attribute class are
limited to the attribute parameter
types, which are:
One of the following types: bool, byte, char,
double, float, int, long, short, string.
The type object.
The type System.Type.
An enum type, provided it has public accessibility and the
types in which it is nested (if any)
also have public accessibility.
Single-dimensional arrays of the above
types.
ECMA-334

C# usage of where statement after function signature [duplicate]

I'm looking at the source code for the MvcContrib Grid and see the class declared as:
public class Grid<T> : IGrid<T> where T : class
What does the where T : class bit do?

It is a generic type constraint.
In this case it means that the generic type (T) must be a reference type, that is class, interface, delegate, or array type.
Other constraints are listed here.
You can also constrain the generic type to inherit from a specific type (base class or interface)

Another examples would be
public A<T> where T : AnInterface
where AnInterface is a interface class. It means then, that T must implement this interface.
These constraints are important, so that the compiler knows the operations which are valid for the type. For example you can not call functions of T without telling the compiler what functions the type provides.

From the Docs http://msdn.microsoft.com/en-us/library/d5x73970.aspx
where T : class
The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.

It is a constraint on the type argument which says that T can either be a class or an interface but not an enum or a struct. So T must be a reference type and not a value type.
Best Regards,
Oliver Hanappi

It restricts T to be a reference type, including any class, interface, delegate, or array type.

It's a generic type constraint. It specifies that the type T has to be a reference type, i.e. a class and not a structure.

you can apply restrictions to the kinds of types that client code can use for type arguments when it instantiates your class are called as Constraints on Type Parameters
E.g : where T : class
Here where T is the Type , The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.

Generic with multiple constraints

I'm trying to call a method with a definition similar to the following (simplified to avoid confusion):
public static void Register<T>(T value) where T : BaseClass, IInterface
This works fine so long as I have a class instance that defines both of those values. The problem occurs when I pass a `BaseClass' into a method and then try to use that instance in the above declaration. For example:
public class MyClass
{
public MyClass(BaseClass value)
{
Register(value);
}
}
I can pass and instance of a class that implements both BaseClass and IInterface into the constructor, but when I try to use that value in the Register method I get a compilation error stating:
The type 'BaseClass' cannot be used as type parameter 'T' in the generic type or method 'Register(T)'. There is no implicit reference conversion from 'BaseClass' to 'IInterface'.
If I change the type in the constructor like so:
public class MyClass
{
public MyClass(IInterface value)
{
Register(value);
}
}
I get an error stating:
The type 'IInterface' cannot be used as type parameter 'T' in the generic type or method 'Register(T)'. There is no implicit reference conversion from 'IInterface' to 'BaseClass'.
This seems like a bit of a catch-22. Is there a way that I can define the parameter to indicate that it must implement both BaseClass and IInterface?

As I was writing the question I came up with the answer and thought I would post it instead of deleting the question.
I just need to redefine the class:
public class MyClass<T> where T : BaseClass, IInterface
{
public MyClass(T value)
{
Register(value);
}
}

The solution given by Matt is an easy answer for situations where it is not necessary to store the passed-in object in a field or collection. If you need to persist the passed-in object, things get much harder. It's easy for a SomeClass<T> where T meets multiple constraints, to store items of class T and pass them as generics to routines with such constraints, but if a class has a method SomeMethod<TParam>(TParam thing) where TParam:IFoo,BaseBar, it won't have any field of type TParam. It could store thing into a field of type IFoo or BaseBar, but unless BaseBar implements IFoo, or all passed-in instances are going to derive from one particular BaseBar derivative which implements IFoo, there's no way to specify that a field's type will meet both constraints (if every instance does derive from one particular BaseBar derivative which implements IFoo, one could simply use that type as a single constraint, or for that matter not bother with generics at all—just use that as the parameter type).
There are ways of getting around these issues, either using Reflection, an interface pattern I call ISelf<T>, or some tricky nested callback interfaces. In some cases, though, it may be better to provide alternatives to methods that take double-constrained parameters (have the methods take a parameter of one constraint type, cast it to the other type, and accept the lack of compile-time safety).

Generic interface in C#

I have a generic interface and I want to constrain types that this generic parameter can accept. Here is the interface:
public interface IBaseRequestRepository<T> where T : IRequestPackage,
IRequestDynamicPackage, IRequestHotelOnly, IRequestFlightOnly
{
IList GetByOccupancyAndTravelDate(int occupancyId, int travelBegYear,
int travelBegDate, int travelEndYear,
int travelEndDate);
}
But this gives an error:
Error 1 The type 'IRequestPackage' cannot be used as type parameter 'T' in the generic type or method 'IBaseRequestRepository'. There is no implicit reference conversion from 'IRequestPackage' to 'IRequestFlightOnly'.
Any suggestions?

You need to satisfy all generic constraints and not just one.
Thus you can't substitute IRequestPackage into T because it doesn't derive from all the other interfaces.
You can pass in either an interface type that inherits from all the interfaces you specified as a constraint or a class type that implements all these interfaces.

The error message suggests that IRequestPackage does not inherit from IRequestFlightOnly - does it?
Note that the where clause is an AND relationship, not an OR - so your where clause is that T must implement ALL of
IRequestPackage,
IRequestDynamicPackage
IRequestHotelOnly,
and IRequestFlightOnly

Looks like you want an IRequest interface or RequestBase abstract class ;)

You should use a type that implement all the interfaces specified by the constraint, not just one of them. It's an "AND", not an "OR"...

You should reconsider your type constraints and your program structure. It looks like you are missing a base interface or an abstract base class.

Can C# generics have a specific base type?

Is it possible for a generic interface's type to be based on a specific parent class?
For example:
public interface IGenericFace<T : BaseClass>
{
}
Obviously the above code doesn't work but if it did, what I'm trying to tell the compiler is that T must be a sub-class of BaseClass. Can that be done, are there plans for it, etc.?
I think it would be useful in terms of a specific project, making sure a generic interface/class isn't used with unintended type(s) at compile time. Or also to sort of self-document: show what kind of type is intended.

public interface IGenericFace<T> where T : SomeBaseClass

What your are referring to is called "Generic Constraints". There are numerous constraints that can be put on a generic type.
Some basic examples are as follows:
where T: struct - The type argument must be a value type. Any value type except Nullable - can be specified. See Using Nullable Types (C# Programming Guide) for more information.
where T : class - The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.
where T : new() - The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.
where T : <base class name> - The type argument must be or derive from the specified base class.
where T : <interface name> - The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic.
where T : U - The type argument supplied for T must be or derive from the argument supplied for U. This is called a naked type constraint.
These can also be linked together like this:
C#
public class TestClass<T> where T : MyBaseClass, INotifyPropertyChanged, new() { }
public interface IGenericFace<T> where T : SomeBaseClass
VB
Public Class TestClass(Of T As {MyBaseClass, INotifyPropertyChanged, New})
Public Interface IGenericInterface(Of T As SomeBaseClass)

yes.
public interface IGenericFace<T>
where T : BaseClass
{
}