Início / coding / Perguntas / 78677699
Accepted
beyarkay
Asked: 2024-06-27 20:35:27 +0800 CST

Padrão de estado de tipo em C#

  • 772

Quero implementar o padrão typestate em C#. Eu tentei algo como:

interface Open {}
interface Closed {}

abstract class Foo<T> { }

class Bar<T> where T: Closed { }
class Bar<T> where T: Open { }

bem como outras permutações, mas todas acabam com a reclamação do compilador. Este exemplo específico fornece (via https://www.programiz.com/csharp-programming/online-compiler/ ):

/tmp/qmk1tTLHWG.cs(12,11): error CS0101: The namespace 'baz' already contains a definition for 'Bar'
/tmp/qmk1tTLHWG.cs(11,11): error CS0265: Partial declarations of 'Bar<T>' have inconsistent constraints for type parameter 'T'

Não sei o suficiente sobre o sistema de tipos do C# para saber o que realmente funcionará e não consigo encontrar muita documentação sobre como fazer isso. É possível implementar o padrão de estado de tipo? Encontrei o blog de Adam , mas ele na verdade não implementa o padrão de estado de tipo conforme mostrado em 1 , que é o que eu gostaria de fazer, se possível.

Idealmente eu gostaria de algo como

struct Closed { }; 
struct Open { };

class Foo<T> {
    // functions applicable to Foo's in both the Closed and Open states
}

class Foo<Closed> {
    // functions applicable to Foo's in just the Open state
}

class Foo<Open> {
    // functions applicable to Foo's in just the Open state
}
c#

1 respostas

  1. Best Answer

    Você deve modelar isso por meio de interfaces, mas só precisa haver uma única classe.

    Um exemplo:

    interface IOpen
{
    IClosed Close();
}

interface IClosed
{
    IOpen Open();
}

class Foo : IOpen, IClosed
{
    public IOpen Open()
    {
        return this;
    }

    public IClosed Close()
    {
        return this;
    }
}

var foo = new Foo();
var open = foo.Open();

var closed = open.Close(); // Only Close() is allowed on an open foo
closed.Open(); // Only Open() is allowed on an closed foo

    Você pode estender isso forçando um estado padrão Foousando um método de fábrica:

    class Foo : IOpen, IClosed
{
    private Foo() // Prevent manual instantiation (using new)
    { }

    public static IClosed Create() // Return closed by default
    {
        return new Foo();
    }

    public IOpen Open()
    {
        return this;
    }

    public IClosed Close()
    {
        return this;
    }
}

var closed = Foo.Create();
var open = closed.Open(); // Only Open() is allowed by default
    • 5

relate perguntas