Beispielteiling der Explicit und Implicit-Verwendung in C#

Heute habe ich während der Überprüfung eines alten Projekts ein seltsames Code-fragment entdeckt.

if (dto.Payment == null) continue;
var entity = entries.FirstOrDefault(e => e.LedgerEntryID == dto.LedgerEntryID);
dto.Payment = entity?.Payment;

Dort ist dto.Payment eine Instanz der Klasse PaymentDTO, entity?.Payment ist eine Instanz der Klasse Payment, die Klasse PaymentDTO und die Klasse Payment haben keine Unter-/Überklasse-Beziehung, daher gibt es keine implizite Umwandlung zwischen Unterklassen und Oberklassen.

Seltsamerweise hat der Compiler von Visual Studio keine Kompilierungsfehler angezeigt.

Nachdem ich die Definition der Klasse PaymentDTO geöffnet habe, habe ich die folgenden Methodensignaturen gefunden.

public static implicit operator PaymentDTO(Payment payment)

Auf den ersten Blick scheint dies die Überschreibung des Operators für den Typ PaymentDTO zu sein, aber es ist nicht das, was ich früher verwendet habe+,-,*,/, == usw.

Nach der Durchsuchung von MSDN wurde ich erst darauf aufmerksam, dass "implicit" und "explicit" ein Paar Umwandlungsoptern sind.

Implicit und Explicit

Implicit

Das Schlüsselwort "Implicit" wird verwendet, um implizite benutzerdefinierte Typumwandlungsoptionen zu deklarieren. Es kann2unterschiedliche implizite Umwandlungen, um die Lesbarkeit des Codes zu verbessern. Allerdings sollte beachtet werden, dass nach der Verwendung des impliziten Umwandlungsopters bei der Kompilierung die Ausnahmeprüfung übersprungen wird, daher sollten implizite Umwandlungsoptern niemals Ausnahmen verursachen und niemals Informationen verlieren,否则在运行时会出现一些意想不到的问题。

Beispielsweise sind die Definitionen von PaymentDTO und Payment wie folgt

public class Payment
  {
     public decimal Amount { get; set; }
  }
  public class PaymentDTO
  {
     public string AmountString { get; set; }
  }

Wenn eine implizite Umwandlung von Payment in PaymentDTO erforderlich ist, muss nur der implizite Umwandlungsoperator von PaymentDTO deklariert werden

public class PaymentDTO
    {
      public string AmountString { get; set; }
public static implicit operator PaymentDTO(Payment payment)
      {
        return new PaymentDTO
        {
AmountString = payment.Amount.ToString("C",2）
        };
      }
    }

Beim Aufruf ist es ausreichend, direkt zuzuweisen

class Program
    {
      static void Main(string[] args)
      {
PaymentDTO dto = new Payment { Amount = 1 };
        Console.WriteLine(dto.AmountString);
        Console.Read();
      }
    }

Explicit

Der Schlüsselwort "Explicit" muss durch Umwandlung aufgerufene benutzerdefinierte Typumwandlungsoptionen deklariert werden. Im Gegensatz zur impliziten Umwandlung muss der explizite Umwandlungsoperator durch Umwandlung aufgerufen werden, wenn keine explizite Umwandlung vorhanden ist, wird bei der Kompilierung ein Fehler aufgetreten.

Beispielsweise werden wir in der vorangegangenen PaymentDTO-Klasse definierte Umwandlungsoperatoren von Implicit auf Explicit geändert

public class PaymentDTO
    {
      public string AmountString { get; set; }
public static explicit operator PaymentDTO(Payment payment)
      {
        return new PaymentDTO
        {
AmountString = payment.Amount.ToString("C",2）
        };
      }
    }

这时候由于Main方法中没有显式转换，所以编译器出错，提示Cannot implicitly convert type 'ExplicitImplicit.Payment' to 'ExplicitImplicit.PaymentDTO'. An explicit conversion exists (are you missing a cast63;)

如果想要编译器通过编译，只需要做一个显示转换即可

class Program
    {
      static void Main(string[] args)
      {
PaymentDTO dto = (PaymentDTO)new Payment { Amount = 1 };
        Console.WriteLine(dto.AmountString);
        Console.Read();
      }
    }

总结

隐式提高了代码的可读性，但程序员需要自己确保转换不会引发异常且不会丢失信息

显式可以阻止编译器静默调用可能产生意外后果的转换操作。

前者更容易使用，后者能向阅读代码的每个人清楚地指示您要转换类型

以上就是我们为大家整理的C#中显式和隐式用法的全部内容，大家在学习时可以多多参考实例，感谢你对呐喊教程的支持。

声明：本文内容来自网络，版权归原作者所有。内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#oldtoolbag.com（在发邮件时，请将#更换为@进行举报，并提供相关证据。一经查实，本站将立即删除涉嫌侵权内容。）