Covariant Zuordnung funktioniert nicht

Question

Ich versuche, die Benachrichtigung über Änderungen an den Eigenschaften eines Objekts über eine IObservable<T> zu verallgemeinern, aber das ist neben dem Punkt der Frage. Der Punkt der Frage ist: die folgende Zuordnung I meldet eine ungültige Kovarianz Fehler machen:

protected virtual void OnPropertyChanged<T>(
         string propertyName, 
         T oldValue, T newValue) 
{ 
    IPropertyChangedNotification<Student, object> notification = 
     new PropertyChangedNotification<Student, T>(this, 
     propertyName, oldValue, newValue); 

    ... 
} 

Dies berichtet:

Cannot implicitly convert type PropertyChangedNotification<UsingSubjectToWatchProperty.Student, T> to IPropertyChangedNotification<UsingSubjectToWatchProperty.Student, object> . An explicit conversion exists (are you missing a cast?)

Dies ist die komplette Code:

class Student 
{ 
    private ISubject<IPropertyChangedNotification<Student, object>> _subject = 
     new Subject<IPropertyChangedNotification<Student, object>>();; 
    private string _name = null; 

    public string Name 
    { 
     get 
     { 
      return _name; 
     } 
     set 
     { 

      var oldValue = _name; 
      _name = value; 

      OnPropertyChanged<string>("Name", oldValue, _name); 
     } 
    } 

    protected virtual void OnPropertyChanged<T>(string propertyName, T oldValue, T newValue) 
    { 
     IPropertyChangedNotification<Student, object> notification = 
      new PropertyChangedNotification<Student, T>(this, 
      propertyName, oldValue, newValue); 

     _subject.OnNext(notification); 
    } 
} 

public class PropertyChangedNotification<TDeclaringType, TPropertyType> 
    : IPropertyChangedNotification<TDeclaringType, TPropertyType> 
{ 
    public PropertyChangedNotification(TDeclaringType declaringObject, 
     string propertyName, 
     TPropertyType oldValue, 
     TPropertyType newValue) 
    { 
     DeclaringObject = declaringObject; 
     PropertyName = propertyName; 
     OldValue = oldValue; 
     NewValue = newValue; 
    } 

    public TDeclaringType DeclaringObject { get; set; } 
    public string PropertyName { get; set; } 

    public TPropertyType OldValue { get; protected set; } 
    public TPropertyType NewValue { get; protected set; } 
} 

public interface IPropertyChangedNotification<TDeclaringType, out TPropertyType> 
{ 
    TDeclaringType DeclaringObject { get; set; } 
    string PropertyName { get; set; } 

    TPropertyType OldValue { get; } 
    TPropertyType NewValue { get; } 
} 

PS : Dies ist kein Produktionscode. Üben Sie einfach Sachen.

Answer 1

Kovarianz und Kontravarianz werden nur für Referenztypen unterstützt (um einen Werttyp in einen Object umzuwandeln, müsste dieser in einem Rahmen dargestellt werden).

So würden Sie T-class beschränken müssen:

void OnPropertyChanged<T>(string propertyName, T oldValue, T newValue) 
    where T : class { ... } 

Alternativ können Sie auch nur new PropertyChangedNotification<Student, object>() nutzen könnten.

public interface IPropertyChangedNotification<TDeclaringType> 
{ 
    TDeclaringType DeclaringObject { get; set; } 
    string PropertyName { get; set; } 
} 

public interface IPropertyChangedNotification<TDeclaringType, out TPropertyType> 
    : IPropertyChangedNotification<TDeclaringType> 
{ 
    TPropertyType OldValue { get; } 
    TPropertyType NewValue { get; } 
} 

dann verwenden, in den Subject (da Sie es zu einem Beton gegossen müßten sowieso eingeben, wenn Sie sich vorher anmelden):

würde Eine dritte Möglichkeit eine Schnittstelle ohne TProperty haben seine

ISubject<IPropertyChangedNotification<Student>>