using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class Work
{
static void Main(string[]
args)
{
//제네릭(Generic)
// - 내부 구조나 알고리즘이 동일하되 다루는 자료형만 다른 경우 클래스나 메서드를 간결화
시키는 기법
// - 컴파일될때 자료형이 결정
WrapperInt n1
= new WrapperInt(10);
Console.WriteLine("int형:{0}", n1.Value);
WrapperString
s1 = new WrapperString("문장");
Console.WriteLine("String형:{0}", s1.Value);
//박싱과 언박싱은 비용이 많이 들어간다. object의
문제점을 보완하기위해 Generic 탄생
WrapperObject
o1 = new WrapperObject(30);
Console.WriteLine("object형 INT형과 더하기 : {0}", (int)o1.Value + 10);
//래퍼 클래스 사용 : 한번 셋팅이 되면
다른 타입은 절대 넣을수가 없다.
//컴파일 하는 순간 매개 변수처럼 단어가
Wrapper<T> t 로넘어가며 생성자를 인트형으로 초기화 한다. <T>에
데이타 타입 대로 자료 형을 매개변수로 넘겨준다
Wrapper<int> n3 = new Wrapper<int>(30);
Console.WriteLine("Generic Int 형:{0}", n3.Value + 30);
Wrapper<string> g2 = new Wrapper<string>("짱");
Console.WriteLine("Generic String형:{0}", g2.Value);
}
}
//요구사항] 멤버 변수 int value을 가지는 클래스 선언
// value를 핸들링 멤버 추가 구성
//기존 값은 스트링형으로 사용할수 없다.
class WrapperInt
{
private int value;
//생성자
public WrapperInt()
{
this.value = 0;
}
//생성자 오버로딩
public WrapperInt(int value)
{
this.value =
value;
}
//프로퍼티
public int Value
{
get { return this.value; }
set { this.value = value; }
}
//요구사항] 멤버 변수 int value을 가지는 클래스 선언
// value를 핸들링 멤버 추가 구성
// WrapperInt 클래스가 하는일과 동일****
}
class WrapperString
{
private string value;
//생성자
public WrapperString()
{
this.value = string.Empty;
}
//생성자 오버로딩
public WrapperString(string value)
{
this.value =
value;
}
//프로퍼티
public string Value
{
get { return this.value; }
set { this.value = value; }
}
//요구사항] 멤버 변수 int value을 가지는 클래스 선언
// value를 핸들링 멤버 추가 구성
// WrapperInt 클래스가 하는일과 동일****
}
class WrapperObject
{
private object value;
public WrapperObject()
{
this.value =
value;
}
public WrapperObject(object value)
{
this.value =
value;
}
public object Value
{
get { return this.value; }
set { this.value = value; }
}
}
//제네릭 클래스
// - 멤버 변수의 타입을 고정시켜놓지 않고, 선언할때
결정하는 방식의 클래스
//<T> = 매개 변수이다. 아무거나 넣어도 상관없다.
class Wrapper<T>
{
private T value;
public Wrapper()
{
this.value = default(T);
}
public Wrapper(T value)
{
this.value =
value;
}
public T Value
{
get { return this.value; }
set { this.value = value; }
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace Work
{
class Generic02
{
static void Main(string[]
args)
{
//제네릭 컬렉션
ArrayList
list1 = new ArrayList();
list1.Add(100);
list1.Add(200);
list1.Add(300);
Console.WriteLine("ArrayList:{0}", (int)list1[0] + (int)list1[1]
+ (int)list1[2]);
ArrayList
list2 = new ArrayList();
list2.Add(true);
list2.Add(false);
if ((bool)list2[0])
{
Console.WriteLine("ArrayList 참");
}
//ArrayList : object형 배열
//ArrayList 제네릭 버젼 : list<>
List<int> list3 = new List<int>();
list3.Add(1000);
list3.Add(2000);
list3.Add(3000);//Boxing발생X
Console.WriteLine("제네릭 인트형:{0}", list3[0] + list3[1] +
list3[2]);
List<bool> list4 = new List<bool>();
list4.Add(true);
list4.Add(false);
Console.WriteLine("제네릭 불리언형:{0}", list4[0]);
//제네릭 컬렉션
//ArrayList ->
list<>
Hashtable ht1
= new Hashtable();
//Dictionary : 하나는 string 하나는 int
Dictionary<string, int> ht2 =
new Dictionary<string, int>();
ht2.Add("하나", 1);
ht2.Add("둘", 2);
Console.WriteLine("Dictionary:{0}", ht2["하나"] + 100);
Queue<int> queue = new Queue<int>();
Stack<string> stack = new
Stack<string>();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class Generic03
{
static void Main(string[]
args)
{
Test<int> t1 = new Test<int>();
t1.m = 10;
Test<char> t2 = new Test<char>();
t2.m = 'a';
Test2<string, bool> t3 =
new Test2<string, bool>();
t3.a = "string";
t3.b = true;
t3.c = "string";
t3.d = 10;
}
}
class Test<T>
{
public T m;
}
class Test2<T,
U>
{
public T a;
public U b;
public T c;
public int d;
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class Generic03
{
static void Main(string[]
args)
{
//제네릭 메서드
int a = 10, b =
20;
Swap(a, b);
Swap<int>(a,
b);
string s1 = "하하", s2 = "호호";
Swap(s1, s2);
Swap<string>(s1,
s2);
bool b1 = true, b2 = false;
Swap<bool>(b1,
b2);
Test<int, byte>(10, 10);
}
public static void
Test<T, U>(T a, U b)
{
//특정 타입의 개체를 알고싶을때
Console.WriteLine(a.GetType().ToString());
Console.WriteLine(b.GetType().ToString());
}
//Swap : 단, 같은 타입끼리 교환
public static void Swap(int a, int b)
{
int temp;
temp = a;
a = b;
b = temp;
Console.WriteLine("a : {0}, b : {1}", a, b);
}
public static void Swap(string a, string b)
{
string temp;
temp = a;
a = b;
b = temp;
Console.WriteLine("a : {0}, b : {1}", a, b);
}
//제네릭 메서드
public static void
Swap<T>(T a, T b)
{
T temp;
temp = a;
a = b;
b = temp;
Console.WriteLine("a : {0}, b : {1}", a, b);
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace Work
{
class Initializer01
{
static void Main(string[]
args)
{
//초기화 리스트, 이니셜라이저, 객체 초기자
//배열 초기자
int[] nums = new int[3] { 100,
200, 300 };
//ArrayList 초기화
ArrayList list1 = new
ArrayList() { 10, 20, 30 };
//제네릭 초기화
//모든것이 초기화가 됨
List<int>
list2 = new List<int>()
{ 100, 200, 300 };
//객체초기자 Initializer(생성자와
같은 맥락) -> 링크를 할때에 이것을 사용한다.
Student s1 = new
Student { Name = "김종현", Age = 10 };
Console.WriteLine(s1);
Student s2 = new
Student("홍길동", 28);
Console.WriteLine(s2);
}
}
class Student
{
public string name;
public int age;
public string Name
{
set { this.name = value; }
}
public int Age
{
set { this.age = value; }
}
public Student() { }
public Student(string name, int age)
{
this.name = name;
this.age = age;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class Initializer02
{
static void Main(string[]
args)
{
Time t1 = new
Time();
t1.Hour = 10;
t1.Min = 20;
t1.Sec = 30;
t1.Check();
Console.WriteLine("{0}---------{1}",
t1.Hour, t1.Min);
//생성, 프로퍼티를 모두 합친 형태 최종형태
Time t2 = new
Time { Hour = 10, Min = 20, Sec = 30};
}
}
class Time
{
//생성자, 프로퍼티, 멤버 변수는 내부적으로 무조건 private
public int Hour { get; set; }
public int Min { get; set; }
public int Sec { get; set; }
internal void Check()
{
}
}
class Student
{
private string name;
public string Name
{
get { return this.name; }
set { this.name = value; }
}
//자동화 프로퍼티
public int Age { get; set; }
public void Test()
{
this.name = "하하";
this.Name = "호호";
this.Age = 20;
}
}
}
var 자료형태
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class var01
{
static void Main(string[]
args)
{
//var : 암묵적 타입변수, 익명 변수 > 내부적으로 박싱이 일어난다.
int n = 10;
Console.WriteLine(n.GetType());
string s = "홍";
Console.WriteLine(s.GetType());
//C#에서의 var는 오브젝트 성격을 가지고
있으나
//var로 생성한 변수는 초기값에 의해서 변수에 타입이 결정된다.
//한번결정이되면 변경이 불가능 하다.
var n2 = 20;
Console.WriteLine(n2);
Console.WriteLine(n2.GetType());
var s2 = "홍";
Console.WriteLine(s2);
Console.WriteLine(s2.GetType());
//var의 특징들..
//1. 한번 자료형이 결정돼면 불면
var num = 100;
//2. 선언과 동시에 초기화 필수!!
//var name;
//name = "홍길동";
var name = "홍길동";
//3. null값 할당이 안된다
//var obj = null;
var obj = new
Random();
//4. 한줄에 하나씩
//var c = 10, d = 20;
var c = 10;
var d = 20;
//5. var 은 지역변수에 한해서 가능
}
}
}
익명타입, 익명변수 : 클래스를
하나 생성할때
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class AnonymousType
{
static void Main(string[]
args)
{
//익명타입(이름이 없는 자료형)
//int n;
//? m;(이름이 없는 타입)
//초기화리스트 사용 - 생성자사용해서는 안된다.
//생성자를 사용하면 초기화리스트를 사용하면 안된다.
Human h = new
Human { Name = "홍길동", Age = 28 };
Console.WriteLine("{0}\t{1}",
h.Name, h.Age);
//유일한 하나뿐인 인스턴스를 생성하기 위해서 클레스를 설계해야하는 경우...***
//이름없는 클래스
Human h2 = new
Human { Name = "홍길동", Age = 20 };
//클래스 없이 하나의 인스턴스를 쓸때 사용할수 있는
var~
//익명 타입, 익명 변수 변수가 무엇인지
잘 모를때 사용한다.
var size1 = new {
Width = 100, Height = 200 };
object size2 = new { Width = 100, Height = 200 };
//size2. 없다
Console.WriteLine(size1.Height + 700);
}
}
class Human
{
public string Name { get; set; }
public int Age { get; set; }
}
}
Sample delegate
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
//Sample delegate(자료형이다.)
public delegate int Sample(int a, int b);
class AnonymousMethod01
{
static void Main(string[]
args)
{
//익명변수 : var
//익명클래스 : new {}
//익명메서드********
//위3가지가 1세트
int sum1 =
Sum(10, 20);
//이름이 없는 함수를 익명 변수라 한다. 메서드이름대신 delegate 키워드를 적어놓았다.
//다른데선 호출을 하지 못한다.
//이벤트를 배워서 이벤트와 같이 엮어서 배운다.
//어떤 행동을 하기위해서 메서드에 대한 정의가 같이 이루어진
//1. 사용하는 용도가 단 한곳일 경우.
//2. 메서드 선언위치가 사용하는 곳에서 선언..
Sample s = delegate(int a, int b)
{
return a *
b;
};
int sum2 = s(10,
20);
}
public static int Sum(int a, int b)
{
return a + b;
}
}
}
Partial
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Work
{
class Partial
{
static void Main(string[]
args)
{
//int n;
//int n;
}
//public void Test() { }
//public void Test() { }
}
//같은 이름이어도 구별할수 있도록 해주는기능을
Partial 이라고 한다.
//코딩은 나누었으나 컴파일러에서 한몸으로 만든다.
//인위적으론 사용할순 없으며 윈폼, .net에서
사용 구조를 만들어 놨다.
//다른 클래스 파일에서도 partial이라는
키워드만 사용하면 다른 파일에 똑같은 이름이 있다면 컴파일 하는순간 하나로 다합쳐서 컴파일 하게 된다.
partial class Test
{
private int n;
}
partial class Test
{
}
}
