Visual Studio 2010과 더불어서 같이 준비중인 C# 4.0에서의 새로운 기능들을 간단히 알아보려고 생각중. 

참고 자료 사이트는

http://code.msdn.microsoft.com/csharpfuture

Visual Studio 2008에서는 Targeting을 정해줄 수 있다 : .NET Framework의 종류를 지정해서 compile을 시킬 수 있다.

    class AutoImplementedClass
    {
        public string Name
        {
            get; set;
        }
        public string Customer
        {
            get;
            private set;
        }
    }

    List<int> powers = new List<int>{ 1, 2, 3, 4, 5, 6, 7 };    
    class Point
    {
        public int x, y;        
    }
    Point point = new Point{x = 0, y = 1};

    static void Main(string[] args)
    {
        var x = new {a =3 , b = 5, c ="some text"}
        assert.AreEqual(3, x.a)
        assert.AreEqual(5, x.b)
        assert.AreEqual("some text", x.c)        
    }

    SomeDelegate d3 = s => s.ToUpper();
    SomeDelegate d4 = (string s) => {return s.ToUpper()}
    string a = d3("abcde")

    public static class Extensions
    {
        public static int ToInt32(this string s)    
        {
            return 0;
        }
    }

    class Customer
    {
        public string CustomerID { get; set; }
        public string ContactName { get; set; }
        public string City { get; set; }
    }
    public class Program
    {
        static void Main(string[] args)
        {
            List<Customers> customers = LoadCustomers();
            var query = from c in customers
                                where c.City == "London"
                                select (new {c.CustomerID, c.ContactName} );
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }                
        }
    }

Windows Mobile에서는 지원하지 않음. 

재미있어보이는 소스라서 들고오기.  

출처 : 데브피아(http://www.devpia.com/forum/BoardView.aspx?no=46886&page=2&Tpage=1501&forumname=csharp_qa&stype=&ctType=&answer=) 

Visual Studio 2005, 2008을 설치할때마다 "이건 뭐하는 것일까.."하는 생각이 드는 내용이였는데, 잘가는 blog에서 포스팅 한 결과를 보고 구경중. 

Flow chart를 그리고, 그 flow chart에 따른 코드를 넣는 것으로 모든 내용이 다 만들어지고, 그에 따른 흐름이 가능해지는 방법으로 여러가지로 살펴볼 내용들이 많다는 생각이 든다. 

각 흐름에 따른 Flow를 만들어주고, 그 Flow에 맞는 code를 작성해주고..

마치 개발을 할때, PM들이 흐름도를 대강 작성하고, 프로그래머들이 코드를 채워넣기만 하면 되는 개발방향과도 너무나도 유사하게 개발을 할 수 있게 되지 않을까.. 하는 생각이 갑자기 든다. 

VS2008개발 발표회때 강연자가 했던 이야기가 기억이 난다. "이렇게 편한 툴이 생긴것 자체가 개발자들에게는 악몽이 되고 있습니다. 누구나 다 개발을 할 수 있게 된다면, 우리는 이제는 필요 없게 되어버릴수도 있습니다." 약간의 엄살이 들어가 있는 이야기이긴 하지만,  왠지 모르게 많은 공감이 되고 있는 이야기들. 

10월달에 볼 책이 결정이 난건가....  

(SYNCmail Background worker를 이걸로 한번 만들어볼까나.) 

sample code: 

public sealed partial class Workflow1: SequentialWorkflowActivity
{
        public string PostalCode
        {
            get;
            set;
        }
   
        public Workflow1()
        {
        InitializeComponent();
        }
   
        /// <summary>
        /// check code in IF-ELSE
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void EvaluatiePostalCode(object sender, ConditionalEventArgs e)
        {
            string USCode = @"^(\d{5}$)|(\d{5}$\-\d{4}$)";
            string CanadianCode = @"^[ABCEGHJKLMNPRSTVXY]\d[A-Z] \d[A-Z]\d$";
   
            e.Result = ( Regex.IsMatch(PostalCode, USCode) || Regex.IsMatch(PostalCode, CanadianCode) );
        }
   
        /// <summary>
        /// method when true result from EvaluatiePostalCode
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ValidatePostalCode(object sender, EventArgs e)
        {
            Console.WriteLine("Right Postal code");
        }
   
        /// <summary>
        /// method when false result from EvaluatiePostalCode
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void NotValidatePostalCode(object sender, EventArgs e)
        {
            Console.WriteLine("Wrong Postal code");
        }
}

1. Contracts

• Service Contract
• Data Contract
• Fault Contracts
• Message Contract 
  

OperationContract : 반드시 Method에서만 구현 가능하다. 이는 WCF Model에서의 제약조건으로 가지고 있으며, 동작에 의해서 구현되는 모델의 기본 사양이 된다. (property 또는 index, value에서는 절대로 구현할 수 없다.) 

              <endpoint
                address ="http://localhost/WCFProduct"
                binding="basicHttpBinding"
                contract="WCFProduct.IProduct"
                />

      productsServiceHost = new ServiceHost(typeof(ProductServiceImpl));
      BasicHttpBinding binding = new BasicHttpBinding();
      productsServiceHost.AddServiceEndpoint(typeof(WCFProduct.IProduct), binding, "http://localhost:8000/WCFProduct");
      productsServiceHost.Open(); 

         <client>
            <endpoint address="http://localhost:8000/WCFProduct" binding="basicHttpBinding"
                bindingConfiguration="NewBinding0" contract="WCFProduct.IProduct"
                name="HttpHost">
                <identity>
                    <certificateReference storeName="My" storeLocation="LocalMachine"
                        x509FindType="FindBySubjectDistinguishedName" />
                </identity>
            </endpoint>
            <endpoint address="http://localhost:8000/WCFProduct" binding="basicHttpBinding"
                bindingConfiguration="BasicHttpBinding_IProduct" contract="WCFProduct.IProduct"
                name="BasicHttpBinding_IProduct" />
        </client>

svcutil.exe http://localhost:8002/MyService /out:proxy.cs /config:app.config 

      //Method 1 : Declare open and close
      client.Open(); //Open proxy
      client.ListProducts();
      client.Close(); //Close proxy

      //Method 2 : use using statement
      using ( client  = new WCFCLient.WCFProduct.ProductClient())
      {
        client.ListProducts();
      }

      //Method 3 : Use IDisposable interface
      IDisposable disposable = client as IDisposable;
      if ( disposable != null )
      {
        disposable.Dispose();
      }

      //Declare endpoint address with URL
      EndpointAddress endpointAddress = new EndpointAddress("http://localhost/WCFProduct/Service.svc");
      //Declare Binding method : http, https, tcp ....
      WSHttpBinding wsBinding = new WSHttpBinding();
      WCFProduct.ProductClient client = new WCFCLient.WCFProduct.ProductClient(wsBinding, endpointAddress);

Windows Communication Foundation was official released with .NET 3.0 a couple of months ago. For those people who're doing connected, distributed systems or are in any way interested in communication aspects of systems, this ought to be a God-send. WCF basically rolled all the different Microsoft messaging formats into one, making it extremely easy to architect the communication layer of simple to complex applications. This tutorial aims to explain the basic concepts behind the common terminology used in WCF development and design.

Below is a quick overview of the WCF architecture

WCF Programs
WCF programs are basically divided into 3 different types of programs. They are common known as

• Clients
  Clients are program that consumes the services, they are normally the ones that initiate the messenging to the service. Depending on the designed architecture of your application, it is possible that a service behaves as a client as well.
  
• Services
  Services are the programs that offers the services to the consumers. They are the ones that react and process the messages, similar to the backend of the application. They can be viewed as the equivalence of web services in .Net 2.0.
  
  All services have to have endpoints specified in order to work. A good way to remember proper endpoint configurations is ABC. A being Address, B being Binding and C being Contracts. 
  
  
  • Address
    Address are the expose points of services. Services have to tell the world that where they are via addresses.
    
  • Bindings
    Bindings will describe to the world on how they will communicate with the world. They contain information such as transport way, how they are encoded, are they reliable etc.
    
  • Contracts are of (but not necessary all have to be present) 3 different kinds
    
    
    • Service Contract
      Describes what the service does.
      
    • Data Contract
      Define custom messaging structure.
      
    • Message Contract
      Define the message format that is passed between services.
      
      
• Intermediaries
  Intermediaries are programs that act as "middle-man", their basic roles can be similar to providing a firewall, routing, gateway etc. They are commonly invisible to the client and services.

Messages
All services and clients communicate via messages, which are made up of one body, and one or more header. All WCF messages are XML formatted and transport neutral. In other words, you can specify different forms of transport (HTTP, MSMQ, Named Pipes etc) for different messages. Within each application, you can specify different messaging transport depending on the communication needs of the system. Basically, messages can be divided into

• Simplex
  One way messaging. Simplex in short means "fire and forget"
  
• Duplex
  Asynchronous two-way messaging. In short this means that once fired, the application will carry on doing its own thing. Upon the return results, it will then handle it.
  
• Request Reply
  Synchronous 2 way messaging. This is the common communicate method whereby you'll fire a request, and wait for the response before continuing.

Channels
Before a client and service can talk to each other, they have to go through a channel. Imagine a channel as a pipe, with one end being the input message and the other end with the results of the message. There're different channels that can be stacked onto each other, they are commonly known as Channel Stacks. They can be of these different types:

• Reliable Sessions
• TCP Transport
• Binary Message Encoder
• Windows Security
• Request Reply

 The way in which messages are sent through the pipe (Channel) is known as a Transport and they way at which they are encoded are known as Encodings. Transport can be made up of the following:

• HTTP
• TCP
• MSMQ
• Named Pipes