C#

George_George wrote:

For 1, from your comments, I think it is also a common feature for any non-generics types -- compile to native code (JIT) only once when the type is used 1st time. The article should mentioned something special for generics?

class Gen<T>
{
}

George_George wrote:

For 2, "In C#, a generic type parameter cannot itself be a generic, although constructed types can be used as generics. C++ does allow template parameters." You mentioned "Constructed types are those that have been JIT'ed.", but what are not JITed (in your points not allowed)? I think during runtime, every type is JITed.

George_George wrote:

For 3, I do not know the differences, both C++ and C# will report compile error other than runtime error when met with some unsupported operator on a specific input parameter type, right?

S. Senthil Kumar wrote:

The statement that you mentioned means that you can't have generic generic type parameters - unlike C++, which allows template template types as template parameters.

using System;
using System.Collections.Generic;

class Test
{
    static void Main()
    {
        Generic<Generic2<List<int>>> gen = new Generic<Generic2<List<int>>>();
    }

}

class Generic<T>
{
    List<T> list1 = new List<T>();
    List<int> list2 = new List<int>();
    List<Generic2<T>> gen1 = new List<Generic2<T>>();
    List<Generic2<int>> gen2 = new List<Generic2<int>>();
}

class Generic2<U>
{
}

S. Senthil Kumar wrote:

In .NET, the generic type can be part of a different assembly from the code attempting to use it,

George_George wrote:

Means a genetics type defined in one assembly, but used/referred from another assembly? So, C# can do binary level (IL) reference, but C++ could only do source code level (header file) reference?

George_George wrote:

Therefore, the C# compiler forces you to declare constraints" -- we can define a generics type without defining any constraints, right?

In what situations, do we have to define constraints when define a generics type?

class G<T>
{
   T t;
   public G(T t)
   {
     this.t = t;
   }

   public void Method()
   {
      t.SayHello();
   }
}

interface IHello
{
   void SayHello();
}

class Hello : IHello
{
   public void SayHello() { Console.WriteLine("Hello"); }
}

static void Main()
{
   Hello h = new Hello();
   G<Hello> g = new G<Hello>(h);
   g.Method();
}

class G<T> where T : IHello
{...}

George_George wrote:

I think the points from the document is, we can not use open constructed type, but only can use close constructed type as type parameter to generics, right? I think I already provide the open constructed type -- List<generic2><t>> gen1, but it could still compile.

template <typename T, template <typename> Container>
class A
{

}

George_George wrote:

Why you stress the point that a different assembly?

George_George wrote:

1.

I want to confirm that the answer to my question #3 is, C# is using constraints to check whether a type is supported or not, but C++ will generate the specific type to check whether the operation is supported or not, right?

George_George wrote:

But from your sample below, I learned more. It seems C# compiler will check more than just the constraints, in your sample, without constraints, it will parse the invoked method to see whether it is supported, right?

<br />
public void Compress(Stream source, Stream target)<br />