Indicate that an interface can only be implemented using C # reference types

Question

If I declare an interface in C #, is there any way to explicitly declare that any type of implementation of this interface is a reference type?

I want to make sure that wherever I use the interface as a type parameter, I do not need to indicate that the implementation type must also be a reference type.

An example of what I want to accomplish:

public interface IInterface { void A(); int B { get; } } public class UsingType<T> where T : IInterface { public void DoSomething(T input) { SomeClass.AnotherRoutine(input); } } public class SomeClass { public static void AnotherRoutine<T>(T input) where T : class { // Do whatever... } } 

Since the argument SomeClass.AnotherRoutine() must be a reference type, here I get a compiler error where I call the method, assuming that I force T be a reference type ( where T : IInterface, class in the declaration of UsingType ). Is there a way that I can apply this already at the interface level?

 public interface IInterface : class 

doesn't work (obviously), but maybe there is another way to accomplish the same thing?

Answer 1

If you pass something in the interface, then even if you have a value type that implements this interface, it will become a box if applied to the interface and behaves like a reference type (because it is placed inside the reference type).

 interface IFoo { int Value { get; set; } } struct Foo : IFoo { public int Value { get; set; } } 

Observe effects when using a value type:

 var a = new Foo() { Value = 3 }; var b = a; // copies value b.Value = 4; Console.WriteLine( "a has {0}", a.Value ); //output: a has 3 Console.WriteLine( "b has {0}", b.Value ); //output: b has 4 

Now let's see what happens when you add it to the interface:

 var a = new Foo() { Value = 3 } as IFoo; //boxed var b = a; // copies reference b.Value = 4; Console.WriteLine( "a has {0}", a.Value ); //output: a has 4 Console.WriteLine( "b has {0}", b.Value ); //output: b has 4 

Thus, it does not matter if the structure or class implements the interface. If it is passed to the interface and then passed through the interface, it will behave like a reference type.

Edit : If these are your requirements ...

For contract X:

• Throw a compilation error if struct implements / inherits X.
• X cannot be an abstract class.

Well, you just got stuck then because they contradict each other.

• The only way to get a compilation error if the structure implements / inherits the contract is an abstract class.
• Since you cannot use an abstract class to preserve open inheritance options, you need to use an interface.
• The only ways to enforce the rule that the structure cannot implement the interface will be performed at run time.

Using the where T: class, IFoo will not work all the time. If I had this method (based on the same Foo and IFoo above):

 static void DoSomething<T>(T foo) where T: class, IFoo { foo.Value += 1; Console.WriteLine( "foo has {0}", foo.Value ); } 

Then in this case a compilation error will be selected:

 var a = new Foo(){ Value = 3 }; DoSomething(a); 

But in this case it will be very good:

 var a = new Foo(){ Value = 3} as IFoo; //boxed DoSomething(a); 

So, as far as I can tell, use the where T: class, IFoo constraint, and then it may not matter if the structure implements the interface if it is boxed. Depending on what check the EF does if the boxed structure is transferred. Maybe it will work.

If that doesn't work, at least the general constraint gives you part of the path and you can check foo.GetType().IsValueType (referring to my DoSomething method above) and throw an ArgumentException to handle the case of nested structures.

Answer 2

http://msdn.microsoft.com/en-us/library/d5x73970.aspx . It looks like you can specify its “class”, which means a reference type.

Answer 3

I do not think that you can restrict interfaces this way, unfortunately. According to msdn, interfaces can be implemented by any type, both structures and classes: /

Answer 4

The behavior in the behavior of volatile structures passed as interfaces can certainly be annoying. I do not know that a ban on all structures will be necessary. There are a number of cases where it can be useful to have an immutable structure that transfers an object of a class (for example, one way to implement something like a dictionary that supports several enumeration methods would be to use dictionary words and a dictionary. Structures, each of which has a link to the dictionary, and each of them provides a special GetEnumerator method; the dictionary is not implemented that way, but this is not a bad template). Such a template can avoid boxing in cases where you call GetEnumerator directly on the object (since vb.net and C # both run with their duck foreach loops); because structures are immutable, even when boxing really deals with a performance issue, not with correctness.