Lição 12 - Estruturas
Esta lição ensina C # Estruturas. Os nossos objectivos são os seguintes:
* Compreender o objecto de Estruturas.
* Implementar uma struct.
* Use uma struct.
Uma struct lhe permite criar novos objetos de valor tipo que são semelhantes aos tipos built-in (int, float, bool, etc.) Quando você ia usar uma struct em vez de uma classe? Pense em como o alto-tipos são utilizados. Eles têm valores distintos e operações para manipular esses valores. Se você tem uma necessidade de se criar um objeto que comporta dessa maneira, considero-o como uma struct execução. Mais tarde neste artigo, vou explicar um jovem regras para a utilização de Estruturas, que lhe dará uma idéia melhor de quando a utilizá-los. Enquanto isso, aqui está um exemplo.
Listing 12-1. Exemplo de uma struct: StructExample.cs
using System;
struct Point
{
public int x;
public int y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public Point Add(Point pt)
{
Point newPt;
newPt.x = x pt.x;
newPt.y = y pt.y;
return newPt;
}
}
/// <summary>
/// Example of declaring and using a struct
/// </summary>
class StructExample
{
static void Main(string[] args)
{
Point pt1 = new Point(1, 1);
Point pt2 = new Point(2, 2);
Point pt3;
pt3 = pt1.Add(pt2);
Console.WriteLine("pt3: {0}:{1}", pt3.x, pt3.y);
}
}
Listando 12-1 mostra como a declarar e usar uma struct. É fácil dizer que um tipo struct porque é uma das palavras-chave struct utilizados na sua definição. O esquema básico de uma struct é bem como uma classe, mas com diferenças, o que será explicado nos parágrafos seguintes. O Ponto struct tem um construtor que inicia os seus campos de x e y valores passados pol Ela também tem um método chamado Adicionar (), que irá aceitar um outro ponto struct, adicioná-lo ao presente struct, e retornar um novo struct.
Repare que há um ponto struct declaradas no Adicione () método. Ela não precisa de ser instanciado com um novo operador, como uma classe. Quando isso ocorre, é implicitamente a struct instanciado com o seu padrão (ou parameterless) construtor. O construtor inicializa parameterless struct todos os campos para os valores padrão. ou seja, são integrais 0, são 0,0 pontos flutuantes, e booleans são falsas. É ilegal para definir um construtor parameterless para uma struct.
Embora não seja necessária, uma struct pode ser instanciado com um novo operador. Na listagem PT1 e 12-1 ao Ponto pt2 Estruturas são inicializado com valores usando o construtor definido no Ponto struct. Um terceiro ponto struct, pt3, é declarada e padrões de utilização do parameterless (padrão) construtor, porque não importa o que ele é valor a este ponto. Adicionar o () o método de PT1 struct é então invocado, passando a pt2 struct como um parâmetro. O resultado é atribuído a pt3, o que mostra que uma struct pode ser utilizado como qualquer outro tipo de valor. Veja a saída de Listing 12-1:
Pt3: 3:3
Outra diferença entre as classes e Estruturas Estruturas é que não pode ter destructors. Além disso, Estruturas não pode herdar uma outra classe ou struct ou ser herdado a partir de. No entanto, uma struct maio implementar várias interfaces. Uma interface é uma referência de tipo C # com os membros que não têm implementações. Qualquer classe ou struct execução deve implementar uma interface que cada um dos métodos da interface. Interfaces são um assunto para mais tarde uma lição.
Em resumo, você já sabe como criar uma struct. Você também pode usar instanciar e Estruturas. Ao decidir se a implementar um tipo de uma struct, você deve considerar a forma como o modelo será utilizado. Além disso, consideram que uma struct incorre menos overhead do que uma classe, porque, sendo um tipo de valor, que é armazenado na pilha e não como uma classe é armazenada, sobre a heap.
StructExample
using System;
struct Point
{
public int x;
public int y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public Point Add(Point pt)
{
Point newPt;
newPt.x = x + pt.x;
newPt.y = y + pt.y;
return newPt;
}
}
/// <summary>
/// Example of declaring and using a struct
/// </summary>
class StructExample
{
static void Main(string[] args)
{
Point pt1 = new Point(1, 1);
Point pt2 = new Point(2, 2);
Point pt3;
pt3 = pt1.Add(pt2);
Console.WriteLine("pt3: {0}:{1}",pt3.x,pt3.y);
}
}
Pode ser compilado, digitando a seguinte linha de comando:
CSC structexample.cs
Prgram pode executar o executável, digitando a seguinte linha de comando:
structexample.exe
Lição 13 - Interfaces
Esta lição ensina C # Interfaces. Os nossos objectivos são os seguintes:
* Compreender o objecto de Interfaces.
* Definir uma interface.
* Use uma interface.
* Implementar Interface Herança.
Uma interface se parece com uma classe, mas não tem aplicação. A única coisa que ele contém são definições de eventos, indexadores, métodos e / ou propriedades. A razão interfaces apenas fornecer definições é porque eles são herdadas por classes e Estruturas, que deve proporcionar uma aplicação para cada membro interface definida.
Então, quais são as interfaces bom para se eles não se aplicar funcionalidade? Eles são grandes para agrupar plug-n-play como arquiteturas onde os componentes podem ser intercambiadas em vão. Uma vez que todos os componentes intercambiáveis implementar a mesma interface, eles podem ser utilizadas sem qualquer programação extra. A interface forças cada componente pública específica para expor os membros que vão ser utilizados em uma determinada maneira.
Porque interfaces devem ser implementadas por classes derivadas e Estruturas, eles definem um contrato. Por exemplo, se foo classe implementa a interface IDisposable, ele está a fazer uma declaração de que ele garante que tem o Descarte () método, que é o único membro da IDisposable interface. Qualquer código que pretenda utilizar class foo maio verificar se foo classe implementa IDisposable. Quando a resposta é verdade, então o código sabe que pode chamar foo.Dispose (). Listando 13-1 mostra como a definir uma interface:
Listing 13-1. Definindo um Interface: MyInterface.cs
interface IMyInterface
{
void MethodToImplement();
}
Listing 13-1 define uma interface chamada IMyInterface. A convenção é a nomenclatura comum prefixo interface todos os nomes com um capital "I". Esta interface tem um único método chamado MethodToImplement (). Isso poderia ter sido qualquer tipo de método declaração com diferentes tipos de parâmetros e retorno. Eu apenas optou por declarar esse método, sem parâmetros e retornar um tipo de tornar nulo o exemplo fácil. Repare que este método não tem uma execução (instruções entre chavetas - ()), mas, em vez termina com um ponto e vírgula, ";". Isto porque a interface especifica apenas a assinatura dos métodos que herda uma classe ou struct deve implementar. Listando 13-2 mostra como essa interface poderia ser utilizado.
Listing 13-2. Utilizando uma interface: InterfaceImplementer.cs
classe InterfaceImplementer: IMyInterface
(
static void Main ()
(
InterfaceImplementer iImp = new InterfaceImplementer ();
iImp.MethodToImplement ();
)
public void MethodToImplement ()
(
Console.WriteLine ( "MethodToImplement () chamado.");
)
)
A classe InterfaceImplementer em 13,2 Listing IMyInterface implementa a interface. Indicando que a classe que herda uma interface é a mesma que herda uma classe. Neste caso, é utilizada a seguinte sintaxe:
classe InterfaceImplementer: IMyInterface
Agora que esta classe herda a interface IMyInterface, deve aplicar os seus membros. Fá-lo através da execução das MethodToImplement () método. Repare que este método de execução tem exatamente a mesma assinatura, parâmetros e método de nome, tal como definido no IMyInterface interface. Qualquer diferença compilador irá causar um erro. Interfaces também podem herdar outras interfaces. Listando 13-3 mostra como herdou as interfaces são implementadas.
Listing 13-3. Interface herança: InterfaceInheritance.cs
using System;
interface IParentInterface
{
void ParentInterfaceMethod();
}
interface IMyInterface : IParentInterface
{
void MethodToImplement();
}
class InterfaceImplementer : IMyInterface
{
static void Main()
{
InterfaceImplementer iImp = new InterfaceImplementer();
iImp.MethodToImplement();
iImp.ParentInterfaceMethod();
}
public void MethodToImplement()
{
Console.WriteLine("MethodToImplement() called.");
}
public void ParentInterfaceMethod()
{
Console.WriteLine("ParentInterfaceMethod() called.");
}
}
O código em 13,3 lista contém duas interfaces: IMyInterface interfaces e os que herda, IParentInterface. Quando uma interface herda um outro, qualquer aplicação ou struct classe deve implementar cada membro interface em toda a cadeia herança. Uma vez que a classe em InterfaceImplementer Listing 13-3 herda de IMyInterface, também herda IParentInterface. Por isso, o InterfaceImplementer classe deve implementar a MethodToImplement () método especificado na IMyInterface interface e os ParentInterfaceMethod () método especificado na IParentInterface interface.
Em resumo, você agora compreender o que são interfaces. Você pode implementar uma interface e usá-lo em uma classe. Interfaces também pode ser herdada por outra relação. Struct ou qualquer classe que herda uma interface também deve executar todos os membros em todo o interface herança cadeia.
InterfaceImplementer
using System;
class InterfaceImplementer : IMyInterface
{
static void Main()
{
InterfaceImplementer iImp = new InterfaceImplementer();
iImp.MethodToImplement();
}
public void MethodToImplement()
{
Console.WriteLine("MethodToImplement() called.");
}
}
Pode ser compilado, digitando a seguinte linha de comando:
CSC interfaceimplementer.cs
Pode executar o programa executável, digitando a seguinte linha de comando:
interfaceimplementer.exe
InterfaceInheritance
using System;
interface IParentInterface
{
void ParentInterfaceMethod();
}
interface IMyInterface : IParentInterface
{
void MethodToImplement();
}
class InterfaceImplementer : IMyInterface
{
static void Main()
{
InterfaceImplementer iImp = new InterfaceImplementer();
iImp.MethodToImplement();
}
public void MethodToImplement()
{
Console.WriteLine("MethodToImplement() called.");
}
public void ParentInterfaceMethod()
{
Console.WriteLine("ParentInterfaceMethod() called.");
}
}
Pode ser compilado, digitando a seguinte linha de comando:
CSC interfaceinheritance.cs
Executabel pode executar o programa, digitando a seguinte linha de comando:
interfaceinheritance.exe
Myinterface
interface IMyInterface
{
void MethodToImplement();
}
Pode ser compilado, digitando a seguinte linha de comando:
CSC myinterface.cs
Pode executar o programa executável, digitando a seguinte linha de comando
myinterface.exe
CONTINUA...
FEAR, DARK FEAR....