come ignorare `operatore is`

Question

sappiamo:

int? number = 10; 
Console.WriteLine(number is int); // true 

ma:

NotNull<string> text = "10"; // NotNull<> is my struct 
Console.WriteLine(text is string); // false 

voglio text is string ritorno vero, come posso farlo?

-------------------------------- modificare

qui è la mia NotNull:

public class NotNull<T> where T : class 
{ 
    public T Value { get; } 

    private NotNull(T value) 
    { 
     this.Value = value; 
    } 

    public static implicit operator T(NotNull<T> source) 
    { 
     return source.Value; 
    } 

    public static implicit explicit NotNull<T>(T value) 
    { 
     if (value == null) throw new ArgumentNullException(nameof(value)); 
     return new NotNull<T>(value); 
    } 
} 

se una classe stava dichiarando come:

public class A 
{ 
    public NotNull<string> B { get; set; } 
} 

spero solo che qualsiasi serializzatore può serializzare e deserializzare esso stesso come:

public class A 
{ 
    public string B { get; set; } 
} 

-------------------------------- Edit 2

ho trovato questa è una domanda impossibile:

1. se NotNull<> è di classe, default(NotNull<>) è nullo, non faccio nulla.
2. se NotNull<> è struct, default(NotNull<>).Value è nullo.

scusa per la domanda.

Answer 1

Come già sottolineato, iscannot be overloaded. Se pubblichi più contesto sulla tua stringa non nullable forse possiamo trovare qualche altra soluzione.

L'operatore is funziona sui tipi annullabili e sui relativi tipi sottostanti non perché è sovraccarico, ma poiché questo comportamento è definito esplicitamente nelle specifiche della lingua. I tipi Nullable vengono considerati come casi speciali quando viene valutato is.

È possibile trovare una descrizione dettagliata dell'operatore is nella sezione 7.10.10 delle specifiche del linguaggio C#. Questi sono i componenti pertinenti ai tipi nullable:

Il risultato dell'operazione E is T, dove E è un'espressione e T è un tipo (...) È valutata come segue

• (...)

• In caso contrario, diamo D rappresentano il tipo dinamico di E come segue:

• (...)

• Se il tipo di E è un tipo annullabile, D è il tipo sottostante di quel tipo annullabile.

• Il risultato dell'operazione dipende S e T come segue:

• (...)

• Se T è un tipo nullable, il risultato è vero se D è il tipo sottostante di T.

• Se T è un tipo di valore non annullabile, il risultato è true se D e T sono dello stesso tipo.

Answer 2

su MSDN avete lista degli operatori sovraccaricabili: Overloadable Operators (C# Programming Guide)

Questi operatori non possono essere sovraccaricati:

=,,:.?, ??, ->, =>, f (x), come, controllato, non controllato, di default, delegato, è, di nuovo, sizeof, typeof

Answer 3

is operatore non è superabile controllo dell'operatore questo per saperne di più sugli operatori overridbale Operator Overloading Tutorial