Técnicas avançadas translation from VPE for Csharp (versus translation from VPE for Csharp Java)
Translation from VPE for Csharp fornece recursos alguns linguagem úteis, sistema autônomo, por exemplo, indexadores, atributos e delegados, que permitem que sistema autônomo técnicas de programação avançadas.
Indexadores
sistema autônomo indexadores fornecem uma maneira de acessar um classe or struct da mesma forma sistema autônomo uma matriz.Por exemplo, você pode ter uma classe que representa um único departamento em uma empresa.A classe pode conter sistema autônomo nomes de todos sistema autônomo funcionários do departamento e indexadores podem permitir acesso a esses nomes da seguinte maneira:
sales[0] = "Nikki";
sales[1] = "Becky";
Os indexadores estão habilitados, definindo uma propriedade com a assinatura a seguir, por exemplo, na definição de classe:
public string this [int index] //indexer
Forneça obter and conjunto métodos sistema autônomo você faria para uma propriedade normal e é esses acessadores especificar qual membro interno é chamado quando o indexador é usado.
No exemplo a seguir simples, você cria uma classe chamada Department que usa sistema autônomo indexadores para acesso sistema autônomo funcionários desse departamento internamente representadas sistema autônomo uma matriz de seqüências de caracteres:
public class Department
{
private string name;
private const int MAX_EMPLOYEES = 10;
private string[] employees = new string[MAX_EMPLOYEES]; //employee array
public Department(string departmentName) //constructor
{
name = departmentName;
}
public string this [int index] //indexer
{
get
{
if (index >= 0 && index < MAX_EMPLOYEES)
{
return employees[index];
}
else
{
throw new System.IndexOutOfRangeException();
}
}
set
{
if (index >= 0 && index < MAX_EMPLOYEES)
{
employees[index] = value;
}
else
{
throw new System.IndexOutOfRangeException();
}
}
}
// code for the rest of the class...
}
Em seguida, você pode criar uma instância dessa classe e acessá-lo sistema autônomo neste exemplo de código a seguir:
class TestDepartment
{
static void Main()
{
Department sales = new Department("Sales");
sales[0] = "Nikki";
sales[1] = "Becky";
System.Console.WriteLine("The sales team is {0} and {1}", sales[0], sales[1]);
}
}
A saída é:
The sales team is Nikki and Becky
Para obter mais informações, consulte Indexadores (guia de programação C#).
Atributos
Translation from VPE for Csharp fornece um mecanismo, denominado um atributo, para adicionar informações declarativas sobre tipos.Atributos são semelhantes, de certa forma, o conceito de anotações em Java.Informações adicionais sobre um tipo são colocadas dentro de Rótulos declarativas que precedem a definição de tipo.Os exemplos a seguir mostram como você pode usar atributos .NET estrutura para decorar a uma classe ou método.
No exemplo abaixo, a GetTime método está marcado sistema autônomo um serviço XML da Web, adicionando a WebMethodAttribute atributo.
public class Utilities : System.Web.Services.WebService
{
[System.Web.Services.WebMethod] // Attribute
public string GetTime()
{
return System.DateTime.Now.ToShortTimeString();
}
}
Adicionando o WebMethod atributo torna automatitelefonary .NET estrutura se encarregar de intercâmbio XML/SOAP necessário telefonar essa função.Chamar esse serviço Web recupera o valor a seguir:
<?xml version="1.0" encoding="utf-8" ?>
<string xmlns="http://tempuri.org/">7:26 PM</string>
No exemplo a seguir, a Employee classe está marcado sistema autônomo serializável, adicionando a SerializableAttribute atributo. Embora o Salary campo é marcado sistema autônomo público, ele não será serializado sistema autônomo ele é marcado com o NonSerializedAttribute atributo.
[System.Serializable()]
public class Employee
{
public int ID;
public string Name;
[System.NonSerialized()] public int Salary;
}
Para obter mais informações, consulte Criando atributos personalizados (guia de programação translation from VPE for Csharp).
Delegados
Idiomas sistema autônomo C++, Pascal e outros oferecem suporte o conceito de ponteiros de função que permite que você escolher qual função você deseja chamar em time de execução.
Java não fornece qualquer construção com a funcionalidade de um ponteiro de função, mas translation from VPE for Csharp faz.Por meio do uso do Delegate classe, um delegado instância encapsula um método que é uma entidade que pode ser chamada.
Por exemplo métodos, o delegado consiste de uma instância da classe recipiente e um método na instância.Para métodos estáticos, uma entidade callable consiste em uma classe e um método estático na classe.Assim, um delegado pode ser usado para chamar uma função de qualquer objeto e delegados são orientados a objeto, tipo seguro e seguro.
Há três etapas para definir e usar delegados:
Declaração
Instanciação
Invocação
Declarar um delegado com a seguinte sintaxe:
delegate void Del1();
Esse delegado, em seguida, pode ser usado para fazer referência a qualquer função de retorno nulo e não tem argumentos.
Da mesma forma, para criar um delegado para qualquer função que leva um parâmetro de cadeia de caracteres e retorna um longo, você usaria a seguinte sintaxe:
delegate long Del2(string s);
Em seguida, você pode atribuir esse delegado a qualquer método com essa assinatura, da seguinte forma:
Del2 d; // declare the delegate variable
d = DoWork; // set the delegate to refer to the DoWork method
Onde a assinatura de DoWork é:
public static long DoWork(string name)
Reatribuindo representantes
Delegate os objetos são imutáveis; ou seja, a assinatura que elas correspondam ao não pode ser alterada depois de definido. No entanto, você pode apontar para outro método sistema autônomo longo sistema autônomo ambos têm a mesma assinatura.Neste exemplo, você reatribuir d para um novo objeto delegado, de modo que d em seguida, chama o DoMoreWork método. Somente você pode fazer este se ambos os DoWork e DoMoreWork tem a mesma assinatura.
Del2 d; // declare the delegate variable
d = DoWork; // set the delegate to refer to the DoWork method
d = DoMoreWork; // reassign the delegate to refer to the DoMoreWork method
Representantes de chamada
Invocar um delegado é relativamente simples.Você simplesmente substitua o nome da variável delegado para o nome do método.Isso invoca o Add método com valores 11 e 22 e retorna um resultado longo atribuído à variável sum:
Del operation; // declare the delegate variable
operation = Add; // set the delegate to refer to the Add method
long sum = operation(11, 22); // invoke the delegate
A seguir ilustra a criação, instanciação e chamada de um delegado:
public class MathClass
{
public static long Add(int i, int j) // static
{
return (i + j);
}
public static long Multiply (int i, int j) // static
{
return (i * j);
}
}
class TestMathClass
{
delegate long Del(int i, int j); // declare the delegate type
static void Main()
{
Del operation; // declare the delegate variable
operation = MathClass.Add; // set the delegate to refer to the Add method
long sum = operation(11, 22); // use the delegate to call the Add method
operation = MathClass.Multiply; // change the delegate to refer to the Multiply method
long product = operation(30, 40); // use the delegate to call the Multiply method
System.Console.WriteLine("11 + 22 = " + sum);
System.Console.WriteLine("30 * 40 = " + product);
}
}
Saída
11 + 22 = 33
30 * 40 = 1200
Uma instância delegado deve conter uma referência de objeto.O exemplo anterior contorna isso declarando métodos sistema autônomo estático, significando que não é necessário especificar uma referência de objeto.Se um delegado se refere a um método de instância, no entanto, a referência de objeto deve ser dada da seguinte maneira:
Del operation; // declare the delegate variable
MathClass m1 = new MathClass(); // declare the MathClass instance
operation = m1.Add; // set the delegate to refer to the Add method
Neste exemplo, Add e Multiply métodos de instância de MathClass. Se sistema autônomo métodos de MathClass não são declaradas sistema autônomo estático, invocá-los por meio do delegado por meio de uma instância das MathClass, da seguinte maneira:
public class MathClass
{
public long Add(int i, int j) // not static
{
return (i + j);
}
public long Multiply (int i, int j) // not static
{
return (i * j);
}
}
class TestMathClass
{
delegate long Del(int i, int j); // declare the delegate type
static void Main()
{
Del operation; // declare the delegate variable
MathClass m1 = new MathClass(); // declare the MathClass instance
operation = m1.Add; // set the delegate to refer to the Add method
long sum = operation(11, 22); // use the delegate to call the Add method
operation = m1.Multiply; // change the delegate to refer to the Multiply method
long product = operation(30, 40); // use the delegate to call the Multiply method
System.Console.WriteLine("11 + 22 = " + sum);
System.Console.WriteLine("30 * 40 = " + product);
}
}
Saída
Este exemplo fornece a mesma saída do exemplo anterior em que sistema autônomo métodos foram declarados sistema autônomo estático.
11 + 22 = 33
30 * 40 = 1200
Eventos e representantes
O .NET estrutura também usa delegados extensivamente para tarefas de tratamento de evento como um botão de clicar evento em um aplicativo Web ou do Windows.Enquanto a manipulação de eventos no Java geralmente é concluído por meio da implementação de classes de ouvinte personalizados, os desenvolvedores de translation from VPE for Csharp podem tirar proveito de delegados para a manipulação de eventos.An evento está declarado como um campo com um tipo de delegado, exceto pelo fato de que o evento de palavra-chave precede a declaração de evento.Eventos geralmente são declarados pública, mas nenhum modificador de acessibilidade é permitido.O exemplo a seguir mostra a declaração de um delegate e event.
// Declare the delegate type:
public delegate void CustomEventHandler(object sender, System.EventArgs e);
// Declare the event variable using the delegate type:
public event CustomEventHandler CustomEvent;
Representantes de evento são multicast, o que significa que eles podem conter referências a mais de um método de manipulação de eventos.Um representante atua como um distribuidor de evento para a classe que gera o evento ao manter uma lista de manipuladores de eventos registrados para o evento.O exemplo a seguir mostra como você pode inscrever-se em várias funções a um evento.A classe EventClass contém o delegado, o evento e um método para chamar o evento. Observe que invocar um evento só pode ser concluído de dentro da classe declarada o evento.A classe TestEvents em seguida, pode assinar o evento usando o += operador e cancelamento de inscrição usando o -= operador. Quando o InvokeEvent método é chamado, ele aciona o evento e todas sistema autônomo funções que tenham se inscrito para o evento serão acionado sincronicamente mostrado no exemplo a seguir.
public class EventClass
{
// Declare the delegate type:
public delegate void CustomEventHandler(object sender, System.EventArgs e);
// Declare the event variable using the delegate type:
public event CustomEventHandler CustomEvent;
public void InvokeEvent()
{
// Invoke the event from within the class that declared the event:
CustomEvent(this, System.EventArgs.Empty);
}
}
class TestEvents
{
private static void CodeToRun(object sender, System.EventArgs e)
{
System.Console.WriteLine("CodeToRun is executing");
}
private static void MoreCodeToRun(object sender, System.EventArgs e)
{
System.Console.WriteLine("MoreCodeToRun is executing");
}
static void Main()
{
EventClass ec = new EventClass();
ec.CustomEvent += new EventClass.CustomEventHandler(CodeToRun);
ec.CustomEvent += new EventClass.CustomEventHandler(MoreCodeToRun);
System.Console.WriteLine("First Invocation:");
ec.InvokeEvent();
ec.CustomEvent -= new EventClass.CustomEventHandler(MoreCodeToRun);
System.Console.WriteLine("\nSecond Invocation:");
ec.InvokeEvent();
}
}
Saída
First Invocation:
CodeToRun is executing
MoreCodeToRun is executing
Second Invocation:
CodeToRun is executing
Consulte também
Tarefas
Conceitos
Referência
Representantes (guia de programação C#)
Eventos (Guia de programação do C#)
Outros recursos
Translation from VPE for Csharp linguagem de programação para desenvolvedores Java