Rzutowanie polimorficzne c#

Question

Witam Mam małe pytanie

mam następujący kod:

  public class BaseClass
    {
        protected string name;

        public virtual string MyMethod()
        {
            name = "BaseClass name";

            return name;
        }

        public T getModel<T>() where T : BaseClass
        {
            return (T) this;
        }
    }

public class DerrivedClass : BaseClass
    {
        public override string MyMethod()
        {
            name = "DerrivedClass Name";

            return name;
        }
    }
////
BaseClass myObj = new BaseClass();
            var check1 = myObj.MyMethod();
            var check2 = myObj.getModel<DerrivedClass>();
            var check3 = check2.MyMethod();

 

I cały program mi się wywala. W sumie to nie dokońca wiem co chciałem osiągnąc ale to czysto w kwesti nauki. Stworzyłem w klasie base metode, której zadanie było rzutowanie typu bazowego na jakis dziedziczony. Mógłby mi ktoś pomóc wyjaśnić o co tu chodzi?

Answer 1

Nie mozna rzutować wyżych klas na dół...

Jeśli ma się klasę bazową i się ją stworzy to z góry wiemy że rzutowanie do bardziej rozwiniętych klas jest niemoźliwe...

 
Jeśli masz np. BaseClass myObj = new DerrivedClass();

To możesz bezproblemowo możesz rzutować w dół.

Streszczenie: Obiekt klasy X który dziedziczy z klasy Y może zostać rzutowany na kasę Y, jeśli klasa także coś dziedziczy ( np.Klasa J) to ten obiekt klasy X może także być rzutowany do klasy J.

Ale jeśli tworzyliśmy Obiekt klasy J to nie można rzutować niżej! gdyż rozerzenia które występują niźej nie istnieją w klasie J!

 

Tu prosty przykład:

using System;
using System.Text;

namespace TestMode
{
	public class BaseClass
	{
	}

	public class DerrivedClass : BaseClass
	{
	}

	public class klasa : DerrivedClass
	{}

	public class MainClass
	{
		public static void Main ()
		{
			BaseClass myObj = new klasa();
			DerrivedClass der = (DerrivedClass)myObj; //No problem
			klasa kl = (klasa)myObj; //No problem

			myObj = new DerrivedClass();
			der = (DerrivedClass)myObj; //No problem
			kl = (klasa)myObj; //problem!

			myObj = new BaseClass();
			der = (DerrivedClass)myObj; //problem!
			kl = (klasa)myObj; //problem!

			Console.ReadKey ();
		}
	}
}

i przy okazji, nie używaj varów. takiemu noobowi jak ja zajeło mi jakieś 10 minut aby ogarnąć twój kod, dopiero po zmianie na poszczególne typy danych znacząco ułatwiło mi czytanie.

Więc podejrzewam że ty także możesz mieć problemy z tym jak "będzieś do czegoś wracał".

Pozdrawiam.

Comments

i tu Cię trochę zaskoczę bochyba  można castować. Po chwili kombinowania udało mi się zrobić coś takiego(dla tych samych klas) :

               DerrivedClass mySecondObj = new DerrivedClass();
                string name1 = mySecondObj.MyMethod(); <-- name2 = "DerrivedClass name"
                BaseClass BaseClassObject  = (BaseClass) mySecondObj;
                string name2 = BaseClassObject.MyMethod();<- name4="BaseClass name"
                var DerrivedObj = BaseClassObject.getModel<DerrivedClass>();
                string name3 = DerrivedObj.MyMethod(); <- name3= "DerrivedClass name"

PS : co do varów to niestety wina ReSharpera :) ale fakt na forum może być to mniej zrozumiałe.

---

A wiesz dlaczego?

Bo masz to:

DerrivedClass mySecondObj = new DerrivedClass();

Zamiast tego:

BaseClass myObj = new BaseClass();

 

Zmień z powrotem na "new BaseClass();" i znowu będziesz miał problem.

---

tak dokładnie:) ale o to mi chodziło właśnie.

---

i tu Cię trochę zaskoczę bochyba  można castować.

 

No to właśnie o tym piszę.

ze trzeba robić takie rzeczy jak:

BaseClass mySecondObj = new DerrivedClass();
DerrivedClass mySecondObj = new DerrivedClass();

Ponieważ nie można obiektu BaseClass rzutować do DerrivedClass.(rzutowanie w dół niź powinno)

 

A to całe "<-- name2 = "DerrivedClass name"" jest raczej nie potrzebne...

---

Ale ja własnie to zrobiłem ( tak mi się zdaje przynajmniej):

1. tworzę obiekt typu DerrivedClass ( pochodny)

  DerrivedClass mySecondObj = new DerrivedClass(); 

2. tworzę referencje type BaseClass i inicjalizuję ją rzutując obiekt powyżej:

BaseClass BaseClassObject  = (BaseClass) mySecondObj; 

3. Mając typ BaseClass uruchamiam generyczną metodę getModel<DerrivedClass>() która zwraca mi obiekt o type generycznym ( w tym wypadku DerrivedClass) i w tym miejscu właśnie dokonałem rzutowania z BaseClas Na DerrivedClass (typ bazowy na pochodny).

 

Oczywiście moge się mylić bo jestem słabiakiem w progsach :D

 

---

Jak już to rzutowałeś wskażnik a nie cały obiekt.

Zmienne to tak jakby wskażniki.

w C++ jak się rzutowało obiekt (nie wskażnik) do góry to się ucinał i spowrotem już nie da.

A w C# wszystkie definicje typu "MyClass ob;" to ukryte wskażniki które jedynie wskazują na obiekt.

---

Dzięki w za pomoc!:D