Defina la clase consigo mismo como implementación genérica. ¿Por qué/cómo funciona esto?

Question

que normalmente he estado creando Prism Eventos utilizados por el EventAggregator como:

public class SomeEvent : CompositePresentationEvent<SomeEventArgs> { }

public class SomeEventArgs 
{ 
    public string Name { get; set; } 
} 

Pero mientras se mira en un código de compañeros de trabajo me di cuenta de que hicieron:

public class SomeEvent : CompositePresentationEvent<SomeEvent> 
{ 
    public string Name { get; set; } 
} 

I Supongo que mi primera pregunta es ¿por qué esto incluso compila? Me parece que está implementando una clase que aún no está definida. Y segundo, ¿afecta negativamente la aplicación en absoluto, es insignificante o mejor?

Answer 1

Supongo que mi primera pregunta es ¿por qué esta compilación?

¿Qué regla en la especificación crees que está violando?

Me parece que está implementando una clase que aún no está definida.

creo que tendría que especificar el exacto significado de cada uno de esos términos para la declaración de ser juzgados como correcta o no. El compilador conoce CompositePresentationEvent como se ha declarado en otro lugar (presumiblemente) y conoce SomeEvent porque esa es la clase que se ha declarado. Es como tener un campo de tipo Foo dentro de una clase Foo - completamente válido.

También es muy útil para poder hacer esto, especialmente para las comparaciones. Por ejemplo:

public sealed class Foo : IComparable<Foo> 

dice que cualquier instancia de la clase Foo sabe cómo comparar mismo con otra instancia, por lo que puede ser utilizado para la clasificación de una manera de tipo seguro. En el caso de las estructuras, esto también le permite reducir el boxeo, ya que al llamar al x.CompareTo(y) no será necesario ningún boxeo cuando se sabe que x es del tipo que implementa IComparable<> de manera apropiada.

Tenga en cuenta que los tipos pueden obtener más más interesante y confusamente recursivo. Tome este ejemplo (ligeramente modificada) de my port of Protocol Buffers:

public interface IMessage<TMessage, TBuilder> 
    where TMessage : IMessage<TMessage, TBuilder> 
    where TBuilder : IBuilder<TMessage, TBuilder> 

public interface IBuilder<TMessage, TBuilder> 
    where TMessage : IMessage<TMessage, TBuilder> 
    where TBuilder : IBuilder<TMessage, TBuilder> 

Aquí, el objetivo es acabar básicamente con dos tipos - un "mensaje" y un "constructor", por lo que siempre se puede construir una de la otra. Por ejemplo:

public class Foo : IMessage<Foo, FooBuilder> 
{ 
    ... 
} 

public class FooBuilder : IBuilder<Foo, FooBuilder> 
{ 
    ... 
}