Come risolvere CA2225 (OperatorOverloadsHaveNamedAlternates) quando si utilizza classe generica

Question

che sto cercando di risolvere CA2225, che mette in guardia sul ContrainedValue<T> di sotto, con il seguente messaggio: Provide a method named 'ToXXX' or 'FromXXX' as an alternate for operator 'ConstrainedValue<T>.implicit operator T(ConstrainedValue<T>)'.

Ho anche incollato PositiveInteger per illustrare un caso d'uso per ConstrainedValue<T>. ConstrainedValue<T> consente alle derivate di specificare semplicemente il vincolo applicato a un tipo di valore, nel costruttore. Sembra un modo abbastanza pulito per codificarlo. C'è un modo per risolvere l'avviso CA2225, dato che ho a che fare con un tipo generico? Come posso fornire un operatore alternativo?

• Forse potrei implementare ToInt, ToDouble, ecc per tutti i tipi di valore e li hanno gettano se il from non è dello stesso tipo? Ma penso che sia una brutta pratica avere il metodo ToXXX?
• È possibile creare un livello compreso tra ConstrainedValue<T> e PositiveInteger<T>, una classe ConstrainedInteger. Potrei inserire ToInt() in quella classe. Ma sembra sbagliato creare un layer semplicemente per soddisfare CA2225 e non penso che l'avvertimento andrebbe via su ConstrainedValue<T> e dovrei sopprimere questo avviso.

Codice:

namespace OBeautifulCode.AutoFakeItEasy 
{ 
    using System.Diagnostics; 

    using Conditions; 

    /// <summary> 
    /// Represents a constrained value. 
    /// </summary> 
    /// <typeparam name="T">The type of the constrained value.</typeparam> 
    [DebuggerDisplay("{Value}")] 
    public abstract class ConstrainedValue<T> 
     where T : struct 
    { 
     /// <summary> 
     /// Initializes a new instance of the <see cref="ConstrainedValue{T}"/> class. 
     /// </summary> 
     /// <param name="value">The value of the <see cref="ConstrainedValue{T}"/> instance.</param> 
     protected ConstrainedValue(T value) 
     { 
      this.Value = value; 
     } 

     /// <summary> 
     /// Gets the underlying value of the instance. 
     /// </summary> 
     public T Value { get; } 

     /// <summary> 
     /// Performs an implicit conversion from <see cref="ConstrainedValue{T}"/> to the underlying value type. 
     /// </summary> 
     /// <param name="from">The <see cref="ConstrainedValue{T}"/> to convert from.</param> 
     /// <returns> 
     /// The result of the conversion. 
     /// </returns> 
     public static implicit operator T(ConstrainedValue<T> from) 
     { 
      return from.Value; 
     }    
    } 

    /// <summary> 
    /// Represents a positive integer. 
    /// </summary> 
    [DebuggerDisplay("{Value}")] 
    public sealed class PositiveInteger : ConstrainedValue<int> 
    { 
     /// <summary> 
     /// Initializes a new instance of the <see cref="PositiveInteger"/> class. 
     /// </summary> 
     /// <param name="value">The value held by the <see cref="PositiveInteger"/> instance.</param> 
     public PositiveInteger(int value) 
      : base(value) 
     { 
      Condition.Requires(value, nameof(value)).IsGreaterThan(0); 
     } 
    } 
} 

Answer 1

È possibile effettuare l'analisi del codice felici effettivamente facendo quello che dice:

Inserire questo ConstrainedValue<T> e l'avviso andrà via.

public T ToT() 
{ 
    return this.Value; 
} 

Personalmente, preferirei sopprimere il messaggio, che già forniscono un metodo per ottenere il valore, anche se la lingua non fornisce casting.