C# 5.0 In a Nutshell. Ch. 4.

C# 5.0 In a Nutshell. [ by Albahari Bro.]

1. Delegates [ 12 / 5 ]

메서드를 부를 줄 아는 객체. 인수 / 리턴형 지정.콜러가 딜리깃을 호출하면, 딜리깃이 대상 메서드를 부름.
콜백 과 유사.

public int Transformer (int x);
Transformer t = SquareThis; // 이것은
Transformer t = new Transformer (SquareThis); // 이것의 축약형
t(3);  // 은
t.Invoke(3) // 의 축약형.

Writing Pulg-in Methods with Delegates

딜리깃 변수는 런타임에 할당. 이것은 플러그-인 메서드를 쓰기 유용.  예제 ..  정수 어레이와 변형 함수를 주어 모든 멤버에 대해 실행하게 함.

Multicast Delegates

+=, -= 등을 이용. 여러 함수 호출.

Instance Vs. Static Method Targets

Target property 는 인스턴스 함수의 인스턴스를 가리킴.
someDelegate.Target ,  someDele.Method

Generic Delegate Types

public delegate T Trans < T > ( T args );

The Func and Action Delegates

delegate TRlst Func < in T, out TRslt > ( T argu );
delegate TRlst Func < in T1, in T2, out TRslt > ( T1 arg1, T2 arg2 );
delegate void Action <in T> (T arg);

Delegates Vs. Interfaces

2. Events

3. Lambda Expressions

4. Anonymous Methods

Advertisements

C# 5.0 In a Nutshell. Ch. 3.

C# 5.0 In a Nutshell. [ by Albahari Bro.]

1. Classes

// Fields : 멤버 변수.
/*
* – The – readonly – modifier : 생성 이후 변경 불가.
* – Field initialization – 기본값으로 세팅. 생성 이전에 초기화됨.
* – Declaring multiple fields together  int a, b, c ; 이러 식.
* */

// Methods
/* Overloading methods  */
void Foo(int x) {}    //float Foo(int x) {} // 에러.
void Foo(ref int x) {} // OK.. out과 ref를 동시사용 은 안됨 (혼동)

// Instance Constructors
/*  생성자는 초기화 코드 : initialization code 를 실행. 메서드 같지만 이름과 리턴타입이 함축. */
/* – Overloading constructors
*   다른 생성자 호출 가능
*   public Apple (int x, int y) : this ( x )  이런 식.  불린 놈이 먼저 실행됨.
*
* – Implicit parameterless constructors : C# 이 자동 생성.
*   struct 는 이런 무인수 생성자는 intrinsic (원래 있는)  사용자가 지정 불가. 기본값 세팅함.
*
* – Constructor and field initialization order
* – Nonpublic constructors : pool 에서 꺼내 쓰거나 하는 등의 용도..  */

// Object Initializers  아래 예처럼 { } 이용하여 멤버 초기값 세팅 가능.

// The This Reference [9/21]

// Properties : get set 코드로 로직이 있는 멤버. [9/21]
/* – Read-only and calculated properties : write-only 가능하지만 드물다.
* – Automatic properties { get; set; }  C# 3.0
* – get and set accessibility : 아래 AccessiBility 예.
* – CLR property implementation : 내부적으로 get_XXX 이름으로 컴파일 됨. 인라인으로.
*/

// Indexers : string의 인덱스. [9/22]
/* – Implementing and indexer public string this [int wordNum] { get …. set … }
* – CLR indexer implementation     */

// Constants : 변하지 않는 static field. 컴파일에 산정되어 값이 사용될 때마다 값 치환 C++ macro 비슷.
//    public const string myMsg = “Hello “;  // 선언과 동시 초기화
//    static readonly 보다 더 제한적. 차이점 : 컴파일 시 값 산정한다는 점. readonly 는 어플마다 다를 수 있다.
//      다른 버전에서 값이 바뀔 수 있을 경우.

// Static Constructors : type 당 한번만 실행. (인스턴스 당이 아님)
/*   static ClassName() { SomeFunction(); }  이 클래스가 사용되기 전에 자동으로 한번 실행.
*   역할 : 타잎 초기화, 타잎의 static member 에 접근.
*   unsafe, extern 에만 접근 가능.
*   예외를 발생하면 그 타잎은 사용 불능.
*
* – Static constructors and field initialization order
*   Static 생성자 이전에 불림. */

// Static Classes [9/30
/*  static member 만 갖고, 상속할 수 없는 클래스.  예) System.Console, System.Math */

// Finalizers : Class only Methods . GC 실행 전에 수행.  ~ClassSample()

// Partial Types and Methods  여러 파일에 코드 분산
/*   구현할 인터페이스를 각각 구성 가능.
* – Partial methods  …  void, implicitly private ..   C# 3.0에서 도입.
*      partial void GetSomeValue();        // definition  코드 제네레이터에 보통 있음.
*
*      partial void GetSomeValue() { 구현 }  // implementation  매뉴얼 작성. */

2. Inheritance [p80]

// Polymorphism [10/1]

// Casting and Reference Conversions : 암시적 upcast to base class / 명시적 downcast to subclass.
/* – Upcasting : 캐스팅 후에도 동일한 객체임. objA == objB
* – Downcasting
* – The as operator : 다운캐스트 실패 시 null 세팅.
* – The is operator : if (a is Stock)  */

// Virtual Function Members : 상속을 위한 클래스. Methods, properties, indexers, events 모두 가능.
//  생성자에서 부르는 것은 잠재적 위험.

// Abstract Classes and Abstract Members  [10/7]
//  추상 클래스는 초기화되지 않음.

// Hiding Inherited Members
//  동일한 이름으로 베이스클래스 속성을 숨긴다.  Warning 발생.
//  new 를 통해 워닝 억제..
/* – new VS override
*   new 로 재정의한 함수는 부모클래스로 캐스팅 하면 상위 함수가 불린다..  */

// Sealing Functions and Classes [10/8 86p]
//  더 이상의 override 를 막기 위해 봉인.

// The base Keyword : this 비슷.
//  파생 클래스에서 상위 멤버 접근, 상위 생성자 콜.

// Constructors and Inheritance
/* – Implicit calling of the parameterless base-class constructor
*   인수 없는 상위 생성자는 암시적으로 자동 실행.
* – Constructor and field initialization order  순서 .. */

// Overloading and Resolution : 상속.. 캐스트하면 어느 함수를 부를 것인가.. dynamic ..

3. The object Type [p89]

// System.object 는 궁극의 베이스. 뭐든 object 로 캐스트 가능. 밸류 타잎도 박싱을 통해 가능.

// Boxing and Unboxing [10/9]
//  Value type 을 reference type 으로
// – Copying semantics of boxing and unboxing

// Static and Runtime Type Checking
//  int x = “5” ;  // static
//  int z = (int) y; // Runtime; unboxing.. GetType 을 통해 형 확인.

// The GetType(runtime) Method and typeof(compile time) Operator
//  theObj.GetType() == typeof(theObj)   Name, FullName

// The ToString Method  (overide 가능.)

// Object Member Listing

4. Structs [p93]

// Struct Construction Semantics [10/10]
//  인수 없는 생성자 안됨.

5. Access Modifiers [p94]

// public (assembly:file 밖에서 인식 가능), internal (assembly 내에서 오픈, non-nested type 기본값) private (class, struct 기본값) protected, protected internal

// Examples

// Friend Assemblies
//    System.Runtime.CompilerServices.InternalsVisibleTo  strong name ?

// Accessibility Capping  타잎의 접근성을 멤버도 따라간다.
//    class C { public void Foo() {} }  C 가 internal 이므로 Foo도 마찬가지.

// Restrictions on Access Modifiers  동일하게 오버라이드 해야.. 예외. protected internal => overide 는 protected 여야 함..

6. Interfaces [p96] 클래스와 비슷하지만 구현보다는 스펙을 제공.  [10/14]

//    멤버는 모두 ‘암시적 추상’ 반면 클래스는 양쪽 모두.  implicitly public …  구현하면 모두 퍼블릭.
//    클래스는 여러 인터페이스 구현 가능. 반면 상속은 한 클래스에서만. 구조체는 상속 불가.   down cast 가능.
//    member, property, event, indexer 만 포함.

// Extending an Interface :: 다른 인터페이스에서 파생 가능.

// Explicit Interface Implementation
//  두 인터페이스 멤버이름이 충돌할 때 I2.Foo(), I3.Foo() 이런식으로 구현 가능.. 리턴형은 다름. 부를려면 캐스트 해야..
//    명시적으로 멤버 이름을 구현하는 이유는 특별한 함수를 숨기거나 혼동하지 않기 위해서.  예)  ISerializable …

// Implementing Interface Members Virtually [10/15]
//    기본적으로 sealed 임.. virtual 로 해야 오버라이드 가능. 상위 클래스 / 인터페이스의 멤버를 불러도 파생된 함수가 불림.

// Reimplementing an Interface in a Subclass
/* – Alternatives to interface reimplementation
*   문제점 : 베이스 메스드를 부를 방법이 없다..  기대하지 않았던 일.  sealed .. 고려해 봐야.  */

// Interfaces and Boxing

7. Enums [p102 10/20] 이름 지어진 숫자 상수

//      기본은 정수이며 바이트도 사용 가능.  enum SomeValue : byte { n1, n2 = 3, n3 }; … 이렇게.

// Enum Conversions : (int) 로 캐스트 가능. enum 끼리 캐스팅도 가능.

// Flags Enums : 2개의 값을 갖을 수 있음.  테스트 함 해볼 것…
//[Flags]   &(and) |(or) ^ (배타적 or)  의 의미들..  1 or 2  면 3인가? ..

// Enum Operators

// Type-Safety Issues : 정수형 연산을 할 수 있다.  플래그 있는 enum validation 확인.

8. Nested Types [p105 11/3] ClassA.ClsB. …

9. Generics [p106 11/5]

상속과 제네릭을 통한 코드 재사용.
C++ template 과 유사.

Generic Types

Stack<T> : open type  정의..
Stack<int> : closed type..   구현

Why Generic Exist

object 로 할 수도 있지만.. 번거롭고, 에러 발생

Generic Methods

static void Swap(ref T a, ref T b) // 요런식..
Swap( ref x, ref y) ; // 이렇게 불리거나
Swap( ref x, ref y) ; // 이렇게 써도 됨.

제네릭 메서드에는 형을 명시하지 않아도 됨. 컴파일러가 암시적으로 형 정의.
메서드와 타잎은 타잎 인수를 도입할 수 있는 유일한 생성자.
프라퍼티, 인덱서, 이벤트, 필드 .. 은 불가. 이미 정의된 타잎을 partake 은 가능. A
비슷하게, 생성자는 기존 타잎인수에서 partake 가능, 하지만 introduce 는 불가. B

public T this [int index] { get { return data [index]; } } // generic item 리턴.  ex) A
public Stack() {  }  // 불가 ... ex) B

Declaring Type Parameters [11/6]

타잎 인수는 클래스, 스트럭, 인터페이스, 딜리깃, 메서드 에서 가능.
일반적으로 T 를 씀.

[typeof] and Unbound Generic Types

오픈 제네릭 타잎은 런타임에는 존재하지 않음 : 컴파일의 일부로 닫힌다.
[언바운드] 제네릭 타잎이 런타임에 존재하는 것은 가능… 순수히 Type 객체로… [typeof]

class A {}
Type a1 = typeof(A<>); // Unbound type
// Closed type
Type a3 = typeof(A<int, int>);

The default Generic Value

default(T) : 디폴트 값.  null / 0 …

Generic Constraints

특정 클래스, 인터페이스 등으로 제한할 때.

class GenClass<T, U> where T : SomeClass, InterfaceSome
where U : new()  // 인수 없는 생성자가 필요함. => 함수 내에서 new U(); 를 부를 수 있음.

Subclassing Generic Types

베이스 클래스를 오픈함. 또는 확정 타잎으로 할 수도 있음.

class Stack
class SomeStack : Stack
// concrete type..
class OtherStack : Stack
// fresh type
class KeyList<T,TKey> : List

Self-Referencing Generic Declarations

Static Data

정적 데이터는 각 닫힌 타잎에서 유니크하다.

class Bob { public static int Count; }
....
++Bob.Count ; 1
++Bob.Count; 1 각 타잎마다 다른 정수 참조.

Type Parameters and Conversions

C# 캐스팅
# Numeric conversion
# Reference conversion
# Boxing/unboxing conversion
# Custom conversion (via operator overloading)
무슨 변환을 할지는 연산자의 알려진 타잎에 기초하여 [컴파일] 때 일어남.
제네릭 변환시 재밌는 현상.. 정확한 형은 모르기 때문. => 모호성.. 커파일러가 에러 발생.

if (arg is StringBuilder) // 1. 레퍼런스 컨버전.
StringBul ssbb = arg as StringBul  // 2. as 연산자.. 사용
if (ssbb == null) return;
(StringBul)(object)arg ; // 3. object 로 변환 후 캐스팅.
int Foo (T x) { return (int) (object) x; }

Covariance [11/19]

정의 :: A is convertible to B 일때 ,  X 는 Covariant 하다 만약 .. X<A> is convertible to X<B>..

Classes

Bear : Animal 상속 관계에서..

public static void Wash (Stach animals) { ... } // 여기엔 Bear 를 못 넣음.
public static void Wash (Stach animals) where T : Animal { ... } // 이렇게는 가능.

Arrays

역사적으로 어레이 타잎은 ‘코베리언트’ 함. 즉,

Bear[] bears;
Animal[] animals = bears ;  // OK

Interfaces

..

public static void Wash (Stach animals) where T : Animal { ... } // 이렇게는 가능.
public static void Wash (IPoppable animals) where T : Animal { ... } // 이게 가능..

Contravariance [11/19]

X 를 X 로 컨버팅 가능하면 컨트라배리언트 .. 함.

public interface IPushable<in T> {}  // <in T> 에 유의.
// Legally do this
IPushable<Animal> animals =  new Stack<Animal>();
IPushable<Bear> bears = animals; // Legal
bears.Push(new Bear() );  // 하지만, output 할 방법이 없음.

C# Generics Versus C++ Templates

C++ 템플릿은 dlls 로 디플로이 되지 않음. 소스코드로만 존재. 컴파일 시 해당 클래스로 치환..

End ..  13 11 19

Functional Programming in C# [ Ch. 4, 5, 6 ] __ Oliver Sturm

Chap. 4. Flexible Typing with Generics [9/22]

제네릭 가능 : class, method, interface, delegate
대표적인 것 : 컨테이너 클래스.  다목적 베이스 클래스.

Generic Functions [9/22]

static void SomeThing<T> (T param) { // 함수 이름 뒤에 <타잎> 표시.
}
// Usage ..
SomeThing<int>(33);
SomeThing<string>(" The Parameter ");

<타잎> 변수 생략 가능 : 컴파일러 추론.

Generic Classes

..

Constraining Types 제한.

static void OutputVal<T> ( T value ) where T : ListItem<string> {}   // ListItem<string> 에서 파생되어야..

Other Generic Types

// Delegate
public delegate Rt SomeDelegate<T, Rt> (T param);  // Func<T, Rt> 와 같은 기능..
// Func
public delegate TResult Func<T1, T2, T3, T4, TResule> (T1 p1, T2 p2, T3 p3, T4 pr);
// 대부분의 추상 함수에 사용 가능.  4개 인수와 1개 리턴 값.
// Action 은 리턴 값이 없는 함수에 사용 가능.

Covariance and Contra variance

object[] objList = new object[3];
objList[2] = 10;
string[] strArr = new string[] { "one", "two", "thr" };
objList = strArr; // 이런 할당을 허용할 것인가..
// 좀 더 복잡한..
objList[2] = 10; // Runtime exception .. 어레이가 스트링 형이므로..
int[] intArr = new .... ;
objList = intArr; // intArr 는 밸류타입임.. 이 경우 covariance 는 레퍼런스 타잎만 지원

Variance 는 언어를 더 직관적으로 기능하게 하는 요소다.

List<object> objLst = new ...;
List<string> strLst = new ...;
objLst = strLst; // 허용 안됨.
// IEnumerable<T> 의 예.
public interface IEnumerable<out T> : IEnumerable { }  // retrieved from methods 에서 사용 가능. not passed into them.
IEnumeralbe<object> objSeq = new .. ;
IEnumeralbe<string> strSeq = new .. ;
objSeq = strSeq; // 가능.

4.0 에서 in, out 제레릭에서 사용 가능. 데이터 흐름의 방향을 제어 가능.

Chap. 5. Lazy Listing with Iterators

데이터를 효율적으로 다루기.

The Meaning of Laziness [9/23]

Linq 도 이같은 원리에 근거.

Enumerating Things with .NET

IEnumerable 인터페이스.
MoveNext(), Current(), Reset() …

Implementing Iterator Functions [9/24]

C# 2.0에서 도입된 IEnumerable / IEnumerator 조합을 이용. 제네릭, 넌제네릭 모두 가능.
특별한 형태의 리턴.  yield return 문.  Laziness ..  p49 코드를 볼 것.
리스트를 다 채우는 것이 아니라… 필요할 때 가져온다.. (미리 할 필요가 없다. 중간에 멈추면 후속 값 계산을 안 한다.).

Returning IEnumerator [9/29]

IEnumerable, IEnumerator ..

Chanining Iterators

.. laziness ..

.

Chap. 6. Encapsulating Data in Closures

Scope문제 Closure를 이용 해결.

Constructing Functions Dynamically [9/30]

C# 1.0 : ~ = C ..
delegate, event  : multicast
C# 2.0 : 무명함수.  함수를 만들어서 외부 스코프에 리턴하는 것은 이득이 많음.

The Problem with Scope

엄격한 스코프.
함수 플글에선 변하는 값을 별로 안 좋아함. 가이드 라인은 : { 변하는 값을 전혀 갖지 않음 }
가장 좁은 스코프 안에 집어 넣는 것.
순수 함수는 로컬 변수만 이용. 외부 참조 없음.   => 첫 반응은 incredulity.. 회의..
전역 변수가 않 좋은 이유 : 특정 시점에 어떤 값을 갖을 지 알 수 없음. ..
클래스 멤버는 좁은 스코프.
초기화 과정에서 나중에 쓰일 변수가 있다면 ?  클로져를 이용하는 대안..

How Closures Work

함수를 리턴하는 경우.. 그 안에 로컬 변수..  리턴 된 후 그 함수를 실행시키면 크래쉬. => 컴파일러가 그 값을 보관.
컴파일러는 무명 클래스를 생성하고 인스턴스 생성해서 그 함수를 부른 함수 내부에 둔다.
무명함수는 그 무명 클래스 내부의 함수로 생성. 그 콜러가 지속할 때까지 살아 있는다.  로컬 변수는 무명클래스의 필드로 된 것.
동적 함수는 객체 지향의 메서드 오버로딩과 유사. 하지만, 동적으로 생성됨.

Functional Programming in C# [ Ch. 1, 2, 3 ] __ Oliver Sturm

Chap. 1. A Look at Functional Programming History

What is Functional Programming ?

함수형 언어에서 Referential transparency 는 중요한 개념.  리턴 값이 입력 값에만 의존.
명령형 (imperative) 프로그래밍 과 대조.
함수형 언어 패러다임을 따르는 언어 : recursion 등 .. 을 쓰느냐..
-> 재귀 함수에서 스택에 위치해서 오버플로 하는 언어..  는 재귀를 쓰지 말아야.
고차 함수 : 함수를 인자로 받거나 리턴하는.
C에서는 무명 함수가 없다.
함수형 언어는 컴퓨터에서 문제를 푸는 방법을 알려주는 것. 일의 순서를 나열하는 것 보다는.. referential transparancy 는 이런 의미..

Functional Languages

Haskell, Erlang, Clojure.

The relationship to OOP

C#, F# .. albeit .

Chap. 2. Putting Functional Programming into a Modern Context

Concurrency Programming 에 의한 함수형 패턴 필요성.
Pararrel.foreach ..

Managing Side effects

Agile Programming Methodologies

함수 차원에서의 모듈화. 세분화된 작업을 할 때의 리팩토링. 클래스 차원에서는 너무 작업이 크다. ?

Declarative Programming

Funtional Programming is a Mindset

Is Functional Programming in C# A Good Idea?

Chap. 3. Functions, Delegates, & Lamda Expressions

Functions and Methods

C# 은 클래스 외에서의 함수는 인정 안함. => Methods 라 불림.

Reusing Functions

Anonymous Functions and Lambda Expressions

[sorting ] 비교 함수. 예.
[custom delegate ]

Func<object, object, bool> compareInt4 =
    (a, b) => ((int) a) > ((int) b);
Func<int, int, int> add = (x, y) => x + y;

람다 함수에서 var 사용 불가. 선언 시 타잎 추론 가능해야 함

Extension Methods [9/19]

Generic 도 가능.

Referential Transparency [9/21]

명령형 프로그램을 말할 때 대부분 ‘상태’ 에 관한 것이다.
명령형 프로그램의 주된 이슈중 하나는 코드가 점점 커진다는 점.
실행 순서에 촛점을 맞추므로 함수/메서드가 참조하기에 불투명해지는 경향이 있다. 같은 인수를 넣어도 동일한 결과가 나온다는 보장이 없다.
함수에서 사용하는 변수들이 여러 영역 (글로벌 .. )에서 가졍오기 때문.
RT 는 이와 반대. 이 단어는 어느 식에나 적용 가능하고, 프로그램을 바꾸지 않고 식이 값으로 바뀌어도 된다는 것.
수학에서 식은 항상 RT 하다. 즉, 3 + 2 는 5로 치환 가능하다.
어떤 함수는 RT 가 불가능. DateTime.Now, ReadByte 같은 것들. 특히 void 를 리턴하는 것들은 식으로 쓰일 수 없고, 참조적으로 불투명하다.
함수형 프로그램의 가장 중요한 컨셉중의 하나는 함수 구현에서 부작용을 피하는 것.
이것은 RT 와 매우 밀접한 관계이다. 순수한 함수는 인수로부터만 결과값을 만들어 부작용이 전혀 없는 것.
함수는 다른 함수를 부르거나 자신의 스코프 밖의 값을 사용할 수도 있다. PI 를 사용하는 예.

The general description of pure functions and side effects leaves out the perspective of the call site, from which a pure function can also be defined by saying that a call into a pure function is expected to be referentially transparent. 이 말이 정확하지는 않더라도  ..
순수한 함수를 쓰려면 인수만을 사용하고 끝에 리턴값을 리턴하라.  외부 변수에 접근하려면 그 일을 하는 다른 순수한 함수를 부르고.
실제 데이터요소에 접근하려면 그것이 상수 임을 확실히 하라. 이 조건에 맞지 않으면 부작용이다.
어떤 언어는 문법이 이를 불가능하게 함. 스크린에 뭘 출력하고 파일에 쓰는 것 들은 이 관점에서 모두 부작용임.

결과적으로 부작용을 피하는 것보다 더 중요한 것이 있다 : 부작용을 관리하는 것.  언어에 따라 이것이 쉽기도, 어렵기도.
순수한 함수를 쓰는 순수한 언어에서는 이를 회피하는 방법이 있다. 하스켈에서는 모나드가 이것을 가능하게 한다.
C#은 특별한 게 없다.  단지 아키텍쳐적인, 구조적인 문제일 뿐.

순수함수.. 마지막 말.
이렇게 코딩을 하면, 실행 순서, 함수가 불리는 순서는 중요하지 않다는 것.
개발자는 어떻게 함수들이 의존성의 네트웤을 형성하는 지 정의한다. 컴파일러가 최적의 실행을 한다.
이것은 최적화가 가능하게 하고, 중복된 코드는 자동제거될 수 있고, 캐시 적용가능하고, 로직파트는 병렬처리가 가능하다.
이런 가능성 리스트는 무한하고 많은 순수함수 환경은 이런 접근을 자동화한다.
충분한 이론-챕터가 나중에 이런 것들의 장점과 확장된 아이디어를 보여줄 것임.

닷넷 4.0 에서 code contracts 개념 도입.
PureAttribute.

C# in Depth. Jon Skeet. ch. 1

Dynamic languages suck away fluff from your code, leaving just the essence … Right..

The interesting thing is that few of the features that tend to give dynamic lan- guages their lightweight feel have anything to do with being dynamic.

Statically typed languages don’t have to be clumsy and heavyweight.

C# 1 : Java 와 비슷.  추가적인 것 :: properties as a first-class feature in the language, delegates and events, foreach loops, using statements, explicit method overriding, operator overloading, and custom value types, to name a few

1.1 Starting with a simple data type

목적 :: impress rather than educate

1.1.1 The Product type in C# 1

using System.Collections;
public class Product
{

   string name;
   public string Name { get { return name; } } // getter 가 필요하면 정의해야 함 .. fluff ..

   decimal price;
   public decimal Price { get { return price; } }

   public Product(string name, decimal price)
   {
      this.name = name;
      this.price = price;
   }

   public static ArrayList GetSampleProducts()
   {
      ArrayList list = new ArrayList(); // 뭐가 들어가는 지 모른다.
      list.Add(new Product("West Side Story", 9.99m));
      list.Add(new Product("Assassins", 14.99m));
      list.Add(new Product("Frogs", 13.99m));
      list.Add(new Product("Sweeney Todd", 10.99m));
      return list;</pre>
}
public override string ToString()
 {
 return string.Format("{0}: {1}", name, price);
 }
}

1.1.2 Strongly typed collections in C# 2  __ generic ..

public class Product
{
   string name;
   public string Name
   {
      get { return name; }
      private set { name = value; } // ***
}
decimal price;
public decimal Price
{
      get { return price; }
      private set { price = value; }</pre>
}
public Product(string name, decimal price)
{
 Name = name;
 Price = price;
}

public static List GetSampleProducts() {
 List list = new List();
 // type 명시.. 리스트에서 가져올 때 캐스팅 필요 없음.
 list.Add(new Product("West Side Story", 9.99m));
 list.Add(new Product("Assassins", 14.99m));
 list.Add(new Product("Frogs", 13.99m));
 list.Add(new Product("Sweeney Todd", 10.99m));
 return list;
}
public override string ToString()
{
 return string.Format("{0}: {1}", name, price);
}
}

1.1.3 Automatically implemented properties in C# 3

using System.Collections.Generic;
class Product
{
  public string Name { get; private set; } // 코드, 변수도 없다. Name 은 함수명.
  public decimal Price { get; private set; }
  public Product(string name, decimal price)
  {
    Name = name;
    Price = price;
  }
  Product() {}
  public static List GetSampleProducts()
  {
    return new List
    {
      new Product { Name="West Side Story", Price = 9.99m },
      new Product { Name="Assassins", Price=14.99m },
      new Product { Name="Frogs", Price=13.99m },
      new Product { Name="Sweeney Todd", Price=10.99m}</pre>
 };
 }
 public override string ToString()
 {
 return string.Format("{0}: {1}", Name, Price); }
 }
}

1.1.4 Named arguments in C# 4

readonly decimal price;
public decimal Price { get { return price; } }
public Product(string name, decimal price)
{
  this.name = name;
  this.price = price;
}
new Product(name: "West Side Story", price: 9.99m);  // 이렇게 인수 이름을 붙여 초기화.

1.2 Sorting and filtering

1.2.1 Sorting products by name

ArrayList products = Product.GetSampleProducts(); // C# 1</pre>
List products = Product.GetSampleProducts(); // C# 2
List products = Product.GetSampleProducts(); // C# 3
products.Sort(delegate(Product x, Product y)
 { return x.Name.CompareTo(y.Name); }
);

1.2.2 Querying collections

List products = Product.GetSampleProducts();
Predicate test = delegate(Product p) { return p.Price > 10m; };
Listmatches = products.FindAll(test);
Action print = Console.WriteLine;  // method group conversion (C# 2)
matches.ForEach(print);
// Differently ...
List products = Product.GetSampleProducts();
products.FindAll(delegate(Product p) { return p.Price > 10;}) .ForEach(Console.WriteLine);  // 노이지 하다. { } 딜리깃.
// C# 3
List products = Product.GetSampleProducts();
foreach (Product product in products.Where(p => p.price > 10)) {
  Console.WriteLine(product);
}

1.3 Handling an absence of data

1.3.1 Representing an unknown price

Nullable
decimal? price;
public decimal? Price
{
  get { return price; }
  private set { prie = value; }
}
..
Price == null // 조건식..

1.3.2 Optional parameters and default values

public Product(string name, decimal? price = null)
{
  this.name = name;
  this.price = price;
}

1.4 Introducing LINQ

C# 3..

1.4.1 Query expressions and in-process queries

List products = Product.GetSampleProducts();
List suppliers = Supplier.GetSampleSuppliers();
var filtered = from p in products
               join s in suppliers
                   on p.SupplierID equals s.SupplierID
               where p.Price > 10
               orderby s.Name, p.Name
               select new { SupplierName = s.Name, ProductName = p.Name };
foreach (var v in filtered)
{
    Console.WriteLine("Supplier={0}; Product={1}",
                 v.SupplierName, v.ProductName);
}

1.4.2 Querying XML

1.4.3 LINQ to SQL

..

1.5 COM and dynamic typing

c# 4 : Com, DLR (Dynamic Language Runtime)

1.5.1 Simplifying COM interoperability

1.5.2 Interoperating with a dynamic language

ScriptEngine engine = Python.CreateEngine();
ScriptScope scope = engine.ExecuteFile("FindProducts.py");
dynamic products = scope.GetVariable("products");
foreach (dynamic product in products)
{
  Console.WriteLine("{0}: {1}", product.ProductName, product.Price);
  // 여기서 에러가 날지도 모르지만.. 어떻게든 진행함.
}

1.6 Dissecting the .NET platform

1.6.1 C#, the language

IL -> JIT compiler.

1.6.2 Runtime

런타임 부분은 IL 의 작은 부분..  CLI : Common Language Infrastructure, CLI 의 런타임은 CLR ( ~~ ~~ 런타임) 으로 불림..  이 책에서는 마소 의 구현을 가리킴.
언어의 일부는 런타임 레벨에 보이지 않지만, 다른 것들은 구분을 넘는다.  … 어레이와 딜리깃은 런타임에 중요.

1.6.3 Framework libraries

 

__