프로그래밍을 할 때 있어서 모든 일이 처음 설계한대로 흘러간다면 얼마나 좋을까? 하지만 Hello World를 출럭하는 프로그램이 아닌 이상에야 그런 일은 있을 수 없다.

확장성을 위해, 재사용성을 위해, 더 나은 구조를 위해 코드와 설계는 변하기 마련이다. 그 와중에 많은 함수나 변수, 클래스가 추가되고 삭제된다. 물론 혼자서만 하는 작업이라면 코드를 바꾸고 바꾼 코드를 바로 적용하면 되지만, 코드 베이스를 만드는 사람과 그 베이스를 이용해서 작업하는 사람이 따로 있는 상황이라면 이야기가 조금 달라진다. 

만약 베이스를 작업하는 사람이 몇몇의 함수를 삭제하고 다른 이름의 함수로 대체했다면 그 베이스를 응용하는 사람 역시 그에 대한 사실을 알아야 한다. 물론 일반적인 상식으로 베이스 작업자가 베이스를 변경했다면 다른 작업자에게 바로 알려주고 다른 작업자는 바로 변경하는게 맞는 이야기지만, 사람과 사람 사이의 의사소통이라는게 말처럼 쉽기만 하던가. 베이스 작업자가 변경사항을 몇 개는 빠뜨리고 알려줄 수도 있고, 다른 작업자는 이야기를 들었지만 까먹을 수도 있는 일이다. 여튼 의사소통 과정에서 문제가 발생했다면 다른 작업자는 뜬금없이 바뀐 베이스 코드에 당황을 금치 못할 것이다.

그런 상황을 맞이한 다른 작업자는 당연히 문제를 해결하기 위해서 베이스 작업자에게 어떻게 변경된 것인지 물어보던지, 코드를 뒤져서 바뀐 함수를 적용하던지 하는 노력을 하겠지만 아무래도 이런 방식은 해결 속도도 느릴 뿐더러 효율적이지 못하다.

그렇기 때문에 나온 해결책이 바로 [Obsolete] 라는 어트리뷰트이다. 

더 이상 사용하지 않거나 그럴 예정인 클래스나 함수, 변수의 앞에 [Obsolete] 어트리뷰트를 붙여주면 된다. 그렇게 하면 해당 함수를 호출할 때 초록색 밑줄과 함께 더 이상 사용하지 않는 함수라는 경고가 뜬다.

그리고 툴팁에서는 함수 앞에 [deprecated]가 붙게 된다.

이 [Obsolete]는 세 가지 방식의 오버로딩을 지원한다.

[Obsolete] :: 더 이상 사용하지 않는 코드라는 경고만 출력한다.

[Obsolete(string message)] :: 더 이상 사용하지 않는다는 경고에 추가적인 메시지를 남길 수 있다. 이 메시지를 통해 더 이상 사용하지 않는 코드 대신에 사용할 코드를 사용자에게 알릴 수 있다.

[Obsolete(string message, bool error)] :: 추가적인 로그와 함께 이 코드를 사용할 경우에 컴파일 에러를 띄울지를 결정한다. true를 넣어주면 컴파일 에러를 띄워서 이 코드를 사용하면 컴파일을 할 수 없게 된다.

이런 식으로 [Obsolete]를 적절하게 사용하면 베이스 작업자는 코드 작업만으로 다른 작업자에게 코드가 변경되었음을 알림과 동시에 그에 대한 해결책도 전해줄 수 있다. 베이스 작업자가 코드를 변경하고 다른 작업자에게 변경사항을 일일이 알리는 것보다 훨씬 빠르고 효율적인 해결책이다.

출처: http://wergia.tistory.com/23 [베르의 프로그래밍 노트]

참조 : http://answers.unity3d.com/questions/559529/how-to-mark-a-method-obsolete.html

// String을 Char[]로 변환 
string str = "Hello 한국";
char[] uchars = str.ToCharArray();

// String은 바이트로 직접 변환할 수 없으며,
// Encoding을 통해 변환 가능. 16바이트 생성
byte[] ubytes = System.Text.Encoding.Unicode.GetBytes(str);

// 보다 컴팩트한 UTF8 인코딩. 12바이트 생성
byte[] utf8bytes = System.Text.Encoding.UTF8.GetBytes(str);

using System.Text;

// Byte Array를 String으로 변환 
string s1 = Encoding.Unicode.GetString(uniBytes);
string s2 = Encoding.UTF8.GetString(utf8bytes);

// Byte Array를 BASE64 Encoding
string s64 = Convert.ToBase64String(utf8bytes);

// BASE64 인코딩한 String을 다시 Byte Array로
byte[] bytes64 = Convert.FromBase64String(s64);

[출처] http://www.csharpstudy.com/Tip/Tip-string-encoding.aspx

// 반복문 관련
    // For Array
    public static void ForToArray
(T[] pArray, Action pCallback)
    {
        if (null == pArray)
            return;

        if (null == pCallback)
            return;

        int iMaxCount = pArray.Length;
        for (int iLoop=0; iLoop < iMaxCount; ++iLoop)
        {
            pCallback(pArray[iLoop]);
        }
    }
    // For Enum
    public static void ForToEnum(Action pCallback)
    {
        var pEnumerator = Enum.GetValues(typeof(T)).GetEnumerator();
        while (pEnumerator.MoveNext())
        {
            pCallback((T)pEnumerator.Current);
        }
    }
    // For List
    public static void ForToList(List pList, Action pCallback)
    {
        if (null == pList)
            return;

        if (null == pCallback)
            return;

        int iMaxCount = pList.Count;
        for (int iLoop = 0; iLoop < iMaxCount; ++iLoop)
        {
            pCallback(pList[iLoop]);
        }
    }
    public static void ForToList(List pList, Func pCallback)
    {
        if (null == pList)
            return;

        if (null == pCallback)
            return;

        int iMaxCount = pList.Count;
        for (int iLoop = 0; iLoop < iMaxCount; ++iLoop)
        {
            if (true == pCallback(pList[iLoop]))
                break;
        }
    }
    // For Dictionary
    public static void ForToDic(Dictionary pDic, Action pCallback)
    {
        if (null == pDic)
            return;

        if (null == pCallback)
            return;

        var pEnumerator = pDic.GetEnumerator();
        while (pEnumerator.MoveNext())
        {
            var kvp = pEnumerator.Current;
            pCallback(kvp.Key, kvp.Value);
        }
    }
    public static void ForToDic(Dictionary pDic, Func pCallback)
    {
        if (null == pDic)
            return;

        if (null == pCallback)
            return;

        var pEnumerator = pDic.GetEnumerator();
        while (pEnumerator.MoveNext())
        {
            var kvp = pEnumerator.Current;
            if (true == pCallback(kvp.Key, kvp.Value))
                break;
        }
    }
    // For One
    public static void For(int iStartIndex, int iMaxIndex, Action pCallback)
    {
        for (int iLoop = iStartIndex; iLoop pCallback)
    {
        for (int iLoop = iStartIndex; iLoop < iMaxIndex; ++iLoop)
        {
            if (true == pCallback(iLoop))
                break;
        }
    }
    // For Double
    public static void ForToDouble(int iMaxToFirst, int iMaxToSecond, Action pCallback)
    {
        for (int iLoop1 = 0; iLoop1 < iMaxToFirst; ++iLoop1)
        {
            for (int iLoop2 = 0; iLoop2 < iMaxToSecond; ++iLoop2)
                pCallback(iLoop1, iLoop2);
        }
    }
    public static void ForToDouble(int iMaxToFirst, int iMaxToSecond, Func pCallback)
    {
        for (int iLoop1 = 0; iLoop1 < iMaxToFirst; ++iLoop1)
        {
            for (int iLoop2 = 0; iLoop2 < iMaxToSecond; ++iLoop2)
            {
                if (true == pCallback(iLoop1, iLoop2))
                    return;
            }
        }
    }
    // Inverse For Double
    public static void ForInverseToDouble(int iMaxToFirst, int iMaxToSecond, Action pCallback)
    {
        for (int iLoop1 = iMaxToFirst; iLoop1 >= 0; --iLoop1)
        {
            for (int iLoop2 = iMaxToSecond; iLoop2 >= 0; --iLoop2)
                pCallback(iLoop1, iLoop2);
        }
    }
    public static void ForInverseToDouble(int iMaxToFirst, int iMaxToSecond, Func pCallback)
    {
        for (int iLoop1 = iMaxToFirst; iLoop1 >= 0; --iLoop1)
        {
            for (int iLoop2 = iMaxToSecond; iLoop2 >= 0; --iLoop2)
            {
                if (true == pCallback(iLoop1, iLoop2))
                    return;
            }
        }
    }

[출처] 이상호

[출처] https://forum.unity3d.com/threads/c-dictionary-loop.337804/

I've come across the situation on a number of occasions when coding where I've wanted to convert from a string to an enum. In the Media Catalog sample, I resorted to one giant switch statement that has a case block for each string that returns an enum from it.

One of my colleagues came up with the answer yesterday; it's one of those methods that you can never find when you're looking for it, but once discovered it seems blindingly obvious:

   object Enum.Parse(System.Type enumType, string value, bool ignoreCase);

So you can write the following kind of code:

   enum Colour
   {
      Red,
      Green,
      Blue
   } 

   // ...
   Colour c = (Colour) Enum.Parse(typeof(Colour), "Red", true);
   Console.WriteLine("Colour Value: {0}", c.ToString());

   // Picking an invalid colour throws an ArgumentException. To
   // avoid this, call Enum.IsDefined() first, as follows:
   string nonColour = "Polkadot";

   if (Enum.IsDefined(typeof(Colour), nonColour))
      c = (Colour) Enum.Parse(typeof(Colour), nonColour, true);
   else
      MessageBox.Show("Uh oh!");

What a time saver - thanks, Simon!

Footnote: interestingly, whilst writing this up I noticed that Enum.IsDefined() doesn’t offer the ignoreCase parameter. If you don’t know whether the casing is right, it seems the only way to do the conversion is using the Parse method and catching the ArgumentException. That's not ideal, since it runs a lot slower. I wonder if this is a loophole in the design; no doubt someone like Brad could cast light on it...

posted on Friday, April 02, 2004 1:49 PM

Feedback

# re: How do you convert a string into an enum? 4/2/2004 7:22 PM SBC

You can get the string values of enums also by calling Enum.GetNames or Enum.GetName...

출처 : http://redccoma.tistory.com/117

출처 : http://overit.tistory.com/entry/C-%EC%8B%9C%EA%B0%84%EC%B2%B4%ED%81%ACStopwatch

참조) http://blog.naver.com/goldrushing/130147289978

http://blog.naver.com/bridman/40195903160

출처 : http://mydoh.tistory.com/63

Sorting Arrays [C#]

This example shows how to sort arrays in C#. Array can be sorted using static method Array.Sortwhich internally use Quicksort algorithm.

Sorting array of primitive types

To sort array of primitive types such as int, double or string use method Array.Sort(Array) with the array as a paramater. The primitive types implements interface IComparable, which is internally used by the Sort method (it calls IComparable.Com­pareTo method). See example how to sort int array:

[C#]

// sort int array
int[] intArray = new int[5] { 8, 10, 2, 6, 3 };
Array.Sort(intArray);
// write array
foreach (int i in intArray) Console.Write(i + " ");  // output: 2 3 6 8 10

or how to sort string array:

[C#]

// sort string array
string[] stringArray = new string[5] { "X", "B", "Z", "Y", "A" };
Array.Sort(stringArray);
// write array
foreach (string str in stringArray) Console.Write(str + " "); // output: A B X Y Z

Sorting array of custom type using delegate

To sort your own types or to sort by more sophisticated rules, you can use delegate to anonymous method. The generic delegate Comparison<T> is declared as public delegate int Comparison<T> (T x, T y). It points to a method that compares two objects of the same type. It should return less then 0 when X < Y, zero when X = Y and greater then 0 when X > Y. The method (to which the delegate points) can be also an anonymous method (written inline).

Following example demonstrates how to sort an array of custom type using the delegate to anonynous comparison method. The custom type in this case is a class User with properties Name and Age.

[C#]

// array of custom type
User[] users = new User[3] { new User("Betty", 23),  // name, age
                             new User("Susan", 20),
                             new User("Lisa", 25) };

[C#]

// sort array by name
Array.Sort(users, delegate(User user1, User user2) {
                    return user1.Name.CompareTo(user2.Name);
                  });
// write array (output: Betty23 Lisa25 Susan20)
foreach (User user in users) Console.Write(user.Name + user.Age + " ");

[C#]

// sort array by age
Array.Sort(users, delegate(User user1, User user2) {
                    return user1.Age.CompareTo(user2.Age); // (user1.Age - user2.Age)
                  });
// write array (output: Susan20 Betty23 Lisa25)
foreach (User user in users) Console.Write(user.Name + user.Age + " ");

Sorting array using IComparable

If you implement IComparable interface in your custom type, you can sort array easily like in the case of primitive types. The Sort method calls internally IComparable.Com­pareTo method.

[C#]

// custom type
public class User : IComparable
{
  // ...

  // implement IComparable interface
  public int CompareTo(object obj)
  {
    if (obj is User) {
      return this.Name.CompareTo((obj as User).Name);  // compare user names
    }
    throw new ArgumentException("Object is not a User");
  }
}

Use it as you sorted the primitive types in the previous examples.

[C#]

// sort using IComparable implemented by User class
Array.Sort(users);  // sort array of User objects

출처 : http://www.csharp-examples.net/sort-array/

List<cTag> week = new List<cTag>();
// add some stuff to the list
// now sort
week.Sort(delegate(cTag c1, cTag c2) { return c1.date.CompareTo(c2.age); });

참조 : http://stackoverflow.com/questions/3163922/sort-a-custom-class-listt