Явный и неявный C#

Question

Явный и неявный C#

Я новичок в C# и изучаю новые слова. Мне трудно понять, что означают эти два слова, когда речь заходит о программировании на C#. Я посмотрел в словаре значение и вот что я получил:

неявный

"То, что подразумевается, выражается косвенным образом".
"Если качество или элемент подразумевается в чем-то, оно вовлечено в это или показано им";

Явный

"То, что явно, выражено или показано ясно и открыто, без каких-либо попыток что-либо скрыть"
"Если вы явно о чем-то говорите, вы говорите об этом очень открыто и четко".

Я хотел бы понять это в C#.

Спасибо за вашу помощь.

ура

Дополнительная информация:

Вот часть предложения в книге, которую я сейчас читаю, с этим словом "неявный"

"Это означает, что Район и Оккупанты внутри AreaPerPerson( ) неявно ссылаются на копии этих переменных, найденных в вызывающем объекте AreaPerPerson( )"

Я совершенно не понимаю, что здесь пытается сказать это предложение.

83

c# dictionary implicit explicit

Источник

user68348 24 июл '09 в 09:39

10 ответов

Решение

В общем

Неявный: что-то делается для вас автоматически.
Явное: вы написали что-то в исходном коде, чтобы указать, что вы хотите, чтобы произошло.

Например:

int x = 10;
long y = x; // Implicit conversion from int to long
int z = (int) y; // Explicit conversion from long to int

Неявное и явное часто используются в разных контекстах, но общее значение всегда будет в том же духе.

Обратите внимание, что иногда они могут собраться вместе. Например:

int x = 10;
long y = (long) x; // Explicit use of implicit conversion!

(Явное преобразование - это то, которое должно быть указано явно; неявная версия - это та, которая может использоваться неявно, т. Е. Без кода, заявляющего это.)

73

Источник

user22656 24 июл '09 в 09:43

Предположим, у вас есть два класса:

internal class Explicit
{
    public static explicit operator int (Explicit a)
    {
        return 5;
    }
}


internal class Implicit
{
    public static implicit operator int(Implicit a)
    {
        return 5;
    }
}

и два объекта:

var obj1 = new Explicit();
var obj2 = new Implicit();

Теперь вы можете написать:

int integer = obj2; // implicit conversion - you don't have to use (int)

или же:

int integer = (int)obj1; // explicit conversion

но:

int integer = obj1; // WON'T WORK - explicit cast required

Неявное преобразование предназначено для использования, когда преобразование не теряет никакой точности. Явное преобразование означает, что вы можете потерять некоторую точность и должны четко заявить, что знаете, что делаете.

Существует также второй контекст, в котором применяются неявные / явные термины - реализация интерфейса. В этом случае нет ключевых слов.

internal interface ITest
{
    void Foo();
}

class Implicit : ITest
{
    public void Foo()
    {
        throw new NotImplementedException();
    }
}

class Explicit : ITest
{
    void ITest.Foo() // note there's no public keyword!
    {
        throw new NotImplementedException();
    }
}

Implicit imp = new Implicit();
imp.Foo();
Explicit exp = new Explicit();
// exp.Foo(); // won't work - Foo is not visible
ITest interf = exp;
interf.Foo(); // will work

Поэтому, когда вы используете явную реализацию интерфейса, методы интерфейса не видны, когда вы используете конкретный тип. Это можно использовать, когда интерфейс является вспомогательным интерфейсом, а не частью основной ответственности класса, и вы не хотите, чтобы дополнительные методы вводили кого-либо в заблуждение при использовании вашего кода.

11

Источник

user142578 24 июл '09 в 09:45

Я думаю, что эта ссылка довольно ясно дает понять, что такое неявное преобразование - это то, где вам не нужно явно приводить значение в присваивании. Итак, вместо того, чтобы делать

myDigit = (Digit) myDouble

... вы можете просто сделать:

myDigit = myDouble;

2

Источник

user98422 24 июл '09 в 09:44

Быть явным в C# - это в основном ясно и недвусмысленно показывать ваши намерения.

Например:

class MyClass
{
    string myField;

    void MyMethod(int someNumber)
    {

    }
}

В приведенном выше коде подразумевается видимость класса, поля и метода. Они используют компилятор по умолчанию.

Теперь я никогда не смогу вспомнить, каковы значения по умолчанию для компилятора, и, возможно, ваши коллеги тоже не смогут, поэтому вместо того, чтобы полагаться на то, что все помнят значения по умолчанию, вы можете быть явными.

public class MyClass
{
    private string myField;

    public void MyMethod(int someNumber)
    {
    }
}

1

Источник

user8152 24 июл '09 в 09:44

Давайте разберемся в этом на примере конвертации в . Если мы определим как

      public class Lead
{
    public Guid Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

и мы хотим преобразовать его в

      public class Opportunity
{
    public string Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public decimal Worth {get;set;} 
}

Карта и конвертация

Для этого нам нужно создать новый экземпляр, а затем скопировать значения, поэтому мы создали для этого новую функцию, и она должна быть в формате .

      public Opportunity Convert(Lead lead)
{
    Opportunity opp = new Opportunity();
    opp.Id = lead.Id.ToString();
    opp.FirstName = lead.FirstName;
    opp.LastName = lead.LastName;
    return opp;
}

Поэтому мы перемещаем этот метод внутрьclassкак и сделай этоstaticтак что его можно назватьOpportunity.Convert():

      public class Opportunity
{
    public string Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public decimal Worth {get;set;} 
    
    public static Opportunity Convert(Lead lead)
    {
        Opportunity opp = new Opportunity();
        opp.Id = lead.Id.ToString();
        opp.FirstName = lead.FirstName;
        opp.LastName = lead.LastName;
        return opp;
    }
}

//main
void Main()
{
    Lead lead = new Lead();
    lead.Id = Guid.NewGuid();
    lead.FirstName = "Vinod";
    lead.LastName = "Srivastv";
    lead.Dump();
    

    Opportunity opp = Opportunity.Convert(lead);
    opp.Dump();
}

Но с помощью и мы можем объявить операторы преобразования, чтобы нам не приходилось вызыватьConvertметодOpportunityсорт.

Пример

вimplicitпреобразование, нам не нужно приводитьobjectвручную, поскольку это делается неявно.

      public class Opportunity
{
    public string Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public decimal Worth {get;set;} 
    
    public static implicit operator Opportunity(Lead lead)
    {
        Opportunity opp = new Opportunity();
        opp.Id = lead.Id.ToString();
        opp.FirstName = lead.FirstName;
        opp.LastName = lead.LastName;
        return opp;
    }
}

//main
void Main()
{
    Lead lead = new Lead();
    lead.Id = Guid.NewGuid();
    lead.FirstName = "Vinod";
    lead.LastName = "Srivastv";
    lead.Dump();
    
    // here the lead is implicitly converted to opportunity 
    //and we get rid of the Convert Method from above 
    Opportunity opp = lead;
    opp.Dump();
}

`explicit`Пример

Теперь мы только что изменили ключевое слово с неявного на явное из приведенного выше кода:

      public class Opportunity
{
    public string Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public decimal Worth {get;set;} 
    
    public static explicit operator Opportunity(Lead lead)
    {
        Opportunity opp = new Opportunity();
        opp.Id = lead.Id.ToString();
        opp.FirstName = lead.FirstName;
        opp.LastName = lead.LastName;
        return opp;
    }
}

//main
void Main()
{
    Lead lead = new Lead();
    lead.Id = Guid.NewGuid();
    lead.FirstName = "Vinod";
    lead.LastName = "Srivastv";
    lead.Dump();
    
    //CS0266 Cannot implicitly convert type '.Lead' to 'Opportunity'. 
    //An explicit conversion exists (are you missing a cast?)
    //Opportunity opp = lead;
    
    //This is an example of explicit conversion, see the casting
    Opportunity opp = (Opportunity)lead;
    opp.Dump();
}

Когда мы меняем ключевое слово, компилятор выдаст ошибку:An explicit conversion exists (are you missing a cast?)поэтому нам нужно привестиLeadвозражать против возможности с(Opportunity)как указано выше.

0

Источник

user3057246 19 авг '23 в 23:37

Неявное можно принять как подразумеваемое, но явное означает, что вы заявляете, что это должно быть сделано самостоятельно. Как с бросками. Вот неявное приведение:

int implicit;
implicit = 7.5;

Значение '7.5' будет неявно приведено как int. Это означает, что компилятор сделает это за вас.

Здесь явно:

int explicit;
explicit = (int)7.5;

Здесь вы говорите компилятору, что вы хотите его привести. Вы явно объявляете конверсию. Надеюсь, это поможет. Источник: http://cboard.cprogramming.com/cplusplus-programming/24371-implicit-explicit.html

0

Источник

user2351341 17 авг '16 в 00:52

Потому что C# статически типизируется во время компиляции.

Неявные преобразования: специального синтаксиса не требуется, поскольку преобразование всегда выполняется успешно и данные не теряются. Примеры включают преобразования из меньших целочисленных типов в большие и преобразования из производных классов в базовые классы.

Явные преобразования (приведения): для явных преобразований требуется выражение приведения. Трансляция требуется, когда информация может быть потеряна при преобразовании или когда преобразование не удалось выполнить по другим причинам. Типичные примеры включают числовое преобразование в тип с меньшей точностью или меньшим диапазоном, а также преобразование экземпляра базового класса в производный класс.

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }

    public static explicit operator Person(Employe employe) => new Person { Id = employe.Id, Name = employe.Name };
}

public class Employe
{

    public int Id { get; set; }
    public string Name { get; set; }
    public string Family { get; set; }

    public static implicit operator Employe(Person person) => new Employe { Id = person.Id, Name = person.Name };
}

static void Main(string[] args)
{
    Person person = new Person() { Id = 1, Name = "Reza" };

    //implicit operator
    Employe employe = person;
    employe.Family = "Jenabi";

    //explicit operator
    Person person1 = (Person)employe;
}

0

Источник

user9549856 02 окт '20 в 14:23

Генераторы кода Microsoft используют ключевое слово "var" для неявного, но я думаю, важно отметить, что

а также

      WebApplicationBuilder? builder = WebApplication.CreateBuilder(args);

такие же, но

      var builder = WebApplication.CreateBuilder(args);

а также

      WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

НЕ одинаковы.

Для ясности кода я всегда предпочитаю Explicit, но, как вы можете видеть, генераторы кода Microsoft этого не делают. С точки зрения выполнения кода разницы в производительности НЕТ.

0

Источник

Rob 04 мар '22 в 19:17

Это отличный ресурс для изучения C#: http://www.functionx.com/csharp/

Посмотрите здесь, в частности: http://www.functionx.com/csharp/math/Lesson20.htm

-1

Источник

user83889 24 июл '09 в 09:45

Другие вопросы по тегам c# dictionary implicit explicit

user93623 24 июл '09 в 09:47 2009-07-24 09:47 · Accepted Answer · 2009-07-24 09:47

implicit а также explicit ключевые слова в C# используются при объявлении операторов преобразования. Допустим, у вас есть следующий класс:

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

Если вы хотите создать новый Role и назначить Name к этому, как правило, вы будете делать это так:

Role role = new Role();
role.Name = "RoleName";

Поскольку у него есть только одно свойство, было бы удобно, если бы мы могли вместо этого сделать это так:

Role role = "RoleName";

Это означает, что мы хотим неявно преобразовать строку в Role (поскольку в коде нет конкретного актера). Чтобы достичь этого, мы добавляем неявный оператор преобразования:

public static implicit operator Role(string roleName)
{
    return new Role() { Name = roleName };
}

Другой вариант - реализовать явный оператор преобразования:

public static explicit operator Role(string roleName)
{
    return new Role() { Name = roleName };
}

В этом случае мы не можем неявно преобразовать строку в Role, но нам нужно привести его в наш код:

Role r = (Role)"RoleName";

Явный и неявный C#

10 ответов

Карта и конвертация

Пример

explicitПример

`explicit`Пример