VB.NET2013.12.18 11:10

Transaction Support(트랜잭션 지원)

트랜잭션 지원이란 분산 트랜잭션에서 호출자(Caller) 와 피 호출자(Callee) 사이의 데이터 무결성을 위해 트랜잭션 (참여) 범위지정 방식이다. MSDTC 서비스는 OLE 트랜잭션 이라 불리는 COM 기반의 트랜잭션 스펙이 기본이지만 XA 트랜잭션, TIP(Transaction Internet Protocol) 를 지원한다.

l  Disabled(사용안함)*
일반적으로 COM 으로 만들어진 컴포넌트를 COM+ 로 등록할 때 설정하는 옵션이며 트랜잭션을 사용하지 않는다는 의미(로컬 트랜잭션으로 동작)

l  Not Supported(지원하지 않음)
트랜잭션에 참여하지 않는다는 의미, 호출자가 트랜잭션이 있더라도 참여하지 않고 단순 실행(로그, 상태정보 처리기에 사용)(로컬 트랜잭션으로 동작)

l  Supported(지원함)
호출자(Caller)가 트랜잭션이 있다면 그 트랜잭션에 참여하지만 호출자가 트랜잭션이 없다면 단순 실행

l  Required(필수)
호출자(Caller)가 트랜잭션이 없어도 피호출자(Callee) 가 트랜잭션을 생성하여 트랜잭션 처리

l  Required New(새 트랜잭션 필요)*
호출자(Caller)가 트랜잭션이 있든 없든 새로운 트랜잭션을 생성하여 처리

 

* ) 의 경우 사용 시 주의

 

Transaction Isolation Levels(트랜잭션 격리 수준)

트랜잭션 격리 수준에서 주의해야 할 점은 다음과 같다. 피 호출자(Callee)는 호출자(Caller)의 격리수준과 동일하거나 낮아야 합니다. 피 호출자의 격리 수준이 높을 경우 오류가 발생합니다. 오라클인 경우 Read Committed, Serializable 만 지원함에 유의.

l  Serialized(연속됨)
COM+
를 등록하면 Default 로 설정이 되는 값. 하나의 트랜잭션이 데이터를 읽을 때 다른 모든 트랜잭션은 이전 트랜잭션이 끝날 때 까지 읽기, 쓰기 모두 할 수 없고 대기 해야 하는 상태. 또한 인덱스의 범위에 대해 잠금을 수행하기 때문에 잘못된 쿼리인 경우 전체 테이블 스캔이 발생하므로 유의

l  Repeatable read(반복할 수 있는 읽기)
하나의 트랜잭션이 읽는 동안 다른 트랜잭션이 변경(update) 을 할 수 없도록 잠그는 상태, 단 추가(insert) 는 가능

l  Read committed(커밋된 읽기)
다른 트랜잭션이 수정하는 동안 읽지 못하는 상태

l  Read uncommitted(커밋되지 않은 읽기)
다른 트랜잭션이 수정하는 동안에도 읽을 수 있는 상태

l  Any(모두)
호출자(Caller) 가 어떤 트랜잭션 격리 수준이든 충돌을 피하기 위해 적용되는 상태, 호출자의 격리수준과 동일하거나 낮게 설정되는 상태(항상 피 호출자인 경우는 이 옵션이 적절함)

 

[참고]

Transactions and Isolation Levels in COM+

COM+ and MTS Always Use SERIALIZABLE Transaction Isolation Level

Configuring Transactions

Configuring Transaction Isolation Levels

About COM+ Transaction Isolation Level

COM+ 트랜잭션과 오라클 OraMTS 실체

Understanding XA Transactions

 

저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2012.02.24 18:20
갑자기 닷넷프레임워크가 무었인지 되짚어보기로 했습니다.

.Net Framework 가 발표된 초기 문서인 Microsoft .Net Framework 제품개요 입니다. (http://www.microsoft.com/Korea/MSDN/netframework/technologyinfo/overview/ )

뭔가 복잡하고 어렵게 설명이 되어 있습니다. 그중에 제일 이상한 부분은 이처럼 JAVA와 비교해서 엄청 나은 성능이다 라는 부분입니다. 
Sun에서 제공하는 Java Pet Store의 .NET 기반 구현인 .NET Pet Shop에서 성능은 J2EE 버전보다 28배나 높고 지원되는 동시 사용자 수는 6배나 많으며 CPU 사용률은 1/6밖에 되지 않습니다. 
물론 당시에는 그럴수 있었겠죠. 예전에 자바 문제가 많았죠.. 하지만 이러한 문장은 처음 닷넷프레임워크를 접하는 사람들에게 혼동을 줄수 있을것 같네요. 

현재는 닷넷이나 자바나 둘다 랭귀지의 성숙도가 높아져서 속도차이는 비슷하지 않을까요? 물론 언어마다 특정 기능부분에서 우위가 있긴 합니다만, 전체적으로 몇배가 더 빠르다고 할수는 없을것 같습니다.  

그럼 정의와 정리를 해보겠습니다.
 

위키에는 다음처럼 정의하고 있습니다.
닷넷 프레임워크(.NET Framework)는 마이크로소프트에서 개발한 윈도 프로그램 개발 및 실행 환경이다. 네트워크 작업, 인터페이스 등의 많은 작업을 캡슐화하였고, 공통 언어 런타임(Common Language Runtime)(CLR)이라는 이름의 가상 머신 위에서 작동한다.
아... 그래도 어렵습니다.

도대체 닷넷 프레임워크가 뭘까요? 쉽게 말하면 프로그램이 돌아가도록 지원해주는 뼈대 역할을 해 주는것 이라고 보면 됩니다. 소프트웨어 프레임워크는 복잡한 문제를 해결하거나 서술하는데 사용되는 기본 개념 구조입니다. 뼈대, 골조, 프레임워크 라고 하는데, 이러한 범위가 폭넓은 용어를 특정 무엇으로 지칭하는 버즈워드(buzzword) = 유행어 라고도 할수 있습니다.




닷넷프레임워크는 빌드, 배포, 웹서비스, 웹어플리케이션 등이 동작하게 하는 공통 환경입니다. 그리고 BCL(Base Class Library)를 포함하고 있는데, 이 클래스 라이브러리는 파일을 제어 하거나 데이터베이스에 접근하거나 네트워크를 제어 할수 있는 기능이 포함되어 있습니다.


위 그림은 1.1 버전의 BCL 입니다. 웹, 윈폼, 데이터, XML 등 다양한 라이브러리들이 존재 합니다. 이러한 기능들이 닷넷 프레임워크에 새롭게 나타난게 아니라 기존 Win32 API 들을 닷넷에 맞게 재구성 했다고 보시면 됩니다. 닷넷 이전에도 DB 관련 프로그램을 VB나 C++ 로 만들었죠. C++의 MFC도 어떻게 보면 BCL이라고도 할수 있겠네요.

대부분의 기능들이 이미 클래스로 만들어져 있어서 개발자는 해당 클래스 라이브러리를 사용하면 되는것입니다. 간편하죠? 하지만 좀 다른 UI나 기능을 구현하려면 직접 구현을 해야 하는데 보통 3rd Party 제품을 많이 사용하죠. 실제로 개발자가 자료구조와 알고리즘을 직접 만들어서 개발하는 경우는 드뭅니다. JAVA도 마찬가지 입니다. 대부분 클래스를 가져다 쓰지요, 하지만 닷넷 프레임워크보다 추상클래스가 많아서 직접 구현해야 하는 경우가 많습니다.

그럼 여기서 잠깐 이 문제를 짚어보겠습니다. 왜 한국 IT는 자바가 판을 칠까?
지극히 개인적인 생각입니다만, 지금은 아니지만 예전(10년전)에는 닷넷에 기본적으로 제공되는 클래스 라이브러리가 자바에 없지만 개발자가 직접 구현하기에 어려움이 없었고, 있다고 하더라도 오픈 마인드가 강한 자바 개발자들 끼리 서로 클래스를 공유하면서 자바의 부족한 부분을 채웠고 MS 제품은 비싸다는 인식이 강해서 납품 받는 기업입장에서는 입찰방식이라 납품하는 업체는 단가가 낮은 자바로 밀어 넣지 않았을까? 하는 생각입니다. 자바개발자분들 고생 많이 하셨습니다. (__)
이런 생태속에서 자연스럽게 자바쪽은 오픈소스 프로젝트가 성장하고, 닷넷쪽은 자체 기술력만으로 버텨왔던것 같습니다.


정리 하자면 .Net Framework 구조는 다음과 같습니다.

공통 언어 기반(Common Language Infrastructure)
CLI를 둔 목적은 compile-time과 run-time에 언어에 종속적이지 않은 플랫폼을 제공하기 위해서입니다. 예외처리, 가비지 콜렉션, 보안 등을 위한 소프트웨어 컴퍼넌트를 포함하고, CLI 가 구현된것이 CLR 입니다.


공통 언어 런타임(Common Language Runtime)
소스코드를 컴파일 하면 어셈블리가 되는데, 이 어셈블리가 CLR 위에서 동작합니다. 즉, CLR에 의해 관리되어 지는것이죠. CLR은 다음과 같은 구성요소가 있습니다.

 - 공통 타입 시스템(Common Type System)
 - 공통 언어  스펙(Common Language Specification)
 - JIT 컴파일러(Just-In-Time Compiler)
 - 가상 실행 시스템(Virtual Execution System)   


... 내용이 길어 조금씩 수정하고 있습니다.(현재 2012-03-07 두번 업데이트 하였습니다.)

혹시 위 글에 오류가 있으면 알려주시면 수정하도록 하겠습니다.



 
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2011.09.08 16:43

iBatis.net은 log4net 으로 로그를 내보냅니다. web.config에 로그 설정을 해 두고, 파일로 로그를 남길수 있는데, 실시간으로 로그를 확인하기가 쉽지 않습니다. Visual Studio의 콘솔창을 통해서 내보낼수도 있는데, 다양한 로그를 설정해 두면 원하는 부분만을 찾아서 보기가 어렵습니다. 이때 로그를 파일로 저장하는 방식으로 설정을 해 두고, 그 로그파일을 baretail 이라는 무료 어플로 보면 쉽습니다.

http://www.baremetalsoft.com/baretail/

web.config의 로그파일 설정 방법은 (http://funnygangstar.tistory.com/entry/iBatisNet-%EB%A1%9C%EA%B9%85) 참고

BareTail Screenshot



저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2011.09.08 16:42
iBatis.net 에서 쿼리 호출을 할때 Mapper.Instance().QueryForList(), Mapper.Instance().QueryForObject() 로 호출을 합니다.

일반적인 예제에는 파라메타 하나 혹은 두개정도로 많이 표현하는데요, 실제 업무에 사용되는 SP는 파라메타가 적게는 한개 부터 많게는 10개 이상도 있을수 있습니다.

이 파라메타를 전달하기가 쉽지 않은데요, 아래 함수로 만들어서 넘기면 보다 쉽게 처리할수 있습니다.

호출 방식은 ...QueryForList("sp명", MakeMappedParams(new { seq = seq, ty_cd = ty_cd, sort_cd = sort_cd }));

이렇게 됩니다. 그러면 앞에서 설명한 DAO 패턴으로 봤을때 실제 DAO객체에서 생성될 함수(다양한 파마메타)에 맞게 원하는 파라메타를 넘기면 됩니다.

        public Hashtable MakeMappedParams(object objParams)
        {
            Hashtable htResult = new Hashtable();
 
            Type t = objParams.GetType();
            foreach (PropertyInfo info in t.GetProperties())
            {
                htResult.Add(info.Name, (info.GetValue(objParams, null) == null ? "" : info.GetValue(objParams, null).ToString()));
            }
            return htResult;
        }
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2011.09.08 16:41

iBatis.net 에서 데이터 반환할때 QueryForObject, QueryForList 두가지 방식으로 반환을 하게 되는데, 보통 MSSQL SP 로 만들어진 비지니스 로직은 다중 결과셋을 반환할때가 많습니다.

아래 클래스는 제가 만들어본 클래스 입니다. 언어가 C# 이죠? ^^;

사용법은 다음과 같습니다.

IList resultset = (IList)Mapper.Instance().QueryForList(...)
ListSmart result = (ListSmart)(ArrayList)resultset; 
으로 캐스팅을 하게 되면 다중 결과셋이 같은 형식의 클래스로 묶입니다.
    /// <summary>
    /// iBatis 에서 반환된 1차원 리스트를 같은 데이터 타입끼리 묶어서 2차원 리스트로 반환(캐스팅 사용)
    /// </summary>
    public class ListSmart : IListICollection
    {
        internal List<object> Items = null;
 
        //리스트 갯수 반환
        public int Count { getset; }
        public string Test { getset; }
        public ListSmart(IList currentList)
        {
            Items = new List<object>();
            List<object> subList = null;
            Type oldType = null;
 
            foreach (object o in currentList)
            {
                Type t = o.GetType();
                if (t.Name != "Int32" && t.Name != "String"//숫자, 문자형 이외 추가될 타입은 여기에 추가
                {
                    if (oldType != t)
                    {
                        if (subList != null)
                        {
                            Items.Add(subList);
                            subList = null;
                        }
                        oldType = t;
                        subList = new List<object>();
                        subList.Add(o);
                    }
                    else
                    {
                        if (subList.Count > 0)
                        {
                            subList.Add(o);
                        }
                        else
                        {
                            Items.Add(o);
                        }
                    }
                }
                else
                {
                    Items.Add(o);
                }
 
            }
 
            if (subList != null && subList.Count > 0) Items.Add(subList);
 
            this.Count = Items.Count;
 
        }
       
        public static explicit operator ListSmart(List<object> obj)
        {
            return new ListSmart(obj);
        }
 
 
        public static explicit operator ListSmart(ArrayList obj)
        {
            List<object> lstResult = new List<object>();
 
            foreach (object o in obj)
            {
                lstResult.Add(o);
            }
 
            return new ListSmart(lstResult);
        }
 
 
        #region IList 멤버
 
        public int Add(object value)
        {
            this.Items.Add(value);
            return this.Count;
        }
 
        public void Clear()
        {
            this.Items.Clear();
        }
 
        public bool Contains(object value)
        {
            return this.Items.Contains(value);
        }
 
        public int IndexOf(object value)
        {
            return this.Items.IndexOf(value);
        }
 
        public void Insert(int index, object value)
        {
            this.Items.Insert(index, value);
        }
 
        public bool IsFixedSize
        {
            get { return false; }
        }
 
        public bool IsReadOnly
        {
            get { return false; }
        }
 
        public void Remove(object value)
        {
            this.Items.Remove(value);
        }
 
        public void RemoveAt(int index)
        {
            this.Items.RemoveAt(index);
        }
 
        public object this[int index]
        {
            get
            {
                return this.Items[index];
            }
            set
            {
                this.Items[index] = value;
            }
        }
 
        #endregion
 
        #region ICollection 멤버
 
        public void CopyTo(Array array, int index)
        {
            throw new NotImplementedException();
        }
 
        public bool IsSynchronized
        {
            get { throw new NotImplementedException(); }
        }
 
        public object SyncRoot
        {
            get { throw new NotImplementedException(); }
        }
 
        #endregion
 
        #region IEnumerable 멤버
 
        public IEnumerator GetEnumerator()
        {
            return (IEnumerator)this;
        }
 
        #endregion
    }
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2011.09.08 16:39


DAO 패턴이란 Data Access Object 를 Factory 패턴화 시키는것으로써, 비즈니스 로직을 컴퍼넌트화 하기 좋은 방법입니다.

위키피디아의 정의에 따르면, DAO (Data Access Objects)는 객체 지향적 설계 패턴의 일종입니다. DAO는 어플리케이션에 대하여 하나 이상의 데이터 저장 장치 혹은 관련 소프트웨어에 대한 공통적인 인터페이스를 제공하는 컴포넌트를 의미합니다.

즉, 애플리케이션에 대해서는 일관성 있는 데이터 접근을 확보해주는 것이지요.

DAO를 활용하면 물리적인 저장 장치가 파일에서 관계형 데이터페이스로 변화하더라도 애플리케이션이 영향을 덜 받도록 해줍니다. 물리적인 저장은 모두 관계형 데이터베이스를 활용하는 경우에도 제품의 종류나 데이터 접근 오퍼레이션(CRUD 작업)을 돕는 솔루션을 활용에 따라서 실제 구현은 많이 달라지게 됩니다. DAO와 같은 공통적인 접근 인터페이스를 두지 않는다면, RDBMS 제품이나 활용 솔루션에 변화가 생길 때마다 애플리케이션에도 변경이 필요하게 되니 주의 하여야 합니다.

DAO 패턴에서는 크게 네가지 레이어로 나누게 됩니다.

BusinessObject
BusinessObject 객체는 데이터를 요구하는 클라이언트를 나타낸다. BusinessObject 객체는 데이터 원본에 접근하여 데이터를 얻거나 저장하기를 요구합니다. 일반적으로 서비스 레이어의 객체로 구현하거나, 도메인 객체로 구현합니다.

DataAccessObject
DataAccessObject 객체는 DAO 패턴의 핵심이라고 할수 있습니다. 기반을 이루는 데이터 접근 구현을 추상화시켜서  BusinessObject 객체가 구체적인 데이터 원본을 고려하지 않고도 접근할 수 있게 합니다. 또한, BusinessObject 객체는 DataAccessObject 객체에게 데이터의 로딩 및 저장을 위임할수 있습니다.

DataSource
데이터 원본에 대한 구현을 나타냅니다. 데이터 원본은 RDBMS, OODBMS, XML 저장소, 일반 파일 시스템 등의 데이터베이스입니다.

TransferObject
데이터를 운반하는 객체를 말합니다. DTO 라고도 합니다. DataAccessObject 객체는 BusinessObject 객체에게 데이터를 전달하거나 수정을 위해 데이터를 받기 위해 TransferObject 객체를 사용합니다. 서비스 레이어 중심으로 구현을 하는 경우는 대부분의 도메인 객체가 TransferObject 역할을 합니다.

아래 다이어그램은 Core J2EE 패턴 카다로그(http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html) 에서 가져왔습니다. 다이어그램을 보시면 흐름을 알기 쉬울것 같습니다.



사실 DAO 패턴이라는건 JAVA 쪽에서 개념이 정립되었습니다.
MS쪽에서는 CBD 개발 방법론이라고 하죠. 사실 CBD와 비슷하면서도 다른게 DAO 패턴입니다.

저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2010.10.20 16:22

RTOS 에서 반드시 필요한 프로세스 우선순위 프로그래밍 중 기본이 되는 부분입니다.

보통 긴 시간을 요구하는 배치성 프로그램일 경우에는 우선순위를 가장 낮게 해서 CPU에 부하를 안주게 되지만, 크리티컬한 프로그램인 경우는 우선순위를 조절할 필요성이 있습니다.

단, 주의해야 할점은 가능하면 이 부분은 손대지 않는점이 좋습니다.

이에 관련해 포스팅을 하는 이유는 이런 방법도 있다는걸 알려드리고자 포스팅을 하게 되었습니다.

우선 작업관리자를 실행해서 실행중인 프로세스에 오른쪽 클릭 해서 우선순위 설정을 눌러보면 다음처럼 우선순위가 나옵니다.


이러한 우선순위를 런타임 시작시에 미리 설정하는 방법은 다음과 같습니다.

우선 윈도우 폼 어플리케이션 프로젝트를 생성하고, Form1.Designer.vb 에서 InitializeComponent() 메서드에 형광펜으로 칠한 부분을 넣어보시고,

빌드 후 프로젝트 위치/bin/Debug 위치에 생성된 exe 를 실행해 보면 다음처럼 우선순위가 조정되어 있는걸 알수 있습니다.


폼에서 이러한 방식을 토대로, 클래스 생성할때에도 우선순위를 줄수 있습니다.
한번 해 보시지요!!


저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2010.01.19 18:55
얼마전 유명한 IT 컨설턴트이신 안재우 수석 님의 블로그(http://blog.naver.com/saltynut/120097740266)에서 VB의 성능이 떨어진다고 하시는것같은 느낌을 받아서 댓글을 달았습니다만 더 자세히 알아보니 다른부분이 좀 있긴 했습니다.

Dynamic 과 LateBinding 이 다른 레벨이라고 안수석님이 설명하셨듯이 다른 레벨이 맞습니다. LateBinding 이 Dynamic 에 포함된 부분이죠.

그러면, 제가 의아해 했던 부분인 DataType을 Object 형으로 선언 했을때와 하지 않았을때의 결과는 완전히 다르게 나타납니다.

Sub Main()

    Dim factory As PersonFactory = New PersonFactory()
    Dim person As Object = factory.Create("moonhyuk")
    person.Greeting()

End Sub


'------------------- or ----------------------

Sub Main()

    Dim factory As PersonFactory = New PersonFactory()
    Dim person = factory.Create("moonhyuk")
    person.Greeting()

End Sub

위처럼 두가지 방법으로 다이나믹 코드를 작성 할수가 있는데요,  DataType을 Object로 선언을 한 부분은 컴파일 후 리팩터를 통해서 보면 다음처럼 변환이 되어 있습니다.

NewLateBinding.LateCall(RuntimeHelpers.GetObjectValue(factory.Create("moonhyuk")), Nothing, _
"Gretting", New Object(0-1){}, Nothing, Nothing, Nothing, True)


두번째, DataType를 선언 하지 않은 전통적 방법의 Dynamic 선언은

factory.Create("moonhyuk").Gretting

처럼 깔끔하게 바뀌게 됩니다.


이에 대해 VB-Insiders 에 문의 한 결과 VB.NET Spec lead 인 Lucian Wischik 에게 다음과 같은 답변이 왔습니다.

Sub f(Byval p as Person)
    p.Greeting()
End Sub
이 경우는 Greeting 메서드에 정적 바인딩이 되고, 컴파일러가 정확히 Greeting 메서드를 알고 있기 때문에 Early Binding이 되어 버립니다.
이말은 컴파일시에 바인딩이 되므로, Dynamic 이라 하기가 어렵다는것이죠. ㅡㅡ;


그러면, 두번째 경우인

Sub f(Byval p as Object)
    p.Greeting()
End Sub

이 경우가 다이나믹 바인딩이 되는것인데, 이때 System.Dynamic.IDynamicObjectProvider (다른말로 DLR 객체) 가 Greeting 이라는 메서드를 Invoke 합니다. 메서드 호출에 실패하면 COM 리플렉션을 통해 p 를 COM 이라고 생각하고 또다시 찾습니다. 그래도 실패하면 System.Reflection 의 look up 을 통해 Greeting 이라는 메서드를 찾습니다.

이 과정이 Microsoft.VisualBasic.dll의 NewLatebinding.LateCall 에 의해 처리가 됩니다.

Late Binding 또는 Dynamic Binding 을 할때 DLR call-site 인스턴스를 생성하게 되고, 다시 호출할때는 call-site를 참조를 합니다만, 아쉽게도 C#의 경우는 call-site cache 영역이 있지만, VB.NET 에는 cache 영역이 없습니다. ㅡㅡ;
이 부분 때문에 속도 차이가 이렇게 많이 나는 것 입니다. 이 부분은 인정 하지 않을수가 없습니다.

Late Binding 혹은 Dynamic Binding 은 성능에 우선을 두는게 아니라 유연함과 접근성에 중점을 두는것인데, 성능 비교를 한다는것 자체가 아이러니 합니다만, 단지 좋아하는 VB 가 성능이 나쁜 언어이고, 뒤쳐지는 언어 라는 느낌을 받아서 몇가지 테스트와 여러군데 자문을 구해보았습니다.

사실 몇천, 몇만번 이상의 반복적인 수행을 하는 코드에 다이나믹으로 처리 한다는것 자체가 이상하긴 하지만, 어쩔수 없이 써야 할 경우는 정성태 MVP 님의 C# 4.0 - dynamic 키워드 에서 사용하신 LCG 를 통한 성능 향상 방법도 있으니 참조하시면 좋겠네요.

결론을 짓자면, VB는 C# 보다 Dynamic Binding 이 느리다! 입니다.

저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2009.12.21 12:03

 VB.NET 과 C#은 문법이 상당히 비슷합니다.

어쩌면 컨버팅 툴도 그리 어렵지 않게 만들수 있을것 같네요 ^^;

VB.NET 이 편한부분, C#이 편한 부분이 있는데요, 앞으로 나오게될 2010에는 서로의 장점을 서로 수렴하는듯 합니다. 특히 VB.NET 에서 불편했던, 다이나믹 변수와, 속성... 그리고 C#에서 오퍼레이터 등이 이슈가 될듯 하네요..

한가지... VB.NET 과 C#을 왔다갔다 하면서 가장 자주 실수 하는 부분이 배열 선언입니다.
vb 의 경우 arrTemp(5)  라고 선언하면 0~5 까지 즉 6개의 공간이 생기는것이고,
C#의 경우 arrTemp[5] 라고 선언하면 0~4 까지 즉 5개의 공간이 생기는것입니다.

VB.NET

Program Structure

C#

Imports System

Namespace Hello
   Class HelloWorld
      Overloads Shared Sub Main(ByVal args() As String)
         Dim name As String = "VB.NET"

        
'See if an argument was passed from the command line
          If args.Length = 1 Then name = args(0)

          Console.WriteLine("Hello, " & name & "!")
      End Sub
   End Class
End Namespace

using System;

namespace Hello {
   public class HelloWorld {
      public static void Main(string[] args) {
         string name = "C#";

        
// See if an argument was passed from the command line
         if (args.Length == 1)
            name = args[0];

         Console.WriteLine("Hello, " + name + "!");
      }
   }
}

VB.NET

Comments

C#

' Single line only
REM Single line only
''' <summary>XML comments</summary>

// Single line
/* Multiple
    line  */
/// <summary>XML comments on single line</summary>
/** <summary>XML comments on multiple lines</summary> */

VB.NET

Data Types

C#

Value Types
Boolean
Byte, SByte
Char
Short, UShort, Integer, UInteger, Long, ULong
Single, Double
Decimal
Date

Reference Types
Object
String

Initializing
Dim correct As Boolean = True
Dim b As Byte = &H2A  
'hex
Dim o As Byte = &O52  
'octal
Dim person As Object = Nothing
Dim name As String = "Dwight"
Dim grade As Char = "B"c
Dim today As Date = #12/31/2007 12:15:00 PM#
Dim amount As Decimal = 35.99@
Dim gpa As Single = 2.9!
Dim pi As Double = 3.14159265
Dim lTotal As Long = 123456L
Dim sTotal As Short = 123S
Dim usTotal As UShort = 123US
Dim uiTotal As UInteger = 123UI
Dim ulTotal As ULong = 123UL

Type Information
Dim x As Integer
Console.WriteLine(x.GetType())         
' Prints System.Int32
Console.WriteLine(GetType(Integer))  
' Prints System.Int32
Console.WriteLine(TypeName(x))       
' Prints Integer

Type Conversion
Dim d As Single = 3.5
Dim i As Integer = CType(d, Integer)  
' set to 4 (Banker's rounding)
i = CInt(d) 
' same result as CType
i = Int(d)   
' set to 3 (Int function truncates the decimal)

Value Types
bool
byte, sbyte
char
short, ushort, int, uint, long, ulong
float, double
decimal
DateTime  
(not a built-in C# type)

Reference Types
object
string

Initializing
bool correct = true;
byte b = 0x2A;  
// hex

object person = null;
string name = "Dwight";
char grade = 'B';
DateTime today = DateTime.Parse("12/31/2007 12:15:00");
decimal amount = 35.99m;
float gpa = 2.9f;
double pi = 3.14159265;
long lTotal = 123456L;
short sTotal = 123;
ushort usTotal = 123;
uint uiTotal = 123;
ulong ulTotal = 123;

Type Information
int x;
Console.WriteLine(x.GetType());              
// Prints System.Int32
Console.WriteLine(typeof(int));              
// Prints System.Int32
Console.WriteLine(x.GetType().Name);  
// prints Int32

Type Conversion
float d = 3.5f;
int i = (int)d;  
// set to 3  (truncates decimal)

VB.NET

Constants

C#

Const MAX_STUDENTS As Integer = 25

' Can set to a const or var; may be initialized in a constructor
ReadOnly MIN_DIAMETER As Single = 4.93

const int MAX_STUDENTS = 25;

// Can set to a const or var; may be initialized in a constructor
readonly float MIN_DIAMETER = 4.93f;

VB.NET

Enumerations

C#

Enum Action
  Start 
  [Stop]   
' Stop is a reserved word
  Rewind
  Forward
End Enum

Enum Status
  Flunk = 50
  Pass = 70
  Excel = 90
End Enum

Dim a As Action = Action.Stop
If a <> Action.Start Then _
   Console.WriteLine(a.ToString & " is " & a)    
' Prints "Stop is 1"

Console.WriteLine(Status.Pass)     
' Prints 70
Console.WriteLine(Status.Pass.ToString())     
' Prints Pass

enum Action {Start, Stop, Rewind, Forward};
enum Status {Flunk = 50, Pass = 70, Excel = 90};

Action a = Action.Stop;
if (a != Action.Start)
  Console.WriteLine(a + " is " + (int) a);    
// Prints "Stop is 1"

Console.WriteLine((int) Status.Pass);   
// Prints 70
Console.WriteLine(Status.Pass);     
// Prints Pass

VB.NET

Operators

C#

Comparison
=  <  >  <=  >=  <>

Arithmetic
+  -  *  /
Mod
(integer division)
(raise to a power)

Assignment
=  +=  -=  *=  /=  \=  ^=  <<=  >>=  &=

Bitwise
And   Or   Xor   Not   <<   >>

Logical
AndAlso   OrElse   And   Or   Xor   Not

Note: AndAlso and OrElse perform short-circuit logical evaluations

String Concatenation
&

Comparison
==  <  >  <=  >=  !=

Arithmetic
+  -  *  /
(mod)
(integer division if both operands are ints)
Math.Pow(x, y)

Assignment
=  +=  -=  *=  /=   %=  &=  |=  ^=  <<=  >>=  ++  --

Bitwise
&   |   ^   ~   <<   >>

Logical
&&   ||   &   |   ^   !

Note: && and || perform short-circuit logical evaluations

String Concatenation
+

VB.NET

Choices

C#

' Ternary/Conditional operator (Iff evaluates 2nd and 3rd expressions)
greeting = If(age < 20, "What's up?", "Hello")

' One line doesn't require "End If"
If age < 20 Then greeting = "What's up?"
If age < 20 Then greeting = "What's up?" Else greeting = "Hello"

' Use : to put two commands on same line
If x <> 100 AndAlso y < 5 Then x *= 5 : y *= 2  

' Preferred
If x <> 100 AndAlso y < 5 Then
  x *= 5
  y *= 2
End If

' To break up any long single line use _
If whenYouHaveAReally < longLine And _
  itNeedsToBeBrokenInto2 > Lines Then _
  UseTheUnderscore(charToBreakItUp)

'If x > 5 Then
  x *= y
ElseIf x = 5 OrElse y Mod 2 = 0 Then
  x += y
ElseIf x < 10 Then
  x -= y
Else
  x /= y
End If

Select Case color   ' Must be a primitive data type
  Case "pink", "red"
    r += 1
  Case "blue"
    b += 1
  Case "green"
    g += 1
  Case Else
    other += 1
End Select

// Ternary/Conditional operator
greeting = age < 20 ? "What's up?" : "Hello";

if (age < 20)
  greeting = "What's up?";
else
  greeting = "Hello";

// Multiple statements must be enclosed in {}
if (x != 100 && y < 5) {   
  x *= 5;
  y *= 2;
}

 

No need for _ or : since ; is used to terminate each statement.





if
(x > 5)
  x *= y;
else if (x == 5 || y % 2 == 0)
  x += y;
else if (x < 10)
  x -= y;
else
  x /= y;



// Every case must end with break or goto case
switch (color) {                         
// Must be integer or string
  case "pink":
  case "red":    r++;    break;
  case "blue":   b++;  
break;
  case "green": g++;  
break;
  default:    other++;   break;      
// break necessary on default
}

VB.NET

Loops

C#

Pre-test Loops:

While c < 10
  c += 1
End While

Do Until c = 10 
  c += 1
Loop

Do While c < 10
  c += 1
Loop

For c = 2 To 10 Step 2
  Console.WriteLine(c)
Next


Post-test Loops:

Do 
  c += 1
Loop While c < 10

Do 
  c += 1
Loop Until c = 10

'  Array or collection looping
Dim names As String() = {"Fred", "Sue", "Barney"}
For Each s As String In names
  Console.WriteLine(s)
Next

' Breaking out of loops
Dim i As Integer = 0
While (True)
  If (i = 5) Then Exit While
  i += 1
End While

' Continue to next iteration
For i = 0 To 4
  If i < 4 Then Continue For
  Console.WriteLine(i)  
' Only prints 4
Next

Pre-test Loops:  

// no "until" keyword
while (c < 10)
  c++;


for (c = 2; c <= 10; c += 2)
  Console.WriteLine(c);


Post-test Loop:

do
  c++;
while (c < 10);

// Array or collection looping
string[] names = {"Fred", "Sue", "Barney"};
foreach (string s in names)
  Console.WriteLine(s);


// Breaking out of loops
int i = 0;
while (true) {
  if (i == 5)
    break;
  i++;
}

// Continue to next iteration
for (i = 0; i < 5; i++) {
  if (i < 4)
    continue;
  Console.WriteLine(i);  
// Only prints 4
}

VB.NET

Arrays

C#

Dim nums() As Integer = {1, 2, 3} 
For i As Integer = 0 To nums.Length - 1
  Console.WriteLine(nums(i))
Next

' 4 is the index of the last element, so it holds 5 elements
Dim names(4) As String
names(0) = "David"
names(5) = "Bobby" 
' Throws System.IndexOutOfRangeException

' Resize the array, keeping the existing values (Preserve is optional)
ReDim Preserve names(6)



Dim twoD(rows-1, cols-1) As Single
twoD(2, 0) = 4.5

Dim jagged()() As Integer = { _
  New Integer(4) {}, New Integer(1) {}, New Integer(2) {} }
jagged(0)(4) = 5

int[] nums = {1, 2, 3};
for (int i = 0; i < nums.Length; i++)
  Console.WriteLine(nums[i]);


// 5 is the size of the array
string[] names = new string[5];
names[0] = "David";
names[5] = "Bobby";  
// Throws System.IndexOutOfRangeException


// C# can't dynamically resize an array.  Just copy into new array.
string[] names2 = new string[7];
Array.Copy(names, names2, names.Length);  
// or names.CopyTo(names2, 0); 

float[,] twoD = new float[rows, cols];
twoD[2,0] = 4.5f; 

int[][] jagged = new int[3][] {
  new int[5], new int[2], new int[3] };
jagged[0][4] = 5;

VB.NET

Functions

C#

' Pass by value (in, default), reference (in/out), and reference (out) 
Sub TestFunc(ByVal x As Integer, ByRef y As Integer, ByRef z As Integer)
  x += 1
  y += 1
  z = 5
End Sub

Dim a = 1, b = 1, c As Integer   ' c set to zero by default 
TestFunc(a, b, c)
Console.WriteLine("{0} {1} {2}", a, b, c)  
' 1 2 5

' Accept variable number of arguments
Function Sum(ByVal ParamArray nums As Integer()) As Integer
  Sum = 0 
  For Each i As Integer In nums
    Sum += i
  Next
End Function  
' Or use Return statement like C#

Dim total As Integer = Sum(4, 3, 2, 1)  
' returns 10

' Optional parameters must be listed last and must have a default value
Sub SayHello(ByVal name As String, Optional ByVal prefix As String = "")
  Console.WriteLine("Greetings, " & prefix & " " & name)
End Sub

SayHello("Strangelove", "Dr.")
SayHello("Madonna")

// Pass by value (in, default), reference (in/out), and reference (out)
void TestFunc(int x, ref int y, out int z) {
  x++;  
  y++;
  z = 5;
}

int a = 1, b = 1, c;  // c doesn't need initializing
TestFunc(a, ref b, out c);
Console.WriteLine("{0} {1} {2}", a, b, c); 
// 1 2 5

// Accept variable number of arguments
int Sum(params int[] nums) {
  int sum = 0;
  foreach (int i in nums)
    sum += i;
  return sum;
}

int total = Sum(4, 3, 2, 1);   // returns 10

/* C# doesn't support optional arguments/parameters.  Just create two different versions of the same function. */ 
void SayHello(string name, string prefix) {
  Console.WriteLine("Greetings, " + prefix + " " + name);


void SayHello(string name) {
  SayHello(name, "");
}

VB.NET

Strings

C#

Special character constants (all also accessible from ControlChars class)
vbCrLf, vbCr, vbLf, vbNewLine
vbNullString
vbTab
vbBack
vbFormFeed
vbVerticalTab
""

' String concatenation (use & or +)
Dim school As String = "Harding" & vbTab
school = school & "University"
' school is "Harding (tab) University"

' Chars
Dim letter As Char = school.Chars(0)  
' letter is H
letter = Convert.ToChar(65)                
' letter is A
letter = Chr(65)                                 
' same thing
Dim word() As Char = school.ToCharArray() ' word holds Harding

' No string literal operator
Dim msg As String = "File is c:\temp\x.dat"

' String comparison
Dim mascot As String = "Bisons"
If (mascot = "Bisons") Then   
' true
If (mascot.Equals("Bisons")) Then  
' true
If (mascot.ToUpper().Equals("BISONS")) Then  
' true
If (mascot.CompareTo("Bisons") = 0) Then   
' true

' String matching with Like - Regex is more powerful
If ("John 3:16" Like "Jo[Hh]? #:*") Then  
'true

' Substring
s = mascot.Substring(2, 3))
' s is "son"

' Replacement
s = mascot.Replace("sons", "nomial"))
' s is "Binomial"

' Split
Dim names As String = "Frank,Becky,Ethan,Braden"
Dim parts() As String = names.Split(",".ToCharArray())  
' One name in each slot

' Date to string
Dim dt As New DateTime(1973, 10, 12)
Dim s As String = "My birthday: " & dt.ToString("MMM dd, yyyy")  
' Oct 12, 1973

' Integer to String
Dim x As Integer = 2
Dim y As String = x.ToString()    
' y is "2"

' String to Integer
Dim x As Integer = Convert.ToInt32("-5")    
' x is -5

' Mutable string
Dim buffer As New System.Text.StringBuilder("two ")
buffer.Append("three ")
buffer.Insert(0, "one ")
buffer.Replace("two", "TWO")
Console.WriteLine(buffer)        
' Prints "one TWO three"

Escape sequences
\r    
// carriage-return
\n    
// line-feed
\t    
// tab
\\    
// backslash
\"    
// quote

// String concatenation
string school = "Harding\t";
school = school + "University";  
// school is "Harding (tab) University"

// Chars
char letter = school[0];           
// letter is H
letter = Convert.ToChar(65);    
// letter is A
letter = (char)65;                   
// same thing
char[] word = school.ToCharArray();   // word holds Harding

// String literal
string msg = @"File is c:\temp\x.dat";
// same as
string msg = "File is c:\\temp\\x.dat";

// String comparison
string mascot = "Bisons";
if (mascot == "Bisons")   
// true
if (mascot.Equals("Bisons"))   
// true
if (mascot.ToUpper().Equals("BISONS"))  
// true
if (mascot.CompareTo("Bisons") == 0)   
// true

// String matching - No Like equivalent, use Regex


// Substring
s = mascot.Substring(2, 3))    
// s is "son"

// Replacement
s = mascot.Replace("sons", "nomial"))    
// s is "Binomial"

// Split
string names = "Frank,Becky,Ethan,Braden";
string[] parts = names.Split(",".ToCharArray());  
// One name in each slot

// Date to string
DateTime dt = new DateTime(1973, 10, 12);
string s = dt.ToString("MMM dd, yyyy");    
// Oct 12, 1973

// int to string
int x = 2;
string y = x.ToString();    
// y is "2"

// string to int
int x = Convert.ToInt32("-5");    
// x is -5

// Mutable string
System.Text.StringBuilder buffer = new System.Text.StringBuilder("two ");
buffer.Append("three ");
buffer.Insert(0, "one ");
buffer.Replace("two", "TWO");
Console.WriteLine(buffer);    
// Prints "one TWO three"

VB.NET

Regular Expressions

C#

Imports System.Text.RegularExpressions

' Match a string pattern
Dim r As New Regex("j[aeiou]h?. \d:*", RegexOptions.IgnoreCase Or _
        RegexOptions.Compiled)
If (r.Match("John 3:16").Success) Then  
'true
    Console.WriteLine("Match")
End If

' Find and remember all matching patterns
Dim s As String = "My number is 305-1881, not 305-1818."
Dim r As New Regex("(\d+-\d+)")
Dim m As Match = r.Match(s)    
' Matches 305-1881 and 305-1818
While m.Success
    Console.WriteLine("Found number: " & m.Groups(1).Value & " at position " _
            & m.Groups(1).Index.ToString)
    m = m.NextMatch()
End While

' Remeber multiple parts of matched pattern
Dim r As New Regex("(\d\d):(\d\d) (am|pm)")
Dim m As Match = r.Match("We left at 03:15 pm.")
If m.Success Then
    Console.WriteLine("Hour: " & m.Groups(1).ToString)      
' 03
    Console.WriteLine("Min: " & m.Groups(2).ToString)        
' 15
    Console.WriteLine("Ending: " & m.Groups(3).ToString)  
' pm
End If

' Replace all occurrances of a pattern
Dim r As New Regex("h\w+?d", RegexOptions.IgnoreCase)
Dim s As String = r.Replace("I heard this was HARD!", "easy")  
' I easy this was easy!

' Replace matched patterns
Dim s As String = Regex.Replace("123 < 456", "(\d+) . (\d+)", "$2 > $1")  
' 456 > 123

' Split a string based on a pattern
Dim names As String = "Frank, Becky, Ethan, Braden"
Dim r As New Regex(",\s*")
Dim parts() As String = r.Split(names)  
' One name in each slot

using System.Text.RegularExpressions;

// Match a string pattern
Regex r = new Regex(@"j[aeiou]h?. \d:*", RegexOptions.IgnoreCase |
        RegexOptions.Compiled);
if (r.Match("John 3:16").Success)  
// true
    Console.WriteLine("Match");


// Find and remember all matching patterns
string s = "My number is 305-1881, not 305-1818.";
Regex r = new Regex("(\\d+-\\d+)");
// Matches 305-1881 and 305-1818
for (Match m = r.Match(s); m.Success; m = m.NextMatch())
    Console.WriteLine("Found number: " + m.Groups[1] + " at position " +
        m.Groups[1].Index);



// Remeber multiple parts of matched pattern
Regex r = new Regex("@(\d\d):(\d\d) (am|pm)");
Match m = r.Match("We left at 03:15 pm.");
if (m.Success) {
    Console.WriteLine("Hour: " + m.Groups[1]);      
// 03
    Console.WriteLine("Min: " + m.Groups[2]);        
// 15
    Console.WriteLine("Ending: " + m.Groups[3]);  
// pm
}

// Replace all occurrances of a pattern
Regex r = new Regex("h\\w+?d", RegexOptions.IgnoreCase);
string s = r.Replace("I heard this was HARD!", "easy"));  
// I easy this was easy!

// Replace matched patterns
string s = Regex.Replace("123 < 456", @"(\d+) . (\d+)", "$2 > $1");  
// 456 > 123

// Split a string based on a pattern
string names = "Frank, Becky, Ethan, Braden";
Regex r = new Regex(@",\s*");
string[] parts = r.Split(names);  
// One name in each slot

VB.NET

Exception Handling

C#

' Throw an exception
Dim ex As New Exception("Something is really wrong.")
Throw  ex 

' Catch an exception
Try 
  y = 0
  x = 10 / y
Catch ex As Exception When y = 0
' Argument and When is optional
  Console.WriteLine(ex.Message)
Finally
  Beep()
End Try

' Deprecated unstructured error handling
On Error GoTo MyErrorHandler
...
MyErrorHandler: Console.WriteLine(Err.Description)

// Throw an exception
Exception up = new Exception("Something is really wrong.");
throw up; 
// ha ha

// Catch an exception
try
  y = 0;
  x = 10 / y;
}
catch (Exception ex) {  
// Argument is optional, no "When" keyword 
  Console.WriteLine(ex.Message);
}
finally {
  Microsoft.VisualBasic.Interaction.Beep();
}

VB.NET

Namespaces

C#

Namespace Harding.Compsci.Graphics 
  ...
End Namespace

' or

Namespace Harding
  Namespace Compsci
    Namespace Graphics 
      ...
    End Namespace
 
End Namespace
End Namespace

Imports Harding.Compsci.Graphics

namespace Harding.Compsci.Graphics {
  ...
}

// or

namespace Harding {
  namespace Compsci {
    namespace Graphics {
      ...
    }
  }
}

using Harding.Compsci.Graphics;

VB.NET

Classes / Interfaces

C#

Accessibility keywords
Public
Private
Friend                   
Protected
Protected Friend
Shared

' Inheritance
Class FootballGame
  Inherits Competition
  ...
End Class 

' Interface definition
Interface IAlarmClock 
  ...
End Interface

// Extending an interface 
Interface IAlarmClock
  Inherits IClock
  ...
End Interface

// Interface implementation
Class WristWatch 
  Implements IAlarmClock, ITimer 
   ...
End Class 

Accessibility keywords
public
private
internal
protected
protected internal
static

// Inheritance
class FootballGame : Competition {
  ...
}


// Interface definition
interface IAlarmClock {
  ...
}

// Extending an interface 
interface IAlarmClock : IClock {
  ...
}


// Interface implementation
class WristWatch : IAlarmClock, ITimer {
   ...
}

VB.NET

Constructors / Destructors

C#

Class SuperHero
  Private _powerLevel As Integer

  Public Sub New()
    _powerLevel = 0
  End Sub

  Public Sub New(ByVal powerLevel As Integer)
    Me._powerLevel = powerLevel
  End Sub

  Protected Overrides Sub Finalize() 
   
' Desctructor code to free unmanaged resources
    MyBase.Finalize()
  End Sub
End Class

class SuperHero {
  private int _powerLevel;

  public SuperHero() {
     _powerLevel = 0;
  }

  public SuperHero(int powerLevel) {
    this._powerLevel= powerLevel; 
  }

  ~SuperHero() {
   
// Destructor code to free unmanaged resources.
    // Implicitly creates a Finalize method
  }
}

VB.NET

Using Objects

C#

Dim hero As SuperHero = New SuperHero
' or
Dim hero As New SuperHero

With hero
  .Name = "SpamMan"
  .PowerLevel = 3
End With

hero.Defend("Laura Jones")
hero.Rest()    
' Calling Shared method
' or
SuperHero.Rest()

Dim hero2 As SuperHero = hero  ' Both reference the same object
hero2.Name = "WormWoman"
Console.WriteLine(hero.Name)  
' Prints WormWoman

hero = Nothing    ' Free the object

If hero Is Nothing Then _
  hero = New SuperHero

Dim obj As Object = New SuperHero
If TypeOf obj Is SuperHero Then _
  Console.WriteLine("Is a SuperHero object.")

' Mark object for quick disposal
Using reader As StreamReader = File.OpenText("test.txt")
  Dim line As String = reader.ReadLine()
  While Not line Is Nothing
    Console.WriteLine(line)
    line = reader.ReadLine()
  End While
End Using

SuperHero hero = new SuperHero();


// No "With" construct
hero.Name = "SpamMan";
hero.PowerLevel = 3;

hero.Defend("Laura Jones");
SuperHero.Rest();  
// Calling static method



SuperHero hero2 = hero;  
// Both reference the same object
hero2.Name = "WormWoman";
Console.WriteLine(hero.Name);  
// Prints WormWoman

hero = null ;   // Free the object

if (hero == null)
  hero = new SuperHero();

Object obj = new SuperHero(); 
if (obj is SuperHero)
  Console.WriteLine("Is a SuperHero object.");

// Mark object for quick disposal
using (StreamReader reader = File.OpenText("test.txt")) {
  string line;
  while ((line = reader.ReadLine()) != null)
    Console.WriteLine(line);
}

VB.NET

Structs

C#

Structure StudentRecord
  Public name As String
  Public gpa As Single

  Public Sub New(ByVal name As String, ByVal gpa As Single)
    Me.name = name
    Me.gpa = gpa
  End Sub
End Structure

Dim stu As StudentRecord = New StudentRecord("Bob", 3.5)
Dim stu2 As StudentRecord = stu  

stu2.name = "Sue"
Console.WriteLine(stu.name)    
' Prints Bob
Console.WriteLine(stu2.name)  
' Prints Sue

struct StudentRecord {
  public string name;
  public float gpa;

  public StudentRecord(string name, float gpa) {
    this.name = name;
    this.gpa = gpa;
  }
}

StudentRecord stu = new StudentRecord("Bob", 3.5f);
StudentRecord stu2 = stu;  

stu2.name = "Sue";
Console.WriteLine(stu.name);   
// Prints Bob
Console.WriteLine(stu2.name);  
// Prints Sue

VB.NET

Properties

C#

Private _size As Integer

Public Property Size() As Integer
  Get
    Return _size
  End Get
  Set (ByVal Value As Integer)
    If Value < 0 Then
      _size = 0
    Else
      _size = Value
    End If
  End Set
End Property

foo.Size += 1

private int _size;

public int Size {
  get {
    return _size;
  }
  set {
    if (value < 0)
      _size = 0;
    else
      _size = value;
  }
}


foo.Size++;

VB.NET

Delegates / Events

C#

Delegate Sub MsgArrivedEventHandler(ByVal message As String)

Event MsgArrivedEvent As MsgArrivedEventHandler

' or to define an event which declares a delegate implicitly
Event MsgArrivedEvent(ByVal message As String)

AddHandler MsgArrivedEvent, AddressOf My_MsgArrivedCallback
' Won't throw an exception if obj is Nothing
RaiseEvent MsgArrivedEvent("Test message")
RemoveHandler MsgArrivedEvent, AddressOf My_MsgArrivedCallback

Imports System.Windows.Forms

Dim WithEvents MyButton As Button   ' WithEvents can't be used on local variable
MyButton = New Button

Private Sub MyButton_Click(ByVal sender As System.Object, _
  ByVal e As System.EventArgs) Handles MyButton.Click
  MessageBox.Show(Me, "Button was clicked", "Info", _
    MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub

delegate void MsgArrivedEventHandler(string message);

event MsgArrivedEventHandler MsgArrivedEvent;

// Delegates must be used with events in C#


MsgArrivedEvent += new MsgArrivedEventHandler(My_MsgArrivedEventCallback);
MsgArrivedEvent("Test message");   
// Throws exception if obj is null
MsgArrivedEvent -= new MsgArrivedEventHandler(My_MsgArrivedEventCallback);



using System.Windows.Forms;

Button MyButton = new Button(); 
MyButton.Click += new System.EventHandler(MyButton_Click);

private void MyButton_Click(object sender, System.EventArgs e) {
  MessageBox.Show(this, "Button was clicked", "Info",
    MessageBoxButtons.OK, MessageBoxIcon.Information);
}

VB.NET

Console I/O

C#

Console.Write("What's your name? ")
Dim name As String = Console.ReadLine()
Console.Write("How old are you? ")
Dim age As Integer = Val(Console.ReadLine())
Console.WriteLine("{0} is {1} years old.", name, age) 
' or
Console.WriteLine(name & " is " & age & " years old.")

Dim c As Integer
c = Console.Read()   
' Read single char
Console.WriteLine(c)  
' Prints 65 if user enters "A"

Console.Write("What's your name? ");
string name = Console.ReadLine();
Console.Write("How old are you? ");
int age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("{0} is {1} years old.", name, age);
// or
Console.WriteLine(name + " is " + age + " years old.");


int c = Console.Read(); 
// Read single char
Console.WriteLine(c);   
// Prints 65 if user enters "A"

VB.NET

File I/O

C#

Imports System.IO

' Write out to text file
Dim writer As StreamWriter = File.CreateText("c:\myfile.txt")
writer.WriteLine("Out to file.")
writer.Close()

' Read all lines from text file
Dim reader As StreamReader = File.OpenText("c:\myfile.txt")
Dim line As String = reader.ReadLine()
While Not line Is Nothing
  Console.WriteLine(line)
  line = reader.ReadLine()
End While
reader.Close()

' Write out to binary file
Dim str As String = "Text data"
Dim num As Integer = 123
Dim binWriter As New BinaryWriter(File.OpenWrite("c:\myfile.dat")) 
binWriter.Write(str) 
binWriter.Write(num) 
binWriter.Close()

' Read from binary file
Dim binReader As New BinaryReader(File.OpenRead("c:\myfile.dat"))
str = binReader.ReadString()
num = binReader.ReadInt32()
binReader.Close()

using System.IO;

// Write out to text file
StreamWriter writer = File.CreateText("c:\\myfile.txt");
writer.WriteLine("Out to file.");
writer.Close();

// Read all lines from text file
StreamReader reader = File.OpenText("c:\\myfile.txt");
string line = reader.ReadLine();
while (line != null) {
  Console.WriteLine(line);
  line = reader.ReadLine();
}
reader.Close();

// Write out to binary file
string str = "Text data";
int num = 123;
BinaryWriter binWriter = new BinaryWriter(File.OpenWrite("c:\\myfile.dat"));
binWriter.Write(str);
binWriter.Write(num);
binWriter.Close();

// Read from binary file
BinaryReader binReader = new BinaryReader(File.OpenRead("c:\\myfile.dat"));
str = binReader.ReadString();
num = binReader.ReadInt32();
binReader.Close();

 

 

저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
TAG c#, vb.net
VB.NET2009.10.20 10:53

Visual Studio 2010 은 IDE가 WPF로 만들어져 무겁게 느껴지는데요, 사실 내부적으로는 더 빨라 졌습니다.



Visual Basic의 가장 큰 장점인 백그라운드 컴파일링 부분인데, MS 의 Visual Studio Langage Program Manager인 Avner Aharoni 씨가 2008버전과 2010 버전을 테스트 한 내용입니다.

한번 해 보시겠어요?
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower

티스토리 툴바