Print Page - Um simples programa C # / Lição 01: Primeiros passos

Introdução

Não há elementos básicos que todos têm em programas executáveis C # e isso é o que nós vamos concentrar-nos para esta primeira lição, começando com um simples programa C #. Após analisar o código na listagem 1-1, eu vou explicar os conceitos básicos que irá seguir para todos os programas C #, vamos escrever durante todo este tutorial. Por favor, veja a listagem 1-1 ver este primeiro programa.

Aviso: C # é sensível a maiúsculas e minúsculas.

Listing 1-1. Um simples programa Bem-vindo: Welcome.cs

Quote// Namespace Declaration
using System;

// Program start class
class WelcomeCSS
{
// Main begins program execution.
static void Main()
{
// Write to console
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}

Quote from: "Traduzido..LOL"/ / Namespace Declaração
usando o Sistema;

/ / Programa começar a classe
classe WelcomeCSS
(
/ / Main inicia programa execução.
static void Main ()
(
/ / Escreva para a consola
Console.WriteLine ( "Bem vindo ao Tutorial C # Station!");
)
)

O programa em Listing 1-1 primário tem 4 elementos, um namespace declaração, uma classe, um método principal, e um programa declaração. Ele pode ser compilado com a seguinte linha de comando:

Quotecsc.exe Welcome.cs

Isso produz um arquivo chamado Welcome.exe, que pode então ser executado. Outros programas podem ser compilados forma semelhante, substituindo seu nome em vez do arquivo Welcome.cs. Para obter mais ajuda sobre opções de linha de comando, digite "csc-ajuda" na linha de comando. O nome do arquivo eo nome da classe pode ser totalmente diferente.

Nota para VS.NET Usuários: A tela será executado e fechar rapidamente ao lançar este programa a partir do Visual Studio. NET. Para evitar esta situação, adicione o código a seguir como a última linha, no principal método:

Quote// keep screen from going away
// when run from VS.NET
Console.ReadLine();

Quote from: "TRADUZIDO"/ / Manter a tela de ir longe
/ / Quando executado a partir de VS.NET
Console.ReadLine ();

Nota: A linha de comando é uma janela que lhe permite executar comandos e programas digitando o texto em manualmente. É muitas vezes referido como prompt do DOS, que era o sistema operacional utilizado pessoas anos atrás, antes do Windows. O. NET Framework SDK, que é livre, principalmente usa ferramentas de linha de comando. Por isso, escrevi este tutorial de modo que ninguém seria capaz de usá-lo. Faça uma pesquisa através do Windows Explorer para "csc.exe", que é o compilador C #. Quando você conhece a sua localização, acrescentar que a sua localização Windows caminho. Se você não pode figurar como adicionar alguma coisa para o seu caminho, chegar a um amigo para lhe ajudar. Com todas as diferentes versões do Windows disponíveis, não tenho o tempo neste tutorial, que é de cerca de programação C # língua, para mostrar-lhe como utilizar o seu sistema operativo. Em seguida, abra a janela do comando, vá para o menu Iniciar do Windows, escolha Executar e digitando cmd.exe.

A primeira coisa que você deve estar ciente de que é C # é sensível a maiúsculas e minúsculas. A palavra "principal" não é o mesmo que a sua ortografia minúscula, "principal". Eles são diferentes identificadores. Se você é proveniente de uma língua que não é caso sensitivo, esta viagem vai até você várias vezes até que você se habitue a ele.

O namespace declaração, utilizando System;, indica que você está referenciando o Sistema namespace. Namespaces incluir grupos de código que pode ser chamado por programas C #. Com a utilização do sistema; declaração, você está dizendo a seu programa que pode, em referência ao código do Sistema namespace sem pré-enquanto se aguarda o termo Sistema de cada referência. Eu vou falar deste assunto com mais pormenor na Aula 06: namespaces, que é dedicado especificamente ao namespaces.

A declaração classe, classe WelcomeCSS, contém os dados e definições método que usa para executar o seu programa. Uma classe é um dos poucos elementos diferentes tipos de seu programa pode usar para descrever os objectos, tais como Estruturas, interfaces, delegados e enums, que será discutida em mais pormenor na Aula 12: Estruturas, Aula 13: Interfaces, Lição 14 : Delegados, e Lição 17: Enums, respectivamente. Isso não tem nenhuma classe particular de dados, mas ele possui um método. Este método define o comportamento desta classe (ou o que ela é capaz de fazer). Eu vou discutir mais em classes Lição 07: Introdução às Classes. Faremos a cobertura de uma grande quantidade de informações sobre aulas durante todo este tutorial.

A um método dentro da classe WelcomeCSS diz que esta turma vai fazer quando executado. O método nome, a principal, é reservada para o ponto de partida de um programa. Principal é muitas vezes chamada de "entrada ponto" e, se alguma vez você receberá um compilador mensagem de erro dizendo que ele não pode encontrar o ponto de entrada, isso significa que você tentou compilar um programa executável sem um método principal.

Um modificador estático precede a palavra principal, o que significa que esse método funciona apenas nesta categoria específica, em vez de uma instância da classe. Isso é necessário, porque quando um programa começa, nenhum objeto instâncias existentes. Eu vou lhe dizer mais sobre as classes, objetos, e nos casos Lição 07: Introdução às Classes.

Todo método deve ter um tipo de retorno. Neste caso, é nula, o que significa que o principal não retornar um valor. Cada método tem também um parâmetro seguinte lista o seu nome com zero ou mais parâmetros entre parênteses. Para simplificar, nós não adicionar parâmetros ao principal. Mais adiante nesta lição você vai ver que tipo de parâmetro o principal método pode ter. Você vai aprender mais sobre métodos de Aula 05: Métodos.

O principal método especifica o seu comportamento com o Console.WriteLine (...) declaração. Console é uma classe no Sistema namespace. WriteLine (...) é um método na classe Console. Usamos o ".", Dot, operador de separar elementos subordinados programa. Note que nós também podemos escrever essa declaração como System.Console.WriteLine (...). Este segue o padrão "namespace.class.method" como uma afirmação totalmente qualificado. Se tivéssemos deixado fora usando o Sistema de declaração no topo do programa, que teria sido obrigatório para nós totalmente qualificado para utilizar o formulário System.Console.WriteLine (...). Esta declaração é o que provoca a corda, "Bem vindo ao Tutorial C # Station!" para imprimir a tela do console.

Observe que os comentários são marcados com "//". Estes são só linha comentários, o que significa que eles são válidos até ao fim-de-linha. Se você quiser span várias linhas com um comentário, começa com "/ *" e terminam com "*/". Tudo o que estiver entre faz parte do comentário. Os comentários são ignorados quando o seu programa compila. Eles estão lá para documentar o que faz o seu programa na planície Inglês (ou o idioma nativo falar com você todos os dias).

Todas as declarações finais com um ";", ponto e vírgula. Classes e métodos começam com "(", à esquerda chave, e terminará com um ")", certo chave. Quaisquer declarações, inclusive no interior "(" e ")" definir um bloco. Blocos definem alcance (ou vida útil e visibilidade) elementos do programa.
Aceitando entrada de linha de comando

No exemplo anterior, você simplesmente decorreu o programa é produzido e saída. No entanto, muitos programas são escritos para aceitar a entrada de linha de comando. Isso faz com que seja mais fácil de escrever scripts automatizados que pode invocar o seu programa e passar informações a ele. Se você olhar para muitos dos programas, incluindo o sistema operacional Windows utilitários, que se faça uso quotidiano; maioria deles tem algum tipo de interface de linha de comando. Por exemplo, se você digitar notepad.exe MyFile.txt (assumindo que o arquivo existe), então o programa irá abrir o seu Notepad MyFile.txt arquivo para que você possa começar a edita-lo. Você pode fazer seus programas aceitar a entrada de linha de comando também, como mostrado na listagem 1-2, o que mostra um programa que aceita um nome a partir da linha de comando e escreve-o para o console.

Nota: Ao executar a aplicação, nos NamedWelcome.exe Listagem 1-2, você deve fornecer um argumento de linha de comando. Por exemplo, digite o nome do programa, seguido pelo seu nome: NamedWelcome SeuNome. Este é o propósito do Listing 1-2 - para mostrar-lhe como lidar com entrada de linha de comando. Por isso, é necessário fornecer um argumento sobre a linha de comando para o programa de trabalho. Se você estiver executando o Visual Studio, clicar com o botão direito do projecto na Solution Explorer, selecione Propriedades, clique na guia Debug, localize Opções Iniciar, e digite SeuNome em Argumentos da linha de comandos. Caso se esqueça de entrar para SeuNome sobre a linha de comando ou introduzi-la nas propriedades do projeto, como eu acabei de explicar, você receberá uma excepção que diz que "o índice foi fora dos limites da matriz." Para manter o programa simples e concentrar apenas sobre o tema da movimentação de entrada de linha de comando, eu não adicionar excepção manuseio. Além disso, não me ensinou-lhe como acrescentar excepção para o seu manuseamento programa ainda - mas vou. Na Aula 15: Introdução ao Exceção Handling, você vai aprender mais sobre as excepções e como lidar com eles adequadamente.
Listing 1-2. Noções de linha de comando de entrada: NamedWelcome.cs

Quote// Namespace Declaration
using System;

// Program start class
class NamedWelcome
{
// Main begins program execution.
static void Main(string[] args)
{
// Write to console
Console.WriteLine("Hello, {0}!", args[0]);
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}

Quote from: "TRADUZIDO"/ / Namespace Declaração
usando o Sistema;

/ / Programa começar a classe
classe NamedWelcome
(
/ / Main inicia programa execução.
static void Main (string [] args)
(
/ / Escreva para a consola
Console.WriteLine ( "Olá, (0)!", Args
);
Console.WriteLine ( "Bem vindo ao Tutorial C # Station!");
)
)

Em Listagem 1-2, você verá uma entrada no principal método de parâmetro da lista. O parâmetro args nome é, o que você vai usar para se referir ao parâmetro mais tarde, em seu programa. A string [] expressão define o tipo de parâmetro que está args. O tipo string detém caracteres. Estes personagens poderiam formar uma única palavra, ou várias palavras. Os colchetes "[]", denotar um Array, que é como uma lista. Por isso, o tipo do parâmetro args, é uma lista de palavras a partir da linha de comando. A qualquer momento que você adicione string [] args para o parâmetro da lista principal método, o compilador C # emite código que analisa argumentos de linha de comando e carrega os argumentos de linha de comando em args. Ao ler args, você tem acesso a todos os argumentos, depois de deduzido o pedido nome, que foram digitados sobre a linha de comando.

Você também perceberá um adicional Console.WriteLine (...) declaração dentro do principal método. O argumento de lista dentro desta declaração é diferente do que antes. Tem uma string formatada com um "(0)" parâmetro incorporado. O primeiro parâmetro na string formatada uma série começa em 0, o segundo é 1, e assim por diante. O "(0)" parâmetro significa que o próximo argumento após o final citação irá determinar o que vai nessa posição. Segure que pensava, e agora vamos olhar para o próximo argumento após o final citação.

O args

argumento remete para a primeira corda na args array. O primeiro elemento de uma matriz é o número 0, o segundo é o número 1, e assim por diante. Por exemplo, se eu digitei NamedWelcome Joe sobre a linha de comando, o valor de args
seria "Joe". Isso é um pouco complicado, porque você sabe que você digitou NamedWelcome.exe sobre a linha de comando, C #, mas não inclui a aplicação executável, em nome da lista args - apenas o primeiro parâmetro após a aplicação executável.

Voltando ao embutido "(0)" parâmetro na string formato: Desde args

é o primeiro argumento, depois de formatar o texto, do Console.WriteLine () declaração, o seu valor será colocado no primeiro parâmetro de embutidos formatado a string. Quando este comando é executado, o valor de args
, que é "Joe" irá substituir "(0)" na corda formatado. Após a execução da linha de comando com "NamedWelcome Joe", a saída será a seguinte:

QuoteHello, Joe!
Welcome to the C# Station Tutorial!

Quote from: "TRADUZIDO"Olá, Joe!
Bem vindo ao Tutorial C # Station!

Interagindo através da linha de comando

Além de linha de comando de entrada, outra maneira de proporcionar contributos para um programa é através do Console. Normalmente, ele trabalha como essa: Você prompt do usuário para algumas entradas, que tipo de coisa e pressione a tecla Enter, e você ler os seus contributos e tomar algumas medidas. Listagem 1-3 mostra como obter interativo entrada do usuário.

Listing 1-3. Obtendo interativo de entrada: InteractiveWelcome.cs

Quote// Namespace Declaration
using System;

// Program start class
class InteractiveWelcome
{
// Main begins program execution.
public static void Main()
{
// Write to console/get input
Console.Write("What is your name?: ");
Console.Write("Hello, {0}! ", Console.ReadLine());
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}

Quote from: "Trazuzido"/ / Namespace Declaração
usando o Sistema;

/ / Programa começar a classe
classe InteractiveWelcome
(
/ / Main inicia programa execução.
public static void Main ()
(
/ / Escreva para o console / get input
Console.Write ( "Qual é seu nome?");
Console.Write ( "Olá, (0)!", Console.ReadLine ());
Console.WriteLine ( "Bem vindo ao Tutorial C # Station!");
)
)

Obter instruções de configuração para o modo de executar esse programa

Na listagem 1-3, o principal método não tem quaisquer parâmetros - principalmente porque ela não é necessária neste momento. Aviso também que eu prefixado o principal método declaração pública com a palavra-chave. O público que significa que qualquer palavra-chave fora desta classe podem acessar um membro dessa classe. Para Main, não importa, porque o seu código jamais chamada principal, mas, como você passar por este tutorial, você verá como você pode criar classes com membros que devem ser públicos para que possam ser utilizados. O padrão é o acesso privado, o que significa que apenas os membros dentro da mesma classe pode acessá-lo. Palavras-chave, tais como público e privado são referidos como modificadores acesso. Lição 19 discute acesso modificadores de forma mais aprofundada.

Há três declarações dentro do principal e as duas primeiras são diferentes a partir do terceiro. Eles são Console.Write (...) em vez de Console.WriteLine (...). A diferença é que a declaração Console.Write (...) escreve para o console e pára na mesma linha, mas o Console.WriteLine (...) vai para a próxima linha após escrever para o console.

A primeira declaração simplesmente escreve "Qual é seu nome?:" Para o console.

A segunda declaração não escrever nada até que seus argumentos sejam devidamente avaliados. O primeiro argumento após a corda é formatado Console.ReadLine (). Isso faz com que o programa de esperar por informações fornecidas pelo usuário no console. Depois que o usuário digita entrada, o seu nome, neste caso, devem pressionar a tecla Enter. O valor de retorno deste método substitui o "(0)" parâmetro da string formatado e é escrito para o console. Esta linha também poderia ter sido escrita como este:

Quotestring name = Console.ReadLine();
Console.Write("Hello, {0}! ", name);

Quote from: "TRADUZIDO"string nome = Console.ReadLine ();
Console.Write ( "Olá, (0)!", Nome);

A última declaração escreve para o console como descrito anteriormente. Após a execução da linha de comando com "InteractiveWelcome", a saída será a seguinte:[/b]

Quote>What is your Name? [Enter Key]
>Hello, ! Welcome to the C# Station Tutorial!

[quoteTRADUZIDO]> Qual é seu nome? [Enter Key]
> Olá, ! Bem vindo ao Tutorial C # Station![/quote]

Resumo 1° Lição

Agora você sabe a estrutura básica de um programa C #. utilizando afirmações permitem-lhe uma referência ao código namespace e permitir ter mais curto e mais legível notação. O método é o principal ponto de entrada para iniciar um programa C #. Você pode capturar entrada de linha de comando quando um pedido é dirigido por leitura itens a partir de uma string [] (string array) parâmetro para o seu principal método. Interactive I / O podem ser realizadas com o ReadLine, Write e WriteLine métodos da classe Console.

Code Select

// Namespace Declaration
using System;

// Program start class
class WelcomeCSS 
{
	// Main begins program execution.
	static void Main() 
	{
		// Write to console
		Console.WriteLine("Welcome to the C# Station Tutorial!"); 

		// Make window wait for input
		Console.ReadLine();
	}
}

CONTINUA....

Esta lição introduz C # operadores, tipos e variáveis. Seu objetivo é o de cumprir os seguintes objectivos:

* Entenda o que é uma variável.
* Familiarização com C # built-in tipos.
* Tenha uma introdução ao C # operadores.
* Saiba como usar Arrays.

Variáveis e Tipos

"Variáveis" são simplesmente locais de armazenamento de dados. Você pode colocar os dados e recuperá-los em seu conteúdo como parte de uma expressão C #. A interpretação dos dados em uma variável é controlada através de "Tipos".

C # é um forte "datilografado" língua. Assim, todas as operações são realizadas com variáveis em consideração de que a variável do "Tipo" é. Existem regras que definem quais as operações são legais, a fim de manter a integridade dos dados que ponha em uma variável.

A C # simples tipos consistem na Booleano tipo numérico e de três tipos - Integrais, Ponto Flutuante, Decimal, e Cordas. O termo "Integrais", que é definido na programação C # Language Specification, refere-se à classificação dos tipos que incluem sbyte, byte, de curto, ushort, int, uint, long, ulong, e char. Mais detalhes estão disponíveis na seção Tipos Integral posteriormente nesta lição. O termo "Ponto Flutuante" refere-se à dupla float e tipos, que são discutidas, junto com o tipo decimal, mais em pormenor, no Ponto Flutuante e Decimal Tipos secção posterior nesta lição. A corda tipo representa um conjunto de caracteres e é discutido na secção Tipo de Cordas, posteriormente nesta lição. A próxima seção introduz o tipo booleano.

O tipo boolean

Booleano tipos são declarados utilizando a palavra-chave, bool. Eles têm dois valores: verdadeiro ou falso. Em outras linguagens, como C, C + +, boolean condições podem ser satisfeitos quando 0 significa falso e qualquer outra coisa, significa verdadeira. No entanto, em C # apenas os valores que satisfazem uma condição boolean é verdadeiro e falso, que são oficiais palavras-chave. 2-1 mostra uma lista de muitas maneiras que boolean tipos podem ser usados em um programa.
Listing 2-1. Mostrando valores booleanos: Boolean.cs

Quoteusing System;

class Booleans
{
public static void Main()
{
bool content = true;
bool noContent = false;

Console.WriteLine("It is {0} that C# Station provides C# programming language content.", content);
Console.WriteLine("The statement above is not {0}.", noContent);
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe Booleans
(
public static void Main ()
(
bool conteúdo = true;
bool noContent = false;

Console.WriteLine ( "É (0) que C # Station programação linguagem C # fornece conteúdo.", Conteúdo);
Console.WriteLine ( "A afirmação acima não é (0).", NoContent);
)
)

Na listagem 2-1, os valores booleanos são escritos para o console como uma parte de uma frase. Os únicos valores válidos para o tipo bool ou são verdadeiras ou falsas, tal como demonstrado pela cessão de verdadeiro e falso para o conteúdo para noContent. Quando executado, esse programa produz a seguinte saída:

QuoteIt is True that C# Station provides C# programming language content.
The statement above is not False.

Quote from: "TRADUZIDO"É verdade que C # Station oferece programação linguagem C # conteúdo.
A afirmação acima não é falso.

Tipos Integral

Em C #, uma é integrante de uma categoria de tipos. Para qualquer um confuso, porque a palavra Integral soa como uma expressão matemática, a partir da perspectiva de programação C #, estas são efectivamente definidos como tipos Integral na linguagem C # programação especificação. Eles são números inteiros, quer assinados ou não assinados, e do tipo char. O tipo char é um caractere Unicode, tal como definido pelo Unicode Standard. Para obter mais informações, visite a Unicode Home Page. 2-1 tabela mostra os tipos integrais, o seu tamanho, e de gama.

Tabela 2-1. O tamanho ea Faixa de C # Integral Tipos

(//http://img145.imageshack.us/img145/7467/ttaabbeellaa11br8.jpg)

Integral tipos estão bem adaptados para as operações que envolvem cálculos número inteiro. O tipo char é a excepção, representando um único caractere Unicode. Como você pode ver a partir do quadro acima, você tem uma vasta gama de opções de escolha, dependendo de suas necessidades.
E tipos de ponto flutuante decimal

AC # ponto flutuante tipo é tanto uma bóia ou dupla. Eles são usados a qualquer momento que você precisa para representar um número real, tal como definido pelo IEEE 754. Para mais informações sobre o IEEE 754, IEEE visite o Web Site. Decimal tipos deve ser usada quando representando dinheiro ou valores financeiros. 2-2 tabela mostra os tipos de ponto flutuante e decimal, o seu tamanho, precisão, e de gama.

Tabela 2-2. O Ponto Flutuante e Decimal Tipos com tamanho, precisão, e Gama

(//http://img144.imageshack.us/img144/6171/ttaabbeellaa22222222vt8.jpg)
Tipos de ponto flutuante é usado quando você precisa para executar operações que exijam representações fracionário. No entanto, para cálculos financeiros, o tipo decimal é a melhor opção porque você pode evitar erros arredondamentos.

A String Tipo

Uma string é uma seqüência de caracteres texto. Você normalmente criar uma string em uma string literal, delimitada entre aspas: "Este é um exemplo de uma string." Você já viu cordas sendo usado desde Lição 1, quando usamos a Console.WriteLine método para enviar dados de saída para o console.

Alguns caracteres não são imprimíveis, mas você ainda precisa usá-los em strings. Por isso, C # tem uma sintaxe especial onde personagens podem ser escapou para representar caracteres não imprimíveis. Por exemplo, é comum a utilização newlines no texto, que é representada pela '\ n' car. A barra invertida, '\', representa a fuga. Quando antecedida por escapar à personagem, o 'n' já não é interpretada como uma letra, mas agora representa uma nova linha.

Você pode estar se perguntando agora como você pode representar uma barra de caracteres em seu código. Temos de escapar a isso também, escrevendo duas barras, como em '\ \'. tabela 2-3 mostra uma lista de seqüências comuns escapar.

Tabela 2-3. C # seqüências de caracteres escapar

(//http://img79.imageshack.us/img79/5314/ttaabbeellaa22fe4.jpg)

Outra característica útil de cordas C # é o literal textualmente, que é uma corda com um símbolo @ prefixo, como em @ "Algumas string". Textualmente literais fazer escapar seqüências traduzir como normal personagens para aumentar a legibilidade. Para apreciar o valor de literais literais, considere um caminho declaração como "c: \ \ topdir \ \ subdir \ \ subdir \ \ myapp.exe". Como você pode ver, as barras são escapou, provocando a string a ser menos legível. Pode melhorar a corda com um literal literal, como este:

Quote@ "c: \ topdir \ subdir \ subdir \ myapp.exe".

Isso é bom, mas agora você tem o problema quando cita texto não é tão fácil. Em tal caso, você irá especificar aspas duplas. Por exemplo, a string "copiar " c: \ \ nome do arquivo fonte spaces.txt \ "c: \ \ newfilename.txt" seria escrito como o literais literal @ "cópia" "c: \ origem do nome do ficheiro com espaços . txt "" c: \ newfilename.txt ".

C # Operadores

Os resultados são calculados pela construção expressões. Estas expressões são construídas pela combinação variáveis e operadores juntos em declarações. A tabela a seguir descreve os operadores admissíveis, a sua precedência, e associatividade.

Tabela 2-4. Operadores com sua precedência e associatividade

(//http://img264.imageshack.us/img264/7886/ttaabbeellaa33io3.jpg)

Esquerda associatividade significa que as operações são avaliadas da esquerda para a direita. Associatividade direita, todas as operações ocorrem da direita para a esquerda, tais como a atribuição operadores do direito para onde tudo é avaliado antes de o resultado seja colocado em uma variável à esquerda.

A maioria dos operadores são quer unário ou binário. Unário operadores formulário de expressões em uma única variável, mas os operadores forma binária expressões com duas variáveis. Listing 2-2 unário demonstra como os operadores são usados.

Listing 2-2. Unário operadores: Unary.cs

Quoteusing System;

class Unary
{
public static void Main()
{
int unary = 0;
int preIncrement;
int preDecrement;
int postIncrement;
int postDecrement;
int positive;
int negative;
sbyte bitNot;
bool logNot;

preIncrement = ++unary;
Console.WriteLine("pre-Increment: {0}", preIncrement);

preDecrement = --unary;
Console.WriteLine("pre-Decrement: {0}", preDecrement);

postDecrement = unary--;
Console.WriteLine("Post-Decrement: {0}", postDecrement);

postIncrement = unary++;
Console.WriteLine("Post-Increment: {0}", postIncrement);

Console.WriteLine("Final Value of Unary: {0}", unary);

positive = -postIncrement;
Console.WriteLine("Positive: {0}", positive);

negative = +postIncrement;
Console.WriteLine("Negative: {0}", negative);

bitNot = 0;
bitNot = (sbyte)(~bitNot);
Console.WriteLine("Bitwise Not: {0}", bitNot);

logNot = false;
logNot = !logNot;
Console.WriteLine("Logical Not: {0}", logNot);
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe unário
(
public static void Main ()
(
int unário = 0;
int preIncrement;
int preDecrement;
int postIncrement;
int postDecrement;
int positivos;
int negativo;
sbyte bitNot;
bool logNot;

preIncrement = + + unário;
Console.WriteLine ( "pré-Incremento: (0)", preIncrement);

preDecrement = - unário;
Console.WriteLine ( "pré-decrementar: (0)", preDecrement);

postDecrement = unário -;
Console.WriteLine ( "Post-decrementar: (0)", postDecrement);

postIncrement = unário + +;
Console.WriteLine ( "Pós-Incremento: (0)", postIncrement);

Console.WriteLine ( "valor final da unário: (0)", unário);

=-postIncrement positivo;
Console.WriteLine ( "Positivo: (0)", positivos);

= + postIncrement negativo;
Console.WriteLine ( "Negativo: (0)", negativos);

bitNot = 0;
bitNot = (sbyte) (~ bitNot);
Console.WriteLine ( "Não bitwise: (0)", bitNot);

logNot = false;
logNot =! logNot;
Console.WriteLine ( "Não Lógico: (0)", logNot);
)
)

Obter instruções de configuração para o modo de executar esse programa

Ao avaliar expressões, pós-incremento (x + +) e de pós-decrementar (x -) operadores retornar seu valor actual e, em seguida, aplicar os operadores. No entanto, quando se utiliza pré-incremento (+ + x) e pré-decrementar (- x) operadores, o operador é aplicado para a variável antes de devolver o valor final.

Na listagem 2-2, o unário variável é inicializado a zero. Quando o pré-incremento (+ + x) operador é utilizado, unário a 1 e é incrementado o valor 1 é atribuído para a variável preIncrement. O pré-decrementar (- x) transforma operador unário de volta para um 0 e, em seguida, atribui o valor para a variável preDecrement.

Quando o pós-decrementar (x -) operador é utilizado, o valor de unário, 0, é colocada na postDecrement variável e, em seguida, unário é decrementado a -1. Próximo do pós-incremento (x + +) operador move o valor corrente de unário, -1, para os postIncrement variável e, em seguida, incrementos unário a 0.

A variável bitNot é inicializado a 0 e não o bitwise (~) operador é aplicado. A não bitwise (~) operador flips os bits na variável. Neste caso, a representação binária de 0, "00000000", foi transformada em -1, "11111111".

A fixação de positivo é um pouco complicado. No momento em que está estabelecido, o postIncrement variável é igual a -1. Aplicando a menos (-) operador para um número negativo resulta em um número positivo, o que significa que postitive será igual 1, em vez de -1. O operador menos (-), o que não é o mesmo que o período de pré-decrementar operador (--), não alteram o valor de postInc - ele apenas se aplica um sinal de negação. O operador mais (+) não afecta o valor de um número, atribuindo negativos com o mesmo valor que postIncrement, -1.

Aviso a expressão (sbyte) (~ bitNot). Qualquer operação realizada em tipos sbyte, byte, de curto, ou ushort retorno int valores. Para atribuir o resultado para a variável bitNot tivemos que utilizar um cast, (Tipo), operador, onde tipo é o tipo que você deseja converter a (neste caso - sbyte). O elenco operador é apresentado como o operador unário, (T) x, no quadro 2-4. Expressos explicitamente os operadores devem ser realizadas quando você ir a partir de uma maior dimensão a um tipo menor tipo de dado o potencial de perda de dados. De uma maneira geral, atribuindo um tipo menor para um maior tipo não é problema, uma vez que o maior tipo de quarto tem a deter a totalidade do valor. Também estar conscientes dos perigos de vazamento assinados e não assinados entre tipos. Você quer ter a certeza de preservar a integridade dos seus dados. Muitos textos básicos programação contém descrições de boas bit representações de variáveis e os perigos de vazamento explícita.

A lógica não (!) Operador lhe permite alternar o valor de uma variável booleana. No exemplo, a logNot variável é alterada de falsa a verdade. Você pode esperar o resultado a partir do programa acima.

Quotepre-Increment: 1
pre-Decrement 0
Post-Decrement: 0
Post-Increment: -1
Final Value of Unary: 0
Positive: 1
Negative: -1
Bitwise Not: -1
Logical Not: true

Quote from: "TRADUZIDO"pré-Incremento: 1
pré-decrementar 0
Pós-decrementar: 0
Pós-Incremento: -1
Valor final da unário: 0
Positivo: 1
Negativo: -1
Não bitwise: -1
Não é lógico: true

Para além de operadores unário, C # possui operadores binários que formam expressões de duas variáveis. Listagem 2-3 mostra como usar o binário operadores.

Listing 2-3. Binário operadores: Binary.cs

Quoteusing System;

class Binary
{
public static void Main()
{
int x, y, result;
float floatresult;

x = 7;
y = 5;

result = x+y;
Console.WriteLine("x+y: {0}", result);

result = x-y;
Console.WriteLine("x-y: {0}", result);

result = x*y;
Console.WriteLine("x*y: {0}", result);

result = x/y;
Console.WriteLine("x/y: {0}", result);

floatresult = (float)x/(float)y;
Console.WriteLine("x/y: {0}", floatresult);

result = x%y;
Console.WriteLine("x%y: {0}", result);

result += x;
Console.WriteLine("result+=x: {0}", result);
}
}

And here's the output:

x+y: 12
x-y: 2
x*y: 35
x/y: 1
x/y: 1.4
x%y: 2
result+=x: 9

Quote from: "TRADUZIDO"usando o Sistema;

classe Binário
(
public static void Main ()
(
int x, y, resultado;
float floatresult;

x = 7;
y = 5;

resultado = x + y;
Console.WriteLine ( "x + y: (0)", resultado);

resultado = x-y;
Console.WriteLine ( "x-y: (0)", resultado);

resultado = x * y;
Console.WriteLine ( "x * y: (0)", resultado);

resultado = x / y;
Console.WriteLine ( "x / y: (0)", resultado);

floatresult = (float) x / (float) y;
Console.WriteLine ( "x / y: (0)", floatresult);

resultado = x% y;
Console.WriteLine ( "x% y: (0)", resultado);

resultado + = x;
Console.WriteLine ( "resultado + = x: (0)", resultado);
)
)

E aqui está a saída:

x + y: 12
x-y: 2
x * y: 35
x / y: 1
x / y: 1,4
x% y: 2
resultado + = x: 9

Obter instruções de configuração para o modo de executar esse programa

Listagem 2-3 mostra vários exemplos de operadores binários. Como você poderia esperar, os resultados de adição (+), subtração (-), multiplicação (*), ea divisão (/) produzir os resultados esperados matemática.

O floatresult variável é um tipo de ponto flutuante. Nós explicitamente o elenco inteiro variáveis x e y para calcular um valor de ponto flutuante.

Existe também um exemplo do restante (%) operador. Ela realiza uma operação divisão em dois valores e retorna o restante.

A última declaração revela uma outra forma de cessão com a operação (+ =) operador. Toda vez que você usar a cessão a operação operador, que é o mesmo que a aplicação do operador binário para tanto a mão esquerda e mão direita lados do operador e da colocação dos resultados no lado esquerdo. O exemplo poderia ter sido escrita como resultado resultado + = x; e devolvido o mesmo valor.

O tipo Array

Outro tipo de dados é o Array, que pode ser pensado como um contentor que tem uma lista de locais de armazenamento para um determinado tipo. Ao declarar um Array, especificar o tipo, nome, dimensões e tamanho.

Listing 2-4. Array operações: Array.cs

Quoteusing System;

class Array
{
public static void Main()
{
int[] myInts = { 5, 10, 15 };
bool[][] myBools = new bool[2][];
myBools[0] = new bool[2];
myBools[1] = new bool[1];
double[,] myDoubles = new double[2, 2];
string[] myStrings = new string[3];

Console.WriteLine("myInts[0]: {0}, myInts[1]: {1}, myInts[2]: {2}", myInts[0], myInts[1], myInts[2]);

myBools[0][0] = true;
myBools[0][1] = false;
myBools[1][0] = true;
Console.WriteLine("myBools[0][0]: {0}, myBools[1][0]: {1}", myBools[0][0], myBools[1][0]);

myDoubles[0, 0] = 3.147;
myDoubles[0, 1] = 7.157;
myDoubles[1, 1] = 2.117;
myDoubles[1, 0] = 56.00138917;
Console.WriteLine("myDoubles[0, 0]: {0}, myDoubles[1, 0]: {1}", myDoubles[0, 0], myDoubles[1, 0]);

myStrings[0] = "Joe";
myStrings[1] = "Matt";
myStrings[2] = "Robert";
Console.WriteLine("myStrings[0]: {0}, myStrings[1]: {1}, myStrings[2]: {2}", myStrings[0], myStrings[1], myStrings[2]);

}
}

And here's the output:

myInts[0]: 5, myInts[1]: 10, myInts[2]: 15
myBools[0][0]: true, myBools[1][0]: true
myDoubles[0, 0]: 3.147, myDoubles[1, 0]: 56.00138917
myStrings[0]: Joe, myStrings[1]: Matt, myStrings[2]: Robert

Quote from: "TRADUZIDO"usando o Sistema;

class Array
(
public static void Main ()
(
int [] myInts = (5, 10, 15);
bool [] [] = new bool myBools [2] [];
myBools
= new bool [2];
myBools [1] = new bool [1];
dupla [de] = new myDoubles dupla [2, 2];
string [] myStrings = new string [3];

Console.WriteLine ( "myInts
: (0), myInts [1]: (1), myInts [2]: (2)", myInts
, myInts [1], myInts [2]);

myBools

= true;
myBools
[1] = false;
myBools [1]
= true;
Console.WriteLine ( "myBools

: (0), myBools [1]
: (1)", myBools

, myBools [1]
);

myDoubles [0, 0] = 3,147;
myDoubles [0, 1] = 7,157;
myDoubles [1, 1] = 2,117;
myDoubles [1, 0] = 56.00138917;
Console.WriteLine ( "myDoubles [0, 0]: (0), myDoubles [1, 0]: (1)", myDoubles [0, 0], myDoubles [1, 0]);

myStrings
= "Joe";
myStrings [1] = "Matt";
myStrings [2] = "Robert";
Console.WriteLine ( "myStrings
: (0), myStrings [1]: (1), myStrings [2]: (2)", myStrings
, myStrings [1], myStrings [2]);

)
)

E aqui está a saída:

myInts
: 5, myInts [1]: 10, myInts [2]: 15
myBools

: true, myBools [1]
: true
myDoubles [0, 0]: 3,147, myDoubles [1, 0]: 56.00138917
myStrings
: Joe, myStrings [1]: Matt, myStrings [2]: Robert

Obter instruções de configuração para o modo de executar esse programa

Listagem 2-4 mostra diferentes implementações de Arrays. O primeiro exemplo é o myInts Array, que é uma dimensão única-array. Ele é inicializado com o tempo a declaração explícita valores.

Seguinte é um array retalhadas, myBools. É essencialmente um array de arrays. Precisávamos de usar o novo operador que exemplificam o tamanho da matriz primária e, em seguida, usar o novo operador de novo para cada sub-array.

O terceiro exemplo é um array bidimensional, myDoubles. Arrays podem ser multi-dimensional, com cada dimensão separada por uma vírgula. Também deve ser instanciado com o novo operador.

Uma das diferenças entre arrays retalhadas, myBools [][], e multi-dimensão arrays, myDoubles [,], que é um multi-dimensão array irá alocar memória para cada elemento de cada dimensão, enquanto que um array retalhadas só irá alocar memória para o tamanho de cada matriz, em cada dimensão que você define. A maior parte do tempo, você estará usando arrays multi-dimensão, se você precisa de múltiplas dimensões, e só irá utilizar retalhadas arrays em circunstâncias muito especiais quando você é capaz de guardar a memória significativa indicar explicitamente os tamanhos das matrizes, em cada dimensão .

Por último, temos o único-dimensional array de tipos string, myStrings.

Em cada caso, você pode ver que a matriz elementos são acessados através da identificação das inteiro índice para o item que você deseja referir-se. Arrays tamanho pode ser qualquer tipo int valor. Os seus índices começam em 0.
Resumo

A variável é um identificador com um tipo que detém um valor desse tipo. Simples incluir os tipos integrais, pontos flutuantes, decimal, e bool. C # tem vários operadores lógicos e matemáticos que participam na formação de expressões. C # também oferece a única dimensão, multi-dimensão e retalhadas array tipos.

RESUMO LIÇÃO 2

Nesta lição você aprendeu a escrever código simples declarações e um programa que funciona linearmente do começo ao fim. No entanto, isso não é tão útil como ele pode ser porque você precisa para ser capaz de tomar decisões e executar diferentes blocos de código dependendo de condições diferentes. Convido-vos a voltar para a Aula 3: Controle Declarações - Seleção, onde você pode aprender a lógica de seu ramo mais poderoso de tomada de decisão.

Extenções

Pode ser compled, digitando a seguinte linha de comando:

CSC Array.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

Array.exe

Pode ser compled, digitando a seguinte linha de comando:

CSC Binary.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

Binary.exe

Pode ser compled, digitando a seguinte linha de comando:

CSC Boolean.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

Boolean.exe

Pode ser compled, digitando a seguinte linha de comando:

CSC Unary.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

Unary.exe

CONTINUA....

Boa safado.. temporada de tutoriais. \o
Tb to fazendo um aqui nervosão =D
Mas primero vo da uma lida pra aprende um poco de C sharp =]

Nas últimas duas lições, cada programa que você viu continha uma quantidade limitada de passos seqüenciais e depois parou. Não foram encontradas decisões que você pode fazer com o contributo e foi o único constrangimento para seguir em frente até ao fim. A informação contida neste lição irá ajudá-lo a sucursal em sequências lógicas distintas baseadas em decisões que fizer. Mais especificamente, os objectivos desta aula são as seguintes:

* Saber se a declarações.
* Saiba o interruptor declaração.
* Saiba como quebrar é utilizado em mudar de declarações.
* Compreender a utilização adequada do goto declaração.

A Declaração se

Uma declaração que lhe permite tomar caminhos diferentes de lógica, dependendo de uma determinada condição. Quando avalia a condição para um boolean true, um bloco de código para que a verdadeira condição irá executar. Você tem a opção de uma única declaração se, então, se múltiplas declarações, e uma outra declaração opcional.
Listagem 3-1 mostra como cada um destes tipos de declarações se trabalhar.

Listing 3-1. se as formas de afirmação: IfSelection.cs

Quoteusing System;

class IfSelect
{
public static void Main()
{
string myInput;
int myInt;

Console.Write("Please enter a number: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);

// Single Decision and Action with brackets
if (myInt > 0)
{
Console.WriteLine("Your number {0} is greater than zero.", myInt);
}

// Single Decision and Action without brackets
if (myInt < 0)
Console.WriteLine("Your number {0} is less than zero.", myInt);

// Either/Or Decision
if (myInt != 0)
{
Console.WriteLine("Your number {0} is not equal to zero.", myInt);
}
else
{
Console.WriteLine("Your number {0} is equal to zero.", myInt);
}

// Multiple Case Decision
if (myInt < 0 || myInt == 0)
{
Console.WriteLine("Your number {0} is less than or equal to zero.", myInt);
}
else if (myInt > 0 && myInt <= 10)
{
Console.WriteLine("Your number {0} is in the range from 1 to 10.", myInt);
}
else if (myInt > 10 && myInt <= 20)
{
Console.WriteLine("Your number {0} is in the range from 11 to 20.", myInt);
}
else if (myInt > 20 && myInt <= 30)
{
Console.WriteLine("Your number {0} is in the range from 21 to 30.", myInt);
}
else
{
Console.WriteLine("Your number {0} is greater than 30.", myInt);
}
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe IfSelect
(
public static void Main ()
(
myInput corda;
int Myint;

Console.Write ( "Por favor introduza um número:");
myInput = Console.ReadLine ();
Myint = Int32.Parse (myInput);

/ / Único decisão e de acção com parênteses
if (Myint> 0)
(
Console.WriteLine ( "Seu número (0) é maior do que zero.", Myint);
)

/ / Único decisão e acção sem colchetes
if (Myint <0)
Console.WriteLine ( "Seu número (0) é inferior a zero.", Myint);

/ / Ou / ou decisão
if (Myint! = 0)
(
Console.WriteLine ( "Seu número (0) não é igual a zero.", Myint);
)
diferente
(
Console.WriteLine ( "Seu número (0) é igual a zero.", Myint);
)

/ / Multiple Processo decisão
if (Myint <0 | | Myint == 0)
(
Console.WriteLine ( "Seu número (0) é inferior ou igual a zero.", Myint);
)
senão Se (Myint> 0 & & Myint <= 10)
(
Console.WriteLine ( "Seu número (0) está na faixa de 1 a 10.", Myint);
)
senão Se (Myint> 10 & & Myint <= 20)
(
Console.WriteLine ( "Seu número (0) está na faixa de 11 a 20.", Myint);
)
senão Se (Myint> 20 & & Myint <= 30)
(
Console.WriteLine ( "Seu número (0) está na faixa de 21 a 30.", Myint);
)
diferente
(
Console.WriteLine ( "Seu número (0) é maior que 30.", Myint);
)
)
)

As declarações na listagem 3-1 usar a mesma variável de entrada, Myint como uma parte das suas avaliações. Essa é outra maneira de obter interativo entrada do usuário. Aqui está o código pertinente:

QuoteConsole.Write("Please enter a number: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);

Quote from: "TRADUZIDO"Console.Write ( "Por favor introduza um número:");
myInput = Console.ReadLine ();
Myint = Int32.Parse (myInput);

Nós imprimir a primeira linha "Por favor introduza um número:" para o console. O Console.ReadLine () declaração faz com que o programa de espera para entrada do usuário, que tipos de prensas e, em seguida, um número Enter. Esse número é retornado na forma de uma corda para o myInput variável, que é um tipo string. Uma vez que temos de avaliar a entrada do usuário, sob a forma de um int, myInput devem ser convertidos. Isto é feito com o comando Int32.Parse (myInput). (Int32 e tipos similares serão cobertos em outra lição sobre avançados tipos) O resultado é colocado na Myint variável, que é um tipo int.

Agora que temos uma variável do tipo que queríamos, iremos avaliá-la se a declarações. A primeira afirmação é a forma de se (boolean expression) (declarações), como mostrado a seguir:

Quote// Single Decision and Action with brackets
if (myInt > 0)
{
Console.WriteLine("Your number {0} is greater than zero.", myInt);
}

Quote from: "TRADUZIDO"/ / Único decisão e de acção com parênteses
if (Myint> 0)
(
Console.WriteLine ( "Seu número (0) é maior do que zero.", Myint);
)

Você deve começar com a palavra-chave se. Seguinte é a expressão booleana entre parênteses. Esta expressão booleana deve avaliar a um valor verdadeiro ou falso. Neste caso, estamos verificando a entrada do usuário para ver se é maior que (>) 0. Se esta expressão avalia para true, nós executar as declarações no âmbito do chavetas. (Referimo-nos à estrutura com chavetas como um "bloco") Pode haver uma ou mais declarações dentro deste bloco. Se a expressão booleana avalia a falsa, ignorarmos as declarações dentro do bloco e continuar a execução do próximo programa declaração após o bloqueio.

Nota: Em outras linguagens, como C, C + +, podem ser avaliadas as condições em que um resultado de 0 é falso e qualquer outro número é verdadeiro. Em C #, deve avaliar a condição para um valor booleano de uma das verdadeiras ou falsas. Se você precisa para simular uma condição numérica em C #, você pode fazê-lo por escrito-o como (Myint! = 0), o que significa que a expressão avaliar a verdade se Myint não é 0.

A segunda afirmação é bem como se o primeiro, exceto que não tem um bloco, como mostrado aqui:

Quote// Single Decision and Action without brackets
if (myInt < 0)
Console.WriteLine("Your number {0} is less than zero.", myInt);

Quote from: "TRADUZIDO"/ / Único decisão e acção sem colchetes
if (Myint <0)
Console.WriteLine ( "Seu número (0) é inferior a zero.", Myint);

Se a sua expressão boolean avalia a verdade, a primeira declaração após a expressão booleana será executado. Quando a expressão booleana avalia a falsa, a primeira declaração após a expressão booleana será pulado ea declaração do próximo programa será executado. Esta forma de declaração, se é adequada quando você só tem uma única declaração para executar. Se você quiser executar dois ou mais declarações, quando a expressão booleana avalia a verdade, você deve anexar-los em um bloco.

A minha recomendação pessoal está a tornar um hábito de sempre colocar suas declarações, se dentro de um bloco, independentemente de haver ou não tem só uma declaração de executar. Isso ajudará a evitar erros caso você decida adicionar mais tarde uma declaração e se esqueça de adicionar o chavetas.

A maior parte do tempo, você vai querer fazer um ou / ou tipo de decisão. Isto é chamado um caso / outra declaração. A terceira se na declaração Listing 3-1 apresenta esta ideia, como mostrado a seguir:

Quote// Either/Or Decision
if (myInt != 0)
{
Console.WriteLine("Your number {0} is not equal to zero.", myInt);
}
else
{
Console.WriteLine("Your number {0} is equal to zero.", myInt);
}

Quote from: "TRADUZIDO"/ / Ou / ou decisão
if (Myint! = 0)
(
Console.WriteLine ( "Seu número (0) não é igual a zero.", Myint);
)
diferente
(
Console.WriteLine ( "Seu número (0) é igual a zero.", Myint);
)

Quando a expressão booleana avalia a verdade, a declaração (ões) no bloco, imediatamente a seguir à declaração, se forem executados. No entanto, quando a expressão booleana avalia a falsa, as declarações no bloco, na sequência da outra palavra-chave é executada.

Quando você tem múltiplas expressões de avaliar, você pode usar o caso / senão quando / se a outra forma de declaração. Mostramos essa forma, no quarto caso de declaração Listing 3-1, e repetida abaixo:

Quote// Multiple Case Decision
if (myInt < 0 || myInt == 0)
{
Console.WriteLine("Your number {0} is less than or equal to zero.", myInt);
}
else if (myInt > 0 && myInt <= 10)
{
Console.WriteLine("Your number {0} is in the range from 1 to 10.", myInt);
}
else if (myInt > 10 && myInt <= 20)
{
Console.WriteLine("Your number {0} is in the range from 11 to 20.", myInt);
}
else if (myInt > 20 && myInt <= 30)
{
Console.WriteLine("Your number {0} is in the range from 21 to 30.", myInt);
}
else
{
Console.WriteLine("Your number {0} is greater than 30.", myInt);
}

Quote from: "TRADUZIDO"/ / Multiple Processo decisão
if (Myint <0 | | Myint == 0)
(
Console.WriteLine ( "Seu número (0) é inferior ou igual a zero.", Myint);
)
senão Se (Myint> 0 & & Myint <= 10)
(
Console.WriteLine ( "Seu número (0) está na faixa de 1 a 10.", Myint);
)
senão Se (Myint> 10 & & Myint <= 20)
(
Console.WriteLine ( "Seu número (0) está na faixa de 11 a 20.", Myint);
)
senão Se (Myint> 20 & & Myint <= 30)
(
Console.WriteLine ( "Seu número (0) está na faixa de 21 a 30.", Myint);
)
diferente
(
Console.WriteLine ( "Seu número (0) é maior que 30.", Myint);
)

Este exemplo se inicia com a palavra-chave, novamente executando o seguinte bloco se a expressão booleana avalia para true. No entanto, este tempo você pode avaliar várias condições posteriores se com o resto combinação palavra-chave. a outra pessoa se toma igualmente uma declaração boolean expressão, tal como se a declaração. As regras são as mesmas, quando a expressão booleana para o resto se avalia a declaração verdadeira, o bloco imediatamente a seguir à expressão booleana é executado. Quando nenhum dos outros ou então se se boolean expressões avaliar a verdadeira, o bloco na sequência da outra palavra-chave será executado. Apenas uma seção de um caso / resto se / senão declaração será executada.

Uma diferença na última declaração de os outros é a boolean expressões. A expressão booleana, (Myint <0 | | Myint == 0), contém o condicional OR (| |) operador. Em ambos os regulares OR (|) e ao condicional operador OR (| |) operador, a expressão irá avaliar a boolean true se nenhuma das duas sub-expressões de ambos os lados do operador avaliar a verdade. A principal diferença entre os dois ou formas são regulares ou que o operador irá avaliar as duas sub-expressões de cada vez. No entanto, a condicional ou irá avaliar a segunda sub-expressão só se a primeira sub-expressão avalia a falso.

A expressão booleana, (Myint> 0 & & Myint <= 10), contém o condicional e operador. Ambos os periódicos e (e) o operador e condicional E (& &) operador irá retornar verdadeiro quando ambos da sub-expressões de ambos os lados do operador avaliar a verdade. A diferença entre os dois é que o operador regular e irá avaliar tanto expressões de cada vez. No entanto, o operador condicional e irá avaliar a segunda sub-expressão apenas quando a primeira sub-expressão avalia para true.

Os operadores condicionais (& &, | |) são comumente chamados de curto-circuito operadores porque nem sempre avaliar a expressão inteira. Assim, elas também são usadas para produzir código mais eficiente, ignorando desnecessária lógica.
O interruptor Declaração

Outra forma de seleção afirmação é o interruptor declaração, que executa um conjunto de lógica, dependendo do valor de um determinado parâmetro. Os tipos de valores a um interruptor opera a declaração pode ser booleans, enums, integrante tipos, e de cordas. Lição 2: Operadores, Tipos, Variáveis e discutido o tipo bool, integrante tipos e cordas e Lição 17: Enums vai ensinar-lhe o que é um ENUM tipo. Listagem 3-2 mostra como utilizar o interruptor declaração com ambos os tipos int e string.

Listing 3-2. Switch declarações: SwitchSelection.cs

Quoteusing System;

class SwitchSelect
{
public static void Main()
{
string myInput;
int myInt;

begin:

Console.Write("Please enter a number between 1 and 3: ");
myInput = Console.ReadLine();
myInt = Int32.Parse(myInput);

// switch with integer type
switch (myInt)
{
case 1:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 2:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
}

decide:

Console.Write("Type "continue" to go on or "quit" to stop: ");
myInput = Console.ReadLine();

// switch with string type
switch (myInput)
{
case "continue":
goto begin;
case "quit":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("Your input {0} is incorrect.", myInput);
goto decide;
}
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe SwitchSelect
(
public static void Main ()
(
myInput corda;
int Myint;

começar:

Console.Write ( "Por favor, digite um número entre 1 e 3:");
myInput = Console.ReadLine ();
Myint = Int32.Parse (myInput);

/ / Switch com tipo inteiro
switch (Myint)
(
caso 1:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
caso 2:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
caso 3:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
default:
Console.WriteLine ( "Seu número (0) não está entre 1 e 3.", Myint);
break;
)

decidir:

Console.Write ( "Tipo " continuar \ "para ir a ou " quit \ "para parar:");
myInput = Console.ReadLine ();

/ / Mudar a string tipo
switch (myInput)
(
caso "continuar":
Goto começar;
caso "sair":
Console.WriteLine ( "Bye.");
break;
default:
Console.WriteLine ( "Sua entrada (0) está incorreto.", MyInput);
Goto decidir;
)
)
)

Nota: Listagem 3-2 irá lançar uma exceção, se você digitar qualquer valor diferente de um int. i.e. a letra "a" seria um erro. Você pode visitar Lição 15: Introdução ao Manuseamento Exceção para saber mais sobre como antecipar e lidar com estes tipos de problemas.

Listagem 3-2 mostra um casal de mudar de declarações. O interruptor declaração começa com a palavra-chave seguido por alternar o interruptor expressão. Na primeira declaração em mudar de listagem 3-2, ao mudar de expressão avalia para um tipo int, como segue:

Quote// switch with integer type
switch (myInt)
{
case 1:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 2:
Console.WriteLine("Your number is {0}.", myInt);
break;
case 3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
}

Quote from: "TRADUZIDO"/ / Switch com tipo inteiro
switch (Myint)
(
caso 1:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
caso 2:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
caso 3:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
default:
Console.WriteLine ( "Seu número (0) não está entre 1 e 3.", Myint);
break;
)

O interruptor bloco segue o interruptor expressão, sempre que uma ou mais opções são avaliados para uma possível combinar com o interruptor expressão. Cada escolha é marcado com o caso palavras-chave, seguido de um exemplo que é do mesmo tipo que o interruptor expressão e seguido por dois pontos (:). No exemplo que temos caso 1:, caso 2:, e caso 3:. Quando os resultados são avaliados no interruptor expressão coincide com uma destas opções, as declarações imediatamente após a escolha de correspondência são executadas, até, e incluindo uma ramificação declaração, que poderá ser tanto uma pausa, continue, goto, o retorno, ou deitar declaração. Tabela 3-1 resume a ramificação declarações.

Tabela 3-1. C # ramificando declarações

(//http://img383.imageshack.us/img383/5638/figura1tb2.jpg)

Você também pode incluir uma opção por defeito após todas as outras opções. Se nenhuma das outras opções jogo e, em seguida, escolha o padrão é tomada e as suas declarações são executados. Embora o uso do rótulo default é opcional, eu recomendo fortemente que você sempre incluí-lo. Isso ajudará a captura circunstâncias imprevistas e tornar seus programas mais confiáveis.

Cada caso deve terminar com um rótulo ramificação declaração, tal como descrito na tabela 3-1, que é normalmente a declaração break. A declaração break irá causar o programa para sair do mapa e começar a mudar com a execução do próximo mapa após a passagem bloco. Há duas excepções a esta regra: declarações em caso adjacentes não entre no código ou usando uma declaração goto. Aqui está um exemplo que mostra como a combinar caso declarações:

Quoteswitch (myInt)
{
case 1:
case 2:
case 3:
Console.WriteLine("Your number is {0}.", myInt);
break;
default:
Console.WriteLine("Your number {0} is not between 1 and 3.", myInt);
break;
}

Quote from: "TRADUZIDO"switch (Myint)
(
caso 1:
caso 2:
caso 3:
Console.WriteLine ( "Seu número é (0).", Myint);
break;
default:
Console.WriteLine ( "Seu número (0) não está entre 1 e 3.", Myint);
break;
)

Ao colocar caso declarações em conjunto, sem qualquer código-nos entre, você cria um único caso de vários valores. Um caso sem qualquer código irá automaticamente através de queda para o próximo caso. O exemplo acima mostra como os três casos para Myint igual a 1, 2 ou 3, caso em que caso 1 e 2 vão cair e executar código através de caso 3.

Um caso declaração só pode ser uma correspondência exata e você não pode usar lógico condições. Se você precisa usar lógico condições, você pode utilizar um caso / resto se / outra declaração.

Outra maneira de controlar o fluxo da lógica de uma declaração switch é usando o goto declaração. Você pode pular para o outro caso declaração, ou saltar de mudar a declaração. A segunda declaração em mudar de Listagem 3-2 mostra o uso da declaração goto, como mostrado a seguir:

Quote// switch with string type
switch (myInput)
{
case "continue":
goto begin;
case "quit":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("Your input {0} is incorrect.", myInput);
goto decide;
}

Quote from: "TRADUZIDO"/ / Mudar a string tipo
switch (myInput)
(
caso "continuar":
Goto começar;
caso "sair":
Console.WriteLine ( "Bye.");
break;
default:
Console.WriteLine ( "Sua entrada (0) está incorreto.", MyInput);
Goto decidir;
)

Nota: no atual exemplo, "continuar", é um caso de mudar a declaração - e não a palavra-chave.

A declaração goto causas programa execução para saltar para o marcador na sequência do goto palavra-chave. Durante a execução, se o usuário digita em "continuar", a declaração mudar esta entrada jogos (um tipo de corda) com o caso "continuar": etiqueta e executa o "goto começar:" instrução. O programa irá então deixar o interruptor declaração e começar a executar o primeiro programa começará a seguinte declaração: rótulo. Isto é efectivamente um loop, permitindo que você execute o mesmo código várias vezes. O ciclo terá fim quando o usuário digita o texto "sair". Esta será avaliada com o caso "sair": escolha, que irá imprimir "Bye". para o console, sair do interruptor ea declaração final do programa.

Aviso: Você não deve criar loops como este. É ruim * * programação estilo. A única razão pela qual ela está aqui é porque eu queria mostrar-lhe a sintaxe da declaração goto. Em vez disso, utilize um dos estruturado looping declarações, descrito na Aula 04: Controlo Declarações - Loops.

Quando nem o "continuar" nem "sair" strings são inscritos, o "padrão:" caso será inscrito. Ele irá imprimir uma mensagem de erro para o console e, em seguida, executar o goto decidir: comando. Isso fará com que o programa execução para pular para a primeira declaração após a decidir: rótulo, que irá perguntar ao usuário se querem continuar ou desistir. Isto é efectivamente um outro ciclo.

Claramente, o goto declaração é poderoso e pode, sob condições controladas, ser útil. Devo, no entanto, prudência lhe vivamente a sua utilização. A declaração goto tem um grande potencial para abuso. Você poderia eventualmente criar um programa muito difícil para depurar e manter. Imagine o espaguete código que poderia ser criado por acaso goto declarações ao longo de um programa. Na aula seguinte, eu vou mostrar-lhe a melhor forma de criar loops em seu programa.

Resumo Lição 3

Se a declaração pode ser escrito em várias maneiras de implementar diferentes ramos da lógica. O interruptor declaração permite uma escolha entre um conjunto de bool, enum, integral, ou tipos string. Você pode utilizar o break, continue, goto, o retorno, ou deitar declarações ao sair de uma declaração caso. Certifique-se de evitar o goto declaração em seu código a menos que você tenha uma excelente razão para utilizá-lo.

OBS:
(IfSelection.cs) Pode ser compilado, digitando a seguinte linha de comando:

CSC ifselection.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

ifselection.exe

(switchselection) Pode ser compilado, digitando a seguinte linha de comando:

CSC switcselection.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

switchselection.exe

CONTINUA...

Continuando...

Lição 4: Controle Declarações - Loops

Na última aula, você aprendeu como criar um simples loop usando o goto declaração. Aconselhei-lhe que esta não é a melhor maneira de executar loops em C #. A informação contida neste lição vai ensinar-lhe a forma correcta de executar iterativo lógica com as várias C # looping declarações. Seu objetivo é o de cumprir os seguintes objectivos:

* Aprenda a while.
* Aprenda a fazer loop.
* Aprender para o loop.
* Aprenda a foreach loop.
* Preencher o seu conhecimento da declaração de quebra.
* Ensinam como usar a continuar declaração.

O while

Um while irá verificar uma condição e, em seguida, continua a executar um bloco de código enquanto a condição avalia para um valor booleano de verdade. Sua sintaxe é a seguinte: ao mesmo tempo () (). As declarações podem ser válido C # quaisquer declarações. A expressão booleana é avaliada antes de qualquer código no bloco seguinte foi executada. Quando a expressão booleana avalia para true, as declarações irá executar. Uma vez que as declarações tenham executado, o controle volta para o início do while para verificar a expressão booleana novamente.

Quando a expressão booleana avalia a falsa, a while declarações são saltados e execução começa após o encerramento da cinta que bloco de código. Antes de entrar na malha, garantir que as variáveis avaliadas em loop condição estão definidos para um estado inicial. Durante a execução, certifique-se de atualizar variáveis associadas com a expressão booleana a fim de que o ciclo vai terminar quando você quer que ele. Listagem 4-1 mostra a forma de implementar um while.

Listing 4-1. O while: WhileLoop.cs

Quoteusing System;

class WhileLoop
{
public static void Main()
{
int myInt = 0;

while (myInt < 10)
{
Console.Write("{0} ", myInt);
myInt++;
}
Console.WriteLine();
}
}

Listagem 4-1 mostra um simples while. Ela começa com a palavra-chave ao mesmo tempo, seguido por uma expressão booleana. Todas as declarações controle boolean expressões como utilizar a sua condição para entrar / continuar o ciclo. Isto significa que a expressão deve avaliar, quer um valor verdadeiro ou falso. Neste caso, nós estamos verificando a variável Myint para ver se é menor que (<) 10. Desde Myint foi inicializado a 0, a expressão irá retornar boolean true a primeira vez que é avaliada. Quando a expressão booleana avalia para true, o bloco imediatamente a seguir à expressão booleana será executado.

Dentro do bloco, enquanto nós imprimir o número e um espaço para o console. Então nós incremento (+ +) Myint para o próximo inteiro. Uma vez que as declarações em bloco, enquanto a ter executado, a expressão booleana é avaliada novamente. Esta seqüência irá continuar até que a expressão booleana avalia a falso. Depois de a boolean expressão é avaliada como falsa, controle programa vai saltar para a primeira declaração seguinte, enquanto o bloco. Neste caso, vamos escrever os números 0 a 9 para o console, enquanto que sair do bloco, e imprimir uma nova linha para o console.
A fazer Loop

Um fazer loop é semelhante ao while, exceto que se verifica a sua condição no final do ciclo. Isto significa que seja garantida a fazer loop para executar pelo menos uma vez. Por outro lado, um while avalia seus boolean expressão no início e geralmente não há nenhuma garantia de que as declarações dentro do ciclo será executado, a menos que você programa o código para fazê-lo explicitamente. Uma das razões que você deseja usar uma vez de fazer um loop while é o de apresentar uma mensagem ou o menu como uma listagem em 4.2 e, depois, recuperar entrada de um usuário.

Listing 4-2. A fazer loop: DoLoop.cs

Quoteusing System;

class DoLoop
{
public static void Main()
{
string myChoice;

do
{
// Print A Menu
Console.WriteLine("My Address Book\n");

Console.WriteLine("A - Add New Address");
Console.WriteLine("D - Delete Address");
Console.WriteLine("M - Modify Address");
Console.WriteLine("V - View Addresses");
Console.WriteLine("Q - Quit\n");

Console.WriteLine("Choice (A,D,M,V,or Q): ");

// Retrieve the user's choice
myChoice = Console.ReadLine();

// Make a decision based on the user's choice
switch(myChoice)
{
case "A":
case "a":
Console.WriteLine("You wish to add an address.");
break;
case "D":
case "d":
Console.WriteLine("You wish to delete an address.");
break;
case "M":
case "m":
Console.WriteLine("You wish to modify an address.");
break;
case "V":
case "v":
Console.WriteLine("You wish to view the address list.");
break;
case "Q":
case "q":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("{0} is not a valid choice", myChoice);
break;
}

// Pause to allow the user to see the results
Console.Write("press Enter key to continue...");
Console.ReadLine();
Console.WriteLine();
} while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe DoLoop
(
public static void Main ()
(
myChoice corda;

fazer
(
/ / Print Uma Menu
Console.WriteLine ( "Meu Address Book \ n");

Console.WriteLine ( "A - Adicionar Novo Endereço");
Console.WriteLine ( "D - Delete Morada");
Console.WriteLine ( "M - Alterar Morada");
Console.WriteLine ( "V - Ver Endereços");
Console.WriteLine ( "Q - Sair \ n");

Console.WriteLine ( "Choice (A, D, M, V, ou Q):");

/ / Recuperar escolha do utilizador
myChoice = Console.ReadLine ();

/ / Faça uma decisão baseada na escolha do utilizador
switch (myChoice)
(
caso "A":
caso "a":
Console.WriteLine ( "Você deseja adicionar um endereço.");
break;
caso "D":
caso "d":
Console.WriteLine ( "Você deseja excluir um endereço.");
break;
caso "M":
caso "m":
Console.WriteLine ( "Você deseja modificar um endereço.");
break;
caso "V":
caso "v":
Console.WriteLine ( "Você quer ver lista de endereços.");
break;
caso "Q":
caso "q":
Console.WriteLine ( "Bye.");
break;
default:
Console.WriteLine ( "(0) não é uma opção válida", myChoice);
break;
)

/ / Pausa para permitir que o usuário de ver os resultados
Console.Write ( "pressione Enter para continuar ...");
Console.ReadLine ();
Console.WriteLine ();
) While (myChoice! = "Q" & & myChoice! = "Q"); / / Manter indo até que o usuário deseja parar de fumar
)
)

Listagem 4-2 mostra fazer um loop em ação. A sintaxe do loop fazer é fazer ) (while ();. As declarações podem ser válidas quaisquer declarações programação C # você quiser. A expressão booleana é o mesmo que todos os outros temos encontradas até agora. Ela quer retorna verdadeiro ou falso.

No método main (), declaramos a variável myChoice do tipo string. Em seguida, imprimir uma série de declaração para o console. Este é um menu de opções para o usuário. Temos de obter entrada do usuário, que está sob a forma de uma Console.ReadLine () método que retorna o valor do usuário na myChoice variável. Temos de tomar a entrada do usuário e processá-la. Uma maneira muito eficiente de fazer isso é com uma declaração switch. Repare que temos colocado correspondência letras maiúsculas e minúsculas em conjunto para obter a mesma funcionalidade. Este é o único meio legal de ter automática através de queda entre os casos. Se você estava a colocar quaisquer declarações entre dois casos, você não seria capaz de cair através. Outro ponto é que temos utilizado o padrão: caso, que é um hábito muito bom para a fundamentação da Aula 3: Controle Declarações - Seleção.
A Loop para

Um funciona como um loop de while, exceto que a sintaxe do loop de inicialização e inclui condição modificação. para os loops são bons para quando você sabe exatamente quantas vezes você quiser executar as declarações no âmbito do ciclo. O conteúdo dentro do lacete parêntese para detém três seções separadas por vírgulas (; ; ) ().

O initializer lista é uma lista separada por vírgulas de expressões. Estas expressões são avaliadas apenas uma vez durante o período de duração do ciclo de. Este é um momento de uma operação, antes da execução loop. Esta seção é comumente usado para inicializar um inteiro para ser usado como um contador.

Uma vez que o initializer lista foi avaliado, o loop dá para controlar a sua segunda secção, a expressão booleana. Existe apenas uma expressão booleana, mas pode ser tão complicado como quiser, desde que o resultado avalia a verdadeira ou falsa. A expressão booleana é comumente usado para verificar o status de um balcão variável.

Quando a expressão booleana avalia para true, as declarações no âmbito do chavetas do ciclo de são executados. Após executar declarações de laço, controlo passar para a parte superior do loop e executa a iterator lista, que é normalmente usado para incrementar ou decrementar um contador. O iterator pode conter uma lista separada por vírgulas lista de declarações, mas geralmente é apenas uma declaração. Listagem 4-3 mostra a forma de aplicar para um loop.

Listing 4-3. O laço para: ForLoop.cs

Quoteusing System;

class ForLoop
{
public static void Main()
{
for (int i=0; i < 20; i++)
{
if (i == 10)
break;

if (i % 2 == 0)
continue;

Console.Write("{0} ", i);
}
Console.WriteLine();
}
}

Normalmente, para executar a partir do lacete declarações abertura chave para o fechamento chave sem interrupção. No entanto, na listagem 4-3, fizemos um jovem excepções. Há algumas declarações se perturbar o fluxo de controle para dentro do bloco.

A primeira declaração se verifica se i é igual a 10. Agora, você vê uma outra utilização de quebrar a declaração. O seu comportamento é semelhante ao da selecção declarações, como discutido na Aula 3: Controle Declarações - Seleção. Limita-se a quebra de um ciclo a que ponto o controlo e as transferências para a primeira declaração após o fim do bloco de.

A segunda declaração se utiliza o restante operador para ver se eu for um múltiplo de 2. Isto irá avaliar a verdadeira quando i é dividido por 2 com um saldo igual a zero, (0). Ao certo, continuará a declaração é executada, causando controle para saltar sobre as restantes declarações na malha e de transferência de volta para a lista iterator. Ao organizar as declarações dentro de um bloco corretamente, você pode executá-los condicionalmente basear-se em qualquer que seja a condição de que você precisa.

Quando chega a controlar quer um programa continuará ou declaração final do bloco, que transfere para a terceira secção para dentro do laço entre parênteses, o iterator lista. Esta é uma lista separada por vírgulas de ações que são executadas após as declarações no bloco de ter sido executada. Listagem 4-3 é uma típica ação, incrementado o contador. Uma vez que este está completo, o controlo das transferências para o booleano expressão para a avaliação.

Semelhante ao while, para um ciclo continuará enquanto a expressão booleana é verdadeira. Quando a expressão se torna falso booleano, o controlo é transferido para a primeira declaração seguinte para o bloco.

Para este tutorial, optei quebrar e continuar a implementar, em declarações Listing 4-3 apenas. No entanto, podem ser utilizadas em qualquer das declarações loop.
A Loop foreach

Um loop foreach é usado para iterate através dos itens em uma lista. O sistema funciona com arranjos ou coleções como ArrayList, que pode ser encontrado no namespace System.Collections. A sintaxe de um loop foreach é foreach ( em ) (). O tipo é o tipo de item da lista. Por exemplo, se o tipo da lista foi int [], então seria o tipo int.

O nome é um elemento identificador que você escolher, o que poderia ser qualquer coisa, mas deverá ser significativo. Por exemplo, se a lista continha um leque de idades da população e, em seguida, um nome significativo para a rubrica nome seria idade.

A palavra-chave nos é exigido.

Como mencionado anteriormente, a lista poderia ser tanto um array ou uma coleção, como definidos por tipos encontrados no namespace System.Collections. Você aprendeu sobre arrays em Lição 02: Operadores, Tipos e Variáveis. Se você não estiver familiarizado com colecções, abrir o. NET Framework SDK documentação e de olhar para o namespace System.Collections para ver quais tipos estão disponíveis.

Enquanto iteração através dos elementos de uma lista com um loop foreach, a lista é somente para leitura. Isto significa que você não pode alterar o valor de todos os itens na lista dentro de um loop foreach.

Em cada iteração através de um loop foreach a lista é consultada para um novo valor. Desde que a lista pode retornar um valor, esse valor será colocado em read-only o item nome variável, causando as declarações na foreach bloco a ser executado. Quando a cobrança tenha sido totalmente atravessado, o controlo deverá transferir para o executável primeira declaração após o final do bloco foreach. Listagem 4-4 mostra como usar um loop foreach.

Listing 4-4. O foreach loop: ForEachLoop.cs

Quoteusing System;

class ForEachLoop
{
public static void Main()
{
string[] names = {"Cheryl", "Joe", "Matt", "Robert"};

foreach (string person in names)
{
Console.WriteLine("{0} ", person);
}
}
}

Na listagem 4-4, a primeira coisa que temos feito dentro do método main () é declarar e inicializar o array com nomes 4 cordas. Esta é a lista utilizada no foreachloop.

No foreach loop, temos usado uma corda variável, pessoa, como nome do item, a manutenção de cada elemento do array nomes. Enquanto existirem nomes no array que não tenham sido devolvidos, o Console.WriteLine () método irá imprimir o valor de cada pessoa variável para a tela.

Resumo Lição 4

Loops permitem que você execute um bloco de declarações repetidas vezes. C # oferece várias declarações para a construção de loops com, incluindo o tempo, fazer, para, e foreach loops. enquanto loops executar um bloco de declarações, enquanto uma expressão for verdadeira, fazer loops executar um bloco de declarações, pelo menos uma vez e, depois, manter, desde que uma condição seja verdade, para loops executar um bloco de declarações num montante especificado de vezes, foreach loops e executar um bloco de declarações para cada item em uma coleção. Normalmente, um bloco de declarações irá executar do começo ao fim. No entanto, o fluxo normal de um ciclo pode ser alterado com a quebrar e continuar declarações.

Até o momento, o único método que tenha visto neste tutorial é o principal método, que é o ponto de entrada de uma aplicação C #. No entanto, você provavelmente deve querer escrever grandes programas para testar os seus novos conhecimentos..

OBS..

DOLOOP (pode ser compilado, digitando a seguinte linha de comando:

CSC doloop.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

doloop.exe)

FOREACHLOOP (pode ser compilado, digitando a seguinte linha de comando:

CSC foreachloop.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

foreachloop.cs)

FORLOOP (pode ser compilado, digitando a seguinte linha de comando:

CSC forloop.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

forloop.exe)

WHILELOOP (pode ser compilado, digitando a seguinte linha de comando:

CSC whileloop.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

whileloop.exe)

CONTINUA.....

FEAR

Lição 05: Métodos

Nas lições anteriores deste tutorial, todos os nossos funcionalidade para cada programa, residia no método main (). Enquanto isso foi suficiente para a simples programas que utilizamos para aprender conceitos anteriores, não existe uma maneira melhor de organizar o seu programa, utilizando métodos. Um método ajuda a separar o seu código em módulos que executar uma dada tarefa. Os objectivos desta aula são as seguintes:

* Compreender a estrutura de um método.
* Conheça a diferença entre métodos estáticos e exemplo.
* Aprenda a instanciar objetos.
* Aprenda a chamar métodos de um objeto instanciado.
* Compreender a 4 tipos de parâmetros.
* Saiba como usar a esta referência.

Método Estrutura

Os métodos são extremamente úteis porque permitem que você separar sua lógica em unidades diferentes. Você pode passar informações aos métodos, tem que executar uma ou mais declarações, e recuperar um valor de retorno. A capacidade de passar parâmetros e retornar valores é opcional e depende do que você deseja que o método de fazer. Aqui está uma descrição da sintaxe necessária para a criação de um método:

Quoteattributes modifiers return-type method-name(parameters )
{
statements
}

[quoteTRADUZIDO]atributos modificadores retorno do tipo método de nome (parâmetros)
(
Declarações
)
[/quote]

Nós adiar discussão dos atributos e modificadores para mais tarde uma lição. O regresso de tipo C # pode ser qualquer tipo. Ela pode ser atribuído a uma variável para uso posterior no programa. O método é nome de um identificador único para aquilo que você deseja chamar um método. Para promover a compreensão de seu código, nome de um método deve ser significativa e associada com o método executa a tarefa. Parâmetros permitem-lhe passar informações para ea partir de um método. Eles estão rodeados por parêntese. As declarações no âmbito do chavetas realizar a funcionalidade do método.

Listing 5-1. Um método simples: OneMethod.cs

Quoteusing System;

class OneMethod
{
public static void Main()
{
string myChoice;

OneMethod om = new OneMethod();

do
{
myChoice = om.getChoice();

// Make a decision based on the user's choice
switch(myChoice)
{
case "A":
case "a":
Console.WriteLine("You wish to add an address.");
break;
case "D":
case "d":
Console.WriteLine("You wish to delete an address.");
break;
case "M":
case "m":
Console.WriteLine("You wish to modify an address.");
break;
case "V":
case "v":
Console.WriteLine("You wish to view the address list.");
break;
case "Q":
case "q":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("{0} is not a valid choice", myChoice);
break;
}

// Pause to allow the user to see the results
Console.WriteLine();
Console.Write("press Enter key to continue...");

Console.ReadLine();
Console.WriteLine();

} while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
}

string getChoice()
{
string myChoice;

// Print A Menu
Console.WriteLine("My Address Book\n");

Console.WriteLine("A - Add New Address");
Console.WriteLine("D - Delete Address");
Console.WriteLine("M - Modify Address");
Console.WriteLine("V - View Addresses");
Console.WriteLine("Q - Quit\n");

Console.Write("Choice (A,D,M,V,or Q): ");

// Retrieve the user's choice
myChoice = Console.ReadLine();
Console.WriteLine();

return myChoice;
}
}

Quote from: "TRADUZIDO"usando o Sistema;

classe OneMethod
(
public static void Main ()
(
myChoice corda;

OneMethod om = new OneMethod ();

fazer
(
myChoice = om.getChoice ();

/ / Faça uma decisão baseada na escolha do utilizador
switch (myChoice)
(
caso "A":
caso "a":
Console.WriteLine ( "Você deseja adicionar um endereço.");
break;
caso "D":
caso "d":
Console.WriteLine ( "Você deseja excluir um endereço.");
break;
caso "M":
caso "m":
Console.WriteLine ( "Você deseja modificar um endereço.");
break;
caso "V":
caso "v":
Console.WriteLine ( "Você quer ver lista de endereços.");
break;
caso "Q":
caso "q":
Console.WriteLine ( "Bye.");
break;
default:
Console.WriteLine ( "(0) não é uma opção válida", myChoice);
break;
)

/ / Pausa para permitir que o usuário de ver os resultados
Console.WriteLine ();
Console.Write ( "pressione Enter para continuar ...");

Console.ReadLine ();
Console.WriteLine ();

) While (myChoice! = "Q" & & myChoice! = "Q"); / / Manter indo até que o usuário deseja parar de fumar
)

string getChoice ()
(
myChoice corda;

/ / Print Uma Menu
Console.WriteLine ( "Meu Address Book \ n");

Console.WriteLine ( "A - Adicionar Novo Endereço");
Console.WriteLine ( "D - Delete Morada");
Console.WriteLine ( "M - Alterar Morada");
Console.WriteLine ( "V - Ver Endereços");
Console.WriteLine ( "Q - Sair \ n");

Console.Write ( "Choice (A, D, M, V, ou Q):");

/ / Recuperar escolha do utilizador
myChoice = Console.ReadLine ();
Console.WriteLine ();

myChoice retorno;
)
)

O programa de Listagem 5-1 é semelhante à da DoLoop programa a partir da Aula 4, com excepção de uma diferença. Em vez de imprimir o menu e aceitando a entrada no método main (), esta funcionalidade foi transferido para um novo método chamado getChoice (). O tipo de retorno é uma string. Esta seqüência é usada na declaração no interruptor principal (). O método nome "getChoice" descreve o que acontece quando ele é invocado. Uma vez que os parênteses estão vazias, nenhuma informação será transferida para o getChoice () método.

Dentro do método primeiro bloco nós declaramos a variável myChoice. Embora este seja o mesmo nome eo tipo que a variável em myChoice Main (), eles são os dois únicos variáveis. Eles são variáveis locais e são visíveis apenas no bloco, eles são declarados. Em outras palavras, o myChoice em getChoice () sabe nada sobre a existência do myChoice em Main (), e vice-versa.

O getChoice () método imprime um menu para o console e fica a entrada do usuário. O regresso declaração envia os dados a partir do myChoice variável de volta para o chamador, Main (), de getChoice (). Note que o tipo retornado por voltar a declaração deve ser o mesmo que o retorno da função do tipo de declaração. Neste caso, trata-se de uma corda.

No método main () temos que exemplificam um novo objeto OneMethod antes de podermos utilizar getChoice (). Isto é devido à forma getChoice () é declarada. Como não especificar um modificador estático, como, por Main (), getChoice () se torna um exemplo método. A diferença entre métodos estáticos e métodos exemplo é que várias instâncias de uma classe podem ser criados (ou instanciado), e cada instância tem a sua própria separado getChoice () método. No entanto, quando um método é estático, não existem casos desse método, e você pode invocar apenas que uma definição do método estático.

Portanto, como afirmou, getChoice () não é estática e, por conseguinte, temos de instanciar um novo objeto de utilizá-la. Isto é feito com a declaração OneMethod om = new OneMethod (). No lado esquerdo da declaração é a referência om que é objeto do tipo OneMethod. A distinção de ser uma referência om é importante. Não se trata de um objeto em si, mas é uma variável que pode remeter (ou ponto) para um objeto do tipo OneMethod. No lado direito da declaração é uma atribuição de uma nova OneMethod opor-se a referência om. A palavra-chave C # é um novo operador que cria uma nova instância de um objeto sobre o monte. O que está a acontecer aqui é que uma nova instância OneMethod está a ser criado sobre o monte e, em seguida, sendo atribuído à om referência. Agora que temos uma instância da classe OneMethod referenciado por om, nós podemos manipular que om exemplo, através da referência.

Métodos, campos, e outros membros classe pode ser acessado, identificados, ou manipuladas através do "." (ponto) operador. Uma vez que queremos chamar getChoice (), fazemo-lo usando o operador ponto om através da referência: om.getChoice (). O programa então executa as declarações na getChoice () e retorna bloco. Para capturar o valor getChoice () retorna, nós usamos o "=" (atribuição) operador. A corda é colocada em devolvidos Main () 's locais myChoice variável. A partir daí, o resto do programa executa como esperado, utilizando conceitos de aulas mais cedo.

Listing 5-2. Método parâmetros: MethodParams.cs

Quoteusing System;

class Address
{
public string name;
public string address;
}

class MethodParams
{
public static void Main()
{
string myChoice;

MethodParams mp = new MethodParams();

do
{
// show menu and get input from user
myChoice = mp.getChoice();

// Make a decision based on the user's choice
mp.makeDecision(myChoice);

// Pause to allow the user to see the results
Console.Write("press Enter key to continue...");
Console.ReadLine();
Console.WriteLine();
} while (myChoice != "Q" && myChoice != "q"); // Keep going until the user wants to quit
}

// show menu and get user's choice
string getChoice()
{
string myChoice;

// Print A Menu
Console.WriteLine("My Address Book\n");

Console.WriteLine("A - Add New Address");
Console.WriteLine("D - Delete Address");
Console.WriteLine("M - Modify Address");
Console.WriteLine("V - View Addresses");
Console.WriteLine("Q - Quit\n");

Console.WriteLine("Choice (A,D,M,V,or Q): ");

// Retrieve the user's choice
myChoice = Console.ReadLine();

return myChoice;
}

// make decision
void makeDecision(string myChoice)
{
Address addr = new Address();

switch(myChoice)
{
case "A":
case "a":
addr.name = "Joe";
addr.address = "C# Station";
this.addAddress(ref addr);
break;
case "D":
case "d":
addr.name = "Robert";
this.deleteAddress(addr.name);
break;
case "M":
case "m":
addr.name = "Matt";
this.modifyAddress(out addr);
Console.WriteLine("Name is now {0}.", addr.name);
break;
case "V":
case "v":
this.viewAddresses("Cheryl", "Joe", "Matt", "Robert");
break;
case "Q":
case "q":
Console.WriteLine("Bye.");
break;
default:
Console.WriteLine("{0} is not a valid choice", myChoice);
break;
}
}

// insert an address
void addAddress(ref Address addr)
{
Console.WriteLine("Name: {0}, Address: {1} added.", addr.name, addr.address);
}

// remove an address
void deleteAddress(string name)
{
Console.WriteLine("You wish to delete {0}'s address.", name);
}

// change an address
void modifyAddress(out Address addr)
{
//Console.WriteLine("Name: {0}.", addr.name); // causes error!
addr = new Address();
addr.name = "Joe";
addr.address = "C# Station";
}

// show addresses
void viewAddresses(params string[] names)
{
foreach (string name in names)
{
Console.WriteLine("Name: {0}", name);
}
}
}

Quote from: "TRADUZIDO"usando o Sistema;

Endereço classe
(
público string nome;
público string morada;
)

classe MethodParams
(
public static void Main ()
(
myChoice corda;

MethodParams mp = new MethodParams ();

fazer
(
/ / Mostrar menu e obter contributos de usuário
myChoice = mp.getChoice ();

/ / Faça uma decisão baseada na escolha do utilizador
mp.makeDecision (myChoice);

/ / Pausa para permitir que o usuário de ver os resultados
Console.Write ( "pressione Enter para continuar ...");
Console.ReadLine ();
Console.WriteLine ();
) While (myChoice! = "Q" & & myChoice! = "Q"); / / Manter indo até que o usuário deseja parar de fumar
)

/ / Menu e mostrar obter escolha do usuário
string getChoice ()
(
myChoice corda;

/ / Print Uma Menu
Console.WriteLine ( "Meu Address Book \ n");

Console.WriteLine ( "A - Adicionar Novo Endereço");
Console.WriteLine ( "D - Delete Morada");
Console.WriteLine ( "M - Alterar Morada");
Console.WriteLine ( "V - Ver Endereços");
Console.WriteLine ( "Q - Sair \ n");

Console.WriteLine ( "Choice (A, D, M, V, ou Q):");

/ / Recuperar escolha do utilizador
myChoice = Console.ReadLine ();

myChoice retorno;
)

/ / Fazer decisão
makeDecision nulo (string myChoice)
(
Endereço novo endereço addr = ();

switch (myChoice)
(
caso "A":
caso "a":
addr.name = "Joe";
addr.address = "C # Station";
this.addAddress (ref addr);
break;
caso "D":
caso "d":
addr.name = "Robert";
this.deleteAddress (addr.name);
break;
caso "M":
caso "m":
addr.name = "Matt";
this.modifyAddress (out addr);
Console.WriteLine ( "Nome é agora (0).", Addr.name);
break;
caso "V":
caso "v":
this.viewAddresses ( "Cheryl", "Joe", "Matt", "Robert");
break;
caso "Q":
caso "q":
Console.WriteLine ( "Bye.");
break;
default:
Console.WriteLine ( "(0) não é uma opção válida", myChoice);
break;
)
)

/ / Inserir um endereço
void addAddress (ref Morada addr)
(
Console.WriteLine ( "Nome: (0), Endereço: (1) acrescentou.", Addr.name, addr.address);
)

/ / Remover um endereço
deleteAddress nulo (string nome)
(
Console.WriteLine ( "Você deseja apagar (0) 's endereço.", Nome);
)

/ / Alterar um endereço
void modifyAddress (out Morada addr)
(
/ / Console.WriteLine ( "Nome: (0).", Addr.name) / / causas erro!
addr = new Address ();
addr.name = "Joe";
addr.address = "C # Station";
)

/ / Mostrar os endereços
void viewAddresses (parâmetros string [] nomes)
(
foreach (string nome nos nomes)
(
Console.WriteLine ( "Nome: (0)", nome);
)
)
)

Listagem 5-2 é uma modificação da listagem 5-1, modularizing o programa e adicionando mais aplicação de mostrar passando parâmetro. Existem 4 tipos de parâmetros C # um método pode tratar: out, ref, parâm, e de valor. Para ajudar a ilustrar uso de parâmetros, nós criamos um endereço classe com dois campos string.

Em Main () que chamamos getChoice () para obter a entrada do usuário e colocar na corda que myChoice variável. Então, nós usamos myChoice como um argumento para makeDecision (). Na declaração de makeDecision () que você vai notar a sua declarada como um parâmetro é uma string com o nome myChoice. Mais uma vez, este é um novo myChoice, distinto do chamador argumento do local e apenas a este método. Desde makeDecision () 's myChoice parâmetro não tem quaisquer outros modificadores, considera-se um valor parâmetro. O real valor do argumento é copiado na pilha. Variáveis dada pelo valor são os parâmetros locais, bem como quaisquer alterações a essa variável local não afetam o valor da variável utilizada na argumentação do autor da chamada.

O interruptor na declaração makeDecision () solicita um método para cada caso. Estes convites são métodos diferentes dos utilizados em nós Main (). Em vez de utilizar o mp referência, eles usam a esta palavra-chave. esta é uma referência ao actual objecto. Nós sabemos que o actual tem sido objeto instanciado porque makeDecision () não é um método estático. Portanto, podemos utilizar a referência a este apelo métodos dentro da mesma instância.

O addAddress () método tem um parâmetro ref. Isto significa que uma referência para o parâmetro é copiado para o método. Esta referência remete ainda para o mesmo objeto sobre o monte que o original usado em referência a argumentação do autor da chamada. Isto significa quaisquer alterações à referência local do objeto chamador também altera a referência do objeto. O código não pode mudar a referência, mas pode fazer as alterações para o objeto a ser referenciado. Você pode pensar no presente como uma forma de ter uma entrada / saída parâmetro.

Como sabem, os métodos têm retornar valores, mas às vezes você quiser retornar um valor de mais de um método. Um out parâmetro permite-lhe devolver valores adicionais a partir de um método.

modifyAddress () tem um parâmetro para fora. os parâmetros são apenas reverterá para a função chamada. Devido a cessão definitiva regras, você não pode usar essa variável que não tenha sido atribuído um valor válido. A primeira linha em modifyAddress (), comentou a propósito para ilustrar este ponto. Descomente-lo e compilar para ver o que acontece. Uma vez atribuído o programa e volta, o valor do parâmetro para fora serão copiados para a tese da chamada variável. Você deve atribuir um valor a um parâmetro para fora antes de seu método retorna.

Um grande utilidade para além da linguagem C # é o parâm parâmetro, o que permite que você defina um método que pode aceitar um número variável de argumentos. O parâm parâmetro deve ser uma única dimensão ou retalhadas array. Ao chamar viewAddresses (), nós passamos na corda quatro argumentos. O número de argumentos é variável e será convertido para uma string [] automaticamente. Em viewAddresses () usamos um loop foreach para imprimir cada uma dessas cordas. Em vez da lista de argumentos string, a contribuição poderia ter sido também uma string array. O parâm parâmetro é considerado um único parâmetro de entrada e de qualquer alteração afecta apenas a cópia local.

Em resumo, você deve compreender a estrutura de um método. Os quatro tipos de valor são paramters, ref, fora, e parâmetros. Quando você quiser usar um método exemplo, você deve instanciar seu objeto, por oposição aos métodos estáticos que podem ser chamados a qualquer momento. A esta referência remete para a sua contendo objetos e pode ser usado para se referir ao seu objeto contendo's membros, incluindo métodos.

OBS:

(onemethod)Pode ser compilado, digitando a seguinte linha de comando:

CSC onemethod.cs

Prgram pode executar o executável, digitando o seguinte cmmand-line:

onemethod.exe

(methodparams)Pode ser compilado, digitando a seguinte linha de comando:

CSC methodparams.cs

Pode executar o programa executável, digitando a seguinte linha de comando:

methodparams.exe

CONTINUA....

Caramba Fear!

São quantas lições? rsrs
Você que está produzindo-as?

Quote from: "#phobia"Caramba Fear!

São quantas lições? rsrs
Você que está produzindo-as?

De fato sim, to seguindo um conselho de um amigo que falou para deixar o delphi de lado...

. Esse tem no total 12 liçoes (tudo em inglês) ae eu fiz um tuto meu e juntei com esse(traduzido) assim nos dara 20 lições sobre c# que ira explicar muitas coisas, achei que o conteudo seria bom e puf! resolvi postar no DK....lol. Pra quem gosta de estuda ta ae um prato cheio..."inté" a proxima lição...

FEAR

Haha, blz!
Ptz..
20 lições!?!?
Tem muito pela frente ainda então... rsrs

Flw Fear!
vlw!

Sinceramente, PERFEITO, merecia uns 10 pontos xD

8)

Enquanto isso, parabens mesmo Medo Negro e termina essa jossa logo e renomeia pra algo como "ultimate C# tuto", ta gigante, só li até a lição 3 e logo logo eu ,mateus e tu vamos codar juntos em C#(quando eu conseguir acabar de ler) =]

e pow, lembra mto java com um pouco de VB e com possibilidade de linkar com WinApis... os empregados do tio bill fizeram um bom trabalho e apesar do pessoal falar q não é uma boa linguagem, já está começando a ser exigida no mercado de trabalho e acredito que ainda vai ser uma das melhores linguagens de alto nível por ter um "unsecure mode" pra poder trabalhar com ponteiros, eu recomendo mesmo.

Depois que nós dois terminarmos nossos tutos, nós vamos procurar aquela fake pelo mundo afora lol =P

Hauhsaushua vlw...logo logo mais lições....LOL

QuoteDepois que nós dois terminarmos nossos tutos, nós vamos procurar aquela fake pelo mundo afora lol =P

kkkkkkkkk...Vamos sair em busca do fake perdido, aliais fake não pois ela existi, so nos resta saber onde mora...lol

FORUM DARKERS

Tecnologia & Informática => Programação => C/C#/C++ => Topic started by: ÐλяkFeλя on 23 de August , 2008, 09:26:38 AM