갑령의 .net programming http://ararion.egloos.com .net 병렬 처리 프로그래밍을 중심으로 경험담을 소개합니다. ko Fri, 12 Dec 2008 04:36:49 GMT Egloos 갑령의 .net programming http://md.egloos.com/img/samplelogo2.gif http://ararion.egloos.com 80 80 .net 병렬 처리 프로그래밍을 중심으로 경험담을 소개합니다. <![CDATA[ PDC에서 발표된 새로운 .NET 테스트 메커니즘 ]]> http://ararion.egloos.com/1237369 http://ararion.egloos.com/1237369 .net 4.0과 studio 2010에 포함될 예정이고 studio 2008에서도 같은 동작을 얻을 수 있는 새로운 개념의 테스트 메커니즘을 발표 했네요. 기존 단위 테스트 개념에서 벗어나 보다 자동화된 테스트 방식입니다. 매개 변수를 가진 테스트 방식이라는 개념이네요.

image

http://research.microsoft.com/contracts/

image

newpexillustration

사용법 : PDC 2008

image

WMV-HQ, PPTX

]]> .NET http://ararion.egloos.com/1237369#comments Fri, 12 Dec 2008 04:36:42 GMT 아라리온 <![CDATA[ WPF 개발 툴들 ]]> http://ararion.egloos.com/1118925 http://ararion.egloos.com/1118925 Visualizer

Xaml Editor

기타

참고

]]> Silverlight http://ararion.egloos.com/1118925#comments Tue, 18 Nov 2008 01:22:47 GMT 아라리온 <![CDATA[ Windows dpi 설정을 알아내는 방법 ]]> http://ararion.egloos.com/1118911 http://ararion.egloos.com/1118911

다음 설정으로 현재 윈도우의 dpi 설정을 알 수 있습니다.
 
private void Form1_Load(object sender, EventArgs e)


{


    using (Graphics myGraphics = this.CreateGraphics())


    {


        MessageBox.Show(String.Format("Resolution X: {0} dpi, Resolution Y: {1} dpi", myGraphics.DpiX, myGraphics.DpiY),


                        "Windows Resolution");


    }


}




참고 : http://blogs.msdn.com/acoat/archive/2008/11/17/finding-the-windows-dpi-setting-in-net.aspx

]]> .NET http://ararion.egloos.com/1118911#comments Tue, 18 Nov 2008 01:14:56 GMT 아라리온 <![CDATA[ Visual Studio 2010과 .NET Framework 4.0 CTP가 발표되었습니다. ]]> http://ararion.egloos.com/1020492 http://ararion.egloos.com/1020492 http://www.microsoft.com/downloads/details.aspx?FamilyID=922b4655-93d0-4476-bda4-94cf5f8d4814&DisplayLang=en

너무 빠르죠.. 제가 봐도 너무 한거 같에요. 3.5 나온지가 얼마나 됬다고.. TT

자세한 내용은

보시면 됩니다.

전에 말씀드렸던 Parallel Extensions이 .NET Framework 4.0 core로 함께 포함됩니다.

]]> http://ararion.egloos.com/1020492#comments Tue, 28 Oct 2008 04:35:04 GMT 아라리온 <![CDATA[ .NET Source를 Offline에서 보려면 ]]> http://ararion.egloos.com/990462 http://ararion.egloos.com/990462 http://referencesource.microsoft.com/netframework.aspx에 가서 설치하려는 소스를 선택

참고 :

http://referencesource.microsoft.com/serversetup.aspx 설정방법

http://social.msdn.microsoft.com/Forums/en-US/refsourceserver/threads/ 공유 소스 게시판

]]> http://ararion.egloos.com/990462#comments Wed, 22 Oct 2008 02:23:14 GMT 아라리온 <![CDATA[ Offline에서 Silverlight RTM 개발 툴 설치하기 ]]> http://ararion.egloos.com/961827 http://ararion.egloos.com/961827 Microsoft® Silverlight™ Tools for Visual Studio 2008 SP1만 인터넷이 없는 상태에서 실행하면 설치 오류가 발생합니다. 다음과정을 거치면 오류를 막을 수 있습니다.

  1. Microsoft® Silverlight™ Tools for Visual Studio 2008 SP1을 다운 받는다
  2. Silverlight.2.0_Developer.exe을 다운 받는다.
  3. Silverlight_Tools.exe /x라고 실행해서 지정한 폴더에 압축을 푼다.
  4. 다운 받은 Silverlight.2.0_Developer.exe을 지정한 폴더에 복사한다.
  5. SP_Intallar.exe를 실행한다.
]]> Silverlight http://ararion.egloos.com/961827#comments Thu, 16 Oct 2008 01:36:55 GMT 아라리온 <![CDATA[ 코드 규칙을 통일하자. Style Cop과 ReSharper 4.1 설정 ]]> http://ararion.egloos.com/948830 http://ararion.egloos.com/948830
  • http://code.msdn.microsoft.com/codeanalysis에 가서 최근 버젼을 다운 받고,
  • http://www.codeplex.com/StyleCopForReSharper에 가서 ReSharper plugin을 다운 받은 뒤에 
    • <CodeStyleSettings>
    
  <CSharp>
    
    <FormatSettings>
    
      <INSERT_TABS>False</INSERT_TABS>
    
      <INDENT_SIZE>4</INDENT_SIZE>
    
      <CONTINUOUS_INDENT_MULTIPLIER>1</CONTINUOUS_INDENT_MULTIPLIER>
    
      <SPACE_BEFORE_METHOD_CALL_PARENTHESES>False</SPACE_BEFORE_METHOD_CALL_PARENTHESES>
    
      <SPACE_BEFORE_EMPTY_METHOD_CALL_PARENTHESES>False</SPACE_BEFORE_EMPTY_METHOD_CALL_PARENTHESES>
    
      <SPACE_BEFORE_METHOD_PARENTHESES>False</SPACE_BEFORE_METHOD_PARENTHESES>
    
      <SPACE_BEFORE_EMPTY_METHOD_PARENTHESES>False</SPACE_BEFORE_EMPTY_METHOD_PARENTHESES>
    
      <SPACE_WITHIN_METHOD_PARENTHESES>False</SPACE_WITHIN_METHOD_PARENTHESES>
    
      <SPACE_WITHIN_EMPTY_METHOD_PARENTHESES>False</SPACE_WITHIN_EMPTY_METHOD_PARENTHESES>
    
      <SPACE_WITHIN_METHOD_CALL_PARENTHESES>False</SPACE_WITHIN_METHOD_CALL_PARENTHESES>
    
      <SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES>False</SPACE_WITHIN_EMPTY_METHOD_CALL_PARENTHESES>
    
      <SPACE_BEFORE_ARRAY_ACCESS_BRACKETS>False</SPACE_BEFORE_ARRAY_ACCESS_BRACKETS>
    
      <SPACE_WITHIN_ARRAY_ACCESS_BRACKETS>False</SPACE_WITHIN_ARRAY_ACCESS_BRACKETS>
    
      <SPACE_BEFORE_IF_PARENTHESES>True</SPACE_BEFORE_IF_PARENTHESES>
    
      <SPACE_WITHIN_IF_PARENTHESES>False</SPACE_WITHIN_IF_PARENTHESES>
    
      <SPACE_WITHIN_TYPECAST_PARENTHESES>False</SPACE_WITHIN_TYPECAST_PARENTHESES>
    
      <SPACE_AFTER_TYPECAST_PARENTHESES>True</SPACE_AFTER_TYPECAST_PARENTHESES>
    
      <SPACE_WITHIN_PARENTHESES>False</SPACE_WITHIN_PARENTHESES>
    
      <SPACE_BEFORE_WHILE_PARENTHESES>True</SPACE_BEFORE_WHILE_PARENTHESES>
    
      <SPACE_WITHIN_WHILE_PARENTHESES>False</SPACE_WITHIN_WHILE_PARENTHESES>
    
      <SPACE_BEFORE_CATCH_PARENTHESES>True</SPACE_BEFORE_CATCH_PARENTHESES>
    
      <SPACE_WITHIN_CATCH_PARENTHESES>False</SPACE_WITHIN_CATCH_PARENTHESES>
    
      <SPACE_BEFORE_SWITCH_PARENTHESES>True</SPACE_BEFORE_SWITCH_PARENTHESES>
    
      <SPACE_WITHIN_SWITCH_PARENTHESES>False</SPACE_WITHIN_SWITCH_PARENTHESES>
    
      <SPACE_BEFORE_FOR_PARENTHESES>True</SPACE_BEFORE_FOR_PARENTHESES>
    
      <SPACE_WITHIN_FOR_PARENTHESES>False</SPACE_WITHIN_FOR_PARENTHESES>
    
      <SPACE_BEFORE_FOREACH_PARENTHESES>True</SPACE_BEFORE_FOREACH_PARENTHESES>
    
      <SPACE_WITHIN_FOREACH_PARENTHESES>False</SPACE_WITHIN_FOREACH_PARENTHESES>
    
      <SPACE_BEFORE_USING_PARENTHESES>True</SPACE_BEFORE_USING_PARENTHESES>
    
      <SPACE_WITHIN_USING_PARENTHESES>False</SPACE_WITHIN_USING_PARENTHESES>
    
      <SPACE_BEFORE_LOCK_PARENTHESES>True</SPACE_BEFORE_LOCK_PARENTHESES>
    
      <SPACE_WITHIN_LOCK_PARENTHESES>False</SPACE_WITHIN_LOCK_PARENTHESES>
    
      <SPACE_BEFORE_TYPEOF_PARENTHESES>False</SPACE_BEFORE_TYPEOF_PARENTHESES>
    
      <SPACE_WITHIN_TYPEOF_PARENTHESES>False</SPACE_WITHIN_TYPEOF_PARENTHESES>
    
      <SPACE_BEFORE_FIXED_PARENTHESES>True</SPACE_BEFORE_FIXED_PARENTHESES>
    
      <SPACE_WITHIN_FIXED_PARENTHESES>False</SPACE_WITHIN_FIXED_PARENTHESES>
    
      <SPACE_BEFORE_SIZEOF_PARENTHESES>True</SPACE_BEFORE_SIZEOF_PARENTHESES>
    
      <SPACE_WITHIN_SIZEOF_PARENTHESES>False</SPACE_WITHIN_SIZEOF_PARENTHESES>
    
      <SPACE_BEFORE_TYPE_PARAMETER_ANGLE>False</SPACE_BEFORE_TYPE_PARAMETER_ANGLE>
    
      <SPACE_WITHIN_TYPE_PARAMETER_ANGLES>False</SPACE_WITHIN_TYPE_PARAMETER_ANGLES>
    
      <SPACE_BEFORE_TYPE_ARGUMENT_ANGLE>False</SPACE_BEFORE_TYPE_ARGUMENT_ANGLE>
    
      <SPACE_WITHIN_TYPE_ARGUMENT_ANGLES>False</SPACE_WITHIN_TYPE_ARGUMENT_ANGLES>
    
      <SPACE_AFTER_COMMA>True</SPACE_AFTER_COMMA>
    
      <SPACE_BEFORE_COMMA>False</SPACE_BEFORE_COMMA>
    
      <SPACE_BEFORE_FOR_SEMICOLON>False</SPACE_BEFORE_FOR_SEMICOLON>
    
      <SPACE_AFTER_FOR_SEMICOLON>True</SPACE_AFTER_FOR_SEMICOLON>
    
      <SPACE_BEFORE_TERNARY_QUEST>True</SPACE_BEFORE_TERNARY_QUEST>
    
      <SPACE_AFTER_TERNARY_QUEST>True</SPACE_AFTER_TERNARY_QUEST>
    
      <SPACE_BEFORE_TERNARY_COLON>True</SPACE_BEFORE_TERNARY_COLON>
    
      <SPACE_AFTER_TERNARY_COLON>True</SPACE_AFTER_TERNARY_COLON>
    
      <SPACE_BEFORE_ATTRIBUTE_COLON>False</SPACE_BEFORE_ATTRIBUTE_COLON>
    
      <SPACE_AFTER_ATTRIBUTE_COLON>True</SPACE_AFTER_ATTRIBUTE_COLON>
    
      <SPACE_BEFORE_EXTENDS_COLON>True</SPACE_BEFORE_EXTENDS_COLON>
    
      <SPACE_AFTER_EXTENDS_COLON>True</SPACE_AFTER_EXTENDS_COLON>
    
      <SPACE_BEFORE_TYPE_PARAMETER_CONSTRAINT_COLON>True</SPACE_BEFORE_TYPE_PARAMETER_CONSTRAINT_COLON>
    
      <SPACE_AFTER_TYPE_PARAMETER_CONSTRAINT_COLON>True</SPACE_AFTER_TYPE_PARAMETER_CONSTRAINT_COLON>
    
      <SPACE_AROUND_LAMBDA_ARROW>True</SPACE_AROUND_LAMBDA_ARROW>
    
      <SPACE_AROUND_ASSIGNMENT_OP>True</SPACE_AROUND_ASSIGNMENT_OP>
    
      <SPACE_AROUND_LOGICAL_OP>True</SPACE_AROUND_LOGICAL_OP>
    
      <SPACE_AROUND_EQUALITY_OP>True</SPACE_AROUND_EQUALITY_OP>
    
      <SPACE_AROUND_RELATIONAL_OP>True</SPACE_AROUND_RELATIONAL_OP>
    
      <SPACE_AROUND_BITWISE_OP>True</SPACE_AROUND_BITWISE_OP>
    
      <SPACE_AROUND_ADDITIVE_OP>True</SPACE_AROUND_ADDITIVE_OP>
    
      <SPACE_AROUND_MULTIPLICATIVE_OP>False</SPACE_AROUND_MULTIPLICATIVE_OP>
    
      <SPACE_AROUND_SHIFT_OP>True</SPACE_AROUND_SHIFT_OP>
    
      <SPACE_AROUND_NULLCOALESCING_OP>True</SPACE_AROUND_NULLCOALESCING_OP>
    
      <SPACE_AFTER_AMPERSAND_OP>False</SPACE_AFTER_AMPERSAND_OP>
    
      <SPACE_AFTER_ASTERIK_OP>False</SPACE_AFTER_ASTERIK_OP>
    
      <SPACE_AROUND_ARROW_OP>False</SPACE_AROUND_ARROW_OP>
    
      <SPACE_AROUND_DOT>False</SPACE_AROUND_DOT>
    
      <SPACE_IN_SINGLELINE_ACCESSOR>True</SPACE_IN_SINGLELINE_ACCESSOR>
    
      <SPACE_IN_SINGLELINE_METHOD>True</SPACE_IN_SINGLELINE_METHOD>
    
      <SPACE_IN_SINGLELINE_ANONYMOUS_METHOD>True</SPACE_IN_SINGLELINE_ANONYMOUS_METHOD>
    
      <SPACE_WITHIN_ATTRIBUTE_BRACKETS>False</SPACE_WITHIN_ATTRIBUTE_BRACKETS>
    
      <SPACE_BEFORE_SEMICOLON>False</SPACE_BEFORE_SEMICOLON>
    
      <SPACE_BEFORE_COLON_IN_CASE>False</SPACE_BEFORE_COLON_IN_CASE>
    
      <SPACE_BEFORE_NULLABLE_MARK>False</SPACE_BEFORE_NULLABLE_MARK>
    
      <SPACE_BEFORE_ARRAY_CREATION_BRACE>True</SPACE_BEFORE_ARRAY_CREATION_BRACE>
    
      <SPACE_BEFORE_ARRAY_RANK_BRACKETS>False</SPACE_BEFORE_ARRAY_RANK_BRACKETS>
    
      <SPACE_WITHIN_ARRAY_RANK_BRACKETS>False</SPACE_WITHIN_ARRAY_RANK_BRACKETS>
    
      <SPACE_WITHIN_ARRAY_RANK_EMPTY_BRACKETS>False</SPACE_WITHIN_ARRAY_RANK_EMPTY_BRACKETS>
    
      <SPACE_BEFORE_POINTER_ASTERIK_DECLARATION>False</SPACE_BEFORE_POINTER_ASTERIK_DECLARATION>
    
      <SPACE_WITHIN_SINGLE_LINE_ARRAY_INITIALIZER_BRACES>True</SPACE_WITHIN_SINGLE_LINE_ARRAY_INITIALIZER_BRACES>
    
      <TYPE_DECLARATION_BRACES>NEXT_LINE</TYPE_DECLARATION_BRACES>
    
      <INVOCABLE_DECLARATION_BRACES>NEXT_LINE</INVOCABLE_DECLARATION_BRACES>
    
      <ANONYMOUS_METHOD_DECLARATION_BRACES>NEXT_LINE</ANONYMOUS_METHOD_DECLARATION_BRACES>
    
      <CASE_BLOCK_BRACES>NEXT_LINE</CASE_BLOCK_BRACES>
    
      <INITIALIZER_BRACES>NEXT_LINE</INITIALIZER_BRACES>
    
      <OTHER_BRACES>NEXT_LINE</OTHER_BRACES>
    
      <EMPTY_BLOCK_STYLE>MULTILINE</EMPTY_BLOCK_STYLE>
    
      <PLACE_ELSE_ON_NEW_LINE>True</PLACE_ELSE_ON_NEW_LINE>
    
      <PLACE_WHILE_ON_NEW_LINE>False</PLACE_WHILE_ON_NEW_LINE>
    
      <PLACE_CATCH_ON_NEW_LINE>True</PLACE_CATCH_ON_NEW_LINE>
    
      <PLACE_FINALLY_ON_NEW_LINE>True</PLACE_FINALLY_ON_NEW_LINE>
    
      <KEEP_USER_LINEBREAKS>True</KEEP_USER_LINEBREAKS>
    
      <SIMPLE_EMBEDDED_STATEMENT_STYLE>DO_NOT_CHANGE</SIMPLE_EMBEDDED_STATEMENT_STYLE>
    
      <FORCE_IFELSE_BRACES_STYLE>ALWAYS_ADD</FORCE_IFELSE_BRACES_STYLE>
    
      <FORCE_FOR_BRACES_STYLE>ALWAYS_ADD</FORCE_FOR_BRACES_STYLE>
    
      <FORCE_FOREACH_BRACES_STYLE>ALWAYS_ADD</FORCE_FOREACH_BRACES_STYLE>
    
      <FORCE_WHILE_BRACES_STYLE>ALWAYS_ADD</FORCE_WHILE_BRACES_STYLE>
    
      <FORCE_USING_BRACES_STYLE>ALWAYS_ADD</FORCE_USING_BRACES_STYLE>
    
      <FORCE_FIXED_BRACES_STYLE>ALWAYS_ADD</FORCE_FIXED_BRACES_STYLE>
    
      <KEEP_BLANK_LINES_IN_DECLARATIONS>1</KEEP_BLANK_LINES_IN_DECLARATIONS>
    
      <KEEP_BLANK_LINES_IN_CODE>1</KEEP_BLANK_LINES_IN_CODE>
    
      <BLANK_LINES_BEFORE_USING>0</BLANK_LINES_BEFORE_USING>
    
      <BLANK_LINES_AFTER_USING>1</BLANK_LINES_AFTER_USING>
    
      <BLANK_LINES_AROUND_NAMESPACE>1</BLANK_LINES_AROUND_NAMESPACE>
    
      <BLANK_LINES_AROUND_TYPE>1</BLANK_LINES_AROUND_TYPE>
    
      <BLANK_LINES_AROUND_FIELD>1</BLANK_LINES_AROUND_FIELD>
    
      <BLANK_LINES_AROUND_SINGLE_LINE_FIELD>0</BLANK_LINES_AROUND_SINGLE_LINE_FIELD>
    
      <BLANK_LINES_AROUND_INVOCABLE>1</BLANK_LINES_AROUND_INVOCABLE>
    
      <BLANK_LINES_AROUND_SINGLE_LINE_INVOCABLE>1</BLANK_LINES_AROUND_SINGLE_LINE_INVOCABLE>
    
      <BLANK_LINES_AROUND_REGION>1</BLANK_LINES_AROUND_REGION>
    
      <BLANK_LINES_INSIDE_REGION>1</BLANK_LINES_INSIDE_REGION>
    
      <BLANK_LINES_BETWEEN_USING_GROUPS>0</BLANK_LINES_BETWEEN_USING_GROUPS>
    
      <BLANK_LINES_AFTER_USING_LIST>1</BLANK_LINES_AFTER_USING_LIST>
    
      <MODIFIERS_ORDER length="14">
    
        <_0>public</_0>
    
        <_1>protected</_1>
    
        <_2>internal</_2>
    
        <_3>private</_3>
    
        <_4>new</_4>
    
        <_5>abstract</_5>
    
        <_6>virtual</_6>
    
        <_7>override</_7>
    
        <_8>sealed</_8>
    
        <_9>static</_9>
    
        <_10>readonly</_10>
    
        <_11>extern</_11>
    
        <_12>unsafe</_12>
    
        <_13>volatile</_13>
    
      </MODIFIERS_ORDER>
    
      <EXPLICIT_PRIVATE_MODIFIER>True</EXPLICIT_PRIVATE_MODIFIER>
    
      <EXPLICIT_INTERNAL_MODIFIER>True</EXPLICIT_INTERNAL_MODIFIER>
    
      <ARRANGE_MODIFIER_IN_EXISTING_CODE>True</ARRANGE_MODIFIER_IN_EXISTING_CODE>
    
      <ALIGN_MULTILINE_PARAMETER>True</ALIGN_MULTILINE_PARAMETER>
    
      <ALIGN_MULTILINE_ARGUMENT>True</ALIGN_MULTILINE_ARGUMENT>
    
      <ALIGN_MULTILINE_EXTENDS_LIST>True</ALIGN_MULTILINE_EXTENDS_LIST>
    
      <ALIGN_MULTILINE_EXPRESSION>True</ALIGN_MULTILINE_EXPRESSION>
    
      <ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER>True</ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER>
    
      <ALIGN_MULTLINE_TYPE_PARAMETER_LIST>True</ALIGN_MULTLINE_TYPE_PARAMETER_LIST>
    
      <ALIGN_MULTLINE_TYPE_PARAMETER_CONSTRAINS>True</ALIGN_MULTLINE_TYPE_PARAMETER_CONSTRAINS>
    
      <ALIGN_MULTILINE_FOR_STMT>True</ALIGN_MULTILINE_FOR_STMT>
    
      <ALIGN_MULTIPLE_DECLARATION>True</ALIGN_MULTIPLE_DECLARATION>
    
      <WRAP_LINES>False</WRAP_LINES>
    
      <WRAP_LIMIT>200</WRAP_LIMIT>
    
      <WRAP_BEFORE_INVOCATION_LPAR>False</WRAP_BEFORE_INVOCATION_LPAR>
    
      <WRAP_AFTER_INVOCATION_LPAR>False</WRAP_AFTER_INVOCATION_LPAR>
    
      <WRAP_BEFORE_DECLARATION_LPAR>False</WRAP_BEFORE_DECLARATION_LPAR>
    
      <WRAP_AFTER_DECLARATION_LPAR>False</WRAP_AFTER_DECLARATION_LPAR>
    
      <WRAP_BEFORE_TYPE_PARAMETER_LANGLE>False</WRAP_BEFORE_TYPE_PARAMETER_LANGLE>
    
      <WRAP_BEFORE_EXTENDS_COLON>False</WRAP_BEFORE_EXTENDS_COLON>
    
      <WRAP_BEFORE_BINARY_OPSIGN>False</WRAP_BEFORE_BINARY_OPSIGN>
    
      <WRAP_BEFORE_FIRST_TYPE_PARAMETER_CONSTRAINT>False</WRAP_BEFORE_FIRST_TYPE_PARAMETER_CONSTRAINT>
    
      <FORCE_CHOP_COMPOUND_IF_EXPRESSION>False</FORCE_CHOP_COMPOUND_IF_EXPRESSION>
    
      <FORCE_CHOP_COMPOUND_WHILE_EXPRESSION>False</FORCE_CHOP_COMPOUND_WHILE_EXPRESSION>
    
      <FORCE_CHOP_COMPOUND_DO_EXPRESSION>False</FORCE_CHOP_COMPOUND_DO_EXPRESSION>
    
      <WRAP_PARAMETERS_STYLE>WRAP_IF_LONG</WRAP_PARAMETERS_STYLE>
    
      <WRAP_ARGUMENTS_STYLE>WRAP_IF_LONG</WRAP_ARGUMENTS_STYLE>
    
      <WRAP_EXTENDS_LIST_STYLE>WRAP_IF_LONG</WRAP_EXTENDS_LIST_STYLE>
    
      <WRAP_FOR_STMT_HEADER_STYLE>CHOP_IF_LONG</WRAP_FOR_STMT_HEADER_STYLE>
    
      <WRAP_TERNARY_EXPR_STYLE>CHOP_IF_LONG</WRAP_TERNARY_EXPR_STYLE>
    
      <WRAP_MULTIPLE_DECLARATION_STYLE>CHOP_IF_LONG</WRAP_MULTIPLE_DECLARATION_STYLE>
    
      <WRAP_MULTIPLE_TYPE_PARAMEER_CONSTRAINTS_STYLE>WRAP_IF_LONG</WRAP_MULTIPLE_TYPE_PARAMEER_CONSTRAINTS_STYLE>
    
      <WRAP_OBJECT_AND_COLLECTION_INITIALIZER_STYLE>WRAP_IF_LONG</WRAP_OBJECT_AND_COLLECTION_INITIALIZER_STYLE>
    
      <FORCE_ATTRIBUTE_STYLE>DO_NOT_CHANGE</FORCE_ATTRIBUTE_STYLE>
    
      <PLACE_ABSTRACT_ACCESSORHOLDER_ON_SINGLE_LINE>True</PLACE_ABSTRACT_ACCESSORHOLDER_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE>False</PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_ACCESSOR_ON_SINGLE_LINE>False</PLACE_SIMPLE_ACCESSOR_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_METHOD_ON_SINGLE_LINE>False</PLACE_SIMPLE_METHOD_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_ANONYMOUSMETHOD_ON_SINGLE_LINE>True</PLACE_SIMPLE_ANONYMOUSMETHOD_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_LINQ_ON_SINGLE_LINE>False</PLACE_SIMPLE_LINQ_ON_SINGLE_LINE>
    
      <PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE>True</PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE>
    
      <PLACE_TYPE_ATTRIBUTE_ON_SAME_LINE>False</PLACE_TYPE_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_METHOD_ATTRIBUTE_ON_SAME_LINE>False</PLACE_METHOD_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE>False</PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE>False</PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_TYPE_CONSTRAINTS_ON_SAME_LINE>True</PLACE_TYPE_CONSTRAINTS_ON_SAME_LINE>
    
      <PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE>True</PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE>
    
      <INDENT_ANONYMOUS_METHOD_BLOCK>True</INDENT_ANONYMOUS_METHOD_BLOCK>
    
      <INDENT_EMBRACED_INITIALIZER_BLOCK>True</INDENT_EMBRACED_INITIALIZER_BLOCK>
    
      <SPECIAL_ELSE_IF_TREATMENT>True</SPECIAL_ELSE_IF_TREATMENT>
    
      <INDENT_CASE_FROM_SWITCH>True</INDENT_CASE_FROM_SWITCH>
    
      <INDENT_NESTED_USINGS_STMT>False</INDENT_NESTED_USINGS_STMT>
    
      <INDENT_NESTED_FIXED_STMT>False</INDENT_NESTED_FIXED_STMT>
    
      <STICK_COMMENT>True</STICK_COMMENT>
    
      <REDUNDANT_THIS_QUALIFIER_STYLE>ALWAYS_USE</REDUNDANT_THIS_QUALIFIER_STYLE>
    
    </FormatSettings>
    
    <UsingsSettings>
    
      <AddImportsToDeepestScope>True</AddImportsToDeepestScope>
    
      <AllowAlias>True</AllowAlias>
    
      <PreferQualifiedReference>False</PreferQualifiedReference>
    
      <CanUseGlobalAlias>True</CanUseGlobalAlias>
    
      <SortUsings>True</SortUsings>
    
      <KeepImports length="0" />
    
      <MandatoryImports length="0" />
    
      <KeepNontrivialAlias>True</KeepNontrivialAlias>
    
    </UsingsSettings>
    
  </CSharp>
    
  <VB>
    
    <FormatSettings>
    
      <INSERT_TABS>False</INSERT_TABS>
    
      <INDENT_SIZE>4</INDENT_SIZE>
    
      <SPACE_BEFORE_INVOCATION_PARENTHESES>True</SPACE_BEFORE_INVOCATION_PARENTHESES>
    
      <SPACE_BEFORE_EMPTY_INVOCATION_PARENTHESES>False</SPACE_BEFORE_EMPTY_INVOCATION_PARENTHESES>
    
      <SPACE_BEFORE_METHOD_PARENTHESES>True</SPACE_BEFORE_METHOD_PARENTHESES>
    
      <SPACE_BEFORE_EMPTY_METHOD_PARENTHESES>False</SPACE_BEFORE_EMPTY_METHOD_PARENTHESES>
    
      <SPACE_WITHIN_INVOCATION_PARENTHESES>False</SPACE_WITHIN_INVOCATION_PARENTHESES>
    
      <SPACE_WITHIN_EMPTY_INVOCATION_PARENTHESES>False</SPACE_WITHIN_EMPTY_INVOCATION_PARENTHESES>
    
      <SPACE_WITHIN_METHOD_PARENTHESES>False</SPACE_WITHIN_METHOD_PARENTHESES>
    
      <SPACE_WITHIN_EMPTY_METHOD_PARENTHESES>False</SPACE_WITHIN_EMPTY_METHOD_PARENTHESES>
    
      <SPACE_BEFORE_TYPE_PARAMETER_PARENTHESES>True</SPACE_BEFORE_TYPE_PARAMETER_PARENTHESES>
    
      <SPACE_WITHIN_TYPE_PARAMETER_PARENTHESES>False</SPACE_WITHIN_TYPE_PARAMETER_PARENTHESES>
    
      <SPACE_WITHIN_EXPRESSION_PARENTHESES>False</SPACE_WITHIN_EXPRESSION_PARENTHESES>
    
      <SPACE_BEFORE_COMMA>False</SPACE_BEFORE_COMMA>
    
      <SPACE_AFTER_COMMA>True</SPACE_AFTER_COMMA>
    
      <SPACE_WITHIN_ATTRIBUTE_ANGLES>False</SPACE_WITHIN_ATTRIBUTE_ANGLES>
    
      <SPACE_BEFORE_ATTRIBUTE_TARGET_COLON>False</SPACE_BEFORE_ATTRIBUTE_TARGET_COLON>
    
      <SPACE_AFTER_ATTRIBUTE_TARGET_COLON>True</SPACE_AFTER_ATTRIBUTE_TARGET_COLON>
    
      <SPACE_BEFORE_ARRAY_RANK_PARENTHESES>False</SPACE_BEFORE_ARRAY_RANK_PARENTHESES>
    
      <SPACE_WITHIN_ARRAY_RANK_PARENTHESES>False</SPACE_WITHIN_ARRAY_RANK_PARENTHESES>
    
      <SPACE_WITHIN_ARRAY_RANK_EMPTY_PARENTHESES>False</SPACE_WITHIN_ARRAY_RANK_EMPTY_PARENTHESES>
    
      <SPACE_WITHIN_ARRAY_INITIALIZATION_BRACES>False</SPACE_WITHIN_ARRAY_INITIALIZATION_BRACES>
    
      <SPACE_AROUND_ASSIGNMENT_OP>True</SPACE_AROUND_ASSIGNMENT_OP>
    
      <SPACE_AROUND_RELATIONAL_OP>True</SPACE_AROUND_RELATIONAL_OP>
    
      <SPACE_AROUND_ADDITIVE_OP>True</SPACE_AROUND_ADDITIVE_OP>
    
      <SPACE_AROUND_MULTIPLICATIVE_OP>False</SPACE_AROUND_MULTIPLICATIVE_OP>
    
      <SPACE_AROUND_SHIFT_OP>True</SPACE_AROUND_SHIFT_OP>
    
      <SPACE_AROUND_DOT>False</SPACE_AROUND_DOT>
    
      <SPACE_BEFORE_LABEL_COLON>False</SPACE_BEFORE_LABEL_COLON>
    
      <SPACE_AROUND_STMT_COLON>True</SPACE_AROUND_STMT_COLON>
    
      <KEEP_BLANK_LINES_IN_DECLARATIONS>2</KEEP_BLANK_LINES_IN_DECLARATIONS>
    
      <KEEP_BLANK_LINES_IN_CODE>2</KEEP_BLANK_LINES_IN_CODE>
    
      <KEEP_USER_LINEBREAKS>True</KEEP_USER_LINEBREAKS>
    
      <BLANK_LINES_AFTER_OPTIONS>1</BLANK_LINES_AFTER_OPTIONS>
    
      <BLANK_LINES_AFTER_IMPORTS>1</BLANK_LINES_AFTER_IMPORTS>
    
      <BLANK_LINES_AROUND_GLOBAL_ATTRIBUTE>0</BLANK_LINES_AROUND_GLOBAL_ATTRIBUTE>
    
      <BLANK_LINES_AROUND_NAMESPACE>1</BLANK_LINES_AROUND_NAMESPACE>
    
      <BLANK_LINES_AROUND_TYPE>1</BLANK_LINES_AROUND_TYPE>
    
      <BLANK_LINES_AROUND_FIELD>1</BLANK_LINES_AROUND_FIELD>
    
      <BLANK_LINES_AROUND_INVOCABLE>1</BLANK_LINES_AROUND_INVOCABLE>
    
      <BLANK_LINES_AROUND_SINGLE_LINE_INVOCABLE>0</BLANK_LINES_AROUND_SINGLE_LINE_INVOCABLE>
    
      <BLANK_LINES_AROUND_SINGLE_LINE_FIELD>0</BLANK_LINES_AROUND_SINGLE_LINE_FIELD>
    
      <BLANK_LINES_AROUND_REGION>1</BLANK_LINES_AROUND_REGION>
    
      <BLANK_LINES_INSIDE_REGION>1</BLANK_LINES_INSIDE_REGION>
    
      <WRAP_LINES>True</WRAP_LINES>
    
      <WRAP_LIMIT>120</WRAP_LIMIT>
    
      <WRAP_BEFORE_INVOCATION_LPAR>False</WRAP_BEFORE_INVOCATION_LPAR>
    
      <WRAP_BEFORE_DECLARATION_LPAR>False</WRAP_BEFORE_DECLARATION_LPAR>
    
      <WRAP_BEFORE_BINARY_OPSIGN>False</WRAP_BEFORE_BINARY_OPSIGN>
    
      <WRAP_PARAMETERS_STYLE>WRAP_IF_LONG</WRAP_PARAMETERS_STYLE>
    
      <WRAP_ARGUMENTS_STYLE>WRAP_IF_LONG</WRAP_ARGUMENTS_STYLE>
    
      <WRAP_EXTENDS_LIST_STYLE>WRAP_IF_LONG</WRAP_EXTENDS_LIST_STYLE>
    
      <WRAP_MULTIPLE_DECLARATION_STYLE>CHOP_IF_LONG</WRAP_MULTIPLE_DECLARATION_STYLE>
    
      <ALIGN_MULTILINE_PARAMETER>True</ALIGN_MULTILINE_PARAMETER>
    
      <ALIGN_MULTILINE_ARGUMENT>True</ALIGN_MULTILINE_ARGUMENT>
    
      <ALIGN_MULTILINE_IMPLEMENTS_LIST>True</ALIGN_MULTILINE_IMPLEMENTS_LIST>
    
      <ALIGN_MULTILINE_EXPRESSION>True</ALIGN_MULTILINE_EXPRESSION>
    
      <ALIGN_MULTILINE_ARRAY_INITIALIZER>True</ALIGN_MULTILINE_ARRAY_INITIALIZER>
    
      <ALIGN_MULTIPLE_DECLARATION>True</ALIGN_MULTIPLE_DECLARATION>
    
      <PLACE_TYPE_ATTRIBUTE_ON_SAME_LINE>False</PLACE_TYPE_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_METHOD_ATTRIBUTE_ON_SAME_LINE>False</PLACE_METHOD_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_PROPERTY_ATTRIBUTE_ON_SAME_LINE>False</PLACE_PROPERTY_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_EVENT_ATTRIBUTE_ON_SAME_LINE>False</PLACE_EVENT_ATTRIBUTE_ON_SAME_LINE>
    
      <PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE>True</PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE>
    
      <INDENT_CASE_FROM_SELECT>True</INDENT_CASE_FROM_SELECT>
    
      <STICK_COMMENT>True</STICK_COMMENT>
    
    </FormatSettings>
    
    <ImportsSettings>
    
      <AllowAlias>True</AllowAlias>
    
      <PreferQualifiedReference>False</PreferQualifiedReference>
    
      <KeepImports length="0" />
    
      <MandatoryImports length="0" />
    
      <KeepNontrivialAlias>True</KeepNontrivialAlias>
    
    </ImportsSettings>
    
  </VB>
    
  <CopyXmlCommentsOnOverride>False</CopyXmlCommentsOnOverride>
    
  <FileHeader Region="File Header"><![CDATA[==++== 
    
작성자 :
    

    
 ==--== 
    
-----------------------------------------------------------------
    
 파일명:
    
 
    
 설명:
    

    
-]]></FileHeader>
    
  <Naming>
    
    <DefaultExceptionName>e</DefaultExceptionName>
    
    <PreferLongerNames>False</PreferLongerNames>
    
    <Field prefix="" suffix="" />
    
    <StaticField prefix="" suffix="" />
    
    <Parameter prefix="" suffix="" />
    
    <LocalVariable prefix="" suffix="" />
    
  </Naming>
    
</CodeStyleSettings>


    • 위 내용을 xml파일로 저장한 뒤 Resharper에서 파일을 import 시키면 됩니다.


    설정이 다 되었으면 코드에서 Full Cleanup 하시면 Style Cop에 맞게 자동 정렬됩니다.


    ]]>     http://ararion.egloos.com/948830#comments Mon, 13 Oct 2008 04:52:16 GMT 아라리온     <![CDATA[ C#에서 병렬 처리 3 - pure function 시작 ]]> http://ararion.egloos.com/948369 http://ararion.egloos.com/948369 조금 지났지만 헤슬버그가 C# 4.0에서 어떻게 언어에서 동시성 처리를 지원 할런지가 제일 큰 이슈라고 했습니다. 인터뷰 내용을 보면 병렬 처리에서 동작하는 코드 블럭이 pure function이라는 것을 컴파일러가 보증하는 방법도 고려하고 있음을 알 수 있습니다. 그럼 pure function에 대해서 알아보도록 하겠습니다.

    A pure function is a function which has no side-effects and does not depend on any state beyond its local scope(ParallelExtensions help)

    Pure Function은 로컬 영역 바깥의 상태에 영향을 받지도 않고 부수적 효과(Side-Effects)도 일으키지 않는  함수를 이야기 합니다.

    간단한 예를 들면 

       1: var list = new List<int>();
       2:  
       3: ThreadPool.QueueUserWorkItem(
       4:     o =>
       5:     {
       6:         var addedList = o as List<int>;
       7:         if (addedList == null) return;
       8:  
       9:         for (int j = 0; j < 100; j++)
      10:         {
      11:             addedList.Add(j);
      12:         }
      13:     }
      14:     , list);
      15:  
      16: Thread.Sleep(1000);
      17: Console.WriteLine(list.Count);

    다음을 실행하면 원하는 값 100을 반환합니다. 하지만 "o => {...}"은 pure function이라고 말할 수 있을까요? List<T>는 mutable 형식이기에 언제든 상태가 변경될 수 있습니다. 따라서 이 식은 pure function이라고 말 할수 없습니다. 만일 다음 예제처럼 복잡한 식에 일부분이면 



       1: var list = new List<int>();
       2:  
       3: for (int i = 0; i < 100; i++)
       4: {
       5:     ThreadPool.QueueUserWorkItem(
       6:         o =>
       7:             {
       8:                 var addedList = o as List<int>;
       9:                 if (addedList == null) return;
      10:  
      11:                 for (int j = 0; j < 100; j++)
      12:                 {
      13:                     addedList.Add(j);
      14:                 }
      15:             }
      16:  
      17:         , list);
      18: }
      19:  
      20: var t = new Thread(
      21:     o =>
      22:         {
      23:             var addedList = o as List<int>;
      24:             if (addedList == null) return;
      25:             addedList.Add(1);
      26:         });
      27: t.Start(list);
      28:  
      29: Thread.Sleep(10000);
      30: Console.WriteLine(list.Count);
      31:  
      32: Assert.AreEqual(100*100 + 1, list.Count);


    원하는 값을 얻을 수도 있고 실패 할 수도 있습니다. 이 예제에서 아셨듯이 pure funtion을 만드는 과정에는 mutable 형식이 걸릴돌이 되고 있음을 알 수 있습니다. 전번 글에 멀티스레드 프로그래밍의 지침 중 공유데이터를 되도록 이면 피해야 하는 이유도 대략 이와 비슷한 맥락입니다.

    OOP에서 개체는 상태를 지니고 있고 언제든 상태를 변경하도록 메서드를 노출하도록 하고 있습니다. 하지만 동시성 영역에 들어서면 주어진 외부 개체의 상태를 변경하는 과정이 없거나 부수효과을 일으키지 않으면서 바꿔야 합니다. pure function은 이보다 좀더 강하게 주어진 외부 개체의 상태를 변경하는 과정이 전혀 없어야합니다. OOP에서 자연스럽게 변경했던 개체의 상태 변경이 동시성 영역에서는 부자연스러워 지면서 잡기 힘든 버그들이 양산되는 겁니다.


    현재 예제는 멀티스레딩이니 lock문을 사용하면 어느 정도 원하는 값을 얻겠지만 아래 예제는 단순히 예제이기 때문에 결코 올바른 방법(전번 시간에 이야기한 주의사항 참고)이 아님을 강조합니다.



       1: var list = new List<int>();
       2: lock (list)
       3: {
       4:     for (int i = 0; i < 100; i++)
       5:     {
       6:         ThreadPool.QueueUserWorkItem(
       7:             o =>
       8:                 {
       9:                     var addedList = o as List<int>;
      10:                     if (addedList == null) return;
      11:  
      12:                     for (int j = 0; j < 100; j++)
      13:                     {
      14:                         addedList.Add(j);
      15:                     }
      16:                 }
      17:  
      18:             , list);
      19:     }
      20:  
      21:     var t = new Thread(
      22:         o =>
      23:             {
      24:                 var addedList = o as List<int>;
      25:                 if (addedList == null) return;
      26:                 addedList.Add(1);
      27:             });
      28:     t.Start(list);
      29:  
      30:     Thread.Sleep(1000);
      31: }
      32:  
      33: Console.WriteLine(list.Count);
      34:  
      35: Assert.AreEqual(100 * 100 + 1, list.Count);

     

    이런 동시성 영역에 조건을 만족하는 프로그램 방식이 함수형 프로그래밍(Functional programming)입니다. 함수형 언어로 작성된 함수들은 pure function고, 함수형 언어에서 다루는 형식들은 기본이 immutable 형식입니다. C# 3.0에 도입된 람다식이 항수형 언어의 특징을 빌어왔고 이를 통해 어느 정도 함수형 프로그래밍을 구현할 요소를 갖추게 되었습니다. C# 3.0은 OOP와 Functional programming이 만나는 공간이 되었고 동시성 처리를 위해 FP 스타일의 개발에 익숙해 질 필요가 생긴 것입니다.

    따라서, 다음은 immutable 형식 또는 값 형식(켄트 백의 구현 패턴, 5장)식이라고 말하는 개체들을 어떻게 C#에서 표현해야 하는지 알아보도록 하겠습니다.


    용어의 혼란 :


    제가 동시성과 병렬 처리를 혼용하고 있습니다. 같이 쓰는 부분도 있고 동시성만 이야기 하는 경우도 있습니다. 이해를 돕기 위해 설명하면


    동시성 프로그래밍은 멀티스레드와 병렬 처리를 아우르는 뜻으로 사용하였고, 병렬 처리는 CPU(주로 Task parallel)나 GPU(주로 Data parallel) 프로그래밍에 한정해서 사용하고 있습니다. 다른 의견 있으시면 의견 달아 주시면 감사하겠습니다.


    참고 :


    Pure function - Wikipedia, the free encyclopedia

    Immutable object - Wikipedia, the free encyclopedia

    Anders Hejlsberg and Guy Steele: Concurrency and Language Design

    The Future of C#
    ]]>     Parallel programming http://ararion.egloos.com/948369#comments Mon, 13 Oct 2008 01:51:32 GMT 아라리온     <![CDATA[ 비즈니스 개체를 Silverlgith와 WPF 동시에 개발하기 ]]> http://ararion.egloos.com/923097 http://ararion.egloos.com/923097 Siverlight와 wpf를 동시에 개발하면 얼마나 좋을까? 꿈만 같은 일이 곧 나올 것 같다. 

    RIScreenshots_small.png

    Scope for Prism 2.0

    Prism 2 Draft

    ]]>     Silverlight http://ararion.egloos.com/923097#comments Tue, 07 Oct 2008 06:13:43 GMT 아라리온     <![CDATA[ C#에서 병렬처리 2 ]]> http://ararion.egloos.com/919209 http://ararion.egloos.com/919209 주의 : 이 분야는 고급 경력의 프로그래머거나 OS에 대한 이해와 동시성 처리에 많은 공부를 한 사람이 아니면 시작하지 않도록 부탁드립니다.

    현업에서 성능을 위해 준비도 안된 사람들이 멀티스레딩을 생각없이 적용하는 경우를 종종 봅니다. 동시성 버그의 특징상 한 두건 테스트 때가 아닌 대량으로 사용하는 Release 때 버그들이 쏟아집니다. 이런 경우 대부분 해결은 못하고 끙끙 앓다가, MS 제품 버그로 고객에게 사기 치고 자신은 빠져나갑니다. 그럴 바에 차라리 모르고 적용하지 않는 편이 여러 사람에게 더 이롭습니다. 디버그에 권위자인 존 로빈(John Robbins)이 자신의 책에서 멀티스레딩에 관련된 지침 중 첫 번째인 "Don't do it.(다중 스레드를 사용하지 않는다)"를 되새기면서 시작하도록 하겠습니다.

    원래는 스레드와 thread Pool에 대한 내용을 자세히 설명하려 했는데 그러면 원래 취지인 동시성 프로그래밍에 빗나갈 것 같고, 각종 서적에서 이미 많은 이야기를 했기 때문에 생락하도록 하겠습니다.(노브레인 copy and paste족은 절대 쓰지 마세요. 제발~ -_-)

    제가 경험한 주의사항만 나열하도록 하겠습니다.

    • 스레드끼리 사용하는 공유 데이터는
      • 반드시 lock 걸어사용 할 것(lock문, Thread.(VolatileRead/VolatileWrite), volatile 키워드 참조)
      • 필요한 부분에서 잠깐 lock 할 것 (그래서 volatile 키워드는 좀 고려사항)
      • 구현부터 하지말고 적절한 도우미 클래스가 있는지 확인 할 것(Interlocked 클래스 참조)
      • 설계든 로직이든 공유 데이터를 쓰지 않는 방법을 동원해 보고 도저히 안될 때 사용할 것
    • 스레드에 실행되는 메서드는
      • 가장 낮은 수준에서
      • 독립적으로 동작 가능하도록
      • 실행 시간은 짧게
      • 재 활용을 위해 ThreadPool을 사용

    참고

    ]]>     Parallel programming http://ararion.egloos.com/919209#comments Mon, 06 Oct 2008 08:04:35 GMT 아라리온