how to cast a generic type to another type?

Question

As shown in the first class displayed, I need to cast Activité to Réunion (Réunion extends Activité) but the compiler tells me that I can't. Why? I'll put a scheme so you can better understand my classes structure and also all my other classes. Thank you.

class Employé<T>
{
    private string nom;
    private Local bureau;
    private LinkedList<Activité<T>> activités;

    public Employé(string nom, Local bureau)
    {
        this.nom = nom;
        this.bureau = bureau;
    }

    public void AjouteActivité(params Activité<T>[] activités)
    {
        foreach(Activité<T> activité in activités)
        {
            if (activité as Réunion != null)
                // here's the problem !!! ((Réunion)activité).EmployéConvoqués = activité;
        }
    }
}

Here's the scheme of my classes structure:

And here are the other classes:

abstract class Activité<T>
{
    private string label;
    private DateTime début, fin;
    private T lieu;
    private readonly int id;
    private static int CPT = 0;

    public Activité(string label, DateTime début, DateTime fin, T lieu)
    {
        this.label = label;
        this.début = début;
        this.fin = fin;
        this.lieu = lieu;
        this.id = ++CPT;
    }

    public override string ToString()
    {
        return $"{id} : {label}(de {début} à {fin}) - {DescriptionLieu()}";
    }

    public double Duree()
    {
        return fin.Subtract(début).TotalMinutes;
    }

    public int Id
    {
        //tester get; seulement
        get
        {
            return id;
        }
    }

    public T Lieu
    {
        get
        {
            return lieu;
        }
    }

    public abstract string DescriptionLieu();
}

class ActivitéExtérieure : Activité<string>
{
    public ActivitéExtérieure(string label, DateTime début, DateTime fin, string lieu) : base(label,début,fin,lieu) { }

    public override string DescriptionLieu()
    {
        return Lieu;
    }
}

class ActivitéInterne : Activité<Local>
{
    public ActivitéInterne(string label, DateTime début, DateTime fin, Local lieu) : base(label,début,fin,lieu)
    {
        lieu.AjouteActivité(this);
    }

    public override string DescriptionLieu()
    {
        return $"local :: {Lieu.NumComplet}";
    }
}

class Employé<T>
{
    private string nom;
    private Local bureau;
    private LinkedList<Activité<T>> activités;

    public Employé(string nom, Local bureau)
    {
        this.nom = nom;
        this.bureau = bureau;
    }

    public void AjouteActivité(params Activité<T>[] activités)
    {
        foreach(Activité<T> activité in activités)
        {
            if (activité as Réunion != null)
                ((Réunion)activité).EmployéConvoqués = activité;
        }
    }
}

class Local
{
    private int etage;
    private int numero;
    private bool possedeWifi;
    private Dictionary<int, ActivitéInterne> historiquesActivités;

    public int Numero
    {
        get
        {
            return numero;
        }
        set
        {
            if (value < 0 || value > 99)
                throw new IndexOutOfRangeException();
            else
                numero = value;
        }
    }

    public int NumComplet
    {
        get
        {
            return etage * 100 + numero;
        }
    }

    public bool PossedeWifi
    {
        get
        {
            return possedeWifi;
        }
    }

    public Local(int etage, bool possedeWifi, int numero)
    {
        this.etage = etage;
        this.possedeWifi = possedeWifi;
        Numero = numero;
    }

    public Local(int etage, int numero) : this(etage, true, numero) { }

    public Local(int local, bool possedeWifi) : this(local / 100, possedeWifi, local % 100) { }

    public void AjouteActivité(ActivitéInterne a)
    {
        historiquesActivités.Add(a.Id, a);
    }
}

class Réunion : ActivitéInterne
{
   private HashSet<Employé<Local>> employésConvoqués;
   public Réunion(string label, DateTime début, DateTime fin, Local lieu) : base(label, début, fin, lieu) { }

   public Employé<Local> EmployéConvoqués
   {
        set
        {
            employésConvoqués.Add(value);
        }
   }
}

Answer 1

The error message says that "cast is redundant". This is because you have already tested for "activité as Réunion != null". The compiler figures out that in the 'if' clause this condition is already true, therefore the cast is not meaningful. On the other hand you cannot access activité.EmployéConvoqués because the static type of activité is not Réunion.

All you have to do is introduce a new variable when testing the type. Like this:

if (activité is Réunion réunion) {
    réunion.EmployéConvoqués = activité;    
}

However if you try this you will see that the assignment cannot be done because you are trying to assign an activity to an Employé<Local>. These are not compatible types. Perhaps you meant something like

        foreach (Activité<T> activité in activités) {
            if (activité is Réunion réunion && this is Employé<Local> employéLocal) {
                réunion.EmployéConvoqués = employéLocal;
            }
        }

Comment: in the definition of Réunion you are adding to HashSet<Employé<Local>> employésConvoqués when setting the property Employé<Local> EmployéConvoqués. From a style point of view this is strange because people generally expect a property of type Employé<Local> will represent a single Employé<Local> rather than a collection of Employé<Local>. I would suggest that you remove the setter and instead define

    public void Ajoute( Employé<Local> employéConvoqué) {
         this.employésConvoqués.Add(employéConvoqué);
    }