Latest web development tutorials

C Metodo #

Un modo è quello di mettere alcune dichiarazioni rilevanti raggruppati per un blocco di istruzioni per eseguire l'operazione. Ogni programma ha almeno una classe C # con un metodo Main.

Per utilizzare un metodo, è necessario:

  • metodo definizione
  • Chiamare il metodo

C # metodo come definito nella

Quando si definisce un metodo, fondamentalmente parlando, è una dichiarazione degli elementi della struttura. In C #, il metodo definizione di sintassi è la seguente: 

<Di accesso di> <Return Type> <Nome metodo> (Elenco dei parametri)
{
   corpo metodo
}

Di seguito sono riportati i singoli elementi:

  • Specificatore di accesso: modificatore di accesso, le variabili di decisione o un metodo per un'altra classe di visibilità.
  • Tipo restituito: tipo di ritorno, un metodo può restituire un valore.Il tipo restituito è il tipo di dati del valore restituito dal metodo. Se il metodo non restituisce alcun valore, il tipo di ritorno ènullo.
  • Nome metodo: il nome del metodo, è un identificatore univoco, ed è case sensitive.Non può essere lo stesso come altri dichiarazione di classe identificatore.
  • Lista dei parametri: la lista dei parametri, racchiusi tra parentesi, il parametro viene utilizzato per la trasmissione dati e il metodo di ricezione.Parametro elenco di parametri di tipo si riferisce al metodo, l'ordine e la quantità. Parametro è facoltativa, vale a dire, un metodo non può contenere parametri.
  • corpo Metodo: Metodo del corpo, compresa la necessità di completare le attività set di istruzioni.

Esempi

Il seguente frammento di codice mostra una funzioneFindMax,che accetta due valori interi, e restituisce il più grande dei due valori. Ha un modificatore di accesso pubblico, in modo che possa essere accessibile tramite l'istanza della classe al di fuori della classe. 

class NumberManipulator
{
   public int FindMax(int num1, int num2)
   {
      /* 局部变量声明 */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

Chiamare i metodi in C #

È possibile utilizzare il nome del metodo chiamante. L'esempio che segue illustra questo punto: 

using System;

namespace CalculatorApplication
{
   classe NumberManipulator
   {
      public int FindMax (int num1, num2 int)
      {
         / * Dichiarazione di variabile locale * /
         int result;

         if (num1> num2)
            risultato = num1;
         altro
            risultato = num2;

         risultato tornare;
      }
      static void Main (string [] args)
      {
         / * Definizioni di variabili locali * /
         int a = 100;
         int b = 200;
         int ret;
         NumberManipulator n = new NumberManipulator ();

         // Chiamata al metodo FindMax ret = n.FindMax (a, b);
         Console.WriteLine ( "Max è di: {0}", ret);
         Console.ReadLine ();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

Il valore massimo è: 200

È possibile anche altri tipi di metodi pubblici istanza di classe chiamato da un'altra classe. Ad esempio, il metodoFindMaxappartengono classeNumberManipulator,è possibile chiamare da un altrotestin classe. 

using System;

namespace CalculatorApplication
{
    classe NumberManipulator
    {
        public int FindMax (int num1, num2 int)
        {
            / * Dichiarazione di variabile locale * /
            int result;

            if (num1> num2)
                risultato = num1;
            altro
                risultato = num2;

            risultato tornare;
        }
    }
    class test
    {
        static void Main (string [] args)
        {
            / * Definizioni di variabili locali * /
            int a = 100;
            int b = 200;
            int ret;
            NumberManipulator n = new NumberManipulator ();
            // Chiamata al metodo FindMax ret = n.FindMax (a, b);
            Console.WriteLine ( "Max è: {0}", ret);
            Console.ReadLine ();

        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

最大值是： 200

chiamate di metodo ricorsivo

Un metodo può chiamare il sé. Questo è chiamatoricorsione.L'esempio seguente utilizza una funzione ricorsiva per calcolare il fattoriale di un numero: 

using System;

namespace CalculatorApplication
{
    classe NumberManipulator
    {
        public int fattoriale (int num)
        {
            / * Definizioni di variabili locali * /
            int result;

            if (num == 1)
            {
                ritornare 1;
            }
            altro
            {
                risultato = fattoriale (num - 1) * num;
                risultato tornare;
            }
        }
    
        static void Main (string [] args)
        {
            NumberManipulator n = new NumberManipulator ();
            // Chiama il metodo Console.WriteLine fattoriale ( "6 fattoriale è: {0}", n.factorial (6));
            Console.WriteLine ( "7 fattoriale è: {0}", n.factorial (7));
            Console.WriteLine ( "8 fattoriale è: {0}", n.factorial (8));
            Console.ReadLine ();

        }
    }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

6 fattoriale è: 720
7 fattoriale è: 5040
8 fattoriale è: 40320

passaggio di parametri

Quando si chiama un metodo con parametri, è necessario passare i parametri al metodo. In C #, ci sono tre modi per passare i parametri al metodo:

方式描述
值参数这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。
引用参数这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。
输出参数这种方式可以返回多个值。

Passaggio di parametri per valore

Questo è il parametro predefinito di passaggio. In questo modo, quando si chiama un metodo che crea un nuovo percorso di archiviazione per ogni parametro.

Il valore del parametro attuale viene copiato parametri, argomenti e parametri utilizzati in due valore di memoria differenti. Così, quando il valore del parametro modifiche non influiranno sul valore dell'argomento, garantendo così la sicurezza dei dati parametro reale. L'esempio seguente illustra questo concetto: 

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(int x, int y)
      {
         int temp;
         
         temp = x; /* 保存 x 的值 */
         x = y;    /* 把 y 赋值给 x */
         y = temp; /* 把 temp 赋值给 y */
      }
      
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         int b = 200;
         
         Console.WriteLine("在交换之前，a 的值： {0}", a);
         Console.WriteLine("在交换之前，b 的值： {0}", b);
         
         /* 调用函数来交换值 */
         n.swap(a, b);
         
         Console.WriteLine("在交换之后，a 的值： {0}", a);
         Console.WriteLine("在交换之后，b 的值： {0}", b);
         
         Console.ReadLine();
      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：100
在交换之后，b 的值：200

I risultati hanno mostrato che, anche all'interno della funzione modifica il valore, il valore di qualsiasi cambiamento fosse accaduto.

Passare da parametri di riferimento

Parametro di riferimento èun riferimento alla posizione di memoria variabile.Quando i parametri passati per riferimento, con il valore del parametro è diverso è che esso non crea una nuova posizione di archiviazione per questi parametri. Parametro di riferimento rappresenta il parametro effettivo al metodo ha lo stesso posizione di memoria.

In C #, utilizzando la parola chiaveref di dichiarare un parametro di riferimento.L'esempio che segue illustra questo punto: 

using System;
namespace CalculatorApplication
{
   classe NumberManipulator
   {
      Swap public void (ref int x, int y ref)
      {
         int temperatura;

         temp = x; / * salvare il valore di x * /
         x = y; / * y è assegnato al x * /
         y = temperatura; / * l'assegnazione temporanea di y * /
       }
   
      static void Main (string [] args)
      {
         NumberManipulator n = new NumberManipulator ();
         / * Definizioni di variabili locali * /
         int a = 100;
         Int b = a 200;

         Console.WriteLine ( "Prima dello scambio, un valore di: {0}", a);
         Console.WriteLine ( "prima dello scambio, valori di b: {0}", b);

         / * Chiamare la funzione di valore di scambio * /
         n.swap (ref una, ref b);

         Console.WriteLine ( "Dopo uno scambio, un valore di: {0}", a);
         Console.WriteLine ( "dopo uno scambio, valori di b: {0}", b);
 
         Console.ReadLine ();

      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：200
在交换之后，b 的值：100

I risultati hanno mostrato che il valore della funzionedi scambioall'interno del cambiamento, e questo cambiamento può essere riflessanellafunzioneprincipale.

Passaggio di parametri per uscita

istruzione return può essere utilizzata solo per restituire un valore da una funzione. Tuttavia, è possibile utilizzare ilparametro di uscita per restituire due valori da funzioni.metodo di uscita dei dati di uscita parametro assegnerà il proprio, e di altri parametri di riferimento simili.

L'esempio che segue illustra questo punto: 

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         
         Console.WriteLine("在方法调用之前，a 的值： {0}", a);
         
         /* 调用函数来获取值 */
         n.getValue(out a);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.ReadLine();

      }
   }
}

Quando il codice di cui sopra è compilato ed eseguito, produce i seguenti risultati: 

在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5

Inserito alle variabili parametro di uscita non richiede l'assegnazione. Quando è necessario restituire un valore dal valore iniziale di un parametro non è specificato nel metodo, il parametro di output è particolarmente utile. Si consideri il seguente esempio per capire questo: 

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("请输入第一个值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("请输入第二个值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a , b;
         
         /* 调用函数来获取值 */
         n.getValues(out a, out b);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.WriteLine("在方法调用之后，b 的值： {0}", b);
         Console.ReadLine();
      }
   }
}

Quando il codice di cui sopra viene compilato ed eseguito, produce il seguente risultato (secondo input dell'utente): 

Inserisci un valore:
7
Si prega di inserire il secondo valore:
8
Dopo la chiamata al metodo, un valore: 7
Dopo la chiamata al metodo, i valori B: 8