Pergunta

Alguém pode quebrar o que um delegado pode ser uma explicação simples, curta e concisa que abrange tanto o objetivo quanto os benefícios gerais? Eu tentei entender isso e isso não está afundando.

Foi útil?

Solução

Uma única web parte pode ser provedora e consumidor?Sim

Você pode fazer conexões de web parte sem postbacks?Tipo de.Você pode usar UpdatePanels para fazer postbacks de página parcial

Você pode cadeia de conexões da Web Parts?Acho que não.Tanto quanto sei, não há como indicar a ordem em que as conexões devem ser processadas.No exemplo, você deu ao gerente da Web Part poderia pedir a B para seus dados antes de receber o valor necessário de A.

Outras dicas

Eu tenho uma função:

public long GiveMeTwoTimesTwo()
{
    return 2 * 2;
}

Esta função é péssima. E se eu quiser 3 * 3?

public long GiveMeThreeTimesThree()
{
    return 3 * 3;
}

Muita digitação. Sou preguiçosa!

public long SquareOf(int n)
{
    return n * n;
}

Meu SquareOf função não se importa com o que n é. Ele funcionará corretamente para qualquer n passou. Não sabe exatamente qual número n é, mas isso faz Saiba disso n é um número inteiro. Você não pode passar "Haha not an integer" em SquareOf.

Aqui está outra função:

public void DoSomethingRad()
{
    int x = 4;
    long y = SquareOf(x);
    Console.WriteLine(y);
}

Ao contrário do seu nome, DosomethRad não faz nada rad. No entanto, ele escreve o quadrado (4), que é 16. Podemos alterá -lo para ser menos chato?

public void DoSomethingRad(int numberToSquare)
{
    long y = SquareOf(numberToSquare);
    Console.WriteLine(y);
}

DoSomethingRad claramente ainda é bastante falha. Mas pelo menos agora podemos passar em um número para o quadrado, para que não escreva 16 todas as vezes. (Ele escreverá 1, ou 4, ou 9, ou 16, ou ... Zzzz ainda meio chato).

Seria bom se houvesse uma maneira de mudar o que acontece com o número passado. Talvez não queiremos em agrupá -lo; Talvez queremos cubar ou subtraí -lo de 69 (número escolhido aleatoriamente da minha cabeça).

Em inspeção mais aprofundada, parece que a única parte de SquareOf este DoSomethingRad se preocupa com o que podemos dar um número inteiro (numberToSquare) e isso nos dá um long (porque colocamos seu valor de retorno em y e y é um long).

public long CubeOf(int n)
{
    return n * n * n;
}

public void DoSomethingLeet(int numberToSquare)
{
    long y = CubeOf(numberToSquare);
    Console.WriteLine(y);
}

Veja como DoSomethingLeet é para DoSomethingRad? Se ao menos houvesse uma maneira de passar comportamento (DoX()) em vez de apenas dados (int n)...

Então agora, se queremos escrever um quadrado de um número, podemos DoSomethingRad E se quisermos escrever o cubo de um número, podemos DoSomethingLeet. Então, se queremos escrever o número subtraído de 69, temos que fazer outro método, DoSomethingCool? Não, porque isso exige muito digitação (e, mais importante, dificulta nossa capacidade de alterar o comportamento interessante, mudando apenas um aspecto do nosso programa).

Então chegamos a:

public long Radlicious(int doSomethingToMe, Func<int, long> doSomething)
{
    long y = doSomething(doSomethingToMe);
    Console.WriteLine(y);
}

Podemos chamar esse método escrevendo isto:

Radlicious(77, SquareOf);

Func<int, long> é um tipo especial de delegado. Ele armazena comportamento que aceita números inteiros e cospe longs. Não temos certeza do que o método que ele aponta fará com um determinado número inteiro que passamos; Tudo o que sabemos é que, aconteça o que acontecer, vamos conseguir um long de volta.

Não precisamos dar nenhum parâmetros a SquareOf Porque Func<int, long> descreve comportamento, não dados. Chamando Radlicious(77, SquareOf) apenas dá a Radlicious o comportamento geral de SquareOf ("Eu pego um número e devolveu seu quadrado"), não o que SquareOf farei com qualquer específico Inteiro.

Agora, se você entendeu o que estou dizendo, já me comprou, pois eu mesmo não entendo essas coisas.

* Resposta final, comece a vagar idiotice *

Quero dizer, parece que ints pode ser percebido como um comportamento realmente chato:

static int Nine()
{
    return 9;
}

Dito isto, a linha entre o que é dados e comportamento parece desfocar, com o que normalmente é percebido como dados é simplesmente um comportamento chato.

Obviamente, pode -se imaginar um comportamento super "interessante", que leva todos os tipos de parâmetros abstratos, mas requer uma tonelada de informações para poder chamá -las. E se exigisse que fornecemos o código -fonte que ele compilaria e executaria para nós?

Bem, então nossa abstração parece ter nos levada a todo o caminho de volta à estaca zero. Temos comportamento tão abstrato que requer todo o código -fonte do nosso programa para determinar o que ele fará. Isso é totalmente indeterminado comportamento: a função pode fazer nada, mas tem que ser fornecido com tudo para determinar o que faz. Por outro lado, comportamento totalmente determinado, como Nine(), não precisa de nenhuma informação adicional, mas não pode fazer nada senão retornar 9.

E daí? Não sei.

Um delegado é um ponteiro para um método. Você pode usar seu delegado como um parâmetro de outros métodos.

aqui é um link para um tutorial simples.

A pergunta que tive foi 'então, por que eu gostaria de fazer isso?' Você realmente não vai 'entender' até resolver um problema de programação com eles.

Edite o documento do SharePoint em vez de fazer o upload de uma nova cópia, que está em vigor dizendo-lhe para sobrescrever os metadados.

Uma instância delegada é uma referência a um método. A razão pela qual eles são úteis é que você pode criar um delegado vinculado a um método específico em uma instância específica de um tipo. A instância delegada permite invocar esse método nessa instância específica, mesmo que o objeto no qual você invocará o método tenha deixado seu escopo lexical.

O uso mais comum para delegados como esse é apoiar o conceito de retornos de chamada no nível do idioma.

Simplesmente faz referência a um método. Eles se unem muito bem com o trabalho com encadeamento cruzado.

Aqui está um exemplo do meu código.

 //Start our advertisiment thread
    rotator = new Thread(initRotate);
    rotator.Priority = ThreadPriority.Lowest;
    rotator.Start();

    #region Ad Rotation
    private delegate void ad();
    private void initRotate()
    {
        ad ad = new ad(adHelper);
        while (true)
        {
            this.Invoke(ad);
            Thread.Sleep(30000);
        }

    }

    private void adHelper()
    {
        List<string> tmp = Lobby.AdRotator.RotateAd();
        picBanner.ImageLocation = @tmp[0].ToString();
        picBanner.Tag = tmp[1].ToString();            
    }
    #endregion

Se você não usou um delegado, não seria capaz de cruzar e chamar a função Lobby.Adrotator.

Além das outras sugestões, se a página for recarregada, suas alterações não persistirão.

Nos termos mais básicos, um delegado é apenas uma variável que contém (uma referência a) uma função. Os delegados são úteis porque permitem que você passe uma função como uma variável sem nenhuma preocupação com a "função" veio.

É importante observar, é claro, que a função não está sendo copiada quando está sendo empacotada em uma variável; Está apenas sendo vinculado por referência. Por exemplo:

class Foo
{
    public string Bar
    {
        get;
        set;
    }

    public void Baz()
    {
        Console.WriteLine(Bar);
    }
}

Foo foo = new Foo();
Action someDelegate = foo.Baz;

// Produces "Hello, world".
foo.Bar = "Hello, world";
someDelegate();

Nos termos mais simples, a responsabilidade de executar um método é delegada a outro objeto. Digamos que o presidente de alguma nação morre e o presidente dos EUA deve estar presente para o funeral com uma mensagem de condolências. Se o presidente dos EUA não puder ir, ele delegará essa responsabilidade a alguém que o vice-presidente ou o secretário do Estado.

O mesmo entra em código. Um delegado é um tipo, é um objeto capaz de executar o método.

por exemplo.

Class Person
{
   public string GetPersonName(Person person)
   {
     return person.FirstName + person.LastName;
   }

   //Calling the method without the use of delegate
   public void PrintName()
   {
      Console.WriteLine(GetPersonName(this));
   }

   //using delegate
   //Declare delegate which matches the methods signature
   public delegate string personNameDelegate(Person person);

  public void PrintNameUsingDelegate()
  {
      //instantiate
      personNameDelegate = new personNameDelegate(GetPersonName);

      //invoke
      personNameDelegate(this);
  }

}

O método getPerSonname é chamado usando o objeto delegado PersonNameleGate. Como alternativa, podemos ter o método PrintNameUsingDelegate para tomar um delegado como um parâmetro.

public void PrintNameUsingDelegate(personNameDelegate pnd, Person person)
{
   pnd(person);
}

A vantagem é que, se alguém quiser imprimir o nome como LastName_firstname, ele/ele só precisa envolver esse método em PersonNameleGate e passar para essa função. Nenhuma mudança de código adicional é necessária.

Delegados são especificamente importantes em

  1. Eventos
  2. Chamadas assíncronas
  3. Linq (como expressões Lambda)

Se você fosse delegar uma tarefa a alguém, o delegado seria a pessoa que recebe o trabalho.

Na programação, é uma referência ao bloco de código que realmente sabe como fazer algo. Muitas vezes, este é um ponteiro para a função ou método que lida com algum item.

Você pode criar um centro de BI para cada produto, é fácil de gerenciar (estou assumindo cada produto com diferentes conjuntos de usuários).

mas [configurando o bi] [1] é mais complicado ... algumas coisas que você deve ter certeza.

    .
  1. planeje adequadamente
  2. Mapeando licença de usuário
  3. Criando os serviços de loja seguras
  4. Configuração adequada dos serviços do Excel, ponto de desempenho e Visio
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top