English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutorial Básico de C#

Tutorial Avançado de C#

C# Orientado a Objetos (OOP)

Operadores do C#

operadores em C# são alguns símbolos especiais que executam certas operações em operandos. Em matemática, o símbolo de adição (+) representa a soma de dois números.+são a soma dos números a esquerda e a direita. Da mesma forma, o C# inclui operadores de diferentes tipos de operações.

Operador é um símbolo que informa ao compilador para executar uma operação matemática ou lógica específica. O C# tem uma rica coleção de operadores, classificados da seguinte forma:

  • Operadores aritméticos

  • operadores relacionais

  • operadores lógicos

  • Operadores de bit

  • Operador de atribuição

  • Outros operadores

Este tutorial explicará um a um os operadores aritméticos, operadores relacionais, operadores lógicos, operadores bit a bit, operadores de atribuição e outros operadores.

Operadores aritméticos

A tabela a seguir mostra todos os operadores aritméticos suportados pelo C#. Supondo a variável A o valor é 10, variável B o valor é 20, então:

OperadoresDescriçãoExemplo
+Adicionar os dois operandosA + B receberá 30
-Subtrair o segundo operando do primeiroA - B receberá -10
*Multiplicar os dois operandosA * B receberá 200
/Divisão do numerador pelo denominadorB / A receberá 2
%Operador de módulo, resto da divisão inteiraB % A resultará em 0
++Operador de incremento, valor inteiro aumentado 1A++ Obterá 11
--Operador de decremento, valor inteiro reduzido 1A-- Obterá 9

Exemplo online

Veja o exemplo a seguir para entender todos os operadores aritméticos disponíveis em C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　21;
　　　　　　　　　　　　int b =;　10;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a　+　b;
　　　　　　　　　　　　Console.WriteLine("Linha　1　-　O valor de c é {0}, c);
　　　　　　　　　　　　c = a　-　b;
　　　　　　　　　　　　Console.WriteLine("Linha　2　-　O valor de c é {0}, c);
　　　　　　　　　　　　c = a　*　b;
　　　　　　　　　　　　Console.WriteLine("Linha　3　-　O valor de c é {0}, c);
　　　　　　　　　　　　c = a　/　b;
　　　　　　　　　　　　Console.WriteLine("Linha　4　-　O valor de c é {0}, c);
　　　　　　　　　　　　c = a % b;
　　　　　　　　　　　　Console.WriteLine("Linha　5　-　O valor de c é {0}, c);
　　　　　　　　　　　　//　++a é incrementada antes de ser atribuída
　　　　　　　　　　　　c =　++a;
　　　　　　　　　　　　Console.WriteLine("Linha　6　-　O valor de c é {0}, c);
　　　　　　　　　　　　//　O valor de a neste momento é　22
　　　　　　　　　　　　//　--a é decrementada antes de ser atribuída
　　　　　　　　　　　　c =　--a;
　　　　　　　　　　　　Console.WriteLine("Linha　7　-　O valor de c é {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Linha　1　-　O valor de c é　31
Linha　2　-　O valor de c é　11
Linha　3　-　O valor de c é　210
Linha　4　-　O valor de c é　2
Linha　5　-　O valor de c é　1
Linha　6　-　O valor de c é　22
Linha　7　-　O valor de c é　21

  • c = a++: Primeiro atribuir a a c, então incrementar a.

  • c = ++a: Primeiro incrementar a, então atribuir a a c.

  • c = a--: Primeiro atribuir a a c, então decrementar a.

  • c = --a: Primeiro decrementar a, então atribuir a a c.

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　1;
　　　　　　　　　　　　int b;
　　　　　　　　　　　　//　a++　atribuição antes do incremento
　　　　　　　　　　　　b = a++;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　++a é incrementada antes de ser atribuída
　　　　　　　　　　　　a =　1;　//　reinitializar a
　　　　　　　　　　　　b =　++a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　a--　atribuição antes do decremento
　　　　　　　　　　　　a =　1;　　//　reinitializar a
　　　　　　　　　　　　b = a--;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　　　　　//　--a é decrementada antes de ser atribuída
　　　　　　　　　　　　a =　1;　　//　reinitializar a
　　　　　　　　　　　　b =　--a;
　　　　　　　　　　　　Console.WriteLine("a = {0}", a);
　　　　　　　　　　　　Console.WriteLine("b = {0}", b);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Execute o programa acima e o resultado de saída será:

a =　2
b =　1
a =　2
b =　2
a = 0
b =　1
a = 0
b = 0

operadores relacionais

A tabela a seguir mostra todos os operadores relacionais suportados pelo C#. Suponha que a variável A o valor é 10, variável B o valor é 20, então:

OperadoresDescriçãoExemplo
==verifica se os valores dos operandos são iguais, se forem, a condição é verdadeira.(A == B) não é verdadeiro.
!=verifica se os valores dos operandos são iguais, se não forem, a condição é verdadeira.(A != B) é verdadeiro.
>verifica se o valor do operando esquerdo é maior que o valor do operando direito, se for, a condição é verdadeira.(A > B) não é verdadeiro.
<verifica se o valor do operando esquerdo é menor que o valor do operando direito, se for, a condição é verdadeira.(A < B) é verdadeiro.
>=verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se for, a condição é verdadeira.(A >= B) não é verdadeiro.
<=verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se for, a condição é verdadeira.(A <= B) é verdadeiro.

Exemplo online

Veja o exemplo a seguir para entender todos os operadores relacionais disponíveis no C#:

Exemplo online

using System;
class Program
{
　　static void Main(string[] args)
　　{
　　　　　　int a =;　21;
　　　　　　int b =;　10;
　　　　　　
　　　　　　if (a == b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　1　-　a é igual a b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　1　-　a não é igual a b);
　　　　　　}
　　　　　　if (a < b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　2　-　a é menor que b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　2　-　a não é menor ou igual que b);
　　　　　　}
　　　　　　if (a > b)
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　3　-　a é maior que b);
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　　　Console.WriteLine("Linha　3　-　a não é maior ou igual que b);
　　　　　　}
　　　　　　/*　modificar os valores de a e b　*/
　　　　　　a =　5;
　　　　　　b =　20;
　　　　　　if (a <= b)
　　　　　　{
　　　　　　　　　Console.WriteLine("Linha　4　-　a é menor ou igual a b);
　　　　　　}
　　　　　　if (b >= a)
　　　　　　{
　　　　　　　　　Console.WriteLine("Linha　5　-　b é maior ou igual a a);
　　　　　　}
　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Linha　1　-　a não é igual a b
Linha　2　-　a não é menor ou igual que b
Linha　3　-　a é maior que b
Linha　4　-　a é menor ou igual a b
Linha　5　-　b é maior ou igual a a

operadores lógicos

A tabela a seguir mostra todos os operadores lógicos suportados pelo C#. Suponha que a variável A para o valor booleano true, a variável B para o valor booleano false, então:

OperadoresDescriçãoExemplo
&&chamado de operador lógico e. Se ambos os operandos forem não nulos, a condição é verdadeira.(A && B) é falso.
||chamado de operador lógico ou. Se qualquer um dos operandos for não nulo, a condição é verdadeira.(A || B) é verdadeiro.
!chamado de operador lógico não. Usado para inverter o estado lógico do operando. Se a condição for verdadeira, o operador lógico não a tornará falsa.!(A && B) é verdadeiro.

Exemplo online

Veja o exemplo a seguir para entender todos os operadores lógicos disponíveis no C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　bool a = true;
　　　　　　　　　　　　bool b = true;
　　　　　　　　　　　
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　Console.WriteLine("Linha　1　-　Condição verdadeira);
　　　　　　　　　　　　}
　　　　　　　　　　　　if (a || b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linha　2　-　Condição verdadeira);
　　　　　　　　　　　　}
　　　　　　　　　　　　/*　modificar os valores de a e b　*/
　　　　　　　　　　　　a = false;
　　　　　　　　　　　　b = true;
　　　　　　　　　　　　if (a && b)
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linha　3　-　Condição verdadeira);
　　　　　　　　　　　　}
　　　　　　　　　　　　else
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linha　3　-　a condição não é verdadeira);
　　　　　　　　　　　　}
　　　　　　　　　　　　if (!(a && b))
　　　　　　　　　　　　{
　　　　　　　　　　　　　　　　Console.WriteLine("Linha　4　-　Condição verdadeira);
　　　　　　　　　　　　}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Linha　1　-　Condição verdadeira
Linha　2　-　Condição verdadeira
Linha　3　-　Condição falsa
Linha　4　-　Condição verdadeira

Operadores de bit

Os operadores de bit agem sobre os bits e executam operações bit a bit. As tabelas de verdade de &、 | e ^ são as seguintes:

pqp & qp | qp ^ q
00000
01011
11110
10011

Suponha que A = 60, e B = 13Agora, representados em formato binário, eles são os seguintes:

A = 0011　1100
B = 0000　1101
-----------------
A&B = 0000　1100
A|B = 0011　1101
A^B = 0011　0001
~A =　1100 0011

A tabela a seguir lista os operadores de bit suportados pelo C#. Suponha que a variável A o valor é 60, variável B o valor é 13então:

OperadoresDescriçãoExemplo
&Se existir em ambos os operandos, o operador AND binário copia um bit para o resultado.(A & B) obterá 12，ou seja, 0000 1100
|Se existir em qualquer um dos operandos, o operador OR binário copia um bit para o resultado.(A | B) obterá 61ou seja, 0011 1101
^Se existir em um dos operandos mas não em ambos, o operador de XOR binário copia um bit para o resultado.(A ^ B) obterá 49ou seja, 0011 0001
~O operador de negação bitwise é um operador unário, que tem o efeito de "inverter" os bits, ou seja, 0 torna-se1,1tornar-se 0, incluindo o bit de sinal.(~A) obterá -61ou seja 1100 0011é a forma de complemento de dois de um número binário assinado.
<<Operador de deslocamento à esquerda binário. O valor do operando à esquerda é movido para a esquerda pela quantidade especificada pelo operando à direita.A << 2 Obterá 240, ou seja 1111 0000
>>Operador de deslocamento à direita binário. O valor do operando à esquerda é movido para a direita pela quantidade especificada pelo operando à direita.A >> 2 Obterá 15，ou seja, 0000 1111

Exemplo online

Veja o exemplo a seguir para entender todos os operadores de bit disponíveis no C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　60;　　　　　　　　　　　　/*　60 = 0011　1100　*/　　
　　　　　　　　　　　　int b =;　13;　　　　　　　　　　　　/*　13　= 0000　1101　*/
　　　　　　　　　　　　int c = 0;　　　　　　　　　　　
　　　　　　　　　　　　　c = a & b;　　　　　　　　　　　/*　12　= 0000　1100　*/　
　　　　　　　　　　　　　Console.WriteLine("Linha　1　-　O valor de c é {0}, c);
　　　　　　　　　　　　　c = a | b;　　　　　　　　　　　/*　61　= 0011　1101　*/
　　　　　　　　　　　　　Console.WriteLine("Linha　2　-　O valor de c é {0}, c);
　　　　　　　　　　　　　c = a ^ b;　　　　　　　　　　　/*　49　= 0011　0001　*/
　　　　　　　　　　　　　Console.WriteLine("Linha　3　-　O valor de c é {0}, c);
　　　　　　　　　　　　　c = ~a;　　　　　　　　　　　　　　　/*-61　=　1100 0011　*/
　　　　　　　　　　　　　Console.WriteLine("Linha　4　-　O valor de c é {0}, c);
　　　　　　　　　　　　　c = a <<　2;　　　　　/*　240 =　1111　0000　*/
　　　　　　　　　　　　　Console.WriteLine("Linha　5　-　O valor de c é {0}, c);
　　　　　　　　　　　　　c = a >>　2;　　　　　/*　15　= 0000　1111　*/
　　　　　　　　　　　　　Console.WriteLine("Linha　6　-　O valor de c é {0}, c);
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Linha　1　-　O valor de c é　12
Linha　2　-　O valor de c é　61
Linha　3　-　O valor de c é　49
Linha　4　-　O valor de c é　-61
Linha　5　-　O valor de c é　240
Linha　6　-　O valor de c é　15

Operador de atribuição

A tabela a seguir lista os operadores de atribuição suportados pelo C#:

OperadoresDescriçãoExemplo
=O operador de atribuição simples atribui o valor do operando à direita ao operando à esquerdaC = A + B atribuirá A + O valor de B é atribuído a C
+=O operador de atribuição de adição atribui o resultado da adição do operando à direita pelo operando à esquerda ao operando à esquerdaC += A é equivalente a C = C + A
-=O operador de atribuição de subtração atribui o resultado da subtração do operando à esquerda pelo operando à direita ao operando à esquerdaC -= A é equivalente a C = C - A
*=O operador de atribuição de multiplicação atribui o resultado da multiplicação do operando à direita pelo operando à esquerda ao operando à esquerdaC *= A é equivalente a C = C * A
/=O operador de atribuição de divisão atribui o resultado da divisão do operando à esquerda pelo operando à direita ao operando à esquerdaC /= A é equivalente a C = C / A
%=Operador de módulo e atribuição, atribui o módulo dos dois operandos à esquerdaC %= A é equivalente a C = C % A
<<=Operador de deslocamento à esquerda e atribuiçãoC <<= 2 É equivalente a C = C << 2
>>=Operador de deslocamento à direita e atribuiçãoC >>= 2 É equivalente a C = C >> 2
&=Operador de e lógico e atribuiçãoC &= 2 É equivalente a C = C & 2
^=Operador de xor lógico e atribuiçãoC ^= 2 É equivalente a C = C ^ 2
|=Operador de ou lógico e atribuiçãoC |= 2 É equivalente a C = C | 2

Exemplo online

Veja o exemplo a seguir para entender todos os operadores de atribuição disponíveis no C#:

using System;
namespace OperatorsAppl
{
　　　　class Program
　　　　{
　　　　　　　　static void Main(string[] args)
　　　　　　　　{
　　　　　　　　　　　　int a =;　21;
　　　　　　　　　　　　int c;
　　　　　　　　　　　　c = a;
　　　　　　　　　　　　Console.WriteLine("Linha　1　-　= valor de c = {0}
　　　　　　　　　　　　c　+= a;
　　　　　　　　　　　　Console.WriteLine("Linha　2　-　+= valor de c = {0}
　　　　　　　　　　　　c　-= a;
　　　　　　　　　　　　Console.WriteLine("Linha　3　-　-= valor de c = {0}
　　　　　　　　　　　　c　*= a;
　　　　　　　　　　　　Console.WriteLine("Linha　4　-　*= valor de c = {0}
　　　　　　　　　　　　c　/= a;
　　　　　　　　　　　　Console.WriteLine("Linha　5　-　/= valor de c = {0}
　　　　　　　　　　　　c =　2c =
　　　　　　　　　　　　00;
　　　　　　　　　　　　Console.WriteLine("Linha　6　-　c %= a;
　　　　　　　　　　　　%= valor de c = {0}　2;
　　　　　　　　　　　　Console.WriteLine("Linha　7　-　c <<=
　　　　　　　　　　　　<<= valor de c = {0}　2;
　　　　　　　　　　　　Console.WriteLine("Linha　8　-　c >>=
　　　　　　　　　　　　>= valor de c = {0}　2;
　　　　　　　　　　　　Console.WriteLine("Linha　9　-　c &=
　　　　　　　　　　　　&= valor de c = {0}　2;
　　　　　　　　　　　　Console.WriteLine("Linha　10　-　c ^=
　　　　　　　　　　　　^= valor de c = {0}　2;
　　　　　　　　　　　　Console.WriteLine("Linha　11　-　|= valor de c = {0}
　　　　　　　　　　　　Console.ReadLine();
　　　　　　　　}
　　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

Linha　1　-　= valor de c =　21
Linha　2　-　+= valor de c =　42
Linha　3　-　-= valor de c =　21
Linha　4　-　*= valor de c =　441
Linha　5　-　/= valor de c =　21
Linha　6　-　%= valor de c =　11
Linha　7　-　<<= valor de c =　44
Linha　8　-　>= valor de c =　11
Linha　9　-　&= valor de c =　2
Linha　10　-　^= valor de c = 0
Linha　11　-　|= valor de c =　2

Outros operadores

A tabela a seguir lista outros operadores importantes suportados pelo C#, incluindo sizeof、typeof e ? :.

OperadoresDescriçãoExemplo
sizeof()Retornar o tamanho do tipo de dados.sizeof(int), retornará 4.
typeof()Retornar o tipo da classe.typeof(StreamReader);
&Retornar o endereço da variável.&a; Obterá o endereço real da variável.
*Ponteiro de variável.*a; Apontará para uma variável.
? :Expressão condicionalSe a condição for verdadeira? Então X : Caso contrário, Y
éDeterminar se um objeto é do tipo específico.Se(Ford é Car) 　// Verificar se o Ford é um objeto da classe Car.
comoA conversão forçada não lança exceção, mesmo que a conversão falhar.Object obj = new StringReader("Hello");
　 　StringReader r = obj as StringReader;

Exemplo online

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　
　　　　　　　　　/*　Exemplo do operador sizeof　*/
　　　　　　　　　Console.WriteLine("O tamanho de int é {0}", sizeof(int));
　　　　　　　　　Console.WriteLine("O tamanho de short é {0}", sizeof(short));
　　　　　　　　　Console.WriteLine("O tamanho de double é {0}", sizeof(double));
　　　　　　　　　
　　　　　　　　　/*　Exemplo de operador ternário　*/
　　　　　　　　　int a, b;
　　　　　　　　　a =　10;
　　　　　　　　　b = (a ==　1) ?　20 :　30;
　　　　　　　　　Console.WriteLine("O valor de b é {0}", b);
　　　　　　　　　b = (a ==　10) ?　20 :　30;
　　　　　　　　　Console.WriteLine("O valor de b é {0}", b);
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

O tamanho de int é　4
O tamanho de short é　2
O tamanho de double é　8
O valor de b é　30
O valor de b é　20

Prioridade dos operadores no C#

A prioridade dos operadores determina como os itens de uma expressão são combinados. Isso afeta como uma expressão é calculada. Alguns operadores têm uma prioridade maior do que outros, por exemplo, os operadores de multiplicação e divisão têm uma prioridade maior do que os operadores de adição e subtração.

Por exemplo, x = 7 + 3 * 2aqui, x é atribuído a 13, não 20, porque o operador * com + Prioridade, então primeiro calcula-se a multiplicação 3*2Então, mais 7.

A tabela a seguir lista os operadores por ordem de prioridade de operação, com os operadores de maior prioridade listados no topo da tabela e os operadores de menor prioridade listados no fundo. Em uma expressão, os operadores de maior prioridade são calculados primeiro.

Categorias　Operadores　Associatividade　
Pós-fixo　() [] -> . 　++ 　 - - 　Da esquerda para a direita　
Unário　+ 　- 　 ! ~ 　++ 　- - 　 (type)* 　& sizeof　Da direita para a esquerda　
Multiplicação e Divisão　* 　/ 　%　Da esquerda para a direita　
Adição e Subtração　+ 　-　Da esquerda para a direita　
Deslocamento　<< >>　Da esquerda para a direita　
Relacional　< <= > >=　Da esquerda para a direita　
Igualdade　== !=　Da esquerda para a direita　
Bitwise e AND　&　Da esquerda para a direita　
Bitwise xor XOR　^　Da esquerda para a direita　
Bitwise ou OR　|　Da esquerda para a direita　
Lógica e AND　&&　Da esquerda para a direita　
Lógica ou OR　||　Da esquerda para a direita　
Condicional　?:　Da direita para a esquerda　
Atribuição　= 　+= 　-= 　*= 　/= %=>>= <<= &= ^= |=　Da direita para a esquerda　
Vírgula　,　Da esquerda para a direita　

Exemplo online

using System;
namespace OperatorsAppl
{
　　　　
　　　class Program
　　　{
　　　　　　static void Main(string[] args)
　　　　　　{
　　　　　　　　　int a =;　20;
　　　　　　　　　int b =;　10;
　　　　　　　　　int c =;　15;
　　　　　　　　　int d =;　5;
　　　　　　　　　int e;
　　　　　　　　　e = (a　+　b)　*　c　/　d;　　　　　//　(　30　*　15　)　/　5
　　　　　　　　　Console.WriteLine("(a　+　b)　*　c　/　O valor de d é {0}, e
　　　　　　　　　e = ((a　+　b)　*　c)　/　d;　　　//　(30　*　15　)　/　5
　　　　　　　　　Console.WriteLine("((a　+　b)　*　c)　/　O valor de d é {0}, e
　　　　　　　　　e = (a　+　b)　*　(c　/　d);　　　//　(30)　*　(15/5)
　　　　　　　　　Console.WriteLine("(a　+　b)　*　(c　/　O valor de d) é {0}, e
　　　　　　　　　e = a　+　(b　*　c)　/　d;　　　　//　　20　+　(150/5)
　　　　　　　　　Console.WriteLine("a　+　(b　*　c)　/　O valor de d é {0}, e
　　　　　　　　　Console.ReadLine();
　　　　　　}
　　　}
}

Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:

(a　+　b)　*　c　/　O valor de d é　90
((a　+　b)　*　c)　/　O valor de d é　90
(a　+　b)　*　(c　/　O valor de d) é　90
a　+　(b　*　c)　/　O valor de d é　50
FileInfo do C#Interface do C# (Interface)