Sabtu, 18 Mei 2013

User Defined Function

Cara Membuat User Defined Function di Excel menggunakan C# dan Visual Studio 2008 :

Langkah 1
Pertama, jalankan Visual Studio 2008 dan membuat C # proyek Class Library baru yang disebut BlackScholesAddin untuk contoh ini.

Langkah 2
Dalam file Class1.cs Anda, menghapus semua kode yang ada dan menggantinya dengan kode berikut
  1. using System;
  2. using System.Runtime.InteropServices;
  3. using Microsoft.Win32;
  5. namespace BlackScholesAddin
  6. {
  7.     [ClassInterface(ClassInterfaceType.AutoDual)]
  8.     [ComVisible(true)]
  9.     public class Functions
  10.     {
  11.         public Functions()
  12.         {
  13.         }
  15.         //cumulative normal distribution function
  16.         private double CND(double X)
  17.         {
  18.             double L = 0.0;
  19.             double K = 0.0;
  20.             double dCND = 0.0;
  21.             const double a1 = 0.31938153;
  22.             const double a2 = -0.356563782;
  23.             const double a3 = 1.781477937;
  24.             const double a4 = -1.821255978;
  25.             const double a5 = 1.330274429;
  26.             L = Math.Abs(X);
  27.             K = 1.0 / (1.0 + 0.2316419 * L);
  28.             dCND = 1.0 - 1.0 / Math.Sqrt(2 * Convert.ToDouble(Math.PI.ToString())) *
  29.                 Math.Exp(-L * L / 2.0) * (a1 * K + a2 * K * K + a3 * Math.Pow(K, 3.0) +
  30.                 a4 * Math.Pow(K, 4.0) + a5 * Math.Pow(K, 5.0));
  32.             if (X < 0)
  33.             {
  34.                 return 1.0 - dCND;
  35.             }
  36.             else
  37.             {
  38.                 return dCND;
  39.             }
  40.         }
  42.         //function phi
  43.         private double phi(double x)
  44.         {
  45.             double phi = 0.0;
  47.             phi = Math.Exp(-x * x / 2) / Math.Sqrt(2 * Math.PI);
  48.             return phi;
  49.         }
  51.         //implied volatility using Newton-Raphson method
  52.         public double blsimpvCall(double Price, double Strike, double Rate, double Time, double Value, double Yield)
  53.         {
  54.             const double ACCURACY = 1.0e-6;
  56.             double ComputedVolatility = Math.Pow(Math.Abs(Math.Log(Price / Strike) + Rate * Time) * 2 / Time, 0.5); // initial value of volatility
  57.             double ComputedValue = blsCall(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  58.             double Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  60.             while (Math.Abs(Value - ComputedValue) > ACCURACY)
  61.             {
  62.                 ComputedVolatility = ComputedVolatility - ((ComputedValue - Value) / Vega);
  63.                 ComputedValue = blsCall(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  64.                 Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  65.             }
  67.             return ComputedVolatility;
  68.         }
  69.         public double blsimpvPut(double Price, double Strike, double Rate, double Time, double Value, double Yield)
  70.         {
  71.             const double ACCURACY = 1.0e-6;
  73.             double ComputedVolatility = Math.Pow(Math.Abs(Math.Log(Price / Strike) + Rate * Time) * 2 / Time, 0.5); // initial value of volatility
  74.             double ComputedValue = blsPut(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  75.             double Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  77.             while (Math.Abs(Value - ComputedValue) > ACCURACY)
  78.             {
  79.                 ComputedVolatility = ComputedVolatility - ((ComputedValue - Value) / Vega);
  80.                 ComputedValue = blsPut(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  81.                 Vega = blsvega(Price, Strike, Rate, Time, ComputedVolatility, Yield);
  82.             }
  84.             return ComputedVolatility;
  85.         }
  86.         //Call pricer
  87.         public double blsCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  88.         {
  89.             double d1 = 0.0;
  90.             double d2 = 0.0;
  91.             double Call = 0.0;
  93.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  94.             d2 = d1 - Volatility * Math.Sqrt(Time);
  96.             Call = Price * Math.Exp(-Yield * Time) * CND(d1) - Strike * Math.Exp(-Rate * Time) * CND(d2);
  97.             return Call;
  98.         }
  100.         //Put pricer
  101.         public double blsPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  102.         {
  103.             double d1 = 0.0;
  104.             double d2 = 0.0;
  105.             double Put = 0.0;
  107.      
  108.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  109.             d2 = d1 - Volatility * Math.Sqrt(Time);
  111.             Put = Strike * Math.Exp(-Rate * Time) * CND(-d2) - Price * Math.Exp(-Yield * Time) * CND(-d1);
  112.             return Put;
  113.         }
  115.         //delta for Call
  116.         public double blsdeltaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  117.         {
  118.             double d1 = 0.0;
  120.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  122.             return Math.Exp(-Yield * Time) * CND(d1);
  123.         }
  125.         //delta for Put
  126.         public double blsdeltaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  127.         {
  128.             double d1 = 0.0;
  130.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  132.             return Math.Exp(-Yield * Time) * CND(d1) - 1;
  133.         }
  135.         //gamma is the same for Put and Call
  136.         public double blsgamma(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  137.         {
  138.             double d1 = 0.0;
  140.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  142.             return Math.Exp(-Yield * Time) * phi(d1) / (Price * Volatility * Math.Sqrt(Time));
  143.         }
  145.         //vega is the same for Put and Call
  146.         public double blsvega(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  147.         {
  148.             double d1 = 0.0;
  150.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  151.             return Price * Math.Exp(-Yield * Time) * phi(d1) * Math.Sqrt(Time);
  152.         }
  154.         //theta for Call
  155.         public double blsthetaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  156.         {
  157.             double d1 = 0.0;
  158.             double d2 = 0.0;
  160.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  161.             d2 = d1 - Volatility * Math.Sqrt(Time);
  162.             return -Math.Exp(-Yield * Time) * Price * phi(d1) * Volatility / (2 * Math.Sqrt(Time)) - Rate * Strike * Math.Exp(-Rate * Time) * CND(d2) + Yield * Price * Math.Exp(-Yield * Time) * CND(d1);
  163.         }
  165.         //theta for Put
  166.         public double blsthetaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  167.         {
  168.             double d1 = 0.0;
  169.             double d2 = 0.0;
  171.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  172.             d2 = d1 - Volatility * Math.Sqrt(Time);
  173.             return -Math.Exp(-Yield * Time) * Price * phi(d1) * Volatility / (2 * Math.Sqrt(Time)) + Rate * Strike * Math.Exp(-Rate * Time) * CND(-d2) - Yield * Price * Math.Exp(-Yield * Time) * CND(-d1);
  174.         }
  176.         //rho for Call
  177.         public double blsrhoCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  178.         {
  179.             double d1 = 0.0;
  180.             double d2 = 0.0;
  182.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  183.             d2 = d1 - Volatility * Math.Sqrt(Time);
  184.             return Strike * Time * Math.Exp(-Rate * Time) * CND(d2);
  185.         }
  187.         //rho for Put
  188.         public double blsrhoPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  189.         {
  190.             double d1 = 0.0;
  191.             double d2 = 0.0;
  193.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  194.             d2 = d1 - Volatility * Math.Sqrt(Time);
  195.             return -Strike * Time * Math.Exp(-Rate * Time) * CND(-d2);
  196.         }
  198.         //volga is the same for Call and Put
  199.         public double blsvolga(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  200.         {
  201.             double d1 = 0.0;
  202.             double d2 = 0.0;
  204.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  205.             d2 = d1 - Volatility * Math.Sqrt(Time);
  206.             return Price * Math.Exp(-Yield * Time) * phi(d1) * Math.Sqrt(Time) * d1 * d2 / Volatility;
  208.         }
  210.         //vanna is the same for Call and Put
  211.         public double blsvanna(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  212.         {
  213.             double d1 = 0.0;
  214.             double d2 = 0.0;
  215.             double vanna = 0.0;
  217.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  218.             d2 = d1 - Volatility * Math.Sqrt(Time);
  220.             vanna = -Math.Exp(-Yield * Time) * phi(d1) * d2 / Volatility;
  222.             return vanna;
  223.         }
  225.         //charm for Call
  226.         public double blscharmCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  227.         {
  228.             double d1 = 0.0;
  229.             double d2 = 0.0;
  230.             double charmC = 0.0;
  232.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  233.             d2 = d1 - Volatility * Math.Sqrt(Time);
  235.             charmC = -Yield * Math.Exp(-Yield * Time) * CND(d1) + Math.Exp(-Yield * Time) * phi(d1) * (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) / (2 * Time * Volatility * Math.Sqrt(Time));
  236.             return charmC;
  237.         }
  239.         //charm for Put
  240.         public double blscharmPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  241.         {
  242.             double d1 = 0.0;
  243.             double d2 = 0.0;
  244.             double charmP = 0.0;
  246.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  247.             d2 = d1 - Volatility * Math.Sqrt(Time);
  249.             charmP = Yield * Math.Exp(-Yield * Time) * CND(-d1) - Math.Exp(-Yield * Time) * phi(d1) * (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) / (2 * Time * Volatility * Math.Sqrt(Time));
  250.             return charmP;
  251.         }
  253.         //color is the same for Call and Put
  254.         public double blscolor(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  255.         {
  256.             double d1 = 0.0;
  257.             double d2 = 0.0;
  258.             double color = 0.0;
  260.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  261.             d2 = d1 - Volatility * Math.Sqrt(Time);
  263.             color = -Math.Exp(-Yield * Time) * (phi(d1) / (2 * Price * Time * Volatility * Math.Sqrt(Time))) * (2 * Yield * Time + 1 + (2 * (Rate - Yield) * Time - d2 * Volatility * Math.Sqrt(Time)) * d1 / (2 * Time * Volatility * Math.Sqrt(Time)));
  264.             return color;
  265.         }
  267.         //dual delta for Call
  268.         public double blsdualdeltaCall(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  269.         {
  270.             double d1 = 0.0;
  271.             double d2 = 0.0;
  272.             double ddelta = 0.0;
  274.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  275.             d2 = d1 - Volatility * Math.Sqrt(Time);
  276.             ddelta = -Math.Exp(-Rate * Time) * CND(d2);
  277.             return ddelta;
  278.         }
  280.         //dual delta for Put
  281.         public double blsdualdeltaPut(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  282.         {
  283.             double d1 = 0.0;
  284.             double d2 = 0.0;
  285.             double ddelta = 0.0;
  287.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  288.             d2 = d1 - Volatility * Math.Sqrt(Time);
  289.             ddelta = Math.Exp(-Rate * Time) * CND(-d2);
  290.             return ddelta;
  291.         }
  293.         //dual gamma is the same for Call and Put
  294.         public double blsdualgamma(double Price, double Strike, double Rate, double Time, double Volatility, double Yield)
  295.         {
  296.             double d1 = 0.0;
  297.             double d2 = 0.0;
  298.             double dgamma = 0.0;
  300.             d1 = (Math.Log(Price / Strike) + (Rate - Yield + Volatility * Volatility / 2.0) * Time) / (Volatility * Math.Sqrt(Time));
  301.             d2 = d1 - Volatility * Math.Sqrt(Time);
  303.             dgamma = Math.Exp(-Rate * Time) * phi(d2) / (Strike * Volatility * Math.Sqrt(Time));
  304.             return dgamma;
  305.         }
  307.         [ComRegisterFunctionAttribute]
  308.         public static void RegisterFunction(Type type)
  309.         {
  311.             Registry.ClassesRoot.CreateSubKey(
  313.               GetSubKeyName(type, "Programmable"));
  315.             RegistryKey key = Registry.ClassesRoot.OpenSubKey(
  317.               GetSubKeyName(type, "InprocServer32"), true);
  319.             key.SetValue("",
  321.               System.Environment.SystemDirectory + @"\mscoree.dll",
  323.               RegistryValueKind.String);
  324.         }
  326.         [ComUnregisterFunctionAttribute]
  327.         public static void UnregisterFunction(Type type)
  328.         {
  330.             Registry.ClassesRoot.DeleteSubKey(
  332.               GetSubKeyName(type, "Programmable"), false);
  333.         }
  335.         private static string GetSubKeyName(Type type,
  337.           string subKeyName)
  338.         {
  340.             System.Text.StringBuilder s =
  342.               new System.Text.StringBuilder();
  344.             s.Append(@"CLSID\{");
  346.             s.Append(type.GUID.ToString().ToUpper());
  348.             s.Append(@"}\");
  350.            s.Append(subKeyName);
  352.            return s.ToString();
  354.        }
  356.    }
  357. }


Langkah 3
Dengan kode ini ditulis, menunjukkan properti untuk proyek dengan mengklik ganda pada sifat simpul bawah proyek di Solution Explorer. Klik pada tab Build dan periksa kotak centang yang mengatakan "Daftar untuk COM Interop". Kemudian pilih "Build" untuk membangun add-in.
Langkah 4
Tambahkan UDF baru saja kita buat ke daftar Excel addins
Untuk Excel 2007
Peluncuran Excel dan klik pada tombol utama di pojok kiri atas dan klik Excel Options. Pilih Add-Ins pada menu kiri dan di drop down menu bawah, pilih Excel Add-ins dan klik Go. Klik pada tombol Otomasi. Anda dapat menemukan kelas yang Anda buat dengan mencari BlackScholesAddin.Functions dalam daftar Otomasi add-in:

Untuk Excel 2003 XP
Peluncuran Excel dan pergi ke Tools, dialog Add-in di Excel dan klik pada tombol Otomasi. Anda dapat menemukan kelas yang Anda buat dengan mencari BlackScholesAddin.Functions dalam daftar Automation add-in:
Dengan mengklik OK dalam dialog ini, Anda menambahkan BlackScholesAddin.Functions ke daftar diinstal add-in seperti yang ditunjukkan di sini. Anda mungkin mendapatkan dialog pada saat ini tentang mscoree.dll. Klik NO untuk dialog ini (ya akan menghapus add-in dari daftar).]
Langkah 5
Sekarang, mari kita coba untuk menggunakan semua fungsi blsCall dalam Excel. Pertama membuat spreadsheet kosong. Klik pada sel kosong di buku kerja dan kemudian klik pada tombol Insert Function dalam formula bar. Dari dialog formula yang tersedia, drop-down "Atau pilih kategori" drop down box dan pilih "BlackScholesAddin.Functions". Kemudian klik pada fungsi blsCall seperti yang ditunjukkan di sini:

Catatan: Saya menggunakan notasi yang sama seperti yang digunakan oleh Matlab fungsi Black-Scholes untuk harga opsi dan Yunani. Lebih lanjut tentang hal itu dapat ditemukan di sini
Catatan 2:. Sebagaimana dicatat oleh chancea jika BlackScholesAddin.Functions tidak muncul dalam daftar Otomasi (dalam instalasi nya VS2010 SP1 dan Excel 2007), mengubah properti proyek dari menggunakan NET 4.0 sampai 3.5.
Langkah 6
Gunakan seperti fungsi biasa Excel builtin.
option pricer:
blsCall(Price, Strike, Rate, Time, Volatility, Yield)
blsPut(Price, Strike, Rate, Time, Volatility, Yield)

Delta
blsdeltaCall(Price, Strike, Rate, Time, Volatility, Yield)
blsdeltaPut(Price, Strike, Rate, Time, Volatility, Yield
Theta
blsthetaCall(Price, Strike, Rate, Time, Volatility, Yield)
blsthetaPut(Price, Strike, Rate, Time, Volatility, Yield)

Rho
blsrhoCall(Price, Strike, Rate, Time, Volatility, Yield)
blsrhoPut(Price, Strike, Rate, Time, Volatility, Yield)

Charm
blscharmCall(Price, Strike, Rate, Time, Volatility, Yield)
blscharmPut(Price, Strike, Rate, Time, Volatility, Yield)

Dual delta
blsdualdeltaCall(Price, Strike, Rate, Time, Volatility, Yield)
blsdualdeltaPut(Price, Strike, Rate, Time, Volatility, Yield)

Gamma
blsgamma(Price, Strike, Rate, Time, Volatility, Yield) //gamma is same for C and P

Vega
blsvega(Price, Strike, Rate, Time, Volatility, Yield) //vega is same for C and P

Vanna
blsvanna(Price, Strike, Rate, Time, Volatility, Yield) //vanna is same for C and P

Volga
blsvolga(Price, Strike, Rate, Time, Volatility, Yield) //volga is same for C and P

Color
blscolor(Price, Strike, Rate, Time, Volatility, Yield) //color is same for C and P

Dual Gamma
blsdualgamma(Price, Strike, Rate, Time, Volatility, Yield) //dual gamma is same for C and P
Memanggil User Defined Function SQL dari C#
Kamu memanggilnya seperti kamu memanggil garis regular SQL code. Berikut codenya:
1 Dim conn As New SqlConnection(configurationManager.ConnectionStrings("conname").ConnectionString)
2 Dim cmd As New SqlCommand
3 Dim dr As SqlDataReader = Nothing
4 cmd.Connection = conn
5 cmd.CommandText = "select datbasename.dbo.functionname(@param1) as functionresult"
6 cmd.CommandType = CommandType.text
7 cmd.Parameters.AddWithValue("param1", "param1val")
8 dim yourresult as string
9 Try
10 conn.Open()
11 dr = cmd.ExecuteReader
12 If dr.HasRows Then
13 dr.Read()
14 yourresult = dr("functionResult")
15 end if
16 Catch ex As SqlException
17 Throw ex
18 Finally
19 conn.Close()
20 conn.Dispose()
21 cmd.Dispose()
22 If dr IsNot Nothing Then
23 dr.Close()
24 End If
25 End Try

User Defined Function Methods in C#
  1. Pengantar
Seperti yang Anda tahu program C # dibuat dengan satu atau lebih kelas. Kelas-kelas ini berisi kode sumber untuk melakukan beberapa tugas tertentu. Kami menulis kode yang biasanya di blok kecil yang disebut 'metode' atau dalam bahasa lain Anda dapat belajar subrutin, sub program, modul atau fungsi.
Anda mungkin sudah menyadari metode built-in seperti Math.sqrt (), Math.abs (), Console.WriteLine () dll. Dalam artikel ini kita akan membahas metode yang didefinisikan oleh pengguna. Berarti, bagaimana menulis sebuah metode!. Mengapa kita perlu menulis metode? Jawaban yang paling umum adalah - untuk menyimpan blok kode yang kita perlu menggunakan di banyak tempat dari sebuah program. Kami akan memanggil blok dengan nama tertentu dan menggunakannya di tempat yang diperlukan daripada menulis seluruh baris lagi dan lagi.
Dalam matematika Anda mungkin belajar ini:
y = f (x) - Berikut x adalah masukan dari proses dan y adalah output dari proses dan f adalah fungsi dari variabel x. Kita hanya bisa mengatakan "y adalah fungsi dari x".
Dalam C #, kita menggunakan format yang sama untuk metode ini adalah:
<access modifier> <return datatype> DisplayName (<datatype> myname)
{
<C# Code>;
}
public string DisplayName(string myname)

{
string greetings = "Good Morning " + myname;
return (greetings + "!");
}

Contoh pengubah akses yaitu public, protected, internal dll

Contoh tipe data int, String, float, bool dll

Akses pengubah dan tipe data berada di luar lingkup artikel ini jadi saya berhenti di sini dan lanjutkan dengan metode.

a). datatypes

Jenis data yang digunakan sebagai <return datatype> serta <datatype> sintaks dapat di setiap C # datatype serta ditetapkan pengguna jenis data. Hal ini dapat berupa array atau objek. Atau bahkan tidak perlu untuk mengembalikan nilai.

Jenis:
void
batal digunakan ketika metode tidak mengembalikan nilai. Perhatikan bahwa Anda tidak bisa lewat void sebagai parameter dalam metode.

  1. Pentingnya Main () metode
Main adalah metode wajib dalam setiap program C #. Apakah itu adalah jendela aplikasi atau aplikasi console, Anda tidak dapat menjalankan program tanpa Main () modul. Kita dapat mengatakan main () adalah titik awal dari program C #.
Seperti yang Anda tahu C # adalah bahasa sensitif kasus dan perhatikan M. dikapitalisasi Saya katakan ini karena kita memiliki huruf kecil main () di bahasa C / C + +.
Ada aturan tertentu untuk menggunakan Main ().
· Jenis kembali harus int .
· Main () harus memiliki modifier static

 C. A.           Kembali lebih dari satu nilai dari sebuah metode

  Seperti yang Anda lihat di y = f (x), hanya dapat mengembalikan satu nilai. Dalam banyak bahasa ini adalah masalah. Orang menggunakan banyak cara curang untuk mencapai hal ini. Seperti kembali array, menggunakan variabel global, oleh objek kelas kembali, menggunakan ref dll Tapi di C # ada cara mudah untuk mencapai hal ini. Hal ini disebut 'keluar'. Dengan cara ini kita bisa menghilangkan semua kerugian dari menggunakan cara-cara alternatif.





Contoh berikut menunjukkan cara menggunakan:
Contoh 6 - Metode dengan beberapa nilai pengembalian

/ / Metode dengan beberapa nilai pengembalian
using System; 

class Program
 {
    private static void DoMath(int a, int b, out int sum, out int product, out double sqrt)
    {
        sum = a + b;
        product = a * b;
        sqrt  = Math.Sqrt(a);
    } 

    static void Main()
    {
        int sum1, product1;
        double sqrt1;

        DoMath(10,20, out sum1, out product1, out sqrt1); 

        Console.WriteLine("Sum = {0}\nProduct = {1}\nSquare = {2}" , sum1,product1,sqrt1);
    }
 }

Perhatikan penggunaan keluar. Anda harus menggunakannya di kedua deklarasi dan pernyataan menelepon.

D. Metode Overloading

  Dalam konsep Object Oriented Programming, ada satu konsep yang disebut polimorfisme. Hal ini memungkinkan nilai-nilai tipe data yang berbeda untuk ditangani menggunakan antarmuka seragam. Polimorfisme dalam C # dicapai dengan istilah yang disebut Overloading. Praktis mengatakan - mereka adalah metode yang berbeda dengan nama metode yang sama. Seperti 'metode' yang disebut 'metode overload'. Ketika skenario seperti timbul? Sebuah contoh kecil di bawah:

Dalam salah satu contoh kita sebelumnya, Sum () adalah metode untuk menemukan a + b. Anda melihat bahwa ini hanya membutuhkan nilai integer sebagai masukan dan nilai integer sebagai output. Apa yang terjadi jika Anda mencoba untuk melewati nilai ganda atau mengambang dengan metode ini? Anda akan mendapatkan dua kesalahan:

Metode kelebihan beban sesuai untuk 'Program.Sum (int, int)' memiliki beberapa argumen yang tidak valid

Hal ini dapat diatasi dengan menulis sebuah metode baru dengan parameter Anda tipe data yang diinginkan menggunakan nama metode yang sama.

E.    Jumlah tak terbatas parameter
            Pikirkan situasi di mana Anda ingin melewati jumlah yang tidak diketahui parameter. Mungkin 2 atau 3 atau nomor apapun. Di sini C # solusi adalah params. 
Diposting oleh di

Tidak ada komentar:

Posting Komentar

Langganan: Posting Komentar (Atom)