Think about it.2010.01.03 14:50

2010년 경인년 1월 1일 반가운 소식이 왔습니다.

VB.NET 부분 MVP가 되었다는 반가운 메일이 왔습니다.

앞으로 더 좋은 컨텐츠를 생산해 내야 하는 부담감이 생겼네요 ^^; 좋은 컨텐츠 많이 생산해 내도록 하겠습니다.

--

10년 전만 해도, 응용프로그램 쪽 시장중 Visual Basic이 차지하는 비율이 엄청났지요.. 하지만, 닷넷프레임웍이 나오고 OOP로 변경이 되면서, Object Driven방식에 익숙해 져있는 VB 개발자들은 언어의 Generation에 따라오기가 힘들었고, 자바쪽으로 많이 넘어갔습니다. 저 또한 왔다갔다 했으니깐요..

하지만, Dim, ReDim, Optional 과 같은 키워드를 사용할수 없어서 불편함을 많이 느꼈습니다.

지금 생각해 보면 단지 좋은경험에 불과한것 같습니다

언어별 색깔이 있고, 시스템에 맞는 언어를 선택하여 구현하는게 제일인것 같습니다.

요즘 JAVA가 잘 나가죠? 2000년만 해도 지금의 자바시장 보다 VB시장이 더 컷던것 같습니다. 물론 개인적인 생각이구요 ^^;

이 아티클을 읽는 사람중 VB개발자에서 필요에 의해서가 아니라, 겉멋(?) 또는 브레이스({})로 인해 C개발자 라고 생각이 들어 C#으로 가신분들은 어리석다고 생각합니다. 

닷넷프레임워크의 기본을 생각해 보십시요.

또한 VB.NET의 Background Compiling 과 같은 우수한 기능, 그리고 예전부터 익숙한 문법들을 버리면서 왜 가셨어요?

많지 않은 경험이지만 경험상 제가 느낀 대세 언어들의 특징은 다음과 같습니다.

<JAVA>
1. Bing, Google에서 모든 자료를 얻을 수 있습니다.
2. 배우기 쉽고 사용하기 쉽습니다.
3. 초기 프로젝트 설정이 어렵습니다. 특히 외부 프레임웍 도입시.

<C#>
1. Bing, Google에서 자료를 얻기가 비교적 수월합니다.
2. 영향력있는 Scott Guthrie 가 C#을 담당하여 전파중입니다.
3. Background Compiling이 잘 안됩니다.

<VB.NET>
1. Bing, Google에서 자료를 얻기가 쉽지 않습니다.
2. 시장이 많이 좁아졌습니다.
3. Background Compiling이 잘 됩니다.
4. VB.NET 1.x 때와 상황이 많이 달라졌습니다.(6.0개발자도 곧바로 넘어올수 있습니다.)


어쩌다 또다시 비교를 하게 되었습니다.
너무 아쉬워서 입니다. 정말 기회가 된다면 "VB개발자들이 왜 JAVA나 C#으로 갔을까요?" 라는 책을 쓰고 싶을정도 입니다.

어쩌다보니 너무 길어지는것 같아서 정리를 하자면,
지금은 언어의 성숙도가 많이 높아져 있으며, 어떤 언어가 더 우수하다고 비교하기가 어려울 정도 입니다.
특정 언어만 좋다고 생각하는것은 그 언어 이외에 다른언어를 사용할 기회가 많이 없었기 때문이라고 생각합니다. 여러가지 언어를 접해 보면서, 상황에 맞는 언어와 프레임웍을 선택하는것이 올바르다고 생각합니다.
이상입니다.


Moonhyuk, Choi
- VB.NET MVP 2010
- VB.NET Insider
- C# Insider
- CodeProject Associate


 
 
 




저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
TAG c#, java, MVP, vb.net
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
Spring.NET2009.04.10 16:09

어떤이는 OOP가 발전되어서 AOP가 되었다 라고 하는데 맞을수도 있고 아닐수도 있다. 내 생각엔 오른손이 하는것을 왼손은 거들뿐!! OOP는 오른손, AOP는 왼손. ㅋㅋ 썰렁한가?

암튼.. 험...

Aspect 하기 좋은 기능중 하나가 DI인데 기존 방식이랑 다른점이 무었인지 코드로 직접 실행 해 보자.
어떻게 Coupling을 줄일 수 있는지...

우선 기존에 어떻게 클래스를 호출하는지 왜 Dependency가 강하게 결합이 되는지 기존 방식대로 해 보자.

VS를 열고 새프로젝트를 선택한 다음 이름이 oldClass라는 콘솔 응용 프로그램을 생성 하도록 하자.
아래와 같이 Person.vb 클래스를 하나 만들자


콘솔용이니깐, 모듈에서 시작하므로 Module1.vb 코드를 아래와 같이 입력하자.

코딩끝!

이제 F5를 과감하게 눌러 실행 해 보자. 아래와 같은 화면이 나타날것이다.

이것이 우리하 흔히 알고 사용하는 OOP 방식이다. 하지만, 코드상에서 Moonhyuk = new Person 이라고 부르는 순간 이미 Dependency 가 강하게 결합되어 버린다.

그럼 SPRING.NET으로 결합도를 낮춰 보자. spring.net 이 설치가 안되어 있으면 http://www.springframework.net 에서 받을수 있다.
새 항목 추가를 하여 응용 프로그램 구성 파일(app.config)를 추가 한다. 추가된 app.config의 내용을 아래와 같이 변경하자.



그리고 프로젝트 참조를 추가 해야 한다. SPRING.NET에서 핵심 영역과 DI 부분을 제공해 주는 Spring.Core.dll 을 추가 하자
일반적으로 설치 했다면 경로는 C:\Program Files\Spring.NET 1.2.0\bin\net\2.0\release 이다.

그리고, 종속성을 제거하기 위해 IPerson.vb 인터페이스를 하나 만든다.


Person 클래스가 인터페이스를 구현 하기 때문에 기존 코드를 아래와 같이 수정한다.


마지막으로 Module1.vb 를 수정한다.



실행해 보면 아래와 같은 화면이 잘 나타난다.


훌륭하지 않은가? 종속성을 제거 하면서, Person 클래스를 config 파일에 설정해 두고 주입시킨것이다.
실제로 컴파일 시점에서 컨텍스트가 로드 될때 이미 spring framework 에서는 <object id="person" type="oldClass.Person, oldClass"> 를 인스턴스화 시켜 버린다. 즉, Module1.vb 에서 생성시키는것이 아니라 SPRING.NET 에서 생성 시켜 두었다가 가져다 쓸 뿐이다.

SPRING.NET은 훌륭한 .NET Framework 을 거들뿐... ㅎㅎ
저작자 표시 비영리 동일 조건 변경 허락
신고
Posted by dotnetpower
VB.NET2009.02.07 20:58
이글 내용은 http://www.codeproject.com/vb/net/Delegate.asp 에서

발췌하여 번역 및 수정하였습니다.



delegate란?

포인터의 개념과 아주 유사한데요, C나 C++의 함수포인터 또는 typedef 문이랑 매우 비슷한

개념입니다. C/C++ 에 비유하자면 함수가 위치한 메모리 주소를 일컫지만 단지

주소을 알고 있을뿐 다른 부가적인 정보를 가지고 있지 않습니다.

이때문에 C/C++에선 잘 쓰면 포인터가 아주 유용하지만 그렇지 않을경우

(파라메타를 잘못 전달 하였을 경우) 심각한 오류를 일으킬수 있습니다.

예전부터 함수 포인터를 호출하는건 지원하는 랭귀지에 많이 의존해 왔죠

포인터는 본질적으로 위험하다고 많이 얘기합니다.

하지만 Delegate는 .NET의 CLR 안에서는 Type-Safe 메커니즘을 제공하여 C/C++의 포인터와 같은

역할을 하면서도 안전하게 사용할 수 있습니다.

그런데 왜 포인터를 쓸까요?

제가 요즘에 여러가지를 배우고 있는데요, 포인터를 쓴다는건 메모리 주소를 바로 찍는다는겁니다.

예를 들어 함수를 하나 호출하려고 하는데, 어디 있는지 모르면 찾아야 겠죠?

그치만 포인터는 함수가 어디에 위치 해 있는지 그 주소를 바로 찍어주기땜에 빠르다는거죠

참고로 이러한 방법을 컴퓨터구조학에선는 인덱스 어드레싱 이라고 합니다.(비슷한 개념)

또, 찾아보니깐.. 포인터를 게임 개발, 암호화, 알고리즘 에 많이 쓰더군요 ㅋ

닷넷이나 자바에서는 포인터랑 비슷한 delegate를 주로 다중쓰레드 처리할때 많이 쓰고요

결국 약간의 성능을 높이고자 쓰는것 같습니다. 저는 잘 안쓸것 같네요 ㅋ


말보단 코드로 이해하는게 빠르겠죠? ^^;

그냥 간단한 콘솔용 인사말입니다.



delegate를 선언하는 방법은 아래와 같습니다.




실제 가져다 쓸 메소드 두개를 작성합니다.


그리고 sub main() 프로시저에 다음 코드를 넣고요

delegate를 쓰기위해선 첨에는 invoke 메소드를 호출해야 하는데요 아랬줄에 이 코드를 넣고요


이것 까지.. ^^;

놀랍지 않으세요? 엇? 근데 invoke메소드가 빠진게 아니냐구요?

아니에요, 인스턴스 선언할때 이미 지정 했습니다.


아래코드는 전체적인 코드 입니다.

이 글은 비베따위를(http://www.mhvb.net) 에서도 볼수 있습니다.
저작자 표시 동일 조건 변경 허락
신고
Posted by dotnetpower

티스토리 툴바