C# wywoływanie klas generycznych

Mam pewnien problem z zadaniem. Poniżej mam taki oto main. Misja doprowadzić to do działania.

Punkt<int> p1 = new Punkt<int>(1,2); 
Punkt<double> p2 = new Punkt<double>(1.0, 2.2); 
 
Console.WriteLine(p1.ToString()); 
Console.WriteLine(p2.ToString());

Posiłkując się dokumentacją wykopałem taki przykład, który próbowałem zaimplementować (to tylko przykład):

class Program
{
 
    static void Main(string[] args)
    {
 
        KlasaGeneryczna<int> obiektKlasyGenerycznej = new KlasaGeneryczna<int>();
        obiektKlasyGenerycznej.Dodaj(12);
 
        KlasaGeneryczna<string> obiektKlasyGenerycznej1 = new KlasaGeneryczna<string>();
        obiektKlasyGenerycznej1.Dodaj("napis");
 
 
        Console.ReadKey();
    }
 
    public class KlasaGeneryczna<T>
    {
        public void Dodaj(T parametr)
        {
            Console.WriteLine("Wynik metody Dodaj: " + parametr);
        }
    }      
        
}

Koniec końców mam taki kod, który się kompiluje, ale wyświetla nie to, co powinno. Skorzystałem z podpowiedzi vs:

    class Program
    {
        static void Main(string[] args)
        {
            Punkt<int> p1 = new Punkt<int>(1, 2);
            Punkt<double> p2 = new Punkt<double>(1.0, 2.2);

            Console.WriteLine(p1.ToString());
            Console.WriteLine(p2.ToString());
        }
    }
        class Punkt<T>
        {
            private int v1;
            private int v2;
            private double v;
            private double v3;

            public Punkt(int v1, int v2)
            {
                this.v1 = v1;
                this.v2 = v2;
            }

            public Punkt(double v, double v3)
            {
                this.v = v;
                this.v3 = v3;
            }

Wynikiem działania jest:

Korzystając z przykłady owej klasy dopisałem:

 public void Dodaj(T p1)
            {
                Console.WriteLine("Wynik metody Dodaj: " + p1);
            }
            public void Dodaj2(T p2)
            {
                Console.WriteLine("Wynik metody Dodaj: " + p2);
            }

Lecz po prostu nic się nie dzieje. Efekt jest nadal taki jak na screenie.
Jest w stanie ktoś mi to objaśnić?

Przeciąż metodę ToString w tej swojej klasie jak chcesz w ten sposób wyświetlać. Ale ta klase masz źle napisana. Nie twórz pol dla każdego typu tylko powinno to mniej więcej tak wyglądać

Public T V1
Public T V2

I jeden konstruktor z generycznymi parametrami.

Generyki polegają na podstawianiu typów, a ty zahardkodowałeś je w te klasie. Zamiast 2 x int i 2 x double w tej klasie powinno być v1 i v2 typu generycznego (twoje T), bo chcesz go podstawić.

ToString() wywołujesz nie na wartościach tej klasy, a na instancji tej klasy, czyli wynik jest dobry, bo dostajesz domyślnie opis typu

Jakbyś nadpisał ToString() w tej klasie - public override ToString() { return "napis"; } to by przeszło

@WeiXiao:
@kzkzg

Może na tym przykładzie. Uproszczone, niby działa.
Ale to nie jest tak jak być powinno napisane nadal.

 class Program
    {
        static void Main(string[] args)
        {
            Punkt<int> p1 = new Punkt<int>(1, 2);
            Punkt<double> p2 = new Punkt<double>(1.0, 2.2);
            Console.WriteLine(p1.ToString());
            Console.WriteLine(p2.ToString());
        }
    }
    class Punkt<T>
    {
        public Punkt(int v, int v3)
        {
        }

        public Punkt(double v4, double v5)
        {
        }

        public void Dodaj(T p1)
        {
            Console.WriteLine("Wynik p1: " + p1);
        }
        public void Dodaj2(T p2)
        {
            Console.WriteLine("Wynik p2: " + p2);
        }
    }

Jeśli rozumiem, to powinno być tak:

        public Punkt(T v, T v3)
        {
        }

  public Punkt(T v4, T v5) //blad. działa jeśli double. Wyżej działa z T
        {
        }

Tak nie powinno być:

public Punkt(T v, T v3)
{
}

public Punkt(T v4, T v5) //blad. działa jeśli double. Wyżej działa z T
{
}

przecież to są te same konstruktory.

O takie coś ci chodziło ?

using System;

class Program
{
    static void Main(string[] args)
    {
        Punkt<int> p1 = new Punkt<int>(1, 2);
        Punkt<double> p2 = new Punkt<double>(1.0, 2.2);

        Console.WriteLine(p1);
        Console.WriteLine(p2);
    }
}
class Punkt<T>
{
    private T x;
    private T y;


    public Punkt(T x, T y)
    {
        this.x = x;
        this.y = y;
    }

    public override string ToString()
    {
        return String.Format("x = {0}, y = {1}", x, y);
    }
}

Domyślny ToString jest zdefiniowany w klasie Object.
Implementacja tej metody wygląda tak:

public virtual String ToString()
   {
       return GetType().ToString();
   }

i dlatego musisz zaimplementować własną wersję
Taki typ jak Punkt powinien być strukturą czyli zamiast class daj struct