We Keep Coding

The type T must be a reference type in order to use it as parameter while using interface

I got the error for the below code
public static Moq.Mock<T> CreateInstanceOfIMock<T>() {
return new Moq.Mock<T>();
}
I have solved the error it by using referred class type. See this below code
public static Moq.Mock<T> CreateInstanceOfIMock<T>() where T : class
{
return new Moq.Mock<T>();
}
Now I want to move this var mockColorsRepository = new Moq.Mock<IColorsRepository>(); code into common code by using generics. here IColorsRepository is an interface. So I made an interface reference for T instead of class like this below code
public static Moq.Mock<T> CreateInstanceOfIMock<T>() where T : interface
{
return new Moq.Mock<T>();
}
But am getting The type T must be a reference type in order to use it as parameter error. How can I refer interface instead of class to T. How can I achieve this?

class and struct in generic type constaints do not mean the same thing as the class and struct declarations that are used to declare class or struct types. Instead, they only restrict whether a generic type argument is a reference type (class), or a value type (struct).
So when you do where T : class you are not saying that T needs to be a class, you are saying that T needs to be a reference type. Similarly struct for value types.
Interfaces on their own do not have this property, so an interface can be implemented by both a reference type and a value type. As such, restricting your type to be of an interface does not really make sense there.
In your case, Moq requires you to pass a reference type, so you need to transitively carry over that type constraint in all your helper methods:
public static Moq.Mock<T> CreateInstanceOfIMock<T>()
where T : class
{
return new Moq.Mock<T>();
}
That’s all you need to do to create a mock of any valid type. You can use it with an interface using CreateInstanceOfIMock<IColorsRepository>() or any other type.
Of course, at that point, the method does not really make that much sense since it does not give you any benefit over just instantiating the mock yourself.

There's no generic constraint in C# to enforce that a type argument is an interface. But where T : class is really "where T is a reference type" - it includes interfaces.
If you wanted to enforce that T is an interface rather than a class, you could perform an execution-time check using typeof(T) within the method, but in this case it sounds like you don't really need to constrain it to be an interface.
I'm not sure that the "helper" method is particularly useful though - if you compare:
var mock = Helper.CreateInstanceOfIMock<Foo>();
and
var mock = new Moq.Mock<Foo>();
or even (unless you have Mock<T> as another type somewhere) just a using Moq; directive and
var mock = new Mock<T>();
The latter seems just as readable and shorter... it makes sense if you're going to add more logic in your method, but if it's only ever going to call the constructor, I don't think I'd bother with it.

Using T as a generic type to a known struct?

Alright, so I have a known struct, which means, I already have members inside this struct... However, I have other structs that I wanna use in 1 function call.
This is the declaration of a function in some class:
public void OpenFile<T, F, U>(ref T body, ref F recordMap, ref U records);
And this is a call for the function in some other class:
OpenFile<SomeStructure1, SomeStructure2, SomeStructure3>(ref someStructureBodyDefinition, ref someStructureRecordMapDefinition, ref someStructureRecordsDefinition);
So, to dump it all down:
Can I use ANY struct for a function call in a generic type and if so, can you show me how to use members of the struct inside the function?

Can I use ANY struct for a function call in a generic type and if so, can you show me how to use members of the struct inside the function?
Okay, based on the edited question it seems you're trying to understand how to use an instance of a parameter of a generic method, where that parameter's type is one of the method's type parameters.
To do that, you need to be able to generalize that type parameter with a constraint. Since we are talking about a value type here (i.e. struct), the only such generalization possible would be for the type to implement an interface, and for that interface to be declared on the method as a constraint.
E.g.:
interface ISomeInterface
{
void M1();
string P1 { get; }
}
struct MyStruct : ISomeInterface { /* ... */ }
void Method<T>(T t) where T : ISomeInterface
{
// can call M1:
t.M1();
// can get property value P1:
string text = t.P1;
}
If you will be calling this method with different type parameters where the types do in fact implement a common interface, but are not actually declared as such (e.g. all the structs implement an M1() method, but there is no ISomeInterface and/or some or all of the structs aren't declared as implementing such an interface), then you could use dynamic, either in lieu of making that parameter use a generic type parameter at all, or assigning the passed-in value to a dynamic local variable and using that.
If there is no way to generalize the type being used, then you should rethink whether a generic method is really good design at all. It probably isn't in that scenario.

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.

Is it possible to make an anonymous class inherit another class?

This is a long shot, but I have a funny coding situation where I want the ability to create anonymous classes on the fly, yet be able to pass them as a parameter to a method that is expecting an interface or subclass. In other words, I'd like to be able to do something like this:
public class MyBase { ... }
public void Foo(MyBase something)
{
...
}
...
var q = db.SomeTable.Select(t =>
new : MyBase // yeah, I know I can't do this...
{
t.Field1,
t.Field2,
});
foreach (var item in q)
Foo(item);
Is there any way to do this other than using a named class?

No. Anonymous types always implicitly derive from object, and never implement any interfaces.
From section 7.6.10.6 of the C# 5 specificiation:
An anonymous object initializer declares an anonymous type and returns an instance of that type. An anonymous type is a nameless class type that inherits directly from object.
So if you want a different base class or you want to implement an interface, you need a named type.

No. From the documentation:
Anonymous types are class types that derive directly from object, and that cannot be cast to any type except object.
To solve your problem, just replace the anonymous type with normal class...

Cannot extend an anonymous but you could declare your method to accept a dynamic parameter if you really need this to work.

Short answer: no
Long answer:
You could use a C# proxy class. There are several tools that can proxy classes. For example Moqs. https://github.com/moq/moq4

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).