<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Referência &#8211; Curso Online de C# .NET</title>
	<atom:link href="//www.tomasvasquez.com.br/cursocsharp/tag/referencia/feed" rel="self" type="application/rss+xml" />
	<link>//www.tomasvasquez.com.br/cursocsharp</link>
	<description>Uma iniciativa de Tomás Vásquez</description>
	<lastBuildDate>Sun, 06 May 2018 04:22:10 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>https://wordpress.org/?v=4.9.8</generator>
	<item>
		<title>Arrays</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/arrays</link>
		<pubDate>Mon, 17 Aug 2009 00:19:57 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos Definidos pelo Usuário]]></category>
		<category><![CDATA[Arrays]]></category>
		<category><![CDATA[Referência]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=210</guid>
		<description><![CDATA[Um array reúne sob o mesmo identificador muitas variáveis do mesmo tipo, acessadas por um índice. Todos os arrays em C# são criados dinamicamente, ou seja, em tempo de execução. O tamanho é sempre definido em tempo de execução. A declaração de um array sempre tem “[]” depois do tipo da variável. Devemos sempre chamar &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/arrays" class="more-link">Continue lendo <span class="screen-reader-text">Arrays</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Um array reúne sob o mesmo identificador muitas variáveis do mesmo tipo, acessadas por um índice.</p>
<p>Todos os arrays em C# são criados dinamicamente, ou seja, em tempo de execução. O tamanho é sempre definido em tempo de execução.</p>
<p>A declaração de um array sempre tem “[]” depois do tipo da variável. Devemos sempre chamar new para inicializar a array. Note que o primeiro índice do array é sempre zero. Veja no exemplo abaixo um array de uma dimensão:</p>
<pre lang="csharp" line="1">using System;

public class Class1
{
      const int Max = 5;
 
      public static void Main()
      {
            double[] Notas = new double[Max];
            Notas[0] = 6;
            Notas[1] = 9.5;
            Notas[2] = 4.2;
            Notas[3] = 7.2;
            Notas[4] = 5.4;
            double Soma = 0;
            foreach (double Nota in Notas)
            {
                  Soma = Soma + Nota;
            }
            Console.WriteLine(Soma / Max);
      }
}</pre>
<p>Um array de várias dimensões pode ser declarado colocando vírgulas dentro dos colchetes. Você pode definir um array “dentado”, um array de arrays. A diferença no array “dentado” é que cada linha pode ter um tamanho diferente. Veja alguns exemplos:</p>
<pre lang="csharp" line="1">...
int[] al;   // array de inteiro de uma dimensão
int[,] a2;  // array de inteiro de duas dimensões
int[,,] a3; // array de inteiro de três dimensões
int[][] j2; // array "dentado" (array de array)
int[][][] j3;     // array de array de array
...</pre>
<p>Todo array deve ser inicializado. Você pode simplesmente especificar o tamanho ou ainda atribuir valores:</p>
<pre lang="csharp" line="1">...
int[] al = new int[] {1, 2, 3};
int[,] a2 = new int[,] {{1, 2, 3}, {4, 5, 6}};
int[,,] a3 = new int[10, 20, 30];
int[] [] j2 = new int[3] [];
j2[0] = new int[] {1, 2, 3};
j2[1] = new int[] {1, 2, 3, 4, 5, 6};
j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] al = new int[] {1, 2, 3};
int[] al = {1, 2, 3};
...</pre>
<p>A faixa dos arrays é verificada em tempo de execução. Se você indexar o array com um valor fora de faixa, uma exception é gerada.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Interface</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/interface</link>
		<pubDate>Sun, 16 Aug 2009 23:18:41 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos Definidos pelo Usuário]]></category>
		<category><![CDATA[Classe]]></category>
		<category><![CDATA[Interface]]></category>
		<category><![CDATA[Referência]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=203</guid>
		<description><![CDATA[Tipo definido pelo usuário. Uma interface é uma espécie de classe, mas contém apenas os &#8220;protótipos&#8221; dos métodos, sem a sua implementação. Corresponde no C++ a uma classe abstrata com todos os métodos &#8220;virtuais puros&#8221;. Uma classe, além de ser derivada de outra, pode implementar várias interfaces. Abaixo pode-se ver um exemplo de declaração de &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/interface" class="more-link">Continue lendo <span class="screen-reader-text">Interface</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Tipo definido pelo usuário. Uma interface é uma espécie de classe, mas contém apenas os &#8220;protótipos&#8221; dos métodos, sem a sua implementação. Corresponde no C++ a uma classe abstrata com todos os métodos &#8220;virtuais puros&#8221;. Uma classe, além de ser derivada de outra, pode implementar várias interfaces. </p>
<p>Abaixo pode-se ver um exemplo de declaração de interface e sua aplicação em uma classe:</p>
<pre lang="csharp" line="1">interface IMinhaInterface
{
    void MeuMetodo();
}

class MinhaClasse : IMinhaInterface
{
    // Implementação explícita do membro da interface herdada: 
    void IMinhaInterface.Metodo()
    {
        // Corpo do método.
    }

    static void Main()
    {
        // Declara uma instância da classe baseada na interface.
        IMinhaInterface obj = new MinhaClasse();

        // Invoca o método.
        obj.MeuMetodo();
    }
}</pre>
<p>Veja maiores detalhes no capítulo sobre Orientação a Objetos.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Class (por referência)</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/class-por-referencia</link>
		<pubDate>Sun, 16 Aug 2009 23:04:04 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos Definidos pelo Usuário]]></category>
		<category><![CDATA[Class]]></category>
		<category><![CDATA[Referência]]></category>
		<category><![CDATA[Tipos]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=199</guid>
		<description><![CDATA[Permite declarar classes, de maneira semelhante ao C++. As principais diferenças são: Não é preciso seguir uma ordem de declaração, podendo declarar variáveis por exemplo, em qualquer parte do corpo da classe Não é permitida a herança múltipla de classes Um exemplo simples de uma classe em C# pode ser visto abaixo: class MinhaClasse { &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipo-definidos-pelo-usuario/class-por-referencia" class="more-link">Continue lendo <span class="screen-reader-text">Class (por referência)</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Permite declarar classes, de maneira semelhante ao C++. As principais diferenças são:</p>
<ul>
<li>Não é preciso seguir uma ordem de declaração, podendo declarar variáveis por exemplo, em qualquer parte do corpo da classe</li>
<li> Não é permitida a herança múltipla de classes</li>
</ul>
<p>Um exemplo simples de uma classe em C# pode ser visto abaixo:</p>
<pre lang="csharp" line="1">class MinhaClasse
{
    // Corpo da classe (Métodos, Variáveis, Propriedades, sub classes)
}</pre>
<p>Veja maiores detalhes no capítulo sobre Orientação a Objetos que será abordado posteriormente neste curso.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Valor null (por referência)</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipos/valor-null-referencia</link>
		<pubDate>Sun, 16 Aug 2009 13:59:19 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos]]></category>
		<category><![CDATA[null]]></category>
		<category><![CDATA[Referência]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=163</guid>
		<description><![CDATA[Todos os tipos por referências podem ter o valor null atribuídos a eles. É um erro usar uma variável que contenha null. A palavra-chave null é uma literal que representa uma referência nula, que não faz referência a qualquer objeto. null é o valor padrão das variáveis do tipo de referência. Os tipos de valor &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipos/valor-null-referencia" class="more-link">Continue lendo <span class="screen-reader-text">Valor null (por referência)</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>Todos os tipos por referências podem ter o valor null atribuídos a eles. É um erro usar uma variável que contenha null.</p>
<p>A palavra-chave null é uma literal que representa uma referência nula, que não faz referência a qualquer objeto. null é o valor padrão das variáveis do tipo de referência. Os tipos de valor comum ou primitivos não podem ser nulos. No entanto, o C# 2.0 introduziu tipos de valor anulável.</p>
<p>O exemplo a seguir demonstra alguns comportamentos do uso da palavra-chave null:</p>
<pre lang="csharp">class Program
{
    class MyClass
    {
        public void MyMethod() { }
    }

    static void Main(string[] args)
    {
        // Variável declarada possui o valor null.
        // Porém, o compilador considera como "unassigned".
        // ou sem valor atribuido. Um erro será gerado
        // ao tentar usar a variável neste momento
        MyClass mc;

        // Agora a variável pode ser utilizada, mas...
        mc = null;

        // A chamada de um método de um objeto nulo
        // gera um erro de execução - NullReferenceException.
        // Decomente esta linha para ver o resultado.
        // mc.MyMethod();

        // Agora, a objeto mc possui um valor, ou referência.
        mc = new MyClass();

        // E seu método pode ser chamado.
        mc.MyMethod();

        // Definir o objeto para null novamente fará com que seu conteúdo ou
        // referência seja perdido ou descartado, podendo porém receber novos valores.
        mc = null;

        // Lembrando que uma string vazia é diferente de uma string nula.
        string s = null;
        string t = String.Empty; // O mesmo que ""

        // O método Equals aplicado em objetos nulos sempre retornará false.
        bool b = (t.Equals(s));
        Console.WriteLine(b);

        // Operador de igualdade também retorna false ao comparar com um
        // objeto é nulo
        Console.WriteLine("Empty string {0} null string", s == t ? "igual": "diferente");

        // Retorna true.
        Console.WriteLine("null == null is {0}", null == null);

        // Tipos por valor ou primitivos não podem receber o valor null
       // int i = null; // Erro de compilação!

        // O C# 2.0 introduziu os tipos anuláveis, promovendo maior flexibilidade
        int? i = null;

        // Mantém a janela do console aberta.
        System.Console.WriteLine("Pressiona qualquer tecla para sair.");
        System.Console.ReadKey();

    }
}</pre>
]]></content:encoded>
			</item>
		<item>
		<title>Object (por referência)</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipos/object-por-referencia</link>
		<pubDate>Thu, 23 Jul 2009 02:26:39 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos]]></category>
		<category><![CDATA[Object]]></category>
		<category><![CDATA[Referência]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=159</guid>
		<description><![CDATA[O tipo de object é um alias para Object no .NET Framework. No sistema de tipo unificado do C#, Todos os tipos, pré-definidos e definidos pelo usuário, tipos de referência e tipos de valor, herdam direta ou indiretamente da Object. Você pode atribuir valores de qualquer tipo a variáveis de tipo object. Quando uma variável &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipos/object-por-referencia" class="more-link">Continue lendo <span class="screen-reader-text">Object (por referência)</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O tipo de object é um alias para Object no .NET Framework. No sistema de tipo unificado do C#, Todos os tipos, pré-definidos e definidos pelo usuário, tipos de referência e tipos de valor, herdam direta ou indiretamente da Object. Você pode atribuir valores de qualquer tipo a variáveis de tipo object. Quando uma variável de um tipo valor é convertido em objeto, é um processo chamado de Boxed. Quando uma variável do tipo object é convertida em um tipo de valor, é um processo chamado unboxed. Ambos serão explicados adiante.</p>
<p>O exemplo a seguir mostra como variáveis do tipo object podem aceitar valores de qualquer tipo de dados e como variáveis do tipo object podem usar métodos em Object do .NET Framework. </p>
<pre lang="csharp" line="1">class ObjectTest
{
   public int i = 10;
}

class MainClass2
{
   static void Main()
   {
      object a;
      a = 1;   // exemplo de boxing
      Console.WriteLine(a);
      Console.WriteLine(a.GetType());
      Console.WriteLine(a.ToString());

      a = new ObjectTest();
      ObjectTest classRef;
      classRef = (ObjectTest)a;
      Console.WriteLine(classRef.i);
   }
}
/* saída no console
    1
    System.Int32
    1
 * 10
*/</pre>
]]></content:encoded>
			</item>
		<item>
		<title>String (por referência)</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipos/string-por-referencia</link>
		<pubDate>Thu, 23 Jul 2009 02:12:51 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos]]></category>
		<category><![CDATA[Referência]]></category>
		<category><![CDATA[string]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=156</guid>
		<description><![CDATA[Tipo string As strings são tecnicamente um tipo por referência, mas possuem algumas características especiais: Não precisam ser inicializadas com o operador new. A atribuição de uma variável a outra funciona como se copiasse o conteúdo, criando efetivamente outra cópia da variável. Uma string contendo o valor null é uma string vazia; não é um &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipos/string-por-referencia" class="more-link">Continue lendo <span class="screen-reader-text">String (por referência)</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<h3>Tipo string</h3>
<p>As strings são tecnicamente um tipo por referência, mas possuem algumas características especiais:</p>
<ul>
<li> Não precisam ser inicializadas com o operador new.</li>
<li> A atribuição de uma variável a outra funciona como se copiasse o conteúdo, criando efetivamente outra cópia da variável.</li>
<li> Uma string contendo o valor null é uma string vazia; não é um erro usá-la.</li>
<li> Você não pode criar uma classe derivada de string.</li>
</ul>
<p>As strings contém caracteres Unicode e podem ter até 1G de comprimento. Veja um exemplo:</p>
<pre lang="csharp" line="1">...
// Declara e inicializa uma string
string Nome = “Maria”
// Copia para outra string. Se alterarmos uma delas, a outra manterá o seu valor
string NovoNome = Nome;
// Atribui à string antiga
Nome = “John”;
// Exibe “John – Mary”
System.Console.WriteLine(Nome + “ - ” + NovoNome);
...</pre>
<p>Existem diversas operações definidas para strings. As principais são:</p>
<ul>
<li>[] para ler um caractere específico;</li>
<li>== para comparar valores;</li>
<li>+ para concatenar;</li>
</ul>
<table border="1" cellspacing="0" cellpadding="0">
<tbody>
<tr>
<td width="65"><strong>Tipo </strong></td>
<td width="355"><strong>lmplementação</strong></td>
</tr>
<tr>
<td width="65">string</td>
<td width="355">String   Unicode com até 1 giga caracteres.</td>
</tr>
</tbody>
</table>
<p>As strings são consideradas imutáveis e não podem ser alteradas depois de criadas. Quando você efetua uma operação qualquer, como por exemplo, concatenar um caractere, você na verdade está criando outra string e descartando a anterior. Caso você queira alterar uma string, use “StringBuilder”. Em algumas situações, a performance com “StringBuilder” pode ser bem melhor.</p>
]]></content:encoded>
			</item>
		<item>
		<title>Tipos no C#</title>
		<link>//www.tomasvasquez.com.br/cursocsharp/tipos/tipos-no-c</link>
		<pubDate>Sun, 03 May 2009 14:40:03 +0000</pubDate>
		<dc:creator><![CDATA[admin]]></dc:creator>
				<category><![CDATA[Tipos]]></category>
		<category><![CDATA[Referência]]></category>
		<category><![CDATA[Valor]]></category>

		<guid isPermaLink="false">//www.tomasvasquez.com.br/cursocsharp/?p=96</guid>
		<description><![CDATA[O C# tem duas grandes categorias de tipos: por valor e por referência. Os tipos por valor são gerenciados diretamente. Os tipos por referência são sempre acessados através de ponteiros. Tipos por valor Os tipos por valor têm as seguintes características principais: São alocados diretamente na pilha. Não precisam ser inicializados com o operador new. &#8230; <a href="//www.tomasvasquez.com.br/cursocsharp/tipos/tipos-no-c" class="more-link">Continue lendo <span class="screen-reader-text">Tipos no C#</span> <span class="meta-nav">&#8594;</span></a>]]></description>
				<content:encoded><![CDATA[<p>O C# tem duas grandes categorias de tipos: por valor e por referência. Os tipos por valor são gerenciados diretamente. Os tipos por referência são sempre acessados através de ponteiros.</p>
<h3>Tipos por valor</h3>
<ul>
<li>Os tipos por valor têm as seguintes características principais:</li>
<li>São alocados diretamente na pilha.</li>
<li>Não precisam ser inicializados com o operador new.</li>
<li>A variável armazena o valor diretamente.</li>
<li>A atribuição de uma variável a outra copia o conteúdo, criando efetivamente outra cópia da variável.</li>
<li>Normalmente são usados com tipos de pequeno tamanho (menos que 16 bytes), onde o uso de referências traria um custo muito grande.</li>
<li>Podem ser automaticamente convertidos para referências em um processo chamado &#8220;boxing&#8221;, descrito na segunda parte deste artigo.</li>
<li>Não podem conter o valor null.</li>
</ul>
<h3>Tipos por referência</h3>
<p>Os tipos por referência têm as seguintes características principais:</p>
<ul>
<li>São alocados em um heap e sujeitos à &#8220;coleta de lixo&#8221; (&#8220;garbage collection&#8221;) quando não forem mais usados.</li>
<li>Devem ser inicializados com o operador new.</li>
<li>A variável armazena uma &#8220;referência&#8221;, uma espécie de ponteiro; o conteúdo em si fica no heap.</li>
<li>A atribuição de uma variável à outra copia a referência; podemos ter muitas variáveis referindo-se ao mesmo valor.</li>
<li>Normalmente usados com tipos de grande tamanho (mais que 16 bytes), onde o custo da alocação dinâmica é relativamente pequeno frente a sua flexibilidade.</li>
<li>Podem conter o valor null, embora se usarmos uma variável com o valor null a exception NullReferenceException será gerada.<span style="font-size: x-small;"><em></em></span></li>
</ul>
<h3>Tipos ponteiro</h3>
<ul>
<li>São ponteiros que poderão ser utilizados em código “inseguro”(unsafe) para acessar funções de código externo (dll win32).</li>
</ul>
<p>Este último são herança da flexibilidade que este tipo de dados dá ao C e C++. Será tratado com mais detalhes no decorrer do curso.</p>
]]></content:encoded>
			</item>
	</channel>
</rss>
