Início / coding / Perguntas / 77919646
Accepted
four-eyes
Asked: 2024-02-01 19:06:54 +0800 CST

Criando “tipo de união” com classes já definidas

  • 772

Eu tenho dois classesque são DTO's

class FooDto (
    val a: String,
    val b: Double,
)

class BarDto (
    val c: String,
    val d: String,
)

Agora, quero definir um terceiro AnotherDtoonde defino o tipo de propriedade como BartDtoou FooDto.

class AnotherDto (
    val e: FooDto || BarDto
)

Obviamente isso não funciona. Eu li sobre sealed classes, que ficaria assim

sealed class Menu{
   data class PIZZA(val name: String, val size:String, val quantity:Int):Menu()
   data class BURGER(val quantity:Int, val size:String): Menu()
   data class CHICKEN(val quantity:Int, val pieces:String):Menu()
}

No entanto, isso exige que eu defina todas as variáveis ​​(como name: Stringe quanitity: Int) novamente. Não é isso que eu quero, quero simplesmente reaproveitar o que foi definido anteriormente FooDtoe BarDtosem duplicar.

Então, é isso

sealed class FooBar{
   data class Foo(val a: String, val b: Double):FooBar()
   data class Bar(val c: String, val d: String): FooBar()
}

é meio inútil porque eu FooDtojá BarDtoescrevi e eles são usados ​​em outro lugar. Eu quero algo assim

sealed class FooBar{
   FooDto:FooBar()
   BarDto: FooBar()
}

O que obviamente não funciona.

Como reutilizo meus DTOs já escritos FooDtoe BarDtofaço um "tipo de união" que posso atribuir como tipo de dados a uma variável em Kotlin?

kotlin

2 respostas

  1. Não acho que você deva rejeitar a herança regular aqui. Além disso, uma interface comum pode ser mais apropriada do que uma classe selada.

    Se você quer isso:

    class AnotherDto (
    val e: FooDto || BarDto
)

    Então FooDtoe BarDto deve implementar algum tipo de funcionalidade comum para que a propriedade eseja útil.

    Então, qualquer que seja a funcionalidade comum, escreva-a em uma interface 1 :

    interface Dto {
   fun doSomethingUseful()
}

    Então você pode implementar a interface em FooDtoe BarDto2 e ter:

    class AnotherDto {
    val e: Dto
}

    Isso ainda não parece concluído porque provavelmente você deseja AnotherDtose parecer com um Dtoobjeto normal. Então você pode usar o recurso de delegação e AnotherDtoficará no lugar de qualquer outro Dtoque for passado para seu construtor:

    class AnotherDto(otherDto: Dto) : Dto by otherDto {
    fun doSomethingElseUseful() {
        // something else useful
    }
}

    1 Classes seladas/abstratas também são possíveis, mas uma interface é mais flexível quando a implementação de classes é menos acoplada

    2 Sim, envolve mudança dessas classes; mas um tipo de união não seria útil sem pelo menos uma interface compartilhada (a menos que você vá empregar reflexão ou similar, o que certamente deve ser o último recurso)

    • 2
  2. Best Answer

    Você poderia usar uma Eitherclasse. Você pode usar um pré-existente de uma biblioteca como Arrow ( https://apidocs.arrow-kt.io/arrow-core/arrow.core/-either/index.html ) ou implementar um você mesmo assim:

    sealed interface Either<out L, out R>
data class Left<L>(val value: L) : Either<L, Nothing>
data class Right<R>(val value: R) : Either<Nothing, R>

    No call-site, agora você pode fazer o seguinte:

    val fooDto = FooDto("Hi", 5.0)
val anotherClass = AnotherClass(Left(fooDto))
    • 1

relate perguntas