Operator konwersji zdefiniowany przez użytkownika z klasy bazowej

Kiedy rzucasz Entitydo Body, nie rzucasz naprawdęjednego do drugiego, ale raczej rzucasz IntPtr do nowego bytu.

Dlaczego nie utworzyć jawnego operatora konwersji z IntPtr?

public class Entity {
    public IntPtr Pointer;

    public Entity(IntPtr pointer) {
        this.Pointer = pointer;
    }
}

public class Body : Entity {
    Body(IntPtr pointer) : base(pointer) { }

    public static explicit operator Body(IntPtr ptr) {
        return new Body(ptr);
    }

    public static void Test() {
        Entity e = new Entity(new IntPtr());
        Body body = (Body)e.Pointer;
    }
}

Powinieneś użyć swojego rozwiązania B( argumentu konstruktora); po pierwsze, oto dlaczego nie używać innych proponowanych rozwiązań:

• roztwór A jest jedynie opakowaniem dla roztworu B;
• rozwiązanie C jest po prostu złe (dlaczego klasa bazowa powinna wiedzieć, jak przekonwertować się na dowolną podklasę?)

Ponadto, jeśli klasa Body ma zawierać dodatkowe właściwości, to do czego należy je zainicjować podczas wykonywania rzutu? O wiele lepiej jest użyć konstruktora i inicjalizuj właściwości podklasy tak, jak to jest w językach OO.

Powodem, dla którego nie możesz tego zrobić, jest to, że nie jest to bezpieczne w ogólnym przypadku. Zastanów się nad możliwościami. Jeśli chcesz być w stanie to zrobić, ponieważ klasa bazowa i pochodna są wymienne, to tak naprawdę masz tylko jedną klasę i powinieneś połączyć te dwie. Jeśli chcesz mieć swój operator cast dla wygody bycia w stanie downcast bazy do pochodnej, to musisz wziąć pod uwagę, że nie każda zmienna wpisana jako klasa bazowa będzie wskazywać na instancję określonej klasy pochodnej próbujesz go rzucić. To może BYĆ w ten sposób, ale musisz najpierw sprawdzić, lub zaryzykować nieważny wyjątek od obsady. Dlatego downcasting jest ogólnie mile widziany i to nic więcej niż downcasting w przeciąganiu. Proponuję przemyśleć swój projekt.

A może:

public class Entity {...}

public class Body : Entity
{
  public Body(Entity sourceEntity) { this.Pointer = sourceEntity.Pointer; }
}

Więc w kodzie nie musisz pisać:

Body someBody = new Body(previouslyUnknownEntity.Pointer);

Ale możesz użyć

Body someBody = new Body(previouslyUnknownEntity);

To tylkokosmetyczna zmiana , wiem, ale jest to dość jasne i można łatwo zmienić wewnętrzne. Jest również używany we wzorze owijania, którego nazwy nie pamiętam (dla lekko różniących się. celów).
Jest również jasne, że tworzysz nowy obiekt z dostarczonego, więc nie powinno to być mylące, ponieważ operator / konwersja be.

Uwaga: nie używałem kompilatora, więc istnieje możliwość literówki.

(powołując się na protokoły nekromancji...)

Oto mój przypadek użycia:

class ParseResult
{
    public static ParseResult Error(string message);
    public static ParseResult<T> Parsed<T>(T value);

    public bool IsError { get; }
    public string ErrorMessage { get; }
    public IEnumerable<string> WarningMessages { get; }

    public void AddWarning(string message);
}

class ParseResult<T> : ParseResult
{
    public static implicit operator ParseResult<T>(ParseResult result); // Fails
    public T Value { get; }
}

...

ParseResult<SomeBigLongTypeName> ParseSomeBigLongTypeName()
{
    if (SomethingIsBad)
        return ParseResult.Error("something is bad");
    return ParseResult.Parsed(new SomeBigLongTypeName());
}

Tutaj {[2] } może wywnioskować T ze swojego parametru, ale Error nie może, ale może zwrócić typeless ParseResult, który jest zamieniany na ParseResult<T> - lub byłoby, gdyby nie ten błąd. Poprawką jest zwrócenie i konwersja z podtypu:

class ParseResult
{
    public static ErrorParseResult Error(string message);
    ...
}

class ErrorParseResult : ParseResult {}

class ParseResult<T>
{
    public static implicit operator ParseResult<T>(ErrorParseResult result);
    ...
}

I wszystko jest szczęśliwe!

Wydaje się, że równość odniesienia nie była twoim zmartwieniem, wtedy możesz powiedzieć:

• Kod

  public class Entity {
      public sealed class To<U> where U : Entity {
          public static implicit operator To<U>(Entity entity) {
              return new To<U> { m_handle=entity.Pointer };
          }
  
          public static implicit operator U(To<U> x) {
              return (U)Activator.CreateInstance(typeof(U), x.m_handle);
          }
  
          To() { // not exposed
          }
  
          IntPtr m_handle; // not exposed
      }
  
      IntPtr Pointer; // not exposed
  
      public Entity(IntPtr pointer) {
          this.Pointer=pointer;
      }
  }
  

  ---

  public class Body:Entity {
      public Body(IntPtr pointer) : base(pointer) {
      }
  }
  
  // added for the extra demonstration
  public class Context:Body {
      public Context(IntPtr pointer) : base(pointer) {
      }
  }
  

I

• Test

  public static class TestClass {
      public static void TestMethod() {
          Entity entity = new Entity((IntPtr)0x1234);
          Body body = (Entity.To<Body>)entity;
          Context context = (Body.To<Context>)body;
      }
  }
  

Nie napisałeś accessorów, ale wziąłem pod uwagę enkapsulację, aby nie ujawniać ich wskaźników. Pod maską tej implementacji jest użycie klasy pośredniej , która nie znajduje się w łańcuchu dziedziczenia, ale łańcuch konwersji.

Activator jest to dobre, aby nie dodawać dodatkowych ograniczeń new(), ponieważ U są już ograniczone do Entity i mają parametryzowany konstruktor. To<U> chociaż jest odsłonięty, ale zapieczętowany bez ujawniania swojego konstruktora, może być utworzony tylko z operatora konwersji.

W kodzie testu, encja faktycznie przekształciła się w obiekt ogólny To<U>, a następnie typ docelowy, tak jest dodatkowa demonstracja z body do context. Ponieważ To<U> jest klasą zagnieżdżoną, może uzyskujemy dostęp do prywatnej Pointer klasy zawierającej, dzięki czemu możemy wykonywać rzeczy bez ujawniania wskaźnika.

Możesz użyć generic, its possible like blow

public class a<based>
    {
        public static implicit operator b(a<based> v)
        {
            return new b();
        }
    }

    public class b
        : a<b>
    {
    }