windows 10 iot에 대한 이미지 검색결과windows 10 iot에 대한 이미지 검색결과

https://wiki.ubuntu-kr.org/index.php/Windows_10_IoT_Study

이 스터디에서 서포터로 참가했다.

 

초반에 설치하고.. 뭐 디바이스 제어하고.. 거기까진 괜찮(좋진 않고)았다.

 

네트워크 들어가면서 헬게이트가 열렸고..

 

Rasbpian에 비해 3배 이상의 시간이 걸리는 체감을 했다.

 

어쨌거나 장단점을 좀 정리해보자면..

 

장점
* Visual Studio로 개발이 가능


* 이쁘다.

 

단점
* File System이 애매하다. 저널도 없고.
시스템 종료로 안 끄고 뽑아서 껐다가 재수없으면 부팅이 안된다.
SD카드에 처음부터 다시 집어넣어야 함..


* 생각보다 덩치가 크다. 부팅시간 오래걸리는건 덤.


* 덩치가 큰데 지원하는 기능이 별로 없다.


* 지원하는 언어가 C# + XAML Only


* 아주 미흡한 Command Line Interface 지원.


* 몇몇 환경에 대한 특성을 탄다. 와이파이나 블루투스.


* PC용 프로그램에 비해 상상 이상으로 제약이 많이 걸려있다.


* 그중 하나로, 라이브러리 등이 매우 미흡하다.
다행히 PiFace쪽 라이브러리들은 공개되어 있지만..
실제 쓸만하게 만들려면 리눅스쪽 코드를 이쪽으로 포팅해야 할일도 많은듯.


* 3D 관련 드라이버도 없다.

당연히 DirectX도 없지.

 

결론
* Windows 10 IoT는 장난감으로 가지고 놀기에는 좋다.


* 안정화되려면 꽤 많은 시간이 필요할 것으로 보인다.


* 그럼에도 불구하고 차라리 XBOX를 가지고 놀자.

신고

'Application > C#' 카테고리의 다른 글

Windows 10 IoT 장단점  (0) 2016.11.23
C# 다른 버튼 액션 갖다쓰기.  (0) 2014.05.10
XNA를 시작합시다!  (0) 2011.12.31
Using Cleartype font in Windows Embedded CE  (0) 2010.11.02
컨트롤 드래그  (0) 2010.10.31
C# 메세지 처리  (0) 2010.07.16


WindowsFormsApplication2.7z


신고

'Application > C#' 카테고리의 다른 글

Windows 10 IoT 장단점  (0) 2016.11.23
C# 다른 버튼 액션 갖다쓰기.  (0) 2014.05.10
XNA를 시작합시다!  (0) 2011.12.31
Using Cleartype font in Windows Embedded CE  (0) 2010.11.02
컨트롤 드래그  (0) 2010.10.31
C# 메세지 처리  (0) 2010.07.16

Microsoft XNA Game Studio Express를 설치하는 방법 등, 기초적인 환경 설정은 인터넷에도 많으니 여기서는 다루지 않습니다.

또한 reimer`s tutorial 01 원문에서는 간단하게 Game1.cs의 구조를 정리하고 있는데 이 또한 나중에 자세하게 다루기로 하고, 여기서는 다루지 않습니다.

일단 기본적인 환경은 모두 갖추어 졌다고 보고, 간단하게 Windows Game 프로젝트를 하나 생성해봅시다.

프로젝트를 처음 생성하고 디버그(F5)키로 실행시켜 보면 DirectX를 다뤄왔을 사람이라면 익숙하게 느껴질 파란 바탕의 윈도우가 하나 생성될 것 입니다.

우리가 이번 tutorial에서 할 일은 이 윈도우의 속성(크기, 전체 화면 등...)을 수정하는 일 입니다.

그러기 위해, 다시 코드로 돌아와 몇가지 코딩을 해 봅시다.

먼저 GraphicsDevice를 사용하기 쉽도록 전역 변수를 설정합니다.

 GraphicsDevice device;

전역 변수를 설정했다면, 윈도우의 속성을 정의할 우리만의 함수를 하나 만들어 봅시다. 이름은 SetupXNADevice로 하고 parameter는 없으며 return type은 void입니다. 물론 이 함수는 다른 클래스에서 접근할 일이 없으므로 private입니다.


 #region Using Statements
using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Storage;
#endregion

namespace reimers_tutorial01_series1
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        ContentManager content;

        GraphicsDevice device; // GraphicsDevice를 설정할 전역 변수


        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            content = new ContentManager(Services);
        }


        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();

            SetupXNADevice(); //추가
        }

        private void SetupXNADevice()
        {
            device = graphics.GraphicsDevice; // 전역 변수에 GraphicsDevice를 설정

            graphics.PreferredBackBufferWidth = 500; // 윈도우의 너비, 높이를 설정
            graphics.PreferredBackBufferHeight = 500;

            graphics.IsFullScreen = false; // 윈도우 모드

            graphics.ApplyChanges(); // 설정 적용

            Window.Title = "riemer`s XNA tutorial 01 - series 1"; // 윈도우 제목 설정
        }


        /// <summary>
        /// Load your graphics content.  If loadAllContent is true, you should
        /// load content from both ResourceManagementMode pools.  Otherwise, just
        /// load ResourceManagementMode.Manual content.
        /// </summary>
        /// <param name="loadAllContent">Which type of content to load.</param>
        protected override void LoadGraphicsContent(bool loadAllContent)
        {
            if (loadAllContent)
            {
                // TODO: Load any ResourceManagementMode.Automatic content
            }

            // TODO: Load any ResourceManagementMode.Manual content
        }


        /// <summary>
        /// Unload your graphics content.  If unloadAllContent is true, you should
        /// unload content from both ResourceManagementMode pools.  Otherwise, just
        /// unload ResourceManagementMode.Manual content.  Manual content will get
        /// Disposed by the GraphicsDevice during a Reset.
        /// </summary>
        /// <param name="unloadAllContent">Which type of content to unload.</param>
        protected override void UnloadGraphicsContent(bool unloadAllContent)
        {
            if (unloadAllContent)
            {
                // TODO: Unload any ResourceManagementMode.Automatic content
                content.Unload();
            }

            // TODO: Unload any ResourceManagementMode.Manual content
        }


        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            // TODO: Add your update logic here

            base.Update(gameTime);
        }


        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here

            base.Draw(gameTime);
        }
    }
}



이제 다시 디버그(F5)키를 눌러 실행하면 윈도우의 모양이 우리가 설정한 대로 바뀌어 나옴을 확인할 수 있습니다.


Array

신고

'Application > C#' 카테고리의 다른 글

Windows 10 IoT 장단점  (0) 2016.11.23
C# 다른 버튼 액션 갖다쓰기.  (0) 2014.05.10
XNA를 시작합시다!  (0) 2011.12.31
Using Cleartype font in Windows Embedded CE  (0) 2010.11.02
컨트롤 드래그  (0) 2010.10.31
C# 메세지 처리  (0) 2010.07.16

Source : http://blog.naver.com/PostView.nhn?blogId=aquayo&logNo=80092583031&redirect=Dlog&widgetTypeCall=true

 

테스트 장비: Windows embedded CE 6.0

PC에서는 C#으로 ClearType을 처리하는데 TextRenderingHint를 가지고 처리가 가능한데, WinCE에서는 지원이 안되는 부분이므로 아래와 같이 처리를 할 수 있습니다.

이 처리가 필요한 이유는 기본 폰트가 아닌 다른 폰트를 사용시 글자가 깨끗하게 보이지 않으므로, ClearType을 적용한것입니다.

(C++은 아래의 함수를 그냥 호출시켜서 쓰시면 됩니다. C#은 대응하는 함수를 찾지 못해서 추가한것입니다)

레지스트리를 수정해서 하는 방법도 있던데 소스로 처리해봅니다.(Display Driver에 따라서 적용안될수도 있다는 것을 웹에서 본듯 합니다)

   1: using System.Runtime.InteropServices;
   2: ...
   3: [DllImport("coredll.dll")]
   4: private static extern int SystemParametersInfo(int uiAction, 
   5: int uiParam, out int pvParam, int fWinIni);
   6:  [DllImport("coredll.dll")]
   7: private static extern int SystemParametersInfo(int uiAction, 
   8: int uiParam, IntPtr pvParam, int fWinIni);
   9: const int SPI_GETFONTSMOOTHING = 0x0000004A; // use pvParam 
  10: to query
  11: const int SPI_SETFONTSMOOTHING = 0x0000004B; // use uiParam 
  12: to set
  13: public bool SystemWideClearType
  14:  {
  15: get
  16:  {
  17: int enabled;
  18:  
  19: SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, out enabled, 0);
  20: return (enabled != 0);
  21:  }
  22: set
  23:  {
  24:  
  25: SystemParametersInfo(SPI_SETFONTSMOOTHING, value ? -1 : 0, IntPtr.Zero, 0);
  26:  }
  27:  }

사용법:

프로그램 시작시(각자 만든 APP) : SystemWideClearType = true;

프로그램 종료시:                        SystemWideClearType = false;

위의 코드를 활용해서 처리하면 내 프로그램이 구동하는 동안 모든 Windows의 APP 폰트가 ClearType으로 변경됩니다.

XP/Vista/windows7 에서 폰트를 ClearType 설정하는 것처럼 된다는 것입니다.

계속 cleartype을 유지시키기 위해서는 프로그램 종료시 false 세팅을 호출 안하면 됩니다.

디바이스에 나의 프로그램이 아닌 다른 프로그램도 실행되어져야 하는경우,

문제가 있을수 있겠네요. 그 프로그램은 cleartype을 안써야 폰트가 깨끗하게 보이는 경우가 있을때...

이런 경우, APP에서만 ClearType을 처리할 수 있습니다. LOGFONT사용...

우선 .NET Compact Framework 2.0이 필요합니다.

이것은 using Microsoft.WindowsCE.Forms; 을 사용하기 위함입니다. 3.x에는 안보이네요..ㅡㅡ;

문제는 메모리가 충분치 않은 상황에서 2.0을 사용하고자 한다면 배포시 설치 문제가 있을 수 있습니다.

따라서 2.0에 있는 LOGFONT클래스들과 enum값을 가지고 와서 3.x대에서 사용해보는데 exception이 발생하네요.

LogFont lf;
Font myFont;          
lf = new LogFont();
lf.Height = -32;
lf.Width = 0;
lf.Escapement = 0;
lf.Orientation = 0;
lf.Weight = (LogFontWeight)0;
lf.Italic = 0;
lf.Underline = 0;
lf.StrikeOut = 0;
lf.CharSet = LogFontCharSet.Default;
lf.OutPrecision = LogFontPrecision.Default;
lf.ClipPrecision = LogFontClipPrecision.Default;
lf.Quality = LogFontQuality.ClearType;
lf.PitchAndFamily = LogFontPitchAndFamily.Default;
lf.FaceName = "AritaM";
myFont = Font.FromLogFont(lf); <- 여기서 발생하네요.

굳이 APP에만 적용할 필요가 없다면 상단의 소스를 사용하시면 됩니다.

소스는 첨부해두니 해결하시는 분은 답글 적어주세요ㅜ.ㅜ 2.0을 안쓰고 하는 방법......

신고

'Application > C#' 카테고리의 다른 글

C# 다른 버튼 액션 갖다쓰기.  (0) 2014.05.10
XNA를 시작합시다!  (0) 2011.12.31
Using Cleartype font in Windows Embedded CE  (0) 2010.11.02
컨트롤 드래그  (0) 2010.10.31
C# 메세지 처리  (0) 2010.07.16
닷넷에서의 INI 파일 입출력  (0) 2010.07.15
   1: private Point 
   2: start_p; 
   3: // 클릭시 마우스 위치
   4: private Point 
   5: end_p; 
   6: // 마우스 이동할때 위치
   7: private bool mouse_move = false; // 마우스가 드레그 상태인지 
   8: 확인
   9: private void button2_MouseMove(object sender, MouseEventArgs e)
  10: // 마우스 
  11: 이동시
  12: {
  13:  Point th; // 마우스의 현재위치를 계산하기 위한 폼의 
  14: 위치
  15:  if (mouse_move == true)
  16:  
  17: {
  18:  th = 
  19: this.Location;
  20:  end_p = 
  21: ((Control)sender).PointToScreen(new Point(e.X, 
  22: e.Y));
  23:  Point tmp = new 
  24: Point((button2.Location.X + (end_p.X - start_p.X)), (button2.Location.Y + 
  25: (end_p.Y - start_p.Y)));
  26:  start_p = 
  27: ((Control)sender).PointToScreen(new Point(e.X, 
  28: e.Y));
  29:  
  30:  
  31:  button2.Location = 
  32: tmp;
  33:  }
  34: }
  35: private void button2_MouseDown(object sender, MouseEventArgs e)
  36: // 마우스로 
  37: 컨트롤 클릭시
  38: {
  39:  mouse_move = 
  40: true;
  41:  start_p = ((Control)sender).PointToScreen(new 
  42: Point(e.X, e.Y));
  43: }
  44: private void button2_MouseUp(object sender, MouseEventArgs e)
  45: // 컨트롤에서 마우스 
  46: 놓았을 때 
  47: {
  48:  mouse_move = false;
  49: }
신고

'Application > C#' 카테고리의 다른 글

XNA를 시작합시다!  (0) 2011.12.31
Using Cleartype font in Windows Embedded CE  (0) 2010.11.02
컨트롤 드래그  (0) 2010.10.31
C# 메세지 처리  (0) 2010.07.16
닷넷에서의 INI 파일 입출력  (0) 2010.07.15
C# Frequently Asked Questions for C++ programmers  (0) 2008.03.18

출처 : http://blog.naver.com/mcgyver3/40016726487

 

저자: 한동훈
C#에서 이벤트를 처리하는 방법에는 크게 두 가지가 있다(정확히는 세 가지 던가?). 한 가지는 클래스에 정의된 메소드를 오버라이드하는 방법이다. 이 경우에는 사용 언어가 VB.NET이냐 C#이냐에 따라 차이는 있지만 이벤트를 이용한 것이다. 다른 한 가지는 EventHandler 클래스를 이용하여 위임하는 것이다.
마우스 왼쪽 버튼을 클릭하면 윈도우에서는 버튼을 누르는 순간에 WM_LBUTTONDOWN과 버튼을 떼는 순간에 WM_LBUTTONUP이라는 메시지가 전달된다. 우리가 흔히 생각하는 클릭이라는 것은 이 두 가지 메시지가 빠르게 전달되는 것을 뜻한다.
폼에 있는 컨트롤을 클릭하면 이러한 메시지가 재빨리 윈도우에 전달되고 반응한다. 이러한 메시지가 윈도우에 전달되기 전에 특별한 처리를 할 필요가 있다. 예를 들어서 키보드를 사용할 수 없게 하는 경우라든가 마우스 클릭을 하지 못하게 하는 경우, 포토샵과 같은 그래픽 드로잉 프로그램에서 도형의 크기를 조절하는 것과 같은 것을 직접 구현하는 경우를 들수 있다.
닷넷에서는 메시지를 가로채려면 IMessageFilter를 사용한다.
먼저 아무것도 하지 않는 닷넷 윈도우 폼 응용 프로그램의 코드는 다음과 같다. 이 코드에는 하나의 버튼이 있고, 버튼을 클릭하면 클릭했음을 알리는 대화창이 나타난다.

이름 : MessageFilter.cs

using System;
using System.Windows.Forms;

class AppMain
{
  public static void Main(string[] args)
  {
    Application.Run(new MyForm());
  }

  public class MyForm : System.Windows.Forms.Form
  {
    private Button btnOk;

    public MyForm()
    {
      btnOk = new Button();
      btnOk.Text = "&Ok";
      btnOk.Click += new System.EventHandler(btnOk_Clicked);
      btnOk.Location = new System.Drawing.Point(100, 100);

      this.Controls.Add(btnOk);


      this.Text = "My Message Filter";
    }

    private void btnOk_Clicked(object sender, System.EventArgs e)
    {
      MessageBox.Show("clicked");
    }
  }
}

메시지 필터를 구현하려면 IMessageFilter를 구현하면 된다. IMessageFilter에서 구현해야하는 메소드는 다음과 같다.

bool PreFilterMessage(ref Message msg)

IMessageFilter를 구현하는 MyMessageFilter 클래스를 위 예제에 추가한다.

public class MyMessageFilter : IMessageFilter
  {
    public bool PreFilterMessage(ref Message msg)
    {
      // 왼쪽 마우스 버튼 이벤트를 가로챈다.
      if ( 513 == msg.Msg )     // WM_LBUTTONDOWN = 513
      {
        MessageBox.Show("WM_LBUTTONDOWN is : " + msg.Msg.ToString());
        return true;
      }
      return false;
    } // end of method PreFilterMessage
} // end of class MyMessageFilter

WM_LBUTTONDOWN에서 WM은 윈도우 메시지(Window Message)를 뜻한다. LBUTTONDOWN이므로 마우스의 왼쪽 버튼을 누르는 순간을 가로채도록 지시한다.
MyMessageFilter 클래스를 추가했으면 윈폼 응용 프로그램에서 이 메시지 필터를 사용하도록 해야한다. MyForm()을 다음과 같이 수정한다.(굵은 글씨로 표시된 부분)

private MyMessageFilter msgFilter = new MyMessageFilter();

public MyForm()
{
  btnOk = new Button();
  btnOk.Text = "&Ok";
  btnOk.Click += new System.EventHandler(btnOk_Clicked);
  btnOk.Location = new System.Drawing.Point(100, 100);
  this.Controls.Add(btnOk);
  Application.AddMessageFilter(msgFilter); 
  this.Text = "My Message Filter";
}

실행하고 버튼을 클릭하면 "clicked" 대신에 다른 메시지가 나타나는 것을 볼 수 있을 것이다. 마우스와 관련하여 자주 사용되는 윈도우 메시지는 다음과 같다.

윈도우 메시지 16진수 10진수 내용
WM_MOUSEMOVE 0x0200 512 마우스 이동
WM_LBUTTONDOWN 0x0201 513 마우스 왼쪽 버튼을 누르고 있는 상태
WM_LBUTTONUP 0x0202 514 마우스 왼쪽 버튼을 떼었을 때
WM_LBUTTONDBLCLK 0x0203 515 마우스 왼쪽 버튼을 더블 클릭할 때
WM_RBUTTONDOWN 0x0204 516 마우스 오른쪽 버튼을 누르고 있는 상태
WM_RBUTTONUP 0x0205 517 마우스 오른쪽 버튼을 떼었을 때
WM_RBUTTONDBLCLK 0x0206 518 마우스 오른쪽 버튼을 더블 클릭할 때
WM_MOUSEWHEEL 0x020A 522 마우스 휠을 움직일 때

 

나 머지 윈도우 메시지들은 여러분이 직접 필터를 만들어서 테스트 해보기 바란다. 휠 마우스와 응용 프로그램의 스크롤바와 관련된 메시지를 처리하여 슬라이딩 스크롤링을 만들 수도 있다.

자료출처:한빛미디어

신고

출처 : http://blog.naver.com/bmk5133?Redirect=Log&logNo=80041790445


using System.Runtime.InteropServices;
using Microsoft.Win32;

// ---- ini 파일 의 읽고 쓰기를 위한 API 함수 선언 ----
[DllImport("kernel32.dll")]
private static extern int GetPrivateProfileString(    // ini Read 함수
            String section,
            String key,
            String def,
            StringBuilder retVal,
            int size,
            String filePath);

[DllImport("kernel32.dll")]
private static extern long WritePrivateProfileString(  // ini Write 함수
            String section,
            String key,
            String val,
            String filePath);

 

/// ini파일에 쓰기

public void G_IniWriteValue(String Section, String Key, String Value, string avsPath)

{
    WritePrivateProfileString(Section, Key, Value, avsPath);
}

 

/// ini파일에서 읽어 오기

public String G_IniReadValue(String Section, String Key, string avsPath)

{

    StringBuilder temp = new StringBuilder(2000);

    int i = GetPrivateProfileString(Section, Key, "", temp, 2000, avsPath); 

 

    return temp.ToString();

}

신고
C#

C# Frequently Asked Questions for C++ programmers

Andy McMullan Last update: 3-Dec-2000

This FAQ tries to address many of the basic questions that C++ developers have when they first come across C#. I recommend that you read the .NET Framework FAQ before reading this one.

If you have any comments, suggestions, corrections or criticisms, please e-mail me at andy@andymcm.com.

Disclaimer: The content of this FAQ is just my interpretation of information gleaned from various sources, including postings to the DOTNET mailing list, various MS documents, and of course practical experimentation with the language. None of the answers are necessarily completely or even partially correct. Even where the answers are correct now, they may change in the future.

Revision history (major updates only):

13-Nov-00 Updated for arrival of Beta 1 of the .NET Framework SDK. 21-Oct-00 Added "C# uses references instead of pointers. Are C# references the same as C++ references?". 31-Aug-00 Added "Does C# have a 'throws' clause?", "How can I process command-line arguments?" and "How can I make sure my C# classes

will interoperate with other .NET languages?" 29-Aug-00 Started revision history 07-Aug-00 to 28-Aug-

Miscellaneous (unrecorded) updates

00 07-Aug-00 Posted first version

1. Introduction

1.1 What is C#?

C# is a programming language designed by Microsoft. It is loosely based on C/C++, and bears a striking similarity to Java in many ways. Microsoft describe C# as follows:

"C# is a simple, modern, object oriented, and type-safe programming language derived from C and C++. C# (pronounced 'C sharp') is firmly planted in the C and C++ family tree of languages, and will immediately be familiar to C and C++ programmers. C# aims to combine the high productivity of Visual Basic and the raw power of C++."

1.2 When will C# be released?

No firm date yet, but it is expected in the second half of 2001.

1.3 How do I develop C# apps?

The .NET SDK contains the C# command-line compiler (csc.exe). The next version of Visual Studio (called Visual Studio 7 or Visual Studio.NET) will have fully integrated support for C# development.

1.4 Where can I download the .NET SDK & Visual Studio 7?

You can download Beta 1 of the SDK from http://msdn.microsoft.com/net. If you are an MSDN Universal subscriber, you can also download Beta 1 of Visual Studio 7.

1.5 Does C# replace Java?

C# is a very Java-like language - the core of both languages have similar advantages and limitations when compared to C++. For example, both languages have garbage collection, but neither language has templates. Microsoft have ceased production of Visual J++, so it's hard not to view C# as Microsoft's alternative to Java.

1.6 Does C# replace C++?

The obvious answer is no. However it's difficult to see C++ as the best choice for new .NET code. For the .NET runtime to function fully, it requires the programming language to conform to certain rules - one of these rules is that language types must conform to the Common Type System (CTS). Unfortunately many C++ features are not supported by the CTS - for example multiple inheritance of classes and templates.

Microsoft's answer to this problem is to offer Managed Extensions (ME) for C++, which allows you to write C++ that conforms to the CTS. New keywords are provided to mark your C++ classes with CTS attributes (e.g. __gc for garbage collection). However, it's difficult to see why ME C++ would be chosen over C# for new projects. In terms of features they are very similar, but unlike C++, C# has been designed from the ground-up to work seamlessly with the .NET environment. The raison d'etre for ME C++ would therefore appear to be porting existing C++ code to the .NET environment.

So, in answer to the question, my suspicion is that C++ will remain an important language outside of the .NET environment, and will be used (via ME) to port existing code to .NET, but I think C# will become the language of choice for one-time C++ developers developing new .NET applications. But only time will tell ...

1.7 What does a simple C# program look like?

Sorry, my imagination has deserted me. Yes, you guessed it, here comes 'Hello, world' ...

class CApplication

{ public static void Main() {

System.Console.Write( "Hello, new .NET world." ); } }

(No, you can't put Main() as a global function - global functions don't exist in C#.)

1.8 Is C# object-oriented?

Yes, C# is an OO language in the tradition of Java and C++.

1.9 Does C# have its own class library?

Not exactly. In common with all .NET languages (e.g. VisualBasic.NET, JScript.NET) C# has access to the .NET class library. C# does not have its own class library.

2. Basic types

2.1 What standard types does C# supply?

C# supports a very similar range of basic types to C++, including int, long, float, double, char, string, arrays, structs and classes. However, don't assume too much. The names may be familiar, but some of the details are different. For example, a long is 64 bits in C#, whereas in C++ the size of a long depends on the platform (typically 32 bits on a 32-bit platform, 64 bits on a 64-bit platform). Also classes and structs are almost the same in C++ -

this is not true for C#.

2.2 Is it true that all C# types derive from a common base class?

Yes and no. All types can be treated as if they derive from object (System.Object), but in order to treat an instance of a value type (e.g. int, float) as object-derived, the instance must be converted to a reference type using a process called 'boxing'. In theory a developer can forget about this and let the run-time worry about when the conversion is necessary, but in reality this implicit conversion can have side-effects that may trip up the unwary.

2.3 So this means I can pass an instance of a value type to a method that takes an object as a parameter?

Yes. For example:

class CApplication

{ public static void Main() {

int x = 25; string s = "fred";

DisplayMe( x ); DisplayMe( s );

}

static void DisplayMe( object o ) { System.Console.WriteLine( "You are {0}", o ); } }

This would display:

You are 25

You are fred

2.4 What are the fundamental differences between value types and reference types?

C# divides types into two categories -value types and reference types. Most of the basic intrinsic types (e.g. int, char) are value types. Structs are also value types. Reference types include classes, interfaces, arrays and strings. The basic idea is straightforward - an instance of a value type represents the actual data (stored on the stack), whereas an instance of a reference type represents a pointer or reference to the data (stored on the heap).

The most confusing aspect of this for C++ developers is that C# has predetermined which types will be represented as values, and which will be represented as references. A C++ developer expects to take responsibility for this decision.

For example, in C++ we can do this:

int x1 = 3; // x1 is a value on the stack int *x2 = new int(3) // x2 is a reference to a value on the heap

but in C# there is no control:

int x1 = 3; // x1 is a value on the stack int x2 = new int(); x2 = 3; // x2 is also a value on the stack!

2.5 Okay, so an int is a value type, and a class is a reference type. How can int be derived from object?

It isn't, really. When an int is being used as an int, it is a value (on the stack). However, when it is being used as an object, it is a reference to an integer value on the heap. In other words, when you treat an int as an object, the runtime automatically converts the int value to an object reference. This process is called boxing. The conversion involves copying the contents of the int from the stack to the heap, and creating an object instance which refers to it. Unboxing is the reverse process - the object is converted back to a stack-based value.

int x = 3; // new int value 3 on the stack object objx = x; // new int on heap, set to value 3 - still have x=3 on stack int y = (int)objx; // new value 3 on stack, still got x=3 on stack and objx=3 on heap

2.6 C# uses references instead of pointers. Are C# references the same as C++ references?

Not quite. The basic idea is the same, but one significant difference is that C# references can be null. So you cannot rely on a C# reference pointing to a valid object. If you try to use a null reference, a NullReferenceException is thrown.

For example, look at the following method:

void displayStringLength( string s ) { Console.WriteLine( "String is length {0}", s.Length ); }

The problem with this method is that it will throw a NullReferenceException if called like this:

string s = null; displayStringLength( s );

Of course for some situations you may deem a NullReferenceException to be a perfectly acceptable outcome, but in this case it might be better to re-write the method like this:

void displayStringLength( string s ) {

if( s == null ) Console.WriteLine( "String is null" ); else Console.WriteLine( "String is length {0}", s.Length ); }

3. Classes and structs

3.1 Structs are largely redundant in C++. Why does C# have them?

In C++, a struct and a class are pretty much the same thing. The only difference is the default visibility level (public for structs, private for classes). However, In C# structs and classes are very different. In C#, structs are value types (stored on the stack), whereas classes are reference types (stored on the heap). Also structs cannot inherit from structs or classes, though they can implement interfaces. Structs cannot have destructors.

3.2 Does C# support multiple inheritance (MI)?

C# supports multiple inheritance of interfaces, but not of classes.

3.3 Is a C# interface the same as a C++ abstract class?

No, not quite. An abstract class in C++ cannot be instantiated, but it can (and often does) contain implementation code and/or data members. A C# interface cannot contain any implementation code or data members - it is simply a group of method names & signatures. A C# interface is more like a COM interface than a C++ abstract class.

The other major difference is that a C# class can inherit from only one class (abstract or not), but can implement multiple interfaces.

3.4 Are C# constructors the same as C++ constructors?

Very similar.

3.5 Are C# destructors the same as C++ destructors?

No! They look the same but they're very different. First of all, a C# destructor isn't guaranteed to be called at any particular time. In fact it's not guaranteed to be called at all. Truth be told, a C# destructor is really just a Finalize method in disguise. In particular, it is a Finalize method with a call to the base class Finalize method inserted. So this:

class CTest

{ ~CTest() {

System.Console.WriteLine( "Bye bye" );

} }

is really this:

class CTest

{ protected override void Finalize() {

System.Console.WriteLine( "Bye bye" ); base.Finalize(); } }

If you don't believe me, try putting a Finalize method and a destructor in a C# class and watch the compiler sheepishly confess its deceit.

3.6 If C# destructors are so different to C++ destructors, why did MS use the same syntax?

Because they're evil, and they want to mess with your mind.

3.7 What is a static constructor?

A constructor for a class, rather than instances of a class. The static constructor is called when the class is loaded.

3.8 Are all methods virtual in C#?

No. Like C++, methods are non-virtual by default, but can be marked as virtual.

3.9 How do I declare a pure virtual function in C#?

Use the abstract modifier on the method. The class must also be marked as abstract (naturally). Note that abstract methods cannot have an implementation (unlike pure virtual C++ methods).

4. Exceptions

4.1 Can I use exceptions in C#?

Yes, in fact exceptions are the recommended error-handling mechanism in C# (and in .NET in general). Most of the .NET framework classes use exceptions to signal errors.

4.2 What types of object can I throw as exceptions?

Only instances of the System.Exception classes, or classes derived from System.Exception. This is in sharp contrast with C++ where instances of almost any type can be thrown.

4.3 Can I define my own exceptions?

Yes, as long as you follow the rule that exceptions derive from System.Exception. More specifically, MS recommend that user-defined exceptions inherit from System.ApplicationException (which is derived from System.Exception).

4.4 Are there any standard exceptions that I can re-use?

Yes, and some of them loosely correspond to standard COM HRESULTs. The table below shows a mapping from HRESULTs to .NET (and therefore C#) exceptions:

Array

Other standard exceptions that you might want to re-use are IndexOutOfRangeException and ArithmeticException .

4.5 Does the System.Exception class have any cool features?

Yes - the feature which stands out is the StackTrace property. This provides a call stack which records where the exception was thrown from. For example, the following code:

using System;

class CApp

{ public static void Main() {

try {

f(); } catch( Exception e ) {

Console.WriteLine( "System.Exception stack trace = n{0}", e.Sta }

}

static void f() { throw new Exception( "f went pear-shaped" ); } }

produces this output:

System.Exception stack trace = at CApp.f() at CApp.Main()

Note, however, that this stack trace was produced from a debug build. A release build may optimise away some of the method calls which could mean that the call stack isn't quite what you expect.

4.6 When should I throw an exception?

This is the subject of some debate, and is partly a matter of taste. However, it is accepted by many that exceptions should be thrown only when an 'unexpected' error occurs. How do you decide if an error is expected or unexpected? This is a judgement call, but a straightforward example of an expected error is failing to read from a file because the seek pointer is at the end of the file, whereas an example of an unexpected error is failing to allocate memory from the heap.

4.7 Does C# have a 'throws' clause?

No, unlike Java, C# does not require (or even allow) the developer to specify the exceptions that a method can throw.

5. Run-time type information

5.1 How can I check the type of an object at runtime?

You can use the is keyword. For example:

using System;

class CApp

{ public static void Main() {

string s = "fred"; long i = 10;

Console.WriteLine( "{0} is {1}an integer", s, (IsInteger(s) ? "" : "not ") ); Console.WriteLine( "{0} is {1}an integer", i, (IsInteger(i) ? "" : "not ") );

}

static bool IsInteger( object obj )

{ if( obj is int || obj is long ) return true; else return false; } }

produces the output:

fred is not an integer 10 is an integer

5.2 Can I get the name of a type at runtime?

Yes, use the GetType method of the object class (which all types inherit from). For example:

using System;

class CTest

{ class CApp {

public static void Main()

{ long i = 10; CTest ctest = new CTest();

DisplayTypeInfo( ctest ); DisplayTypeInfo( i ); }

static void DisplayTypeInfo( object obj ) { Console.WriteLine( "Type name = {0}, full type name = {1}", obj.G } } }

produces the following output:

Type name = CTest, full type name = CTest Type name = Int64, full type name = System.Int64

6. Advanced language features

6.1 What are delegates?

A delegate is a class derived from System.Delegate. However the language has a special syntax for declaring delegates which means that they don't look like classes. A delegate represents a method with a particular signature. An instance of a delegate represents a method with a particular signature on a particular object (or class in the case of a static method). For example:

using System;

delegate void Stereotype();

class CAmerican

{ public void BePatriotic() {

Console.WriteLine( "... <gulp> ... God bless America."); } }

class CBrit

{ public void BeXenophobic() {

Console.WriteLine( "Bloody foreigners ... " ); } }

class CApplication

{ public static void RevealYourStereotype( Stereotype[] stereotypes ) {

foreach( Stereotype s in stereotypes ) s(); }

public static void Main()

{ CAmerican chuck = new CAmerican(); CBrit edward = new CBrit();

// Create our list of sterotypes. Stereotype[] stereotypes = new Stereotype[2]; stereotypes[0] = new Stereotype( chuck.BePatriotic ); stereotypes[1] = new Stereotype( edward.BeXenophobic );

// Reveal yourselves! RevealYourStereotype(stereotypes ); } }

This produces the following result:

... <gulp>... God bless America.

Bloody foreigners ...

6.2 Are delegates just like interfaces with a single method?

Conceptually delegates can be used in a similar way to an interface with a single method. The main practical difference is that with an interface the method name is fixed, whereas with a delegate only the signature is fixed - the method name can be different, as shown in the example above.

6.3 What is the C# equivalent of QueryInterface?

The as keyword. For example:

using System;

interface IPerson { string GetName(); }

interface IPerson2 : IPerson { int GetAge(); }

class CPerson : IPerson

{ public CPerson( string name ) {

m_name = name; }

// IPerson public string GetName() {

return m_name; }

private string m_name; }

class CPerson2 : IPerson2

{ public CPerson2( string name, int age ) {

m_name = name; m_age = age; }

// IPerson2 public string GetName() { return m_name; } public int GetAge() { return m_age; } private string m_name; private int m_age;

}

public class CApp

{ public static void Main() {

CPerson bob = new CPerson( "Bob" ); CPerson2 sheila = new CPerson2( "Sheila", 24 );

DisplayAge( bob ); DisplayAge( sheila ); }

static void DisplayAge( IPerson person )

{ IPerson2 person2 = person as IPerson2; // QueryInterface lives on !!! if( person2 != null )

Console.WriteLine( "{0} is {1} years old.", person2.GetName(), pe else Console.WriteLine( "Sorry, don't know {0}'s age.", person.GetNam } }

Running the program produces the following output:

Sorry, don't know Bob's age.

Sheila is 24 years old.

7. It doesn't work like that in C++ ...

7.1 I 'new'-ed an object, but how do I delete it?

You can't. You are not allowed to call the destructor explicitly, and no delete operator is provided. Don't worry, the garbage collector will destroy your object .... eventually .... probably .... :-)

7.2 I tried to create an object on the stack, but the C# compiler complained. What's going on?

Unlike C++, you cannot create instances of classes on the stack. Class instances always live on the heap and are managed by the garbage collector.

7.3 I defined a destructor, but it never gets called. Why?

A C# destructor is really just an implementation of Finalize, and the runtime doesn't guarantee to call Finalize methods. In particular, the runtime doesn't usually bother calling Finalize methods for objects that are still alive when you exit an application. However, you can politely ask it to reconsider that approach by calling the GC.RequestFinalizeOnShutdown() method.

7.4 Most of the C# basic types have the same names as C++ basic types? Are they the same?

No. A char in C# is equivalent to a wchar_t in C++. All characters (and strings, obviously) are Unicode in C#. Integral values in C# are concrete sizes, unlike C++ (where size depends on processor). For example, a C# int is 32 bits, whereas a C++ int is normally 32 bits on a 32-bit processor and 64 bits on a 64-bit processor. A C# long is 64 bits.

8. Miscellaneous

8.1 String comparisons using == seem to be case-sensitive? How do I do a case-insensitive string comparison?

Use the String.Compare function. Its third parameter is a boolean which specifies whether case should be ignored or not.

"fred" == "Fred" // false System.String.Compare( "fred", "Fred", true ) // true

8.2 I've seen some string literals which use the @ symbol, and some which don't. What's that all about?

The @ symbol before a string literal means that escape sequences are ignored. This is particularly useful for file names, e.g.

string fileName = "c:temptest.txt"

versus:

string fileName = @"c:temptest.txt"

8.3 Does C# support a variable number of arguments?

Yes, using the params keyword. The arguments are specified as a list of arguments of a specific type, e.g. int. For ultimate flexibility, the type can be object. The standard example of a method which uses this approach is System.Console.WriteLine().

8.4 How can I process command-line arguments?

Like this:

using System;

class CApp

{ public static void Main( string[] args ) {

Console.WriteLine( "You passed the following arguments:" ); foreach( string arg in args ) Console.WriteLine( arg ); } }

8.5 Does C# do array bounds checking?

Yes. An IndexOutOfRange exception is used to signal an error.

8.6 How can I make sure my C# classes will interoperate with other .NET languages?

Make sure your C# code conforms to the Common Language Subset (CLS). To help with this, add the [assembly:CLSCompliant(true)] global attribute to your C# source files. The compiler will emit an error if you use a C# feature which is not CLS-compliant.

9. Resources

9.1 Where can I find out more about C#?

The Microsoft .NET homepage is at http://www.microsoft.com/net/

Robert Scoble has compiled an extremely comprehensive list of .NET on-line resources at

http://www.devx.com/dotnet/resources/

There is a very snazzy site dedicated to C# at http://csharpindex.com/

9.2 Sample code and utilities

Peter Drayton has some .NET utilities (with C# source) at http://www.razorsoft.net/

신고
C#
C# 관리되는, 되지 않는 리소스 사용에 대한 문제점과 해결방법

Written by ProgC

2007-05-31

C#은 CLR에 의해 모든 것이 관리된다. 그로 인해서 메모리 해제를 까먹는다거나 하는 실수를 하지 않게 된다. 실제 필자도 C계열 언어를 10년이 넘게 사용해오면서 메모리 관리가 그다지 쉽지 많은 않다는 것을 피부로 느꼈다. 근래 C#으로 프로그램을 작성하면서 굉장히 많은 이득을 얻을 수 있었는데 그 중 하나가 메모리 관리에 대한 부담이 사라진다는 점이다.
C#에 마법은 없다.
관리되지 않는 리소스를 사용할 경우에 메모리 릭이나 프로그램이 멎어 버리는 현상이 발생하기 때문이다. 이러한 프로그램들이 문제인 것은 프로그램을 실행시켜보고 바로 다운되지는 않는다는 점이다. 단지 서서히 죽어갈 뿐이다.
문제점은 알았으니 문제를 어떻게 풀어 나가야 할 지 다음과 같이 정리했다.
1. 관리되지 않는 리소스란 무엇인가?
2. 리소스가 유출 된다는 사실을 어떻게 알아낼 수 있는가?
3. 해결방법은 무엇인가?

관리되는 리소스는 이미 많은 책들에서 코드와 함께 다루고 있으므로 여기에서는 제외하기로 한다. 우리의 문제는 관리되지 않는 리소스이므로 이것에 대해서만 집중하기로 한다.

관리되지 않는 리소스.

MS의 문서에 의하면 관리되지 않는 리소스는 리소스를 래핑 하는 객체가 소멸될 때 그 소멸자를 명시적으로 호출하지 않을 때 리소스가 해제 되지 않는다고 한다. 즉 A라는 본래 리소스가 있고 B라는 리소스 래핑 객체가 생성되어 A를 사용하고 있다. 내부적으로 A를 가지고 있을 것이며 이것이 소멸될 때 A를 참조하지 않아야 한다. 그렇게 해야만 최종적으로 프로그램이 종료될 때 A라는 객체가 소멸된다. 래핑 객체가 B, C, D로 많아 질 경우에 이러한 래핑 객체는 가비지 컬렉터에 의해서 소멸되지만 그 내부에서 참조하는 것은 소멸되지 않는다. 명시적으로 소멸자를 호출해 주어야 한다. (내부적으로 래핑 객체가 어떻게 구성되었을지 모른다면.)

리소스가 유출 된다는 사실을 어떻게 알아낼 수 있는가?

불행하게도 Visual C# 2005에서 메모리가 새는 방법을 알아내는 방법은 없었다. 대신 Windows Task Manager를 이용하면 된다.

Array

열 선택을 하여 우리가 보고 싶은 정보를 선택한다.

Array

그리고 나서 작업 관리자를 보면 GDI객체나 핸들 수를 알아낼 수 있다.

private void Form1_MouseMove(object sender, MouseEventArgs e)

{

for (int i = 0; i < 10; i++)

{

Bitmap bmp = new Bitmap(100, 100);

Graphics g = Graphics.FromImage(bmp);

g.DrawImage(MouseImg, 50, 50);

Cursor newCursor = new Cursor(bmp.GetHicon());

this.Cursor = newCursor;

g.Dispose();

}

}

위의 코드는 비트맵 마우스 커서를 설정하는 것이고 MouseMove가 움직일 때 설정하게 한 코드이다.

이 코드를 실행하고 작업 관리자의 핸들 수를 보면 MouseMove가 실행될 때 핸들 수가 증가하지만 MouseMove가 끝났음에도 불구하고 핸들은 줄어들지 않는다. 즉 메모리가 유실되고 있는 것이다.

해결 방법은 무엇인가?

MS의 문서에 이미 설명이 되어 있지만 너무 간단하게만 다루고 있다. 관리되지 않는 리소스는 바로 저런 핸들이다.

private void Form1_MouseMove(object sender, MouseEventArgs e)

{

for (int i = 0; i < 10; i++)

{

Bitmap bmp = new Bitmap(100, 100);

Graphics g = Graphics.FromImage(bmp);

g.DrawImage(MouseImg, 50, 50);

// 핸들로 객체를 만들어서 할당한 후에

IntPtr refObj = bmp.GetHicon();

Cursor newCursor = new Cursor(refObj);

this.Cursor = newCursor;

// 핸들을 삭제해 주어야 한다.

DestroyIcon(newCursor.Handle);

g.Dispose();

}

}

물론 DestroyIcon함수를 사용하기 위해서 다음과 같이 코드를 작성해 주어야 한다.

// 아래 2개를 using해주어야 한다.

using Microsoft.Win32;

using System.Runtime.InteropServices;

[System.Runtime.InteropServices.DllImport("user32.dll", CharSet = CharSet.Auto)]

extern static bool DestroyIcon(IntPtr handle);

프로그램을 실행하여 정상 동작하는 프로그램 화면.

Array

마지막.

원칙.

C#은 C#답게 쓰자. 라는 원칙으로 C# 프로그램을 작성하고 있지만 언제까지 MS믿고 C

버전 올려줄 때까지 기다려주지 못한다. 정말 피할 수 없을 때에만 WinAPI코드를 사용하는 것이 좋다.

핫 스팟.

Cursor클래스에서 이미지를 이용해서 커서를 만들 때 핫스팟은 이미지의 중앙을 뜻한다. 그래서 50, 50으로 위치를 이동시켜준 것이다.

신고
C#
시간을 계산해야 할 일이 필요했다.

내가 필요했던 부분은 경매사이트에서 DB에 들어있는 마감시각을 가져와서 현재시각과 계산하여 남은 시간을 계산하기 위해서였다.

C#에서 DateTime이 시간이다. 보통 DB에도 "2007-07-23 오전 12:52"같은 형식으로 들어가는데 그럼 이것을 어떻게 계산을 해야하는가? 일단 그냥 빼기를 해서는 계산이 되지를 않았다.

C#에서는 연산자 오버로드를 할 수 있으므로 연산자 오버로드를 해야하는가 하면서 이것저것 뒤지다가 나온 것인 TimeSpan이다. 둘다 System네임스페이스를 사용한다.

TiemSpan은 시간 간격을 나타내는 구조체이다. DateTime을 계산하기 위해서 사용한다.

일단 소스를 보자.

(Language : cpp)


  1. DateTime end = DateTime.Parse(EndtimeHF.Value.ToString());



  2. TimeSpan t3 = end.Subtract(DateTime.Now);



  3. TimeSpan t2 = DateTime.Now.Subtract(DateTime.Now);



  4. if (t3.CompareTo(t2) > 0)



  5. {



  6. ? ? DeadlineLB.Text = t3.Days + "일 " + t3.Hours + "시간 " + t3.Minutes + "분 " + t3.Seconds + "초 남았습니다.";



  7. }



  8. else



  9. {



  10. ? ? DeadlineLB.Text = EndtimeHF.Value.ToString();



  11. }



따로 또 수정하기 귀찮아서 그냥 내가 쓴 소스를 그대로 잘라왔다. ㅋ

여기선 히든필드에서 값을 가져왔지만 스트링이면 DateTime으로 캐스팅하면 되고 DateTime이면 그냥 쓰면 된다.

Substract가 값을 빼는 메서드이다. end에서 현재의 시간을 빼고 이걸 TimeSpan t3에 저장해서 남은 시간을 계산했다.

여 기에 시간 간격이 0이하일 경우에는 그냥 종료시간만 표시하기 위해서 TimeSpan t2를 썼다. 이것저것 만져봤지만 TimeSpan의 형식을 정확히 알 수가 없어서 크기를 계산할 수가 없어서 나름대로 꼼수를 부렸다. Substract로 현재에서 현재를 빼서 t2에 저장을 했다. 연산속도를 보았을때 0이 나올 것이고 머 꼭 0이 아니더라도 너무 작은 값이므로 큰 상관이 없다.

비교메서드인 CompareTo를 사용해서 t3와 t2를 사용해서 시간간격이 0보다 큰지 아닌지를 비교했다.
신고
  1. kinhana 2009.04.27 01:11 신고

    질문좀 드리겠습니다
    post 로 값을 던졌습니다.....그리고...

    HttpWebRequest를 이용하여 얻어진 쿠키값을 이용하여 WebBrowser를 사용하고 싶습니다.

    HttpWebRequest HTTP = (HttpWebRequest)WebRequest.Create("a-login URL";);
    HTTP.CookieContainer = new CookieContainer();
    HTTP.Method = "POST";
    HTTP.ContentType = "application/x-www-form-urlencoded";
    MemoryStream bufferStream = new MemoryStream();
    byte[] LoginParamattaBytes = System.Text.Encoding.GetEncoding("EUC-KR";).GetBytes("ID=aa&amp;PW=bb";);

    bufferStream.Write(LoginParamattaBytes, 0, LoginParamattaBytes.Length);
    HTTP.ContentLength = bufferStream.Length;
    bufferStream.WriteTo(HTTP.GetRequestStream());
    bufferStream.Close();

    LoginCookie = HTTP.CookieContainer; &lt;== 로그인후 쿠키값 LoginCookie

    위 HttpWebRequest를 이용하여 얻어진 쿠키값을 이용하여 webBrowser1에 접속하고싶습니다.
    webBrowser1.Navigate("로그인 쿠키값이 필요한 URL";);&lt;-이렇게 제응용플에서 저쿠키를
    가져와 로그인유지하며 다른페이지로 가려고 합니다....
    방법좀 알려주시면 대단히 감사하겠습니다

    webBrowser1.Navigate(a-다른페이지, null, null, webBrowser1.Document.Cookie);
    이런식으로는 적용이 안되더라고요;;;;

    제이메일주소는 automute@live.co.kr입니다 곽창수입니다

+ Recent posts