석수코딩교육

class WindowsManageFrm : Form
{
    System.Windows.Forms.ListBox listBox1 = null;
    System.Windows.Forms.ListBox listBox2 = null;

    void init()
    {
        this.listBox1 = new System.Windows.Forms.ListBox();
        this.listBox2 = new System.Windows.Forms.ListBox();
        this.SuspendLayout();
        this.Controls.Add(this.listBox1);
        this.Controls.Add(this.listBox2);
        this.ResumeLayout(false);

        this.listBox2.Items.Add("KKKKKKK");
        this.listBox2.Items.Add("MMMMMMMMMMMMMMM");
        this.listBox2.Items.Add("KKKKKKK");
    }
    protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
    {
const int WM_KEYDOWN = 0x0100, WM_SYSKEYDOWN = 0x0104;
if ((msg.Msg == WM_KEYDOWN) || (msg.Msg == WM_SYSKEYDOWN))
{
         switch (keyData.ToString())
         {
case "Return" :
Console.WriteLine(this.listBox2.SelectedItem.ToString());
break;
case "Escape" :
DialogResult dialogResult = MessageBox.Show("Quit!!", "Inform",
                    MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
if (dialogResult == DialogResult.OK) Application.Exit();
break;
         default:
             break;
        }
    }
}

비고)
// 0->ID, 1->Handle, 2->Seq
string[] split = recv.id.Split('.');

Linux sinfo 5.4.0-135-generic #152-Ubuntu SMP Wed Nov 23 20:19:22 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

1.1
1.  swap(2,048)  -> 10,000
2.  /boot(100)   ->  2,000
3.  /(3,072)     -> 12,000
4.  /usr(8,192)  -> 70,000
5.  /usr2(90,000)-> 90,000
6.  /var(4,096)  -> 12,000
7.  /tmp(4,096)  -> 12,000
8.  /data(70,000)-> 70,000
9.  /home(2,000) ->  2,000
10. /web(나머지 부분을 할당, 체크)

2.1
sudo passwd root

3.2
userdel sinfo

groupadd other
useradd -d /usr2/sinfo -s /bin/bash -g other -m sinfo
passwd sinfo

4.1
$apt install telnetd -y
$systemctl status inetd

5.1
$apt-get install vsftpd
$systemctl restart vsftpd
$vi /etc/vsftpd.conf
/*------------------------------------
listen=NO
listen_ipv6=YES
anonymous_enable=NO
local_enable=YES
chroot_local_user=YES
allow_writeable_chroot=YES
local_root=/data/ftp/files
write_enable=YES
local_umask=022
dirmessage_enable=YES
userlist_enable=YES
userlist_file=/etc/vsftpd.userlist
userlist_deny=NO
------------------------------------*/
/*------------------------------------
write_enable=YES
write_enable=YES
write_enable=YES
write_enable=YES
------------------------------------*/
$systemctl restart vsftpd

6.1
$gcc --version
$apt update
$apt install build-essential

7. 원하는 버전의 gcc 설치
$apt -y install gcc-7 g++-7 gcc-8 g++-8 gcc-9 g++-9

8. gcc default 설정 (명령어 뒤 700, 800, 900은 임의 숫자 적용)

$update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 700
$update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 700 
$update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800
$update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-8 800
$update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 900
$update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 900

9. default 설정 확인 및 변경
$update-alternatives --config gcc
$update-alternatives --config g++

root@sinfo:~# update-alternatives --config gcc
There are 3 choices for the alternative gcc (providing /usr/bin/gcc).

  Selection    Path            Priority   Status
------------------------------------------------------------
* 0            /usr/bin/gcc-9   900       auto mode
  1            /usr/bin/gcc-7   700       manual mode
  2            /usr/bin/gcc-8   800       manual mode
  3            /usr/bin/gcc-9   900       manual mode

Press <enter> to keep the current choice[*], or type selection number: 1
update-alternatives: using /usr/bin/gcc-7 to provide /usr/bin/gcc (gcc) in manual mode


root@sinfo:~# update-alternatives --config g++
There are 3 choices for the alternative g++ (providing /usr/bin/g++).

  Selection    Path            Priority   Status
------------------------------------------------------------
* 0            /usr/bin/g++-9   900       auto mode
  1            /usr/bin/g++-7   700       manual mode
  2            /usr/bin/g++-8   800       manual mode
  3            /usr/bin/g++-9   900       manual mode

Press <enter> to keep the current choice[*], or type selection number: 1
update-alternatives: using /usr/bin/g++-7 to provide /usr/bin/g++ (g++) in manual mode

10.
source ~/.bash_profile
source ~/.bashrc

using System.Runtime.InteropServices;

class UAPDBMQ0010 : Form
{
IntPtr tailHandle = IntPtr.Zero;
System.Timers.Timer tm = new System.Timers.Timer();
string qryText = "";

[DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr FindWindow(string strClassName, string strWindowName);
        [DllImport("user32.dll")]
        public static extern int SendMessage(int hWnd, uint Msg, int wParam, int lParam);

public UAPDBMQ0010(IntPtr prmHandle, string qryFileName)
{
tailHandle = prmHandle;

tm.Elapsed += new ElapsedEventHandler(____time_tick);
qryText = System.IO.File.ReadAllText(qryFileName);
}
void ____time_tick(object sender, ElapsedEventArgs e)
{
try
                {
                    byte[] dataByte = Encoding.UTF8.GetBytes(qryText);

                    COPYDATASTRUCT copyData = new COPYDATASTRUCT();
                    copyData.dwData = (IntPtr)0;
            copyData.cbData = dataByte.Length;
                    copyData.lpData = Marshal.AllocHGlobal(dataByte.Length);
                    Marshal.Copy(dataByte, 0, copyData.lpData, dataByte.Length);

                    IntPtr sendData = Marshal.AllocHGlobal(Marshal.SizeOf(copyData));
                    Marshal.StructureToPtr(copyData, sendData, true);

                    IntPtr _result = SendMessage(tailHandle, APMApiPublic.WM_COPYDATA, (IntPtr)index, sendData);

                    Marshal.FreeHGlobal(copyData.lpData);
                    Marshal.FreeHGlobal(sendData);
                }
                catch (Exception exp)
                {
                    Console.WriteLine(exp.Message);
                }
}
}

class APMCommManage : Form
{
IntPtr currentHandle = IntPtr.Zero;

public APMCommManage()
        {
            currentHandle = Handle;
        }
protected override void WndProc(ref Message m)
{
const int WM_PAINT=0x000f;

base.WndProc(ref m);

switch(m.Msg)
{
case WM_PAINT:
break;
default:
break;
}
}
protected override bool ProcessCmdKey(ref Message m, Keys keyData)
{
const int WM_KEYDOWN=0x0100;

if(m.Msg==WM_KEYDOWN)
{
switch(keyData.ToString())
{
case "Return":
Console.WriteLine("HANDLE:" + "[" + currentHandle.ToString() + "]");
break;
case "Right":
break;
case "Left":
break;
case "Space":
DBMS2022FRM dbms2022frm  = new DBMS2022FRM(currentHandle, "QUERY.567342.001");
dbms2022frm.Show();
break;
case "Escape":
Application.Exit();
break;
default:
break;
}
}
return base.ProcessCmdKey(ref m, keyData);
}
}

//IntPtr.ToString 메서드

using System;
using System.Windows.Forms;

class Program
{
public static void Main()
{
Application.Run(new APMCommManage());
#if(false)
APMCommManage nm = new APMCommManage();
nm.running();
#endif
}
}
class DBMS2022FRM : Form
{
public DBMS2022FRM()
{
this.Text = "DBMS2022FRM";
}
protected override bool ProcessCmdKey(ref Message m, Keys keyData)
{
const int WM_KEYDOWN=0x0100;

if(m.Msg==WM_KEYDOWN)
{
switch(keyData.ToString())
{
case "Return":
break;
case "Right":
break;
case "Left":
break;
case "Space":
break;
case "Escape":
this.Close();
break;
default:
break;
}
}
return base.ProcessCmdKey(ref m, keyData);
}
}
class APMCommManage : Form
{
IntPtr currentHandle = IntPtr.Zero;

public APMCommManage()
        {
            currentHandle = Handle;
        }
protected override void WndProc(ref Message m)
{
const int WM_PAINT=0x000f;

base.WndProc(ref m);

switch(m.Msg)
{
case WM_PAINT:
break;
default:
break;
}
}
protected override bool ProcessCmdKey(ref Message m, Keys keyData)
{
const int WM_KEYDOWN=0x0100;

if(m.Msg==WM_KEYDOWN)
{
switch(keyData.ToString())
{
case "Return":
Console.WriteLine("HANDLE:" + "[" + currentHandle.ToString() + "]");
break;
case "Right":
break;
case "Left":
break;
case "Space":
DBMS2022FRM dbms2022frm  = new DBMS2022FRM();
dbms2022frm.ShowDialog();
break;
case "Escape":
Application.Exit();
break;
default:
break;
}
}
return base.ProcessCmdKey(ref m, keyData);
}
}

/*
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe frm_01.cs
*/

#USING
using ServiceStack.Redis;

#DELCARE
RedisClient sendRedis = null;
RedisClient receiveRedis = null;

#CONNECT
sendRedis = new RedisClient("10.245.1.65", 9111);
recvRedis = new RedisClient("10.245.1.65", 9111);

#PUSH
byte[] sendbytes = Encoding.UTF8.GetBytes(qryText);

int resultcode = sendRedis.RPush("QCS", sendbytes);

if(resultcode==1){}

#POP
string sendFormatText = "CLI:/cli/admin/" + "127.0.0.1" + "/" + "45645";

byte[][] recvbytes = null;
recvbytes = recvRedis.BLPop(sendFormatText, 1);
for(int ii=0; ii<recvbytes.Length; ii++)
{
byte[] jsonbyte = new byte[recvbytes[ii].Length];
recvbytes[ii].CopyTo(jsonbyte, 0);

formatText = Encoding.UTF8.GetString(jsonbyte);

if(ii==1){}
}

#COMPILE
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc /reference:Newtonsoft.Json.Net20.dll,ServiceStack.dll,ServiceStack.Interfaces.dll,ServiceStack.ServiceInterface.dll /out:send_shmqry.exe send_shmqry.cs

Redis 기본 자료 구조 및 명령어

Strings

일반적으로 사용되는 Key - Value의 형식을 가지는 자료구조입니다. 
key와 value의 관계는 1 : 1이 됩니다.

기본 명령어 - get, set, del

get key - key에 해당하는 value를 가져옵니다.
set key value - key에 value를 저장합니다.
del key - key를 삭제합니다.

List

Redis Collection 중 하나인 List입니다. 
List는 redis Strings의 묶음 자료구조입니다. 
Last 또는 First에 삽입, 삭제가 가능합니다. 
Redis는 List의 자료구조로 Quick List를 사용한다고 합니다. 
Quick List의 자세한 내용은 문서를 참고해주세요.

기본 명령어 - lpush, rpush, lpop, rpop, lrange

lpush key value - List의 index 0 쪽으로 데이터를 넣습니다. ( redis의 list index는 0부터 시작합니다.)
rpush key value - List의 index last 쪽으로 데이터를 넣습니다.
lrange key start end - List의 start부터 end까지의 element를 반환합니다.
lpop key - List의 index 0의 데이터를 뺍니다.
rpop key - List의 index last의 데이터를 뺍니다.

#기본적으로, push는 데이타를 입력하는것이고, pop은 데이타를 빼는것이다.
#pop은 데이타를 빼는것이며, 빼어낸 데이타는 LIST에서 사라지게 될것이다.

class Program
{
public static void Main()
{
DebugManage nm = new DebugManage();

nm.running();
}
}

public struct COPYDATASTRUCT
{
public IntPtr dwData {get; ste;}
public int cbData {get; ste;}
public IntPtr lpData {get; ste;}
}

public class RcvDefaultResult
{
public string code { get; set; }
public string text { get; set; }
public List<List<string>> data { get; set; }
}
public class PWInterface
{
private RcvDefaultResult _result;
public string id { get; set; }
public string sender { get; set; }
public string proto { get; set; }

public RcvDefaultResult result
{
get { return _result; }
set { _result = value; }
}
}
class DebugManage
{
class dataInterface
{
public List<List<string>> data {get; set;}
}

public void running()
{
int ii,kk;
string formatText="";

COPYDATASTRUCT cds = (COPYDATASTRUCT)m.GetLParam(typeof(COPYDATASTRUCT));
byte[] recvData = new byte[cds.cbData];
Marshal.Copy(cds.lpData, recvData, 0, cds.cbData);
FormatText = Encoding.UTF8.GetString(recvData);

try
{
PWInterface ifRecieve = JsonConvert.DeserializeObject<PWInterface>(formatText);

//ifRecieve.result.code
//ifRecieve.result.text
//ifRecieve.result.data.Count
}
catch(Exception e)
{
Console.WriteLine(e.Message);
}
try
{
JObject jobject = JObject.Parse(formatText);

string screen = jobject["id"].ToString().Substring(0+1+5+1, 10);
string mmm = jobject["result"].ToString();

dataInterface data;
data = JsonConvert.DeserializeObject<dataInterface>(mmm);

for(kk=0; kk<data.data.Count; kk++)
{
List<string> mmm_mmm = data.data[kk];

for(ii=0; ii<mmm_mmm.Count; ii++)
{
Console.WriteLine(mmm_mmm[ii].ToString());
}
}
}
catch(Exception e)
{
Console.WriteLine(e.Message);
}
}
}

protected override void WndProc(ref Message m)
{
base.WndProc(ref m);

switch (m.Msg)
{
case WM_COPYDATA:
break;

default:
break;
}
}

/*
//JSON FORMAT

{
"teamname": "My Team",
"etc": "master group",
"members": [{
"name": "Mad Dog",
"age": 36,
"job": "Engineer",
"sex": "male",
}, {
"name": "Angry Bird",
"age": 30,
"job": "self-employment",
"sex": "female",
}]
}

json parsing - JsonConvert.DeserializeObject
json 문자열을 클래스로 바로 파싱을 하려면 JsonConvert 객체의 DeserializeObject 함수를 이용하면 됩니다.

json 변환 - JsonConvert.SerializeObject
클래스를 json 문자열로 변환할때는 JsonConvert의 SerializeObject 를 이용하면 됩니다.

string json = JsonConvert.SerializeObject(Teams, Formatting.None);
*/



using System;
using System.Linq;
using System.Collections.Generic;


#if(true)
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
#endif

class Program
{
public static void Main(string[] args)
{
DeserializeObjectManage nm = new DeserializeObjectManage();
nm.running();
}
}
class DeserializeObjectManage
{
public class clTeams
{
public string teamname;         //json 항목명과 동일해야함 (대소문자 구분)
public string etc;              //json 항목명과 동일해야함 (대소문자 구분)

public List<clMember> members;  //json 항목명과 동일해야함 (대소문자 구분)
}

public class clMember
{
public string name;
public int age;
public string job;
public string sex;
}

public void running()
{
string jsontext = "{ \"teamname\": \"My Team\", \"etc\": \"master group\", \"members\": [{ \"name\": \"Mad Dog\", \"age\": 36, \"job\": \"Engineer\", \"sex\": \"male\", }, { \"name\": \"Angry Bird\", \"age\": 30, \"job\": \"self-employment\", \"sex\": \"female\", }]}";

clTeams Teams; //선언해준 클래스

Teams = JsonConvert.DeserializeObject<clTeams>(jsontext);

Console.WriteLine(Teams.members.Count);

for (int kk = 0; kk < Teams.members.Count; kk++)
{
Console.WriteLine(Teams.members[kk].name);
Console.WriteLine(Teams.members[kk].age);
Console.WriteLine(Teams.members[kk].job);
Console.WriteLine(Teams.members[kk].sex);
}
}
}

/*
csc /reference:Newtonsoft.Json.Net20.dll /out:form_6.exe form_6.cs
csc /reference:Newtonsoft.Json.Net20.dll /out:form_6.exe form_6.cs
csc /reference:Newtonsoft.Json.Net20.dll /out:form_6.exe form_6.cs
*/

1. SendMessage.cs(Timer, Background)
- 데이타를 Title을 Handle로 잡아서, 송신한다.

2. ReceiveMessage.cs
- 데이타를 Title을 Handle로 잡아서, 수신한다.

KEY POINT)주고 받는, 메세지의 길이가 명확해야 한다.

>등록
update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-3.3
update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.7
update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9

>선택
update-alternatives --config g++ 

Newtonsoft.Json.Net20.dll 을 이용한 파싱 sample

int check_horizon()
{
int ii,kk,ff,mm;

for(ii=0; ii<MAPY-1; ii++)
{
for(kk=1; kk<MAPX-1; kk++)
{
ff=0;
while(true)
{
if(kk+ff+1 == MAPX-1) break;

if(comm[ii,kk+ff]==0) break;
else
{
if(comm[ii,kk+ff]==comm[ii,kk+ff+1]) ff++;
else break;
}
}

if(ff>=MAXARR-1)
{
score_horizon++;
for(mm=0; mm<=ff; mm++)
{
delete_col(kk+mm, ii);
}
return(SUCC);
}
}
}
return(FAIL);
}

>>>REDIS 소개
REDIS는 BSD 라이센스 기반의 Key-value 캐쉬 & Store 소프트웨어다. 
String, hash, lists, sets, sorted set, bitmap, hyperloglogs 등 다양한 데이터 구조를 저장할 수 있기 때문에, 
data structure server라고 부르기도 한다.
메모리에 데이터를 쓰는 In memory 데이터베이스 그리고 NoSQL 데이터베이스로 분류된다. 
데이터에 대한 읽기와 쓰기가 많은 서비스에 사용 할 수 있다. 
Memcached와 비슷한 스팩을 가지고 있는데, 다양한 유형의 데이터를 지원한다는게 장점이다.

>>>Redis 자료구조 테스트
1.
Strings키에 대한 값으로 문자열(string)를 저장한다. 
단순한 타입으로, redis를 사용한다고 하면 가장 먼저 고려해볼만한 타입이다. 
JSON, XML등 문자열로 된 데이터들을 저장할 수 있다. 
웹 서비스를 한다면, HTML 문서의 전체 혹은 일부분을 캐쉬하기 위해서 사용할 수 있다.

SET을 이용해서 값을 저장하고, GET을 이용해서 값을 가져올 수 있다. 
이미 있는 key에 대해서 값을 설정하면, 값을 덮어쓴다.
특이한 점은 string이라고 해서 문자열만 저장하는게 아니고, 바이너리(binary) 데이터도 저장할 수 있다는 거다.

MSET과 MGET을 이용해서 한 번에 여러 개의 key, value를 저장하고 읽을 수 있다.

2.
리스트

LPUSH를 이용해서 리스트의 맨 앞(왼쪽-left)에, RPUSH를 이용해서 리스트의 맨 뒤에 값을 밀어넣을 수 있다. LRANGE로 일정 범위의 값을 읽을 수 있다.
LRANGE는 시작과 끝을 위한 두 개의 index 값이 필요하다. 인덱스가 마이너스(-)이면, 리스트의 끝(오른쪽)을 기준으로 인덱스 값을 메긴다. 
오른쪽 끝의 인덱스는 -1이다. 따라서 "0 -1"은 0번째 부터 마지막 까지의 범위를 의미한다.한번에 여러개의 값을 저장할 수도 있다.

KEY POINT>>>>
pop은 Redis list에서 가장 중요한 연산일 것이다. 이 연산은 리스트에서 값을 읽는게, 아니라 꺼낸다. 
읽으면서 지운다라고 생각하면 되겠다.
pop은 Redis list에서 가장 중요한 연산일 것이다. 이 연산은 리스트에서 값을 읽는게, 아니라 꺼낸다. 
읽으면서 지운다라고 생각하면 되겠다.
pop은 Redis list에서 가장 중요한 연산일 것이다. 이 연산은 리스트에서 값을 읽는게, 아니라 꺼낸다. 
읽으면서 지운다라고 생각하면 되겠다.
pop은 Redis list에서 가장 중요한 연산일 것이다. 이 연산은 리스트에서 값을 읽는게, 아니라 꺼낸다. 
읽으면서 지운다라고 생각하면 되겠다.
3.

Blocking operation on lists

REDIS는 list 데이터 타입에 대해서 Blocking operation을 지원한다.list로 부터 값을 꺼내기(POP)위한 가장 방법은 주기적으로 rpop를 호출하는 것이다. 
이 방식은 주기를 조절하는게 애매모호하기 때문에 그다지 좋아 보이지 않는다. 
POP을 호출하는 시점에 읽을 데이터가 없다면, 읽을 데이터가 준비될 때까지 blocking 되는게 깔끔해 보인다. 
한번의 호출로 데이터를 읽을 수 있기 때문이다.BRPOP과 BLPOP 명령을 이용하면, blocking 작업이 가능하다. 
이들 명령을 호출하면, 데이터가 없을 경우 데이터가 준비될 때까지 block된다. 물론 block 시간 설정도 가능하다.

1. 객체 지향(Object oriented) 프로그래밍이란?
2. 절차 지향과 객체 지향
- 절차 지향
- 객체 지향
- 절차 지향 VS 객체 지향
3. 객체 지향 프로그래밍의 특징
- 객체 지향 프로그래밍의 장점
- 소프트웨어의 생산성 향상
- 실세계에 대한 쉬운 모델링
- 보안성 향상
- 객체 지향 프로그래밍의 단점
- 느린 실행 속도

객체 지향(Object oriented) 프로그래밍이란? #
우리가 실생활에서 쓰는 모든 것을 객체라 하며, 객체 지향 프로그래밍은 프로그램 구현에 필요한 객체를 파악하고 각각의 객체들의 역할이 무엇인지를 정의하여 객체들 간의 상호작용을 통해 프로그램을 만드는 것을 말한다. 객체는 클래스라는 틀에서 생겨난 실체(instance)이다. 따라서 객체 지향 프로그램은 객체와 객체 간의 연결로 되어 있으며 각각의 객체 안에 자료구조와 알고리즘이 들어있는 것이다.

절차 지향과 객체 지향 #

절차 지향 #
절차 지향 모델링은 프로그램을 기능중심으로 바라보는 방식으로 "무엇을 어떤 절차로 할 것인가?"가 핵심이 된다. 즉, 어떤 기능을 어떤 순서로 처리하는가에 초점을 맞춘다.

객체 지향 #
객체 지향 모델링은 기능이 아닌 객체가 중심이 되며 "누가 어떤 일을 할 것인가?"가 핵심이 된다. 즉, 객체를 도출하고 각각의 역할을 정의해 나가는 것에 초점을 맞춘다.

절차 지향 VS 객체 지향 #
대형 프로그래밍의 경우 많은 기능을 수반하기 때문에 절차 지향보다는 객체 지향이 적합

각 객체가 하는 역할이 많아도, 많은 역할을 객체로 묶을 수 있기 때문
소형 프로그래밍의 경우 작은 기능을 수반하기 때문에 객체 지향보다는 절차 지향이 적합

작은 기능을 객체별로 나눌 경우, 오히려 복잡해질 수 있기 때문
객체 지향 프로그래밍의 특징 #
추상화(abstraction)

객체들의 공통적인 특징(기능, 속성)을 도출하는 것
객체지향적 관점에서는 클래스를 정의하는 것을 추상화라고 할 수 있다.(클래스가 없는 객체지향 언어도 존재 ex.JavaScript)
캡슐화(encapsulation)

실제로 구현되는 부분을 외부에 드러나지 않도록 하여 정보를 은닉할 수 있다.
객체가 독립적으로 역할을 할 수 있도록 데이터와 기능을 하나로 묶어 관리하는 것
코드가 묶여있어서 오류가 없어 편리하다.
데이터를 보이지 않고 외부와 상호작용을 할 때는 메소드를 이용하여 통신을 한다. 보통 라이브러리로 만들어서 업그레이드해 사용할 수 있다.
상속성(inheritance)

하나의 클래스가 가진 특징(함수, 데이터)을 다른 클래스가 그대로 물려받는 것
이미 작성된 클래스를 받아서 새로운 클래스를 생성하는 것
기존 코드를 재활용해서 사용함으로써 객체지향 방법의 중요한 기능 중 하나에 속한다.
다형성(polymorphism)

약간 다른 방법으로 동작하는 함수를 동일한 이름으로 호출하는 것
동일한 명령의 해석을 연결된 객체에 의존하는 것
오버라이딩(Overriding), 오버로딩(Overloading)

오버라이딩(Overriding) - 부모클래스의 메소드와 같은 이름을 사용하며 매개변수도 같되 내부 소스를 재정의하는 것
오버로딩(Overloading) - 같은 이름의 함수를 여러 개 정의한 후 매개변수를 다르게 하여 같은 이름을 경우에 따라 호출하여 사용하는 것
동적바인딩(Dynamic Binding)

가상 함수를 호출하는 코드를 컴파일할 때, 바인딩을 실행시간에 결정하는 것.
파생 클래스의 객체에 대해, 기본 클래스의 포인터로 가상 함수가 호출될 때 일어난다.
함수를 호출하면 동적 바인딩을 통해 파생 클래스에 오버라이딩 된 함수가 실행
프로그래밍의 유연성을 높여주며 파생 클래스에서 재정의한 함수의 호출을 보장(다형 개념 실현)
객체 지향 프로그래밍의 장점 #
소프트웨어의 생산성 향상 #
객체지향 프로그래밍은 다형성, 객체, 캡슐화 등 소프트웨어의 재사용을 지향한다. 이미 만들어진 클래스를 상속받거나 객체를 가져다 재사용하거나, 부분 수정을 통해, 소프트웨어를 작성하는 부담을 대폭 줄일 수 있다.

신뢰성 있는 소프트웨어를 손쉽게 작성할 수 있다. (개발자가 만든 데이터를 사용하기 때문에 신뢰할 수 있다.)
코드를 재사용하기 쉽다 (상속, 캡슐화, 다형성으로 인해 재사용할 수 있다.)
업그레이드가 쉽다.
디버깅이 쉽다.
실세계에 대한 쉬운 모델링 #
컴퓨터가 산업 전반에 다양하게 활용되는 요즘 시대에는 응용 소프트웨어를 하나의 절차로 모델링하기 어렵다. 산업 전반에서 요구되는 응용 소프트웨어 특성상, 절차나 과정보다 관련된 많은 물체(객체)들의 상호 작용으로 묘사하는 것이 더 쉽고 적합하다.

실세계에 대한 모델링을 좀 더 쉽게 해준다. (모든 것을 객체들의 상호작용으로 생각)
보안성 향상 #
객체 지향적 프로그래밍의 캡슐화 특징으로 실제로 구현되는 부분을 외부에 드러나지 않도록 하여 정보를 은닉할 수 있다.

보안성이 높다 (캡슐화, 데이터 은닉, 다형성으로 인해 필요한 정보를 재정의하거나 getter, setter를 이용하기 때문에 보안성이 높다.)
객체 지향 프로그래밍의 단점 #
느린 실행 속도 #
객체 지향 프로그래밍은 캡슐화와 격리구조에 때문에 절차지향 프로그래밍과 비교하면 실행 속도가 느리다. 또한, 객체지향에서는 모든 것을 객체로 생각하기 때문에 추가적인 포인터 크기의 메모리와 연산에 대한 비용이 들어가게 된다.

절차지향 프로그래밍에 비해 느린 실행 속도
필요한 메모리양의 증가

VERILOG 및 VHDL은 전자 칩 용 프로그램을 작성하는데 사용되는 하드웨어 설명 언어이다. 이러한 언어는 컴퓨터의 기본 아키텍처를 공유하지 않는 전자 장치에 사용된다. VHDL은 VERILOG 보다 오래된 언어이며 ADA와 PASCAL을 기반으로 한다. VERILOG는 상대적으로 최근 버전이며 C 프로그래밍 언어를 기반으로 한다.
VHDL은 강력한 형식의 언어(Strong Type Language)이다. 반대의 개념으로 약한 타입 언어(Weak Type Language)가 있다. 강한 타입 언어는 타입 검사를 통과하지 못한 ㅡ로그램의 실행 자체를 막지만, 약 타입 언어는 런타임에 타입 오류를 만나는 한이 있더라도 실행을 막지 않는다는 것이다. 그렇기에 VHDL은 강력한 형식이 아닌 스크립트는 컴파일 할 수 없다. VHDL과 같이 같이 강력한 형식의 언어는 다른 클래스와 함께 변수의 혼합 또는 연산을 허용하지 않는다. VERILOG는 강력한 형식의 언어와 반대되는 약한 형식을 사용한다. 또 다른 차이점은 대소 문자 구분이다.
VERILOG는 대소 문자를 구별하며, 사용된 사례가 이전에 사례와 일치하지 않는 경우 변수를 인식하지 못한다. 반면 VHDL은 대소 문자를 구분하지 않으므로 이름의 문자와 주문이 동일하게 유지되는 한 사용자는 자유롭지 대소 문자를 변경할 수 있다.
일반적으로 VERILOG는 VGDL보다 배우기 쉽다는 장점이 있다. 이것은 부분적으로 C 프로그래밍 언어의 인기 때문에 대부분의 프로그래머가 VERILOG에서 사용되는 문법적 규칙을 잘 알고 있기 때문이다.
VHDL은 높은 수준의 모델링을 돕는 훨씬 많은 구조를 갖는 이점에 있으며 프로그래밍되는 장치의 실제 작동을 반영한다. 복잡한 데이터 유형과 패키지는 크고 복잡한 시스템을 프로그래밍할 때 매우 바람직하다. VERILOG에는 패키지 개념은 없으며 모든 프로그래밍은 프로그래머가 제공 하난 간단한 데이터 유형으로만 수행해야 한다.
마지막으로, VERILOG는 소프트웨어 프로그래밍 언어의 라이버러리 관리가 부족하다. 즉, VERILOG는 프로그래머가 컴파일 하는 동안 호출되는 별도의 파일에 피료한 모듈을 넣는 것을 허용하지 않는다. VERILOG의 대규모 프로젝트는 대규모의 추적이 어려운 파일로 끝날 수 있다.

/*Singletone Pattern sample*/

using System;
using System.Drawing;

public class APMMemory
{
    private static APMMemory apmMemory=null;
    string ____processid;
    System.Drawing.Color ____bgColor;

    public static APMMemory GetInstance
    {
        get
        {
            if(apmMemory == null)
            {
                apmMemory=new APMMeory();
                Console.WriteLine("Singletone Pattern sample");
            }
        }
    }
    public string processid
    {
        get{return ____processid;}
        set{___processid=value;}
    }
    public System.Drawing.Color bgColor
    {
        get{return ____bgColor;}
        set{____bgColor=value;}
    }
}
class SampleManage
{
    public void running()
    {
        Console.WriteLine("" + APMMemory.GetInstance.processid);
        Console.WriteLine("" + APMMemory.GetInstance.bgColor);
    }
}
class Program
{
    public static void Main()
    {
        APMMemory.GetInstance.processid = "9999";
        APMMemory.GetInstance.bgColor=System.Drawing.Color.SteelBlue;

        SampleManage nm = new SampleManage();
        nm.running();
    }
}

/*Update by 2022.04.18*/

int common_chek(int direction)
{
    int ii,kk;
    int[,] tmp = new int[MAPY,MAPX];

    for(ii=0; ii <MAPY; ii++)
    for(kk=0; kk<MAPX; kk++)
    {
        tmp[ii,kk]=comm[ii,kk];
    }

    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        if(design[ii,kk]==1)
        {
             if(ypos+ii>MAPY-1) continue;
             if(xpos+kk>MAPX-1) continue;
             if(xpos+kk<0) continue;

             tmp[ypos+ii,xpos+kk]=0;
        }
    }

    if(direction==D_RIGHT) xpos++;
    if(direction==D_LEFT) xpos--;
    if(direction==D_DOWN) ypos++;

    ff=0;
    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        if(design[ii,kk]==1)
        {
             if(ypos+ii>MAPY-1) continue;
             if(xpos+kk>MAPX-1) continue;
             if(xpos+kk<0) continue;

             tmp[ypos+ii,xpos+kk] += 1;
             if(tmp[ypos+ii,xpos+kk]>1) ff++;
        }
    }

    if(ff>0)
    {
        if(direction==D_RIGHT) xpos--;
        if(direction==D_LEFT) xpos++;
        if(direction==D_DOWN) ypos--;

        return(FAIL);
    }
    else
    {
        for(ii=0; ii<MAPY; ii++)
        for(kk=0; kk<MAPX; kk++)
        {
            comm[ii,kk]=tmp[ii,kk];
        }
    }
    return(SUCC);
}

/*Update by 2022.04.18*/

int common_chek(int direction)
{
    int ii,kk;
    int[,] tmp = new int[MAPY,MAPX];

    for(ii=0; ii <MAPY; ii++)
    for(kk=0; kk<MAPX; kk++)
    {
        tmp[ii,kk]=comm[ii,kk];
    }

    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        if(design[ii,kk]==1)
        {
             if(ypos+ii>MAPY-1) continue;
             if(xpos+kk>MAPX-1) continue;
             if(xpos+kk<0) continue;

             tmp[ypos+ii,xpos+kk]=0;
        }
    }

    if(direction==D_RIGHT) xpos++;
    if(direction==D_LEFT) xpos--;
    if(direction==D_DOWN) ypos++;

    ff=0;
    for(ii=0; ii<ARR; ii++)
    for(kk=0; kk<ARR; kk++)
    {
        if(design[ii,kk]==1)
        {
             if(ypos+ii>MAPY-1) continue;
             if(xpos+kk>MAPX-1) continue;
             if(xpos+kk<0) continue;

             tmp[ypos+ii,xpos+kk] += 1;
             if(tmp[ypos+ii,xpos+kk]>1) ff++;
        }
    }

    if(ff>0)
    {
        if(direction==D_RIGHT) xpos--;
        if(direction==D_LEFT) xpos++;
        if(direction==D_DOWN) ypos--;

        return(FAIL);
    }
    else
    {
        for(ii=0; ii<MAPY; ii++)
        for(kk=0; kk<MAPX; kk++)
        {
            comm[ii,kk]=tmp[ii,kk];
        }
    }
    return(SUCC);
}

/*
c# 프로그램 전체 종료*/

1. Console

Environment.Exit(0);

2. Windows Form

Application.Exit();