Shadowing generic method class constraint

c# generic type constraint
class type constraint
c# generic method
generic method with multiple type parameters c#
scala type constraint
c# generic nullable constraint
c# generic class constructor
c# generic inherit from type

Is there a way store IReturn<T> ... where T : class, IFeatureX in variable type IReturn<IFeatureX> or can you explain why this cannot be done?


Lets say that I have a container constructor:

public ContainerX(IReturn<IFeatureX> body) : this()
{
    Body = body;
}

I want to say that IFeatureX extends also class, I have tried changing the constructor to private and using:

public static ContainerX CreateInstance<T>(IReturn<T> instance) 
  where T : class, IFeatureX => new ContainerX { Body = instance };

However c# does not know that IReturn<T> ... where T : class, IFeatureX is IReturn<IFeatureX>.

It seems that I cannot cast or safe cast it.

I cannot use object or dynamic because IFeatureX is actually IProtobufBody and it is a label interface that I use to make a integration test level guarantee that all assemblies that store instances in the container have a protobuf contract defined.

You simply need to make IReturn<T> covariant by declaring it as IReturn<out T>. You can read more about covariance and contravariance here.

where (generic type constraint), Constraints can specify interfaces, base classes, or require a generic You can also attach constraints to type parameters of generic methods,  If your generic class or method uses any operation on the generic members beyond simple assignment or calling any methods not supported by System.Object, you'll have to apply constraints to the type parameter. For example, the base class constraint tells the compiler that only objects of this type or derived from this type will be used as type

This is a problem of covariance and contravariance (see here).

Lets say you have a class called Dog which inherits from Animal, consider the following code:

List<Dog> l = new List<Dog>();
List<Animal> la = l;
la.Add(new Giraffe()); // this is not allowed

This example shows why it is not allowed by default.

There are the keywords in and out that lets you use the contravariance and covariance like IReturn<in T>or IReturn<out T>.

When you use in, then you can store a IReturn<Object> object in a variable of type IReturn<Class> and define functions in IReturn that use T as input variable Type.

When you use out, then you can store a IReturn<Class> object in a variable of type IReturn<Object> and define functions in IReturn that use T as return Type.

If you need T to be an input variable type in some functions and a return type in other functions, then you can only work with the exact class.

Scala Generics III: Generalized type constraints, Scala Generics III: Generalized type constraints In this example, the parking method can return any type of vehicle, just as Obviously, the clue that the IDE gave us: Suspicious shadowing by a type parameter means that  Here you have a class Container, that defines a generic parameter T, with a constraint that anyone wants to use this class, must pass an argument that implements the IItem Interface. So here we added the IItem Interface, that has a method showName(). We also added a class Item, that will implement IItem Interface.

Sorry, the other answers were not applicable. In this particular case the answer was to have

IReturn<T> ... where T : FeatureBase

and have instances extend FeatureBase.

Scala Generics: Generalized Type Constraints (Part 3), This entry in this series on Scala generics builds on type bounds and use In this example, the parking method can return any type of vehicle, just as the IDE gave us: Suspicious shadowing by a type parameter means that  In c#, constraints are used to restrict a generics to accept only the particular type of placeholders. By using where keyword, we can apply constraints on generics. In c#, you can apply multiple constraints on generic classes or methods based on your requirements.

How to work with generics in C#, Generics enables you to work with type safe data with no boxing and You can leverage generics to create typesafe collections, create classes and methods that Amid the pandemic, using trust to fight shadow IT · 5 tips for running a constrained to defining the type of any object you need to work with. C#: Constraints in Generics. You have learned about the generics in the previous section. Generics allow you to define a class with placeholders for the type of its fields, methods, parameters, etc. Consider the following example of a generic class.

Common LISP: The Language, series-element-type, type specifier,950 series expressions constraint cysles, 822 (set f class-name) primary method, 822 (set f documentation) generic function, type declarations and, 222 See also extent; scope : Shadowing-import - from  The main change was related to generics, starting from C# 7.3 there 3 more constraints: unmanaged, System.Enum and System.Delegate. The unmanaged constraint The unmanaged constraint on generic type T enforces the type to be an ‘unmanaged’ struct that does not recursively contain reference type fields.

Visual Basic 2012 Programmer's Reference, This appendix summarizes generic classes, extensions, and methods. a generic class is as follows: [attribute_list] [Partial] [accessibility] [Shadows] Each type can be optionally followed by the keyword As and a list of constraints that the  Makes sense for calling methods, but what prevents a feature like this from existing in this particular use case - where an object is passed along to an overloaded method that actually does something different? I.e. Is there a reason the compiler cannott only verify T is the proper type (and disallow any methods be called on T in that method)?

Comments
  • IFeatureX => new ContainerX { Body = instance }; is surely something that is evaluated at runtime, whereas generics are a compile-time feature. What exactly would you achieve by this assignment? Just ommit the new part. Anyway IFeature is a really bad name for a class. Most people would interpret the leading I as an indicator for an interface.
  • @HimBromBeere like I mentioned I replaced IProtobufBody with IFeature so that it would not sidetrack attention, the same way ContainerX is actually a RabbitMq message storing servicestack request, a "promise" to return response.