Apakah penggunaan operator casting eksplisit saya masuk akal atau hack yang buruk?

Saya memiliki objek besar:

class BigObject{
    public int Id {get;set;}
    public string FieldA {get;set;}
    // ...
    public string FieldZ {get;set;}
}

dan objek khusus, seperti DTO:

class SmallObject{
    public int Id {get;set;}
    public EnumType Type {get;set;}
    public string FieldC {get;set;}
    public string FieldN {get;set;}
}

Saya pribadi menemukan konsep yang secara eksplisit memasukkan BigObject ke dalam SmallObject - mengetahui bahwa itu adalah operasi satu arah, kehilangan data - sangat intuitif dan mudah dibaca:

var small = (SmallObject) bigOne;
passSmallObjectToSomeone(small);

Diimplementasikan menggunakan operator eksplisit:

public static explicit operator SmallObject(BigObject big){
    return new SmallObject{
        Id = big.Id,
        FieldC = big.FieldC,
        FieldN = big.FieldN,
        EnumType = MyEnum.BigObjectSpecific
    };
}

Sekarang, saya dapat membuat SmallObjectFactorykelas dengan FromBigObject(BigObject big)metode, yang akan melakukan hal yang sama, menambahkannya ke injeksi dependensi dan memanggilnya saat diperlukan ... tetapi bagi saya sepertinya lebih rumit dan tidak perlu.

PS Saya tidak yakin apakah ini relevan, tetapi akan ada OtherBigObjectyang juga akan dapat dikonversi menjadi SmallObject, pengaturan berbeda EnumType.

Tidak ada jawaban lain yang benar menurut pendapat saya. Dalam pertanyaan stackoverflow ini, jawaban dengan suara terbanyak berpendapat bahwa kode pemetaan harus dijauhkan dari domain. Untuk menjawab pertanyaan Anda, tidak - penggunaan operator pemeran Anda tidak bagus. Saya akan menyarankan untuk membuat layanan pemetaan yang terletak di antara DTO Anda dan objek domain Anda, atau Anda bisa menggunakan automapper untuk itu.

Itu ... Tidak hebat. Saya telah bekerja dengan kode yang melakukan trik pintar ini dan itu menyebabkan kebingungan. Setelah semua, Anda akan berharap untuk dapat hanya menetapkan variabel BigObjectke dalam suatu objek SmallObjectjika objek cukup terkait untuk melemparkannya. Itu tidak berfungsi - Anda mendapatkan kesalahan kompiler jika Anda mencoba karena sejauh menyangkut sistem tipe, mereka tidak berhubungan. Juga agak tidak disukai bagi operator casting untuk membuat objek baru.

Saya akan merekomendasikan .ToSmallObject()metode sebagai gantinya. Lebih jelas tentang apa yang sebenarnya terjadi dan tentang sebagai verbose.

Sementara saya dapat melihat mengapa Anda perlu memiliki SmallObject, saya akan mendekati masalahnya secara berbeda. Pendekatan saya untuk masalah jenis ini adalah menggunakan Facade . Tujuan utamanya adalah untuk merangkum BigObjectdan hanya menyediakan anggota khusus. Dengan cara ini, ini adalah antarmuka baru pada instance yang sama, dan bukan salinan. Tentu saja Anda juga bisa ingin melakukan salinan, tetapi saya akan merekomendasikan Anda melakukannya melalui metode yang dibuat untuk tujuan itu dalam kombinasi dengan Facade (misalnya return new SmallObject(instance.Clone())).

Facade memiliki sejumlah keunggulan lain, yaitu memastikan bahwa bagian-bagian tertentu dari program Anda hanya dapat memanfaatkan anggota yang disediakan melalui fasad Anda, secara efektif menjamin bahwa ia tidak dapat memanfaatkan apa yang seharusnya tidak diketahui. Selain itu, ini juga memiliki keuntungan luar biasa karena Anda memiliki lebih banyak fleksibilitas dalam mengubah BigObjectpemeliharaan di masa mendatang tanpa harus terlalu khawatir tentang bagaimana itu digunakan di seluruh program Anda. Selama Anda bisa meniru perilaku lama dalam beberapa bentuk atau lainnya, Anda dapat membuat SmallObjectpekerjaan sama seperti sebelumnya tanpa harus mengubah program Anda di mana pun BigObjectakan digunakan.

Catatan, ini berarti BigObjecttidak tergantung pada SmallObjectmelainkan sebaliknya (seperti yang seharusnya menurut pendapat saya yang sederhana).

Ada konvensi yang sangat kuat yang menggunakan tipe referensi yang bisa berubah adalah pelestarian identitas. Karena sistem umumnya tidak mengizinkan operator casting yang ditentukan pengguna dalam situasi di mana objek dari tipe sumber dapat ditugaskan ke referensi dari tipe tujuan, hanya ada beberapa kasus di mana operasi casting yang ditentukan pengguna akan masuk akal untuk referensi yang bisa berubah-ubah jenis.

Saya akan menyarankan sebagai persyaratan yang, diberikan x=(SomeType)foo;diikuti beberapa saat kemudian y=(SomeType)foo;, dengan kedua gips diterapkan pada objek yang sama, x.Equals(y)harus selalu dan selamanya benar, bahkan jika objek tersebut dimodifikasi di antara dua gips. Situasi seperti itu dapat berlaku jika misalnya satu memiliki sepasang objek dari jenis yang berbeda, masing-masing memiliki referensi yang tidak dapat diubah ke yang lain, dan melemparkan salah satu objek ke jenis lainnya akan mengembalikan instance yang dipasangkan. Itu juga bisa berlaku dengan tipe yang berfungsi sebagai pembungkus untuk objek yang bisa berubah, asalkan identitas objek yang dibungkus tidak dapat diubah, dan dua pembungkus dari tipe yang sama akan melaporkan diri mereka sama jika mereka membungkus koleksi yang sama.

Contoh khusus Anda menggunakan kelas yang bisa berubah, tetapi tidak mempertahankan bentuk identitas apa pun; dengan demikian, saya akan menyarankan bahwa ini bukan penggunaan yang tepat dari operator casting.

Mungkin baik-baik saja.

Masalah dengan contoh Anda adalah bahwa Anda menggunakan nama contoh-ish tersebut. Mempertimbangkan:

SomeMethod(long longNum)
{
  int num = (int)longNum;
  /* ... */

Sekarang, ketika Anda punya ide yang baik apa yang panjang dan int berarti, maka kedua pemain implisit intuntuk longdan cor eksplisit dari longke intcukup dimengerti. Ini juga bisa dimengerti bagaimana 3menjadi 3dan hanya cara lain untuk bekerja dengannya 3. Dapat dimengerti bagaimana ini akan gagal dengan int.MaxValue + 1dalam konteks yang diperiksa. Bahkan bagaimana itu akan bekerja dengan int.MaxValue + 1dalam konteks yang tidak dicentang untuk menghasilkanint.MinValue bukanlah hal yang paling sulit untuk dilakukan

Demikian juga, ketika Anda melemparkan secara implisit ke tipe basis atau secara eksplisit ke tipe turunan, hal ini dapat dimengerti oleh siapa pun yang tahu cara kerja pewarisan apa yang terjadi, dan apa hasilnya nanti (atau bagaimana itu mungkin gagal).

Sekarang, dengan BigObject dan SmallObject saya tidak memiliki perasaan tentang bagaimana hubungan ini bekerja. Jika tipe nyata Anda di mana sedemikian rupa sehingga hubungan casting di mana jelas, maka casting mungkin memang ide yang baik, meskipun banyak waktu, mungkin sebagian besar, jika ini yang terjadi maka harus tercermin dalam hierarki kelas dan casting berbasis warisan yang normal akan cukup.