Selasa, 08 Oktober 2013

Membuat program menghitung nilai Mata kuliah dan konversinya


outputnya


COde nya:
Classmahasiswa
 {
//atribute
privatedouble _nuas;
privatedouble _nuts;
privatedouble _ntugas;
privatedouble _npart;
privatedouble _nakhir;
privatestring _huruf;




publicdouble nuas
     {
get { return _nuas; }
set { _nuas = value; }
     }
publicdouble nuts
     {
get { return _nuts; }
set { _nuts = value; }
     }
publicdouble npart
     {
get { return _npart; }
set { _npart = value; }
     }
publicdouble ntugas
     {
get { return _ntugas; }
set { _ntugas = value; }
     }

publicdouble HitungNilaiAkhir(double nt, double np, double nuas, double nuts)
 {
return 0.2 * nt + 0.3 * np + 0.3 * nuas + 0.2 * nuts;
 }

publicstring konversiHuruf(double na)
 {
string nh = "";
if (na > 85 && na <= 100)
            {
                nh = "A";

            }
if (na > 80 && na <= 85)
            {
                nh = "A-";
            }
if (na > 75 && na <= 80)
            {
                nh = "B+";
            }
if (na > 70 && na <= 75)
            {
                nh = "B";
            }
if (na > 65 && na <= 70)
            {
                nh = "B-";
            }
if (na > 60 && na <= 65)
            {
                nh = "C+";
            }
if (na > 55 && na <= 60)
            {
                nh = "C";
            }
if (na > 50 && na <= 55)
            {
                nh = "C-";
            }
if (na > 40 && na <= 50)
            {
                nh = "D";
            }
if (na <= 40)
            {
                nh = "E";
            }
return nh;
        }

publicvoid tampilkan()
        {
Console.WriteLine("-----------------------------------------------");
Console.WriteLine("Menghitung Nilai Akhir Mata Kuliah");
Console.WriteLine("-----------------------------------------------");
Console.Write("nilai tugas    = ");
            _ntugas = double.Parse(Console.ReadLine());
Console.Write("nilai part     = ");
            _npart = double.Parse(Console.ReadLine());
Console.Write("nilai UTS      = ");
            _nuts = double.Parse(Console.ReadLine());
Console.Write("nilai UAS      = ");
            _nuas = double.Parse(Console.ReadLine());
Console.WriteLine("-----------------------------------------------");
            _nakhir = HitungNilaiAkhir(_ntugas, _npart, _nuas, _nuts);
Console.Write("nilai akhir  = " + _nakhir);
Console.WriteLine();
Console.WriteLine("-----------------------------------------------");
            _huruf = konversiHuruf(_nakhir);
Console.Write("nilai huruf  = " + _huruf);

        }

    }
classProgram
    {
staticvoid Main(string[] args)
        {
// membuat objek
mahasiswa m1 = newmahasiswa();
            m1.tampilkan();

Console.ReadKey();
        }
    }
}
Diposting oleh di Tidak ada komentar:

Karakteristik OOP dan contohnya

Inheritance = Pewarisan , Mewariskan objek yang dimiliki ke pada objek yang diturunkan , bersifat menyeluruh.
Kelas yang mewariskan biasa di sebut super class / class induk
Kelas yang diwariskan biasa di sebut sub class / kelas anak
Secara lebih singkat begini :
A sebagai Ayah memiliki Anak bernama B , A berkulit Hitam maka B akan berkulit Hitam jg .
Ini merupakan inheritance terhadap A kepada B , dan inheritance bukan hanya dapat 1x diwariskan , tetapi dapat lebih dari 1x. seperti berikut :
A sebagai Ayah memiliki Anak bernama B , A berkulit Hitam maka B akan berkulit Hitam jg . dan B pun memiliki anak C maka C pun akan berkulit hitam
Keuntungan dari inheritance :
- Tidak perlu mendefinisikan Variabel Bila membutuhkan , Cukup menurunkan dari class induk
- Memudahkan dan Mempercepat pemprogramman , mengurangi Code
Sample inheritance dalam C#.Net
public class A
{
    public A() { }
}

public class B : A
{
    public B() { }
}

Baca selengkapnya »
Diposting oleh di Tidak ada komentar:

Objek dan Konstruktor

Pengertian Objek
Objek adalah membungkus data dan fungsi bersama menjadi suatu unit dalam sebuah program komputer; objek merupakan dasar dari modularitas danstruktur dalam sebuah program komputer berorientasi objek.

Cara Membuat Objek
Nama class nama variabel = new nama class ();
Contoh : membuat objek class Lingkaran
Lingkaran.l1 = new lingkaran ()
Konstruktor
Konstruktor adalah methode yang dipanggil ketika objek dibuat, digunakan untuk memberi nilai awal, namanya sama dengan nama class
Contoh :
Public tabungan (int saldo awal)
{
            _saldo = saldoawal;

}
Diposting oleh di Tidak ada komentar:

Pengertian Class, Atribute, Method pada C#

1.      Class
Class merupakan suatu tipe data yang menggabungkan data dan fungsi untuk mengakses data. Sebagai contoh suatu kelas kalkulator yang megandung data bilangan1 dan bilangan2 dan memiliki fungsi untuk mengakses data tersebut, seperti : inisialisasi(), penjumlahan(), pengurangan(), perkalian() dan pembagian().
Data dan fungsi yang berada dalam sebuah class dinamakan anggota. Secara lebih khusus , data yang terletak dalam kelas dinamakan anggota data dan fungsi yang berada dalam kelas disebut anggota fungsi atau fungsi anggota atau terkadang disebut metode.
Contoh :
classProgram
    {
        privatestaticvoidtulis()
        {
            Console.WriteLine("method pertama");
        }
}

Attribute
Adalah suatu pengenal yang digunakan untuk menyimpan suatu nilai. Nilai dalam variabel dapat berubah2 selama proses pada program masih berlangsung. Sebelum variabel digunakan, harus dideklarasikan terlebih dahulu, dengan format penulisan :
Contoh :
string kata;
int angka;
Method          
Method adalah bagian dari tubuh program yang mengimplementasikan suatu action sehinggga class atau object dapat bekerja. Method diimplementasikan didalam class dan menyediakan informasi tambahan yang mana class tidak dapat menangani sendiri.
Penggunaan method mempunyai beberapa keuntungan diantaranya :
Ø Mempermudah perawatan dan manajemen kode.
Ø Method bisa di panggil dari program utama atau dari sub program yang lain.
Ø Method dipanggil berulang kali, sehingga tidak perlu menulis ulang kode yang sama ketika dibutuhkan.
Secara umum method dapat dibagi menjadi dua, yaitu method static dan non static. method static hanya dapat di akses dari class, sedangkan method non static dapat di akses dari instances. Masing-masing method tersebut dapat mempunyai parameter atau tidak. Jika sebuah method mempunyai parameter, maka method tersebut dapat menerima dan/atau memberikan nilai kepada pemanggilnya.
Contoh :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
namespacemethod
{
    classProgram
    {
        privatestaticvoidtulis()
        {
            Console.WriteLine("method pertama");
        }
        privatestaticvoidgaris()
        {
            Console.WriteLine("--------------------------");
        }
        publicstaticvoidMain(string[] args)
        {
            garis();
            tulis();
            garis();
            garis();
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }
}
Diposting oleh di 1 komentar:

Sabtu, 18 Mei 2013

Kelompok 2

Berikut Link tugas bahasa pemrogaman tgl 19 Mei 2013
Kelompok 2
.
http://www.mediafire.com/?9rpwk8f52p236cs

berikut data ms .word
http://www.mediafire.com/view/?x7xqqo1yojiuvq4

berikut data ms.power pointnya
http://www.mediafire.com/view/?tf4az118ryv5vpo
Diposting oleh di Tidak ada komentar:

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. }

Baca selengkapnya »
Diposting oleh di Tidak ada komentar:
Langganan: Postingan (Atom)