COLLECTION Archives - 28 중 26 번째 페이지

[C#/COMMON] 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 2개 이상 지정)

■ 객체 리스트를 특정 속성 값에 따라 정렬하는 방법을 보여준다. (속성 2개 이상 지정) ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

#region 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 2개 이상 지정) - SortList(sourceList, propertyNameArray)

/// <summary>
/// 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 2개 이상 지정)
/// </summary>
/// <param name="sourceList">소스 리스트</param>
/// <param name="propertyNameArray">속성명 배열</param>
/// <returns>정렬 객체 리스트</returns>
public List<object> SortList(List<object> sourceList, string[] propertyNameArray)
{
    if(sourceList == null || sourceList.Count == 0)
    {
        return null;
    }

    if(propertyNameArray.Length < 1)
    {
        return null;
    }

    Type sourceType = sourceList[0].GetType();

    var result = sourceList.OrderBy(p => sourceType.GetProperty(propertyNameArray[0]).GetValue(p, null));

    foreach(string colunmName in propertyNameArray.Skip(1))
    {
        result = result.ThenBy(p => sourceType.GetProperty(colunmName).GetValue(p, null)); // 또는 ThenByDescending
    }

    return result.ToList();
}

#endregion

using System;

using System.Collections.Generic;

using System.Linq;

#region 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 2개 이상 지정) - SortList(sourceList, propertyNameArray)

/// <summary>

/// 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 2개 이상 지정)

/// </summary>

/// <param name="sourceList">소스 리스트</param>

/// <param name="propertyNameArray">속성명 배열</param>

/// <returns>정렬 객체 리스트</returns>

public List<object> SortList(List<object> sourceList, string[] propertyNameArray)

{

if(sourceList == null || sourceList.Count == 0)

{

return null;

}

if(propertyNameArray.Length < 1)

{

return null;

}

Type sourceType = sourceList[0].GetType();

var result = sourceList.OrderBy(p => sourceType.GetProperty(propertyNameArray[0]).GetValue(p, null));

foreach(string colunmName in propertyNameArray.Skip(1))

{

result = result.ThenBy(p => sourceType.GetProperty(colunmName).GetValue(p, null)); // 또는 ThenByDescending

}

return result.ToList();

}

#endregion

[C#/COMMON] 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 1개만 지정)

■ 객체 리스트를 특정 속성 값에 따라 정렬하는 방법을 보여준다. (속성 1개만 지정) ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;

#region 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 1개만 지정) - SortList<TSource>(sourceList, propertyName, sortDirection)

/// <summary>
/// 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 1개만 지정)
/// </summary>
/// <typeparam name="TSource">소스 타입</typeparam>
/// <param name="sourceList">소스 리스트</param>
/// <param name="propertyName">속성명</param>
/// <param name="sortDirection">정렬 방향</param>
/// <returns>정렬 객체 리스트</returns>
public List<TSource> SortList<TSource>(List<TSource> sourceList, string propertyName, string sortDirection)
{
    int reverser = sortDirection.ToLower().StartsWith("asc") ? 1 : -1;

    Comparison<TSource> comparison = new Comparison<TSource>
    (
        delegate(TSource x, TSource y)
        {
            MethodInfo methodInfo = GetCompareToMethodInfo<TSource>(x, propertyName);

            object xValue = x.GetType().GetProperty(propertyName).GetValue(x, null);
            object yValue = y.GetType().GetProperty(propertyName).GetValue(y, null);

            object result = methodInfo.Invoke(xValue, new object[] { yValue });

            return reverser * Convert.ToInt16(result);
        }
    );

    sourceList.Sort(comparison);

    return sourceList;
}

#endregion

#region CompareTo 메소드 정보 구하기 - GetCompareToMethodInfo<T>(sourceObject, propertyName)

/// <summary>
/// CompareTo 메소드 정보 구하기
/// </summary>
/// <typeparam name="TSource">소스 타입</typeparam>
/// <param name="sourceObject">소스 객체</param>
/// <param name="propertyName">속성명</param>
/// <returns>CompareTo 메소드 정보</returns>
private MethodInfo GetCompareToMethodInfo<TSource>(TSource sourceObject, string propertyName)
{
    Type sourceType = sourceObject.GetType();

    object propertyValue = sourceType.GetProperty(propertyName).GetValue(sourceObject, null);

    Type propertyType = propertyValue.GetType();

    MethodInfo methodInfo = propertyType.GetMethod("CompareTo", new Type[] { propertyType });

    return methodInfo;
}

#endregion

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Reflection;

#region 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 1개만 지정) - SortList<TSource>(sourceList, propertyName, sortDirection)

/// <summary>

/// 객체 리스트 특정 속성 값에 따라 정렬하기 (속성 1개만 지정)

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <param name="sourceList">소스 리스트</param>

/// <param name="propertyName">속성명</param>

/// <param name="sortDirection">정렬 방향</param>

/// <returns>정렬 객체 리스트</returns>

public List<TSource> SortList<TSource>(List<TSource> sourceList, string propertyName, string sortDirection)

{

int reverser = sortDirection.ToLower().StartsWith("asc") ? 1 : -1;

Comparison<TSource> comparison = new Comparison<TSource>

(

delegate(TSource x, TSource y)

{

MethodInfo methodInfo = GetCompareToMethodInfo<TSource>(x, propertyName);

object xValue = x.GetType().GetProperty(propertyName).GetValue(x, null);

object yValue = y.GetType().GetProperty(propertyName).GetValue(y, null);

object result = methodInfo.Invoke(xValue, new object[] { yValue });

return reverser * Convert.ToInt16(result);

}

);

sourceList.Sort(comparison);

return sourceList;

}

#endregion

#region CompareTo 메소드 정보 구하기 - GetCompareToMethodInfo<T>(sourceObject, propertyName)

/// <summary>

/// CompareTo 메소드 정보 구하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <param name="sourceObject">소스 객체</param>

/// <param name="propertyName">속성명</param>

/// <returns>CompareTo 메소드 정보</returns>

private MethodInfo GetCompareToMethodInfo<TSource>(TSource sourceObject, string propertyName)

{

Type sourceType = sourceObject.GetType();

object propertyValue = sourceType.GetProperty(propertyName).GetValue(sourceObject, null);

Type propertyType = propertyValue.GetType();

MethodInfo methodInfo = propertyType.GetMethod("CompareTo", new Type[] { propertyType });

return methodInfo;

}

#endregion

[C#/COMMON] 객체 컬렉션 특정 객체 속성 값의 집합 구하기 (속성 2개 이상 지정 가능)

■ 객체 컬렉션에서 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. (속성 2개 이상 지정 가능) ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;

#region 객체 컬렉션 특정 객체 속성 값의 집합 구하기 - GetDistinctCollection(sourceCollection, propertyNameArray)

/// <summary>
/// 객체 컬렉션 특정 객체 속성 값의 집합 구하기
/// </summary>
/// <param name="sourceCollection">소스 컬렉션</param>
/// <param name="propertyNameArray">속성명 배열</param>
/// <returns>객체 컬렉션 특정 객체 속성 값의 집합</returns>
public ObservableCollection<object> GetDistinctCollection(ObservableCollection<object> sourceCollection, string[] propertyNameArray)
{
    if(sourceCollection == null || sourceCollection.Count == 0)
    {
        return null;
    }

    var result = sourceCollection.AsEnumerable().GroupBy(item => new DistinctTuple<object>(from propertyName in propertyNameArray select item.GetType().GetProperty(propertyName).GetValue(item)));

    int propertyNameCount = propertyNameArray.Length;

    PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(sourceCollection[0]);

    DynamicClass dynamicClass = new DynamicClass(); // '동적 클래스 사용하기' 참조

    for(int i = 0; i < propertyNameCount; i++)
    {
        dynamicClass.AddProperty(propertyNameArray[i], pdc[propertyNameArray[i]].PropertyType);
    }

    dynamicClass.CreateType();

    ObservableCollection<object> targetCollection = new ObservableCollection<object>();

    foreach(var group in result)
    {
        dynamicClass.CreateInstance();

        for(int i = 0; i < propertyNameCount; i++)
        {
            dynamicClass.SetValue(i, group.Key.ValueArray[i]);
        }

        targetCollection.Add(dynamicClass.Instance);
    }

    return targetCollection;
}

#endregion



/// <summary>
/// 중복 제거 튜플
/// </summary>
/// <typeparam name="T">타입</typeparam>
public class DistinctTuple<T> : IEquatable<DistinctTuple<T>>
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region Field

    /// <summary>
    /// 값 배열
    /// </summary>
    public readonly T[] ValueArray;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - DistinctTuple(enumerable)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="enumerable">열거 가능형</param>
    public DistinctTuple(IEnumerable<T> enumerable)
    {
        ValueArray = enumerable.ToArray();
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 동등 여부 조사하기 - Equals(sourceTuple)

    /// <summary>
    /// 동등 여부 조사하기
    /// </summary>
    /// <param name="sourceTuple">소스 Tuple</param>
    /// <returns>동등 여부</returns>
    public bool Equals(DistinctTuple<T> sourceTuple)
    {
        if(ReferenceEquals(this, sourceTuple))
        {
            return true;
        }

        if(sourceTuple == null)
        {
            return false;
        }

        int length = ValueArray.Length;

        if(length != sourceTuple.ValueArray.Length)
        {
            return false;
        }

        for(int i = 0; i < length; i++)
        {
            if(!Equals(ValueArray[i], sourceTuple.ValueArray[i]))
            {
                return false;
            }
        }

        return true;
    }

    #endregion

    #region 동등 여부 조사하기 - Equals(sourceObject)

    /// <summary>
    /// 동등 여부 조사하기
    /// </summary>
    /// <param name="sourceObject">소스 객체</param>
    /// <returns>동등 여부</returns>
    public override bool Equals(object sourceObject)
    {
        if(ReferenceEquals(this, sourceObject))
        {
            return false;
        }

        if(sourceObject == null)
        {
            return false;
        }

        return Equals(sourceObject as DistinctTuple<T>);
    }

    #endregion

    #region 해시 코드 구하기 - GetHashCode()

    /// <summary>
    /// 해시 코드 구하기
    /// </summary>
    /// <returns>해시 코드</returns>
    public override int GetHashCode()
    {
        int hashCode = 17;

        foreach(var value in ValueArray)
        {
            hashCode = hashCode * 37 + (!ReferenceEquals(value, null) ? value.GetHashCode() : 0);
        }

        return hashCode;
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Linq;

#region 객체 컬렉션 특정 객체 속성 값의 집합 구하기 - GetDistinctCollection(sourceCollection, propertyNameArray)

/// <summary>

/// 객체 컬렉션 특정 객체 속성 값의 집합 구하기

/// </summary>

/// <param name="sourceCollection">소스 컬렉션</param>

/// <param name="propertyNameArray">속성명 배열</param>

/// <returns>객체 컬렉션 특정 객체 속성 값의 집합</returns>

public ObservableCollection<object> GetDistinctCollection(ObservableCollection<object> sourceCollection, string[] propertyNameArray)

{

if(sourceCollection == null || sourceCollection.Count == 0)

{

return null;

}

var result = sourceCollection.AsEnumerable().GroupBy(item => new DistinctTuple<object>(from propertyName in propertyNameArray select item.GetType().GetProperty(propertyName).GetValue(item)));

int propertyNameCount = propertyNameArray.Length;

PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(sourceCollection[0]);

DynamicClass dynamicClass = new DynamicClass(); // '동적 클래스 사용하기' 참조

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

{

dynamicClass.AddProperty(propertyNameArray[i], pdc[propertyNameArray[i]].PropertyType);

}

dynamicClass.CreateType();

ObservableCollection<object> targetCollection = new ObservableCollection<object>();

foreach(var group in result)

{

dynamicClass.CreateInstance();

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

{

dynamicClass.SetValue(i, group.Key.ValueArray[i]);

}

targetCollection.Add(dynamicClass.Instance);

}

return targetCollection;

}

#endregion

/// <summary>

/// 중복 제거 튜플

/// </summary>

/// <typeparam name="T">타입</typeparam>

public class DistinctTuple<T> : IEquatable<DistinctTuple<T>>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 값 배열

/// </summary>

public readonly T[] ValueArray;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - DistinctTuple(enumerable)

/// <summary>

/// 생성자

/// </summary>

/// <param name="enumerable">열거 가능형</param>

public DistinctTuple(IEnumerable<T> enumerable)

{

ValueArray = enumerable.ToArray();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 동등 여부 조사하기 - Equals(sourceTuple)

/// <summary>

/// 동등 여부 조사하기

/// </summary>

/// <param name="sourceTuple">소스 Tuple</param>

/// <returns>동등 여부</returns>

public bool Equals(DistinctTuple<T> sourceTuple)

{

if(ReferenceEquals(this, sourceTuple))

{

return true;

}

if(sourceTuple == null)

{

return false;

}

int length = ValueArray.Length;

if(length != sourceTuple.ValueArray.Length)

{

return false;

}

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

{

if(!Equals(ValueArray[i], sourceTuple.ValueArray[i]))

{

return false;

}

return true;

}

#endregion

#region 동등 여부 조사하기 - Equals(sourceObject)

/// <summary>

/// 동등 여부 조사하기

/// </summary>

/// <param name="sourceObject">소스 객체</param>

/// <returns>동등 여부</returns>

public override bool Equals(object sourceObject)

{

if(ReferenceEquals(this, sourceObject))

{

return false;

}

if(sourceObject == null)

{

return false;

}

return Equals(sourceObject as DistinctTuple<T>);

}

#endregion

#region 해시 코드 구하기 - GetHashCode()

/// <summary>

/// 해시 코드 구하기

/// </summary>

/// <returns>해시 코드</returns>

public override int GetHashCode()

{

int hashCode = 17;

foreach(var value in ValueArray)

{

hashCode = hashCode * 37 + (!ReferenceEquals(value, null) ? value.GetHashCode() : 0);

}

return hashCode;

}

#endregion

}

[C#/COMMON] 객체 리스트 특정 객체 속성 값의 집합 구하기 (속성 2개 이상 지정 가능)

■ 객체 리스트에서 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. (속성 2개 이상 지정 가능) ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;

#region 객체 리스트 특정 객체 속성 값의 집합 구하기 - GetDistinctList(sourceList, propertyNameArray)

/// <summary>
/// 객체 리스트 특정 객체 속성 값의 집합 구하기
/// </summary>
/// <param name="sourceList">소스 리스트</param>
/// <param name="propertyNameArray">속성명 배열</param>
/// <returns>객체 리스트 특정 객체 속성 값의 집합</returns>
public List<object> GetDistinctList(List<object> sourceList, string[] propertyNameArray)
{
    if(sourceList == null || sourceList.Count == 0)
    {
        return null;
    }

    var result = sourceList.AsEnumerable().GroupBy(item => new DistinctTuple<object>(from propertyName in propertyNameArray select item.GetType().GetProperty(propertyName).GetValue(item)));

    int propertyNameCount = propertyNameArray.Length;

    PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(sourceList[0]);

    DynamicClass dynamicClass = new DynamicClass(); // '동적 클래스 사용하기' 참조

    for(int i = 0; i < propertyNameCount; i++)
    {
        dynamicClass.AddProperty(propertyNameArray[i], pdc[propertyNameArray[i]].PropertyType);
    }

    dynamicClass.CreateType();

    List<object> targetList = new List<object>();

    foreach(var group in result)
    {
        dynamicClass.CreateInstance();

        for(int i = 0; i < propertyNameCount; i++)
        {
            dynamicClass.SetValue(i, group.Key.ValueArray[i]);
        }

        targetList.Add(dynamicClass.Instance);
    }

    return targetList;
}

#endregion



/// <summary>
/// 중복 제거 튜플
/// </summary>
/// <typeparam name="T">타입</typeparam>
public class DistinctTuple<T> : IEquatable<DistinctTuple<T>>
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region Field

    /// <summary>
    /// 값 배열
    /// </summary>
    public readonly T[] ValueArray;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - DistinctTuple(enumerable)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="enumerable">열거 가능형</param>
    public DistinctTuple(IEnumerable<T> enumerable)
    {
        ValueArray = enumerable.ToArray();
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 동등 여부 조사하기 - Equals(sourceTuple)

    /// <summary>
    /// 동등 여부 조사하기
    /// </summary>
    /// <param name="sourceTuple">소스 Tuple</param>
    /// <returns>동등 여부</returns>
    public bool Equals(DistinctTuple<T> sourceTuple)
    {
        if(ReferenceEquals(this, sourceTuple))
        {
            return true;
        }

        if(sourceTuple == null)
        {
            return false;
        }

        int length = ValueArray.Length;

        if(length != sourceTuple.ValueArray.Length)
        {
            return false;
        }

        for(int i = 0; i < length; i++)
        {
            if(!Equals(ValueArray[i], sourceTuple.ValueArray[i]))
            {
                return false;
            }
        }

        return true;
    }

    #endregion

    #region 동등 여부 조사하기 - Equals(sourceObject)

    /// <summary>
    /// 동등 여부 조사하기
    /// </summary>
    /// <param name="sourceObject">소스 객체</param>
    /// <returns>동등 여부</returns>
    public override bool Equals(object sourceObject)
    {
        if(ReferenceEquals(this, sourceObject))
        {
            return false;
        }

        if(sourceObject == null)
        {
            return false;
        }

        return Equals(sourceObject as DistinctTuple<T>);
    }

    #endregion

    #region 해시 코드 구하기 - GetHashCode()

    /// <summary>
    /// 해시 코드 구하기
    /// </summary>
    /// <returns>해시 코드</returns>
    public override int GetHashCode()
    {
        int hashCode = 17;

        foreach(var value in ValueArray)
        {
            hashCode = hashCode * 37 + (!ReferenceEquals(value, null) ? value.GetHashCode() : 0);
        }

        return hashCode;
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

#region 객체 리스트 특정 객체 속성 값의 집합 구하기 - GetDistinctList(sourceList, propertyNameArray)

/// <summary>

/// 객체 리스트 특정 객체 속성 값의 집합 구하기

/// </summary>

/// <param name="sourceList">소스 리스트</param>

/// <param name="propertyNameArray">속성명 배열</param>

/// <returns>객체 리스트 특정 객체 속성 값의 집합</returns>

public List<object> GetDistinctList(List<object> sourceList, string[] propertyNameArray)

{

if(sourceList == null || sourceList.Count == 0)

{

return null;

}

var result = sourceList.AsEnumerable().GroupBy(item => new DistinctTuple<object>(from propertyName in propertyNameArray select item.GetType().GetProperty(propertyName).GetValue(item)));

int propertyNameCount = propertyNameArray.Length;

PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(sourceList[0]);

DynamicClass dynamicClass = new DynamicClass(); // '동적 클래스 사용하기' 참조

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

{

dynamicClass.AddProperty(propertyNameArray[i], pdc[propertyNameArray[i]].PropertyType);

}

dynamicClass.CreateType();

List<object> targetList = new List<object>();

foreach(var group in result)

{

dynamicClass.CreateInstance();

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

{

dynamicClass.SetValue(i, group.Key.ValueArray[i]);

}

targetList.Add(dynamicClass.Instance);

}

return targetList;

}

#endregion

/// <summary>

/// 중복 제거 튜플

/// </summary>

/// <typeparam name="T">타입</typeparam>

public class DistinctTuple<T> : IEquatable<DistinctTuple<T>>

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 값 배열

/// </summary>

public readonly T[] ValueArray;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - DistinctTuple(enumerable)

/// <summary>

/// 생성자

/// </summary>

/// <param name="enumerable">열거 가능형</param>

public DistinctTuple(IEnumerable<T> enumerable)

{

ValueArray = enumerable.ToArray();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 동등 여부 조사하기 - Equals(sourceTuple)

/// <summary>

/// 동등 여부 조사하기

/// </summary>

/// <param name="sourceTuple">소스 Tuple</param>

/// <returns>동등 여부</returns>

public bool Equals(DistinctTuple<T> sourceTuple)

{

if(ReferenceEquals(this, sourceTuple))

{

return true;

}

if(sourceTuple == null)

{

return false;

}

int length = ValueArray.Length;

if(length != sourceTuple.ValueArray.Length)

{

return false;

}

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

{

if(!Equals(ValueArray[i], sourceTuple.ValueArray[i]))

{

return false;

}

return true;

}

#endregion

#region 동등 여부 조사하기 - Equals(sourceObject)

/// <summary>

/// 동등 여부 조사하기

/// </summary>

/// <param name="sourceObject">소스 객체</param>

/// <returns>동등 여부</returns>

public override bool Equals(object sourceObject)

{

if(ReferenceEquals(this, sourceObject))

{

return false;

}

if(sourceObject == null)

{

return false;

}

return Equals(sourceObject as DistinctTuple<T>);

}

#endregion

#region 해시 코드 구하기 - GetHashCode()

/// <summary>

/// 해시 코드 구하기

/// </summary>

/// <returns>해시 코드</returns>

public override int GetHashCode()

{

int hashCode = 17;

foreach(var value in ValueArray)

{

hashCode = hashCode * 37 + (!ReferenceEquals(value, null) ? value.GetHashCode() : 0);

}

return hashCode;

}

#endregion

}

[C#/COMMON] 객체 컬렉션 특정 객체 속성 값의 집합 구하기 (속성 1개만 지정)

■ 객체 컬렉션에서 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. (속성 1개만 지정) ▶ 예제 코드 (C#)


using System;
using System.ComponentModel;
using System.Collections;
using System.Collections.ObjectModel;
using System.Linq;

#region 객체 컬렉션 특정 객체 속성 값의 집합 구하기 - GetDistinctValueCollection(sourceCollection, propertyName)

/// <summary>
/// 객체 컬렉션 특정 객체 속성 값의 집합 구하기
/// </summary>
/// <param name="sourceCollection">소스 컬렉션</param>
/// <param name="propertyName">속성명</param>
/// <returns>객체 컬렉션 특정 객체 속성 값의 집합</returns>
public ObservableCollection<object> GetDistinctValueCollection
(
    ObservableCollection<object> sourceCollection,
    string                       propertyName
)
{
    ObservableCollection<object> targetCollection = new ObservableCollection<object>();

    if(sourceCollection.Count == 0)
    {
        return targetCollection;
    }

    var sourceItem = sourceCollection.First();

    PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(sourceItem);

    PropertyDescriptor propertyDescriptor = propertyDescriptorCollection[propertyName];

    var result = sourceCollection.GroupBy(p => propertyDescriptor.GetValue(p))
                 .Select(p => p.FirstOrDefault())
                 .OrderBy(p => propertyDescriptor.GetValue(p));

    foreach(var item in result)
    {
        targetCollection.Add(propertyDescriptor.GetValue(item));
    }

    return targetCollection;
}

#endregion

using System;

using System.ComponentModel;

using System.Collections;

using System.Collections.ObjectModel;

using System.Linq;

#region 객체 컬렉션 특정 객체 속성 값의 집합 구하기 - GetDistinctValueCollection(sourceCollection, propertyName)

/// <summary>

/// 객체 컬렉션 특정 객체 속성 값의 집합 구하기

/// </summary>

/// <param name="sourceCollection">소스 컬렉션</param>

/// <param name="propertyName">속성명</param>

/// <returns>객체 컬렉션 특정 객체 속성 값의 집합</returns>

public ObservableCollection<object> GetDistinctValueCollection

(

ObservableCollection<object> sourceCollection,

string propertyName

)

{

ObservableCollection<object> targetCollection = new ObservableCollection<object>();

if(sourceCollection.Count == 0)

{

return targetCollection;

}

var sourceItem = sourceCollection.First();

PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(sourceItem);

PropertyDescriptor propertyDescriptor = propertyDescriptorCollection[propertyName];

var result = sourceCollection.GroupBy(p => propertyDescriptor.GetValue(p))

.Select(p => p.FirstOrDefault())

.OrderBy(p => propertyDescriptor.GetValue(p));

foreach(var item in result)

{

targetCollection.Add(propertyDescriptor.GetValue(item));

}

return targetCollection;

}

#endregion

[C#/COMMON] ITypedList 인터페이스 : TypedCollection 만들기

■ ITypedList 인터페이스를 사용해 TypedCollection<T>를 만드는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Windows.Forms;

namespace TestProject
{
    /// <summary>
    /// 메인 폼
    /// </summary>
    public partial class MainForm : Form
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Class
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 임직원 - Employee

        /// <summary>
        /// 임직원
        /// </summary>
        private class Employee
        {
            //////////////////////////////////////////////////////////////////////////////////////////////////// Field
            ////////////////////////////////////////////////////////////////////////////////////////// Public

            #region Field

            /// <summary>
            /// 아이디
            /// </summary>
            public string ID;

            /// <summary>
            /// 성명
            /// </summary>
            public string Name;

            #endregion
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - MainForm()

        /// <summary>
        /// 생성자
        /// </summary>
        public MainForm()
        {
            InitializeComponent();

            this.gridControl.DataSource = GetCollection(); // Employee 필드도 바인딩이 정상적으로 된다.
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region 컬렉션 구하기 - GetCollection()

        /// <summary>
        /// 컬렉션 구하기
        /// </summary>
        /// <returns>컬렉션</returns>
        private TypedCollection<Employee> GetCollection()
        {
            TypedCollection<Employee> collection = new TypedCollection<Employee>();

            collection.Add(new Employee(){ ID = "A", Name = "홍길동" });
            collection.Add(new Employee(){ ID = "B", Name = "강동구" });
            collection.Add(new Employee(){ ID = "C", Name = "홍길숙" });

            return collection;
        }

        #endregion
    }
}

using System;

using System.Windows.Forms;

namespace TestProject

{

/// <summary>

/// 메인 폼

/// </summary>

public partial class MainForm : Form

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Class

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 임직원 - Employee

/// <summary>

/// 임직원

/// </summary>

private class Employee

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Public

#region Field

/// <summary>

/// 아이디

/// </summary>

public string ID;

/// <summary>

/// 성명

/// </summary>

public string Name;

#endregion

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - MainForm()

/// <summary>

/// 생성자

/// </summary>

public MainForm()

{

InitializeComponent();

this.gridControl.DataSource = GetCollection(); // Employee 필드도 바인딩이 정상적으로 된다.

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Private

#region 컬렉션 구하기 - GetCollection()

/// <summary>

/// 컬렉션 구하기

/// </summary>

/// <returns>컬렉션</returns>

private TypedCollection<Employee> GetCollection()

{

TypedCollection<Employee> collection = new TypedCollection<Employee>();

collection.Add(new Employee(){ ID = "A", Name = "홍길동" });

collection.Add(new Employee(){ ID = "B", Name = "강동구" });

collection.Add(new Employee(){ ID = "C", Name = "홍길숙" });

return collection;

}

#endregion

}

※ this.gridControl은 그리드 컨트롤을 가정한다. ▶ TypedPropertyDescriptor.cs


using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace TestProject
{
    /// <summary>
    /// 타입 속성 설명자
    /// </summary>
    /// <typeparam name="T">타입</typeparam>
    public class TypedPropertyDescriptor<T> : PropertyDescriptor
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// GetValue 함수
        /// </summary>
        private Func<object, object> getValue;

        /// <summary>
        /// SetValue 액션
        /// </summary>
        private Action<object, object> setValue;

        /// <summary>
        /// 타입
        /// </summary>
        private Type type;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 컴포넌트 타입 - ComponentType

        /// <summary>
        /// 컴포넌트 타입
        /// </summary>
        public override Type ComponentType
        {
            get
            {
                return typeof(TypedCollection<T>);
            }
        }

        #endregion

        #region 읽기 전용 여부 - IsReadOnly

        /// <summary>
        /// 읽기 전용 여부
        /// </summary>
        public override bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        #endregion

        #region 속성 타입 - PropertyType

        /// <summary>
        /// 속성 타입
        /// </summary>
        public override Type PropertyType
        {
            get
            {
                return this.type;
            }
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 생성자 - TypedPropertyDescriptor(getValue, setValue, memberName, type)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="getValue">GetValue 함수</param>
        /// <param name="setValue">SetValue 액션</param>
        /// <param name="memberName">멤버명</param>
        /// <param name="type">타입</param>
        public TypedPropertyDescriptor(Func<object, object> getValue, Action<object, object> setValue, string memberName, Type type) : base(memberName, null)
        {
            this.getValue = getValue;
            this.setValue = setValue;
            this.type     = type;
        }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 값 리셋 가능 여부 구하기 - CanResetValue(component)

        /// <summary>
        /// 값 리셋 가능 여부 구하기
        /// </summary>
        /// <param name="component">컴포넌트</param>
        /// <returns>값 리셋 가능 여부</returns>
        public override bool CanResetValue(object component)
        {
            return false;
        }

        #endregion

        #region 값 구하기 - GetValue(component)

        /// <summary>
        /// 값 구하기
        /// </summary>
        /// <param name="component">컴포넌트</param>
        /// <returns>값</returns>
        public override object GetValue(object component)
        {
            return this.getValue(component);
        }

        #endregion

        #region 값 리셋하기 - ResetValue(component)

        /// <summary>
        /// 값 리셋하기
        /// </summary>
        /// <param name="component">컴포넌트</param>
        public override void ResetValue(object component)
        {
            this.setValue(component, null);
        }

        #endregion

        #region 값 설정하기 - SetValue(component, value)

        /// <summary>
        /// 값 설정하기
        /// </summary>
        /// <param name="component">컴포넌트</param>
        /// <param name="value">값</param>
        public override void SetValue(object component, object value)
        {
            this.setValue(component, value);
        }

        #endregion

        #region 값 직렬화 여부구하기 - ShouldSerializeValue(component)

        /// <summary>
        /// 값 직렬화 여부 구하기
        /// </summary>
        /// <param name="component">컴포넌트</param>
        /// <returns>값 직렬화 여부</returns>
        public override bool ShouldSerializeValue(object component)
        {
            return true;
        }

        #endregion
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

using System;

using System.Collections.Generic;

using System.ComponentModel;

namespace TestProject

{

/// <summary>

/// 타입 속성 설명자

/// </summary>

/// <typeparam name="T">타입</typeparam>

public class TypedPropertyDescriptor<T> : PropertyDescriptor

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// GetValue 함수

/// </summary>

private Func<object, object> getValue;

/// <summary>

/// SetValue 액션

/// </summary>

private Action<object, object> setValue;

/// <summary>

/// 타입

/// </summary>

private Type type;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 컴포넌트 타입 - ComponentType

/// <summary>

/// 컴포넌트 타입

/// </summary>

public override Type ComponentType

{

get

{

return typeof(TypedCollection<T>);

}

#endregion

#region 읽기 전용 여부 - IsReadOnly

/// <summary>

/// 읽기 전용 여부

/// </summary>

public override bool IsReadOnly

{

get

{

return false;

}

#endregion

#region 속성 타입 - PropertyType

/// <summary>

/// 속성 타입

/// </summary>

public override Type PropertyType

{

get

{

return this.type;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - TypedPropertyDescriptor(getValue, setValue, memberName, type)

/// <summary>

/// 생성자

/// </summary>

/// <param name="getValue">GetValue 함수</param>

/// <param name="setValue">SetValue 액션</param>

/// <param name="memberName">멤버명</param>

/// <param name="type">타입</param>

public TypedPropertyDescriptor(Func<object, object> getValue, Action<object, object> setValue, string memberName, Type type) : base(memberName, null)

{

this.getValue = getValue;

this.setValue = setValue;

this.type = type;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 값 리셋 가능 여부 구하기 - CanResetValue(component)

/// <summary>

/// 값 리셋 가능 여부 구하기

/// </summary>

/// <param name="component">컴포넌트</param>

/// <returns>값 리셋 가능 여부</returns>

public override bool CanResetValue(object component)

{

return false;

}

#endregion

#region 값 구하기 - GetValue(component)

/// <summary>

/// 값 구하기

/// </summary>

/// <param name="component">컴포넌트</param>

/// <returns>값</returns>

public override object GetValue(object component)

{

return this.getValue(component);

}

#endregion

#region 값 리셋하기 - ResetValue(component)

/// <summary>

/// 값 리셋하기

/// </summary>

/// <param name="component">컴포넌트</param>

public override void ResetValue(object component)

{

this.setValue(component, null);

}

#endregion

#region 값 설정하기 - SetValue(component, value)

/// <summary>

/// 값 설정하기

/// </summary>

/// <param name="component">컴포넌트</param>

/// <param name="value">값</param>

public override void SetValue(object component, object value)

{

this.setValue(component, value);

}

#endregion

#region 값 직렬화 여부구하기 - ShouldSerializeValue(component)

/// <summary>

/// 값 직렬화 여부 구하기

/// </summary>

/// <param name="component">컴포넌트</param>

/// <returns>값 직렬화 여부</returns>

public override bool ShouldSerializeValue(object component)

{

return true;

}

#endregion

}

▶

[C#/COMMON] 객체 리스트를 데이터 테이블로 변환하기

■ 객체 리스트를 데이터 테이블로 변환하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;

#region 데이터 테이블 구하기 - GetDataTable<TSource>(sourceList)

/// <summary>
/// 데이터 테이블 구하기
/// </summary>
/// <typeparam name="TSource">소스 타입</typeparam>
/// <param name="sourceList">소스 리스트</param>
/// <returns>데이터 테이블</returns>
public DataTable GetDataTable<TSource>(IList<TSource> sourceList)
{
    DataTable targetTable = GetDataTable<TSource>(); // '객체 타입을 갖고 데이터 테이블 구하기' 참조

    Type sourceType = typeof(TSource);

    PropertyDescriptorCollection sourcePDC = TypeDescriptor.GetProperties(sourceType);

    foreach(TSource item in sourceList)
    {
        DataRow targetRow = targetTable.NewRow();

        foreach(PropertyDescriptor propertyDescriptor in sourcePDC)
        {
            targetRow[propertyDescriptor.Name] = propertyDescriptor.GetValue(item);
        }

        targetTable.Rows.Add(targetRow);
    }

    return targetTable;
}

#endregion

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

#region 데이터 테이블 구하기 - GetDataTable<TSource>(sourceList)

/// <summary>

/// 데이터 테이블 구하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <param name="sourceList">소스 리스트</param>

/// <returns>데이터 테이블</returns>

public DataTable GetDataTable<TSource>(IList<TSource> sourceList)

{

DataTable targetTable = GetDataTable<TSource>(); // '객체 타입을 갖고 데이터 테이블 구하기' 참조

Type sourceType = typeof(TSource);

PropertyDescriptorCollection sourcePDC = TypeDescriptor.GetProperties(sourceType);

foreach(TSource item in sourceList)

{

DataRow targetRow = targetTable.NewRow();

foreach(PropertyDescriptor propertyDescriptor in sourcePDC)

{

targetRow[propertyDescriptor.Name] = propertyDescriptor.GetValue(item);

}

targetTable.Rows.Add(targetRow);

}

return targetTable;

}

#endregion

[C#/COMMON] 객체 타입으로 데이터 테이블 만들기

■ 객체 타입으로 데이터 테이블을 만드는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.ComponentModel;
using System.Data;

#region 데이터 테이블 구하기 - GetDataTable<TSource>()

/// <summary>
/// 데이터 테이블 구하기
/// </summary>
/// <typeparam name="TSource">소스 타입</typeparam>
/// <returns>데이터 테이블</returns>
public DataTable GetDataTable<TSource>()
{
    Type sourceType = typeof(TSource);

    DataTable targetTable = new DataTable(sourceType.Name);

    PropertyDescriptorCollection sourcePDC = TypeDescriptor.GetProperties(sourceType);

    foreach(PropertyDescriptor propertyDescriptor in sourcePDC)
    {
        targetTable.Columns.Add(propertyDescriptor.Name, propertyDescriptor.PropertyType);
    }

    return targetTable;
}

#endregion

using System;

using System.ComponentModel;

using System.Data;

#region 데이터 테이블 구하기 - GetDataTable<TSource>()

/// <summary>

/// 데이터 테이블 구하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <returns>데이터 테이블</returns>

public DataTable GetDataTable<TSource>()

{

Type sourceType = typeof(TSource);

DataTable targetTable = new DataTable(sourceType.Name);

PropertyDescriptorCollection sourcePDC = TypeDescriptor.GetProperties(sourceType);

foreach(PropertyDescriptor propertyDescriptor in sourcePDC)

{

targetTable.Columns.Add(propertyDescriptor.Name, propertyDescriptor.PropertyType);

}

return targetTable;

}

#endregion

[C#/COMMON] List 클래스 : 데이터 테이블 구하기

■ List<T> 클래스에서 데이터 테이블을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Data;
using System.Reflection;

#region 데이터 테이블 구하기 - GetDataTable<T>(list)

/// <summary>
/// 데이터 테이블 구하기
/// </summary>
/// <typeparam name="T">리스트 타입</typeparam>
/// <param name="list">리스트</param>
/// <returns>데이터 테이블</returns>
public DataTable GetDataTable<T>(List<T> list)
{
    DataTable targetTable = new DataTable();

    foreach(PropertyInfo propertyInfo in typeof(T).GetProperties())
    {
        targetTable.Columns.Add(new DataColumn(propertyInfo.Name, GetNullableType(propertyInfo.PropertyType)));
    }

    foreach(T item in list)
    {
        DataRow dataRow = targetTable.NewRow();

        foreach(PropertyInfo propertyInfo in typeof(T).GetProperties())
        {
            if(!IsNullableType(propertyInfo.PropertyType))
            {
                dataRow[propertyInfo.Name] = propertyInfo.GetValue(item, null);
            }
            else
            {
                dataRow[propertyInfo.Name] = (propertyInfo.GetValue(item, null) ?? DBNull.Value);
            }
        }

        targetTable.Rows.Add(dataRow);
    }

    return targetTable;
}

#endregion

#region 널 가능 타입 구하기 - GetNullableType(sourceType)

/// <summary>
/// 널 가능 타입 구하기
/// </summary>
/// <param name="sourceType">소스 타입</param>
/// <returns>널 가능 타입</returns>
private static Type GetNullableType(Type sourceType)
{
    Type targetType = sourceType;

    if(sourceType.IsGenericType && sourceType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
    {
        targetType = Nullable.GetUnderlyingType(sourceType);
    }

    return targetType;
}

#endregion

#region 널 가능 타입 여부 구하기 - IsNullableType(sourceType)

/// <summary>
/// 널 가능 타입 여부 구하기
/// </summary>
/// <param name="sourceType">소스 타입</param>
/// <returns>널 가능 타입 여부</returns>
private bool IsNullableType(Type sourceType)
{
    return (sourceType == typeof(string) || sourceType.IsArray || (sourceType.IsGenericType && sourceType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))));
}

#endregion

using System;

using System.Collections.Generic;

using System.Data;

using System.Reflection;

#region 데이터 테이블 구하기 - GetDataTable<T>(list)

/// <summary>

/// 데이터 테이블 구하기

/// </summary>

/// <typeparam name="T">리스트 타입</typeparam>

/// <param name="list">리스트</param>

/// <returns>데이터 테이블</returns>

public DataTable GetDataTable<T>(List<T> list)

{

DataTable targetTable = new DataTable();

foreach(PropertyInfo propertyInfo in typeof(T).GetProperties())

{

targetTable.Columns.Add(new DataColumn(propertyInfo.Name, GetNullableType(propertyInfo.PropertyType)));

}

foreach(T item in list)

{

DataRow dataRow = targetTable.NewRow();

foreach(PropertyInfo propertyInfo in typeof(T).GetProperties())

{

if(!IsNullableType(propertyInfo.PropertyType))

{

dataRow[propertyInfo.Name] = propertyInfo.GetValue(item, null);

}

else

{

dataRow[propertyInfo.Name] = (propertyInfo.GetValue(item, null) ?? DBNull.Value);

}

targetTable.Rows.Add(dataRow);

}

return targetTable;

}

#endregion

#region 널 가능 타입 구하기 - GetNullableType(sourceType)

/// <summary>

/// 널 가능 타입 구하기

/// </summary>

/// <param name="sourceType">소스 타입</param>

/// <returns>널 가능 타입</returns>

private static Type GetNullableType(Type sourceType)

{

Type targetType = sourceType;

if(sourceType.IsGenericType && sourceType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))

{

targetType = Nullable.GetUnderlyingType(sourceType);

}

return targetType;

}

#endregion

#region 널 가능 타입 여부 구하기 - IsNullableType(sourceType)

/// <summary>

/// 널 가능 타입 여부 구하기

/// </summary>

/// <param name="sourceType">소스 타입</param>

/// <returns>널 가능 타입 여부</returns>

private bool IsNullableType(Type sourceType)

{

return (sourceType == typeof(string) || sourceType.IsArray || (sourceType.IsGenericType && sourceType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))));

}

#endregion

[C#/LINQ] Enumerable 클래스 : GroupBy 확장 메소드 : 객체 컬렉션의 특정 객체 속성 값의 집합 구하기 (속성 2개 이상 지정 가능)

■ Enumerable 클래스의 GroupBy<TSource, TKey> 확장 메소드를 사용해 객체 컬렉션에서 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Collections.ObjectModel;
using System.Linq;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ObservableCollection<Employee> collection = Employee.GetCollection();

            string[] propertyNameArray = new string[] { "ID", "Sex" };

            var result = collection.AsEnumerable()
                .GroupBy(item => new Tuple<object>(from propertyName in propertyNameArray select item.GetType()
                .GetProperty(propertyName).GetValue(item)));

            foreach(var group in result)
            {
                foreach(var keyValue in group.Key.ValueArray)
                {
                    Console.Write(keyValue);
                    Console.Write(":");
                }

                Console.WriteLine();
            }

        }

        #endregion
    }
}

using System;

using System.Collections.ObjectModel;

using System.Linq;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ObservableCollection<Employee> collection = Employee.GetCollection();

string[] propertyNameArray = new string[] { "ID", "Sex" };

var result = collection.AsEnumerable()

.GroupBy(item => new Tuple<object>(from propertyName in propertyNameArray select item.GetType()

.GetProperty(propertyName).GetValue(item)));

foreach(var group in result)

{

foreach(var keyValue in group.Key.ValueArray)

{

Console.Write(keyValue);

Console.Write(":");

}

Console.WriteLine();

}

#endregion

}

▶

[C#/LINQ] Enumerable 클래스 : GroupBy 확장 메소드 : 객체 컬렉션의 특정 객체 속성 값의 집합 구하기 (속성 1개만 지정)

■ Enumerable 클래스의 GroupBy<TSource, TKey> 확장 메소드를 사용해 객체 컬렉션에서 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. ▶ Program.cs


using System;
using System.ComponentModel;
using System.Collections.ObjectModel;
using System.Linq;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ObservableCollection<Employee> collection = Employee.GetCollection();

            Employee employee = collection.FirstOrDefault();

            if(employee != null)
            {
                PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(employee);

                PropertyDescriptor propertyDescriptor = propertyDescriptorCollection["Sex"];

                var result = collection.GroupBy(p => propertyDescriptor.GetValue(p))
                                       .Select(p => p.FirstOrDefault())
                                       .OrderBy(p => propertyDescriptor.GetValue(p));

                foreach(var item in result)
                {
                    Console.WriteLine((item as Employee).Sex);
                }
            }
        }

        #endregion
    }
}

using System;

using System.ComponentModel;

using System.Collections.ObjectModel;

using System.Linq;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ObservableCollection<Employee> collection = Employee.GetCollection();

Employee employee = collection.FirstOrDefault();

if(employee != null)

{

PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(employee);

PropertyDescriptor propertyDescriptor = propertyDescriptorCollection["Sex"];

var result = collection.GroupBy(p => propertyDescriptor.GetValue(p))

.Select(p => p.FirstOrDefault())

.OrderBy(p => propertyDescriptor.GetValue(p));

foreach(var item in result)

{

Console.WriteLine((item as Employee).Sex);

}

#endregion

}

▶

[C#/LINQ] group … by new { … } 키워드 질의 형식 : 객체 컬렉션 특정 객체 속성 값의 집합 구하기 (속성 2개 이상 지정 가능)

■ group … by new { … } 키워드 질의 형식을 사용해 객체 컬렉션 특정 객체 속성 값의 집합을 구하는 방법을 보여준다.

[C#/LINQ] Expression 클래스 : 객체 컬렉션 특정 객체 속성 값의 집합 구하기 (속성 1개만 지정)

■ Expression 클래스를 사용해 객체 컬렉션 특정 객체 속성 값의 집합을 구하는 방법을 보여준다. (속성 1개만 지정) ▶ Program.cs


using System;
using System.ComponentModel;
using System.Collections.ObjectModel;
using System.Linq;
using System.Linq.Expressions;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ObservableCollection<Employee> collection = Employee.GetCollection();

            string propertyName = "Sex";

            ParameterExpression parameterExpression = Expression.Parameter(typeof(Employee), "p");
            MemberExpression    memberExpression    = Expression.Property(parameterExpression, propertyName);
            LambdaExpression    lambdaExpression    = Expression.Lambda(memberExpression, parameterExpression);
            Delegate            function            = lambdaExpression.Compile();

            var result =
            (
                from    item in collection
                group   item by function.DynamicInvoke(item)
                into    group1
                select  group1.First().GetType().GetProperty(propertyName).GetValue(group1.First()).ToString()
                into    group2
                orderby group2
                select  group2
            ).ToList();

            foreach(var item in result)
            {
                Console.WriteLine(item);
            }
        }

        #endregion
    }
}

using System;

using System.ComponentModel;

using System.Collections.ObjectModel;

using System.Linq;

using System.Linq.Expressions;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ObservableCollection<Employee> collection = Employee.GetCollection();

string propertyName = "Sex";

ParameterExpression parameterExpression = Expression.Parameter(typeof(Employee), "p");

MemberExpression memberExpression = Expression.Property(parameterExpression, propertyName);

LambdaExpression lambdaExpression = Expression.Lambda(memberExpression, parameterExpression);

Delegate function = lambdaExpression.Compile();

var result =

(

from item in collection

group item by function.DynamicInvoke(item)

into group1

select group1.First().GetType().GetProperty(propertyName).GetValue(group1.First()).ToString()

into group2

orderby group2

select group2

).ToList();

foreach(var item in result)

{

Console.WriteLine(item);

}

#endregion

}

▶ Employee.cs

[C#/LINQ] group … by .. 키워드 질의 형식 : 객체 컬렉션 특정 속성 값의 집합 구하기

■ group … by .. 키워드 질의 형식을 사용해 객체 컬렉션 특정 속성 값의 집합을 구하는 방법을 보여준다. ▶ Program.cs


using System;
using System.ComponentModel;
using System.Collections.ObjectModel;
using System.Linq;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ObservableCollection<Employee> collection = Employee.GetCollection();

            Employee employee = collection.FirstOrDefault();

            if(employee != null)
            {
                PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(employee);

                PropertyDescriptor propertyDescriptor = propertyDescriptorCollection["Sex"];

                var result = from item in collection
                             orderby propertyDescriptor.GetValue(item)
                             group item by propertyDescriptor.GetValue(item);

                foreach(var group in result)
                {
                    Console.WriteLine(group.Key);
                }
            }
        }

        #endregion
    }
}

using System;

using System.ComponentModel;

using System.Collections.ObjectModel;

using System.Linq;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ObservableCollection<Employee> collection = Employee.GetCollection();

Employee employee = collection.FirstOrDefault();

if(employee != null)

{

PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(employee);

PropertyDescriptor propertyDescriptor = propertyDescriptorCollection["Sex"];

var result = from item in collection

orderby propertyDescriptor.GetValue(item)

group item by propertyDescriptor.GetValue(item);

foreach(var group in result)

{

Console.WriteLine(group.Key);

}

#endregion

}

▶

[C#/COMMON] HashSet 클래스 : 객체 컬렉션 특정 속성 값의 집합 구하기

■ HashSet 클래스를 사용해 객체 컬렉션 특정 속성 값의 집합을 구하는 방법을 보여준다. ▶ Program.cs


using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace TestProject
{
    /// <summary>
    /// 프로그램
    /// </summary>
    public class Program
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region 프로그램 시작하기 - Main()

        /// <summary>
        /// 프로그램 시작하기
        /// </summary>
        private static void Main()
        {
            ObservableCollection<Employee> collection = Employee.GetCollection();

            var result = collection.DistinctBy(p => p.Sex).OrderBy(p => p.Sex);

            foreach(var item in result)
            {
                Employee employee = item as Employee;

                Console.WriteLine(employee.Sex);
            }
        }

        #endregion
    }
}

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

namespace TestProject

{

/// <summary>

/// 프로그램

/// </summary>

public class Program

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Private

#region 프로그램 시작하기 - Main()

/// <summary>

/// 프로그램 시작하기

/// </summary>

private static void Main()

{

ObservableCollection<Employee> collection = Employee.GetCollection();

var result = collection.DistinctBy(p => p.Sex).OrderBy(p => p.Sex);

foreach(var item in result)

{

Employee employee = item as Employee;

Console.WriteLine(employee.Sex);

}

#endregion

}

▶ Employee.cs


using System.Collections.ObjectModel;

namespace TestProject
{
    /// <summary>
    /// 직원
    /// </summary>
    public class Employee
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region ID - ID

        /// <summary>
        /// ID
        /// </summary>
        public string ID { get; set; }

        #endregion

        #region 성명 - Name

        /// <summary>
        /// 성명
        /// </summary>
        public string Name { get; set; }

        #endregion

        #region 성별 - Sex

        /// <summary>
        /// 성별
        /// </summary>
        public string Sex { get; set; }

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 컬렉션 구하기 - GetCollection()

        /// <summary>
        /// 컬렉션 구하기
        /// </summary>
        /// <returns>컬렉션</returns>
        public static ObservableCollection<Employee> GetCollection()
        {
            ObservableCollection<Employee> collection = new ObservableCollection<Employee>();

            for(int i = 0; i < 100000; i++)
            {
                collection.Add
                (
                    new Employee()
                    {
                        ID   = i.ToString(),
                        Name = "직원" + i.ToString(),
                        Sex  = (i % 3 == 1 ? "남" : "여")
                    }
                );
            }

            return collection;
        }

        #endregion
    }
}

using System.Collections.ObjectModel;

namespace TestProject

{

/// <summary>

/// 직원

/// </summary>

public class Employee

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region ID - ID

/// <summary>

/// ID

/// </summary>

public string ID { get; set; }

#endregion

#region 성명 - Name

/// <summary>

/// 성명

/// </summary>

public string Name { get; set; }

#endregion

#region 성별 - Sex

/// <summary>

/// 성별

/// </summary>

public string Sex { get; set; }

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 컬렉션 구하기 - GetCollection()

/// <summary>

/// 컬렉션 구하기

/// </summary>

/// <returns>컬렉션</returns>

public static ObservableCollection<Employee> GetCollection()

{

ObservableCollection<Employee> collection = new ObservableCollection<Employee>();

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

{

collection.Add

(

new Employee()

{

ID = i.ToString(),

Name = "직원" + i.ToString(),

Sex = (i % 3 == 1 ? "남" : "여")

}

);

}

return collection;

}

#endregion

}

▶ EnumerableExtension.cs


using System;
using System.Collections.Generic;

namespace TestProject
{
    /// <summary>
    /// 열거 가능 확장
    /// </summary>
    public static class EnumerableExtension
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Method
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 중복 값을 제거한 리스트 구하기 - DistinctBy<TSource, TKey>(sourceEnumerable, keySelector)

        /// <summary>
        /// 중복 값을 제거한 리스트 구하기
        /// </summary>
        /// <typeparam name="TSource">소스 타입</typeparam>
        /// <typeparam name="TKey">키 타입</typeparam>
        /// <param name="sourceEnumerable">소스 열거 가능</param>
        /// <param name="keySelector">키 셀렉터</param>
        /// <returns>중복 값을 제거한 리스트</returns>
        public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> sourceEnumerable, Func<TSource, TKey> keySelector)
        {
            HashSet<TKey> hashSet = new HashSet<TKey>();

            foreach(TSource sourceItem in sourceEnumerable)
            {
                if(hashSet.Add(keySelector(sourceItem)))
                {
                    yield return sourceItem;
                }
            }
        }

        #endregion
    }
}

using System;

using System.Collections.Generic;

namespace TestProject

{

/// <summary>

/// 열거 가능 확장

/// </summary>

public static class EnumerableExtension

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 중복 값을 제거한 리스트 구하기 - DistinctBy<TSource, TKey>(sourceEnumerable, keySelector)

/// <summary>

/// 중복 값을 제거한 리스트 구하기

/// </summary>

/// <typeparam name="TSource">소스 타입</typeparam>

/// <typeparam name="TKey">키 타입</typeparam>

/// <param name="sourceEnumerable">소스 열거 가능</param>

/// <param name="keySelector">키 셀렉터</param>

/// <returns>중복 값을 제거한 리스트</returns>

public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> sourceEnumerable, Func<TSource, TKey> keySelector)

{

HashSet<TKey> hashSet = new HashSet<TKey>();

foreach(TSource sourceItem in sourceEnumerable)

{

if(hashSet.Add(keySelector(sourceItem)))

{

yield return sourceItem;

}

#endregion

}

[C#/COMMON] IList 인터페이스 사용하기

■ IList 인터페이스를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;

SimpleList simpleList = new SimpleList();

Console.WriteLine("리스트 만들기");

simpleList.Add("one"  );
simpleList.Add("two"  );
simpleList.Add("three");
simpleList.Add("four" );
simpleList.Add("five" );
simpleList.Add("six"  );
simpleList.Add("seven");
simpleList.Add("eight");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트에서 요소 제거하기]");

simpleList.Remove("six");
simpleList.Remove("eight");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트 끝에 요소 추가하기]");

simpleList.Add("nine");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트 중간에 요소 삽입하기]");

simpleList.Insert(4, "number");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트에서 특정 요소 체크하기]");

Console.WriteLine();

Console.WriteLine("리스트가 \"three\"를 포함한다 : {0}", simpleList.Contains("three"));
Console.WriteLine("리스트가 \"ten\"을 포함한다   : {0}", simpleList.Contains("ten"  ));

using System;

SimpleList simpleList = new SimpleList();

Console.WriteLine("리스트 만들기");

simpleList.Add("one" );

simpleList.Add("two" );

simpleList.Add("three");

simpleList.Add("four" );

simpleList.Add("five" );

simpleList.Add("six" );

simpleList.Add("seven");

simpleList.Add("eight");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트에서 요소 제거하기]");

simpleList.Remove("six");

simpleList.Remove("eight");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트 끝에 요소 추가하기]");

simpleList.Add("nine");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트 중간에 요소 삽입하기]");

simpleList.Insert(4, "number");

Console.WriteLine();

simpleList.DisplayStatus();

Console.WriteLine();

Console.WriteLine("[리스트에서 특정 요소 체크하기]");

Console.WriteLine();

Console.WriteLine("리스트가 \"three\"를 포함한다 : {0}", simpleList.Contains("three"));

Console.WriteLine("리스트가 \"ten\"을 포함한다 : {0}", simpleList.Contains("ten" ));

▶ SimpleList.cs


using System;
using System.Collections;

/// <summary>
/// 심플 리스트
/// </summary>
public class SimpleList : IList
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 객체 배열
    /// </summary>
    private object[] objectArray = new object[8];

    /// <summary>
    /// 카운트
    /// </summary>
    private int count;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    // IList
    #region 리스트 고정 크기 여부 - IsFixedSize

    /// <summary>
    /// 리스트 고정 크기 여부
    /// </summary>
    public bool IsFixedSize
    {
        get
        {
            return true;
        }
    }

    #endregion

    // IList
    #region 읽기 전용 여부 - IsReadOnly

    /// <summary>
    /// 읽기 전용 여부
    /// </summary>
    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    #endregion

    // IList
    #region 인덱서 - this[index]

    /// <summary>
    /// 인덱서
    /// </summary>
    /// <param name="index">인덱스</param>
    /// <returns>항목</returns>
    public object this[int index]
    {
        get
        {
            return this.objectArray[index];
        }
        set
        {
            this.objectArray[index] = value;
        }
    }

    #endregion

    // ICollection
    #region 카운트 - Count

    /// <summary>
    /// 카운트
    /// </summary>
    public int Count
    {
        get
        {
            return this.count;
        }
    }

    #endregion

    // ICollection
    #region 동기화 여부 - IsSynchronized

    /// <summary>
    /// 동기화 여부
    /// </summary>
    public bool IsSynchronized
    {
        get
        {
            return false;
        }
    }

    #endregion

    // ICollection
    #region 동기화 객체 - SyncRoot

    /// <summary>
    /// 동기화 객체
    /// </summary>
    public object SyncRoot
    {
        get
        {
            return this;
        }
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - SimpleList()

    /// <summary>
    /// 생성자
    /// </summary>
    public SimpleList()
    {
        this.count = 0;
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    // IList
    #region 추가하기 - Add(value)

    /// <summary>
    /// 추가하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns>인덱스</returns>
    public int Add(object value)
    {
        if(this.count < this.objectArray.Length)
        {
            this.objectArray[this.count] = value;

            this.count++;

            return (this.count - 1);
        }
        else
        {
            return -1;
        }
    }

    #endregion

    // IList
    #region 지우기 - Clear()

    /// <summary>
    /// 지우기
    /// </summary>
    public void Clear()
    {
        this.count = 0;
    }

    #endregion

    // IList
    #region 포함 여부 구하기 - Contains(value)

    /// <summary>
    /// 포함 여부 구하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns>포함 여부</returns>
    public bool Contains(object value)
    {
        bool inList = false;

        for(int i = 0; i < Count; i++)
        {
            if(this.objectArray[i] == value)
            {
                inList = true;

                break;
            }
        }

        return inList;
    }

    #endregion

    // IList
    #region 인덱스 구하기 - IndexOf(value)

    /// <summary>
    /// 인덱스 구하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns></returns>
    public int IndexOf(object value)
    {
        int index = -1;

        for(int i = 0; i < Count; i++)
        {
            if(this.objectArray[i] == value)
            {
                index = i;

                break;
            }
        }

        return index;
    }

    #endregion

    // IList
    #region 삽입하기 - Insert(index, value)

    /// <summary>
    /// 삽입하기
    /// </summary>
    /// <param name="index">인덱스</param>
    /// <param name="value">값</param>
    public void Insert(int index, object value)
    {
        if((this.count + 1 <= this.objectArray.Length) && (index < Count) && (index >= 0))
        {
            this.count++;

            for(int i = Count - 1; i > index; i--)
            {
                this.objectArray[i] = this.objectArray[i - 1];
            }

            this.objectArray[index] = value;
        }
    }

    #endregion

    // IList
    #region 제거하기 - Remove(value)

    /// <summary>
    /// 제거하기
    /// </summary>
    /// <param name="value">값</param>
    public void Remove(object value)
    {
        RemoveAt(IndexOf(value));
    }

    #endregion

    // IList
    #region 제거하기 - RemoveAt(index)

    /// <summary>
    /// 제거하기
    /// </summary>
    /// <param name="index">인덱스</param>
    public void RemoveAt(int index)
    {
        if((index >= 0) && (index < Count))
        {
            for(int i = index; i < Count - 1; i++)
            {
                this.objectArray[i] = this.objectArray[i + 1];
            }

            this.count--;
        }
    }

    #endregion

    // ICollection
    #region 복사하기 - CopyTo(array, index)

    /// <summary>
    /// 복사하기
    /// </summary>
    /// <param name="array">배열</param>
    /// <param name="index">인덱스</param>
    public void CopyTo(Array array, int index)
    {
        int j = index;

        for(int i = 0; i < Count; i++)
        {
            array.SetValue(this.objectArray[i], j);

            j++;
        }
    }

    #endregion

    // IEnumerable
    #region 열거자 구하기 - GetEnumerator()

    /// <summary>
    /// 열거자 구하기
    /// </summary>
    /// <returns>열거자</returns>
    public IEnumerator GetEnumerator()
    {
        throw new Exception("The method or operation is not implemented.");
    }

    #endregion

    #region 상태 출력하기 - DisplayStatus()

    /// <summary>
    /// 상태 출력하기
    /// </summary>
    public void DisplayStatus()
    {
        Console.WriteLine("리스트는 {0}개 용량과 현재 {1}개 요소를 갖는다.", this.objectArray.Length, this.count);

        Console.Write("리스트 : ");

        for(int i = 0; i < Count; i++)
        {
            Console.Write(" {0}", this.objectArray[i]);
        }

        Console.WriteLine();
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

using System;

using System.Collections;

/// <summary>

/// 심플 리스트

/// </summary>

public class SimpleList : IList

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 객체 배열

/// </summary>

private object[] objectArray = new object[8];

/// <summary>

/// 카운트

/// </summary>

private int count;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

// IList

#region 리스트 고정 크기 여부 - IsFixedSize

/// <summary>

/// 리스트 고정 크기 여부

/// </summary>

public bool IsFixedSize

{

get

{

return true;

}

#endregion

// IList

#region 읽기 전용 여부 - IsReadOnly

/// <summary>

/// 읽기 전용 여부

/// </summary>

public bool IsReadOnly

{

get

{

return false;

}

#endregion

// IList

#region 인덱서 - this[index]

/// <summary>

/// 인덱서

/// </summary>

/// <param name="index">인덱스</param>

/// <returns>항목</returns>

public object this[int index]

{

get

{

return this.objectArray[index];

}

set

{

this.objectArray[index] = value;

}

#endregion

// ICollection

#region 카운트 - Count

/// <summary>

/// 카운트

/// </summary>

public int Count

{

get

{

return this.count;

}

#endregion

// ICollection

#region 동기화 여부 - IsSynchronized

/// <summary>

/// 동기화 여부

/// </summary>

public bool IsSynchronized

{

get

{

return false;

}

#endregion

// ICollection

#region 동기화 객체 - SyncRoot

/// <summary>

/// 동기화 객체

/// </summary>

public object SyncRoot

{

get

{

return this;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - SimpleList()

/// <summary>

/// 생성자

/// </summary>

public SimpleList()

{

this.count = 0;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

// IList

#region 추가하기 - Add(value)

/// <summary>

/// 추가하기

/// </summary>

/// <param name="value">값</param>

/// <returns>인덱스</returns>

public int Add(object value)

{

if(this.count < this.objectArray.Length)

{

this.objectArray[this.count] = value;

this.count++;

return (this.count - 1);

}

else

{

return -1;

}

#endregion

// IList

#region 지우기 - Clear()

/// <summary>

/// 지우기

/// </summary>

public void Clear()

{

this.count = 0;

}

#endregion

// IList

#region 포함 여부 구하기 - Contains(value)

/// <summary>

/// 포함 여부 구하기

/// </summary>

/// <param name="value">값</param>

/// <returns>포함 여부</returns>

public bool Contains(object value)

{

bool inList = false;

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

{

if(this.objectArray[i] == value)

{

inList = true;

break;

}

return inList;

}

#endregion

// IList

#region 인덱스 구하기 - IndexOf(value)

/// <summary>

/// 인덱스 구하기

/// </summary>

/// <param name="value">값</param>

/// <returns></returns>

public int IndexOf(object value)

{

int index = -1;

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

{

if(this.objectArray[i] == value)

{

index = i;

break;

}

return index;

}

#endregion

// IList

#region 삽입하기 - Insert(index, value)

/// <summary>

/// 삽입하기

/// </summary>

/// <param name="index">인덱스</param>

/// <param name="value">값</param>

public void Insert(int index, object value)

{

if((this.count + 1 <= this.objectArray.Length) && (index < Count) && (index >= 0))

{

this.count++;

for(int i = Count - 1; i > index; i--)

{

this.objectArray[i] = this.objectArray[i - 1];

}

this.objectArray[index] = value;

}

#endregion

// IList

#region 제거하기 - Remove(value)

/// <summary>

/// 제거하기

/// </summary>

/// <param name="value">값</param>

public void Remove(object value)

{

RemoveAt(IndexOf(value));

}

#endregion

// IList

#region 제거하기 - RemoveAt(index)

/// <summary>

/// 제거하기

/// </summary>

/// <param name="index">인덱스</param>

public void RemoveAt(int index)

{

if((index >= 0) && (index < Count))

{

for(int i = index; i < Count - 1; i++)

{

this.objectArray[i] = this.objectArray[i + 1];

}

this.count--;

}

#endregion

// ICollection

#region 복사하기 - CopyTo(array, index)

/// <summary>

/// 복사하기

/// </summary>

/// <param name="array">배열</param>

/// <param name="index">인덱스</param>

public void CopyTo(Array array, int index)

{

int j = index;

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

{

array.SetValue(this.objectArray[i], j);

j++;

}

#endregion

// IEnumerable

#region 열거자 구하기 - GetEnumerator()

/// <summary>

/// 열거자 구하기

/// </summary>

/// <returns>열거자</returns>

public IEnumerator GetEnumerator()

{

throw new Exception("The method or operation is not implemented.");

}

#endregion

#region 상태 출력하기 - DisplayStatus()

/// <summary>

/// 상태 출력하기

/// </summary>

public void DisplayStatus()

{

Console.WriteLine("리스트는 {0}개 용량과 현재 {1}개 요소를 갖는다.", this.objectArray.Length, this.count);

Console.Write("리스트 : ");

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

{

Console.Write(" {0}", this.objectArray[i]);

}

Console.WriteLine();

}

#endregion

}

[C#/COMMON] IEnumerable 인터페이스 사용하기

■ IEnumerable 인터페이스를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


Employee[] employeeArray = new Employee[3]
{
    new Employee("John", "Smith"  ),
    new Employee("Jim" , "Johnson"),
    new Employee("Sue" , "Rabon"  )
};

EmployeeEnumerable employeeEnumerable = new EmployeeEnumerable(employeeArray);

foreach(Employee employee in employeeEnumerable)
{
    Console.WriteLine(employee.FirstName + " " + employee.LastName);
}

Employee[] employeeArray = new Employee[3]

{

new Employee("John", "Smith" ),

new Employee("Jim" , "Johnson"),

new Employee("Sue" , "Rabon" )

};

EmployeeEnumerable employeeEnumerable = new EmployeeEnumerable(employeeArray);

foreach(Employee employee in employeeEnumerable)

{

Console.WriteLine(employee.FirstName + " " + employee.LastName);

}

▶ Employee.cs


/// <summary>
/// 직원
/// </summary>
public class Employee
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 이름 - FirstName

    /// <summary>
    /// 이름
    /// </summary>
    public string FirstName { get; set; }

    #endregion

    #region 성 - LastName

    /// <summary>
    /// 성
    /// </summary>
    public string LastName { get; set; }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - Employee(firstName, lastName)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="firstName">이름</param>
    /// <param name="lastName">성</param>
    public Employee(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName  = lastName;
    }

    #endregion
}

/// <summary>

/// 직원

/// </summary>

public class Employee

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 이름 - FirstName

/// <summary>

/// 이름

/// </summary>

public string FirstName { get; set; }

#endregion

#region 성 - LastName

/// <summary>

/// 성

/// </summary>

public string LastName { get; set; }

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - Employee(firstName, lastName)

/// <summary>

/// 생성자

/// </summary>

/// <param name="firstName">이름</param>

/// <param name="lastName">성</param>

public Employee(string firstName, string lastName)

{

FirstName = firstName;

LastName = lastName;

}

#endregion

}

▶ EmployeeEnumerator.cs


using System;
using System.Collections;

/// <summary>
/// 직원 열거자
/// </summary>
public class EmployeeEnumerator : IEnumerator
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 직원 배열
    /// </summary>
    private  Employee[] employeeArray;

    /// <summary>
    /// 현재 위치
    /// </summary>
    private int currentPosition = -1;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 직원 배열 - EmployeeArray

    /// <summary>
    /// 직원 배열
    /// </summary>
    public Employee[] EmployeeArray
    {
        get
        {
            return this.employeeArray;
        }
        set
        {
            this.employeeArray = value;
        }
    }

    #endregion

    #region 현재 항목 - IEnumerator.Current

    /// <summary>
    /// 현재 항목
    /// </summary>
    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    #endregion

    #region 현재 항목 - Current

    /// <summary>
    /// 현재 항목
    /// </summary>
    public Employee Current
    {
        get
        {
            try
            {
                return this.employeeArray[this.currentPosition];
            }
            catch(IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - EmployeeEnumerator(employeeArray)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="employeeArray">직원 배열</param>
    public EmployeeEnumerator(Employee[] employeeArray)
    {
        this.employeeArray = employeeArray;
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 다음 요소로 이동하기 - MoveNext()

    /// <summary>
    /// 다음 요소로 이동하기
    /// </summary>
    /// <returns>현재 위치가 마지막 요소 뒤 위치 여부</returns>
    public bool MoveNext()
    {
        this.currentPosition++;

        return (this.currentPosition < this.employeeArray.Length);
    }

    #endregion

    #region 위치 처음 요소 앞으로 이동하기 - Reset()

    /// <summary>
    /// 위치 처음 요소 앞으로 이동하기
    /// </summary>
    public void Reset()
    {
        this.currentPosition = -1;
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

using System;

using System.Collections;

/// <summary>

/// 직원 열거자

/// </summary>

public class EmployeeEnumerator : IEnumerator

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 직원 배열

/// </summary>

private Employee[] employeeArray;

/// <summary>

/// 현재 위치

/// </summary>

private int currentPosition = -1;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 직원 배열 - EmployeeArray

/// <summary>

/// 직원 배열

/// </summary>

public Employee[] EmployeeArray

{

get

{

return this.employeeArray;

}

set

{

this.employeeArray = value;

}

#endregion

#region 현재 항목 - IEnumerator.Current

/// <summary>

/// 현재 항목

/// </summary>

object IEnumerator.Current

{

get

{

return Current;

}

#endregion

#region 현재 항목 - Current

/// <summary>

/// 현재 항목

/// </summary>

public Employee Current

{

get

{

try

{

return this.employeeArray[this.currentPosition];

}

catch(IndexOutOfRangeException)

{

throw new InvalidOperationException();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - EmployeeEnumerator(employeeArray)

/// <summary>

/// 생성자

/// </summary>

/// <param name="employeeArray">직원 배열</param>

public EmployeeEnumerator(Employee[] employeeArray)

{

this.employeeArray = employeeArray;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 다음 요소로 이동하기 - MoveNext()

/// <summary>

/// 다음 요소로 이동하기

/// </summary>

/// <returns>현재 위치가 마지막 요소 뒤 위치 여부</returns>

public bool MoveNext()

{

this.currentPosition++;

return (this.currentPosition < this.employeeArray.Length);

}

#endregion

#region 위치 처음 요소 앞으로 이동하기 - Reset()

/// <summary>

/// 위치 처음 요소 앞으로 이동하기

/// </summary>

public void Reset()

{

this.currentPosition = -1;

}

#endregion

}

▶ EmployeeEnumerable.cs


using System;
using System.Collections;

/// <summary>
/// 직원 열거가능
/// </summary>
public class EmployeeEnumerable : IEnumerable
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 직원 배열
    /// </summary>
    private Employee[] employeeArray;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - EmployeeEnumerable(employeeArray)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="employeeArray">직원 배열</param>
    public EmployeeEnumerable(Employee[] employeeArray)
    {
        this.employeeArray = new Employee[employeeArray.Length];

        for(int i = 0; i < employeeArray.Length; i++)
        {
            this.employeeArray[i] = employeeArray[i];
        }
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 열거자 구하기 - IEnumerable.GetEnumerator()

    /// <summary>
    /// 열거자 구하기
    /// </summary>
    /// <returns>열거자</returns>
    IEnumerator IEnumerable.GetEnumerator()
    {
        return (IEnumerator)GetEnumerator();
    }

    #endregion

    #region 열거자 구하기 - GetEnumerator()

    /// <summary>
    /// 열거자 구하기
    /// </summary>
    /// <returns>직원 열거자</returns>
    public EmployeeEnumerator GetEnumerator()
    {
        return new EmployeeEnumerator(this.employeeArray);
    }

    #endregion
}

using System;

using System.Collections;

/// <summary>

/// 직원 열거가능

/// </summary>

public class EmployeeEnumerable : IEnumerable

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 직원 배열

/// </summary>

private Employee[] employeeArray;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - EmployeeEnumerable(employeeArray)

/// <summary>

/// 생성자

/// </summary>

/// <param name="employeeArray">직원 배열</param>

public EmployeeEnumerable(Employee[] employeeArray)

{

this.employeeArray = new Employee[employeeArray.Length];

for(int i = 0; i < employeeArray.Length; i++)

{

this.employeeArray[i] = employeeArray[i];

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 열거자 구하기 - IEnumerable.GetEnumerator()

/// <summary>

/// 열거자 구하기

/// </summary>

/// <returns>열거자</returns>

IEnumerator IEnumerable.GetEnumerator()

{

return (IEnumerator)GetEnumerator();

}

#endregion

#region 열거자 구하기 - GetEnumerator()

/// <summary>

/// 열거자 구하기

/// </summary>

/// <returns>직원 열거자</returns>

public EmployeeEnumerator GetEnumerator()

{

return new EmployeeEnumerator(this.employeeArray);

}

#endregion

}

[C#/COMMON] IEnumerator 인터페이스 사용하기

■ IEnumerator 인터페이스를 사용하는 방법을 보여준다. ▶ Employee.cs


/// <summary>
/// 직원
/// </summary>
public class Employee
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 이름 - FirstName

    /// <summary>
    /// 이름
    /// </summary>
    public string FirstName { get; set; }

    #endregion

    #region 성 - LastName

    /// <summary>
    /// 성
    /// </summary>
    public string LastName { get; set; }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - Employee(firstName, lastName)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="firstName">이름</param>
    /// <param name="lastName">성</param>
    public Employee(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName  = lastName;
    }

    #endregion
}

/// <summary>

/// 직원

/// </summary>

public class Employee

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 이름 - FirstName

/// <summary>

/// 이름

/// </summary>

public string FirstName { get; set; }

#endregion

#region 성 - LastName

/// <summary>

/// 성

/// </summary>

public string LastName { get; set; }

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - Employee(firstName, lastName)

/// <summary>

/// 생성자

/// </summary>

/// <param name="firstName">이름</param>

/// <param name="lastName">성</param>

public Employee(string firstName, string lastName)

{

FirstName = firstName;

LastName = lastName;

}

#endregion

}

▶ EmployeeEnumerator.cs


using System;
using System.Collections;

/// <summary>
/// 직원 열거자
/// </summary>
public class EmployeeEnumerator : IEnumerator
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 직원 배열
    /// </summary>
    private  Employee[] employeeArray;

    /// <summary>
    /// 현재 위치
    /// </summary>
    private int currentPosition = -1;

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 직원 배열 - EmployeeArray

    /// <summary>
    /// 직원 배열
    /// </summary>
    public Employee[] EmployeeArray
    {
        get
        {
            return this.employeeArray;
        }
        set
        {
            this.employeeArray = value;
        }
    }

    #endregion

    #region 현재 항목 - IEnumerator.Current

    /// <summary>
    /// 현재 항목
    /// </summary>
    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    #endregion

    #region 현재 항목 - Current

    /// <summary>
    /// 현재 항목
    /// </summary>
    public Employee Current
    {
        get
        {
            try
            {
                return this.employeeArray[this.currentPosition];
            }
            catch(IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 생성자 - EmployeeEnumerator(employeeArray)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="employeeArray">직원 배열</param>
    public EmployeeEnumerator(Employee[] employeeArray)
    {
        this.employeeArray = employeeArray;
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 다음 요소로 이동하기 - MoveNext()

    /// <summary>
    /// 다음 요소로 이동하기
    /// </summary>
    /// <returns>현재 위치가 마지막 요소 뒤 위치 여부</returns>
    public bool MoveNext()
    {
        this.currentPosition++;

        return (this.currentPosition < this.employeeArray.Length);
    }

    #endregion

    #region 위치 처음 요소 앞으로 이동하기 - Reset()

    /// <summary>
    /// 위치 처음 요소 앞으로 이동하기
    /// </summary>
    public void Reset()
    {
        this.currentPosition = -1;
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

using System;

using System.Collections;

/// <summary>

/// 직원 열거자

/// </summary>

public class EmployeeEnumerator : IEnumerator

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Field

////////////////////////////////////////////////////////////////////////////////////////// Private

#region Field

/// <summary>

/// 직원 배열

/// </summary>

private Employee[] employeeArray;

/// <summary>

/// 현재 위치

/// </summary>

private int currentPosition = -1;

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 직원 배열 - EmployeeArray

/// <summary>

/// 직원 배열

/// </summary>

public Employee[] EmployeeArray

{

get

{

return this.employeeArray;

}

set

{

this.employeeArray = value;

}

#endregion

#region 현재 항목 - IEnumerator.Current

/// <summary>

/// 현재 항목

/// </summary>

object IEnumerator.Current

{

get

{

return Current;

}

#endregion

#region 현재 항목 - Current

/// <summary>

/// 현재 항목

/// </summary>

public Employee Current

{

get

{

try

{

return this.employeeArray[this.currentPosition];

}

catch(IndexOutOfRangeException)

{

throw new InvalidOperationException();

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Constructor

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 생성자 - EmployeeEnumerator(employeeArray)

/// <summary>

/// 생성자

/// </summary>

/// <param name="employeeArray">직원 배열</param>

public EmployeeEnumerator(Employee[] employeeArray)

{

this.employeeArray = employeeArray;

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 다음 요소로 이동하기 - MoveNext()

/// <summary>

/// 다음 요소로 이동하기

/// </summary>

/// <returns>현재 위치가 마지막 요소 뒤 위치 여부</returns>

public bool MoveNext()

{

this.currentPosition++;

return (this.currentPosition < this.employeeArray.Length);

}

#endregion

#region 위치 처음 요소 앞으로 이동하기 - Reset()

/// <summary>

/// 위치 처음 요소 앞으로 이동하기

/// </summary>

public void Reset()

{

this.currentPosition = -1;

}

#endregion

}

[C#/COMMON] 데이터 테이블 복사하기

■ 데이터 테이블을 복사하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Data;

#region 복사하기 - Copy(sourceTable, targetTable)

/// <summary>
/// 복사하기
/// </summary>
/// <param name="sourceTable">소스 테이블</param>
/// <param name="targetTable">타겟 테이블</param>
public void Copy(DataTable sourceTable, ref DataTable targetTable)
{
    targetTable = sourceTable.Clone();

    for(int i = 0; i < sourceTable.Rows.Count; i++)
    {
        object array = sourceTable.Rows[i].ItemArray.Clone();

        DataRow targetRow = targetTable.NewRow();

        targetRow.ItemArray = (object[])array;

        targetTable.Rows.Add(targetRow);
    }
}

#endregion

using System.Data;

#region 복사하기 - Copy(sourceTable, targetTable)

/// <summary>

/// 복사하기

/// </summary>

/// <param name="sourceTable">소스 테이블</param>

/// <param name="targetTable">타겟 테이블</param>

public void Copy(DataTable sourceTable, ref DataTable targetTable)

{

targetTable = sourceTable.Clone();

for(int i = 0; i < sourceTable.Rows.Count; i++)

{

object array = sourceTable.Rows[i].ItemArray.Clone();

DataRow targetRow = targetTable.NewRow();

targetRow.ItemArray = (object[])array;

targetTable.Rows.Add(targetRow);

}

#endregion

[C#/COMMON] IDictionaryEnumerator 인터페이스 사용하기

■ IDictionaryEnumerator 인터페이스를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections;
using System.Collections.Generic;

Dictionary<string, string> codeDictionary = new Dictionary<string, string>();

codeDictionary.Add("A", "가");
codeDictionary.Add("B", "나");
codeDictionary.Add("C", "다");

IDictionaryEnumerator dictionaryEnumerator = codeDictionary.GetEnumerator();

while(dictionaryEnumerator.MoveNext())
{
    string codeName = dictionaryEnumerator.Value as string;

    Console.WriteLine(codeName);
}

using System;

using System.Collections;

using System.Collections.Generic;

Dictionary<string, string> codeDictionary = new Dictionary<string, string>();

codeDictionary.Add("A", "가");

codeDictionary.Add("B", "나");

codeDictionary.Add("C", "다");

IDictionaryEnumerator dictionaryEnumerator = codeDictionary.GetEnumerator();

while(dictionaryEnumerator.MoveNext())

{

string codeName = dictionaryEnumerator.Value as string;

Console.WriteLine(codeName);

}

[C#/LINQ] Enumerable 클래스 : Select 확장 메소드 사용하기

■ Enumerable 클래스의 Select<TSource, TResult> 확장 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

/// <summary>
/// 임직원
/// </summary>
class Employee
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 성명 - Name

    /// <summary>
    /// 성명
    /// </summary>
    public string Name { get; set; }

    #endregion

    #region 부서 - Department

    /// <summary>
    /// 부서
    /// </summary>
    public string Department { get; set; }

    #endregion

    #region 취미 배열 - HobbyArray

    /// <summary>
    /// 취미 배열
    /// </summary>
    public string[] HobbyArray { get; set; }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static
    //////////////////////////////////////////////////////////////////////////////// Public

    #region 임직원 리스트 구하기 - GetEmployeeList()

    /// <summary>
    /// 임직원 리스트 구하기
    /// </summary>
    /// <returns>임직원 리스트</returns>
    public static List<Employee> GetEmployeeList()
    {
        List<Employee> employeeList = new List<Employee>
        {
            new Employee { Name = "홍길동", Department = "영업부"      , HobbyArray = new string[] { "게임", "독서"     }},
            new Employee { Name = "황희"  , Department = "경리부"      , HobbyArray = new string[] { "수영", "영화감상" }},
            new Employee { Name = "정약용", Department = "신사업기획부", HobbyArray = new string[] { "등산", "DIY"      }}
        };

        return employeeList;
    }

    #endregion
}

...

List<Employee> employeeList = Employee.GetEmployeeList();

var result = employeeList.Select(employee => employee.HobbyArray);

foreach(string[] hobbyArray in result)
{
    foreach(string hobby in hobbyArray)
    {
        Console.WriteLine(hobby);
    }
}

/*
게임
독서
수영
영화감상
등산
DIY
*/

using System;

using System.Collections.Generic;

using System.Linq;

/// <summary>

/// 임직원

/// </summary>

class Employee

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Property

////////////////////////////////////////////////////////////////////////////////////////// Public

#region 성명 - Name

/// <summary>

/// 성명

/// </summary>

public string Name { get; set; }

#endregion

#region 부서 - Department

/// <summary>

/// 부서

/// </summary>

public string Department { get; set; }

#endregion

#region 취미 배열 - HobbyArray

/// <summary>

/// 취미 배열

/// </summary>

public string[] HobbyArray { get; set; }

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Method

////////////////////////////////////////////////////////////////////////////////////////// Static

//////////////////////////////////////////////////////////////////////////////// Public

#region 임직원 리스트 구하기 - GetEmployeeList()

/// <summary>

/// 임직원 리스트 구하기

/// </summary>

/// <returns>임직원 리스트</returns>

public static List<Employee> GetEmployeeList()

{

List<Employee> employeeList = new List<Employee>

{

new Employee { Name = "홍길동", Department = "영업부" , HobbyArray = new string[] { "게임", "독서" }},

new Employee { Name = "황희" , Department = "경리부" , HobbyArray = new string[] { "수영", "영화감상" }},

new Employee { Name = "정약용", Department = "신사업기획부", HobbyArray = new string[] { "등산", "DIY" }}

};

return employeeList;

}

#endregion

}

...

List<Employee> employeeList = Employee.GetEmployeeList();

var result = employeeList.Select(employee => employee.HobbyArray);

foreach(string[] hobbyArray in result)

{

foreach(string hobby in hobbyArray)

{

Console.WriteLine(hobby);

}

게임

독서

수영

영화감상

등산

DIY

[C#/LINQ] Enumerable 클래스 : TakeWhile 확장 메소드를 사용해 지정된 조건이 true인 동안 시퀀스에서 요소 구하기

■ Enumerable 클래스의 TakeWhile<T> 확장 메소드를 사용해 지정된 조건이 true인 동안 시퀀스에서 요소를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

int[] integerArray = { 19, 31, 25, -10, 45, 29 };

IEnumerable<int> result = integerArray.TakeWhile(n => n < 29);

foreach(int integer in result)
{
    Console.WriteLine(integer);
}

using System;

using System.Collections.Generic;

using System.Linq;

int[] integerArray = { 19, 31, 25, -10, 45, 29 };

IEnumerable<int> result = integerArray.TakeWhile(n => n < 29);

foreach(int integer in result)

{

Console.WriteLine(integer);

}

[C#/LINQ] Enumerable 클래스 : Take 확장 메소드를 사용해 지정된 수의 연속 요소 구하기

■ Enumerable 클래스의 Take<T> 확장 메소드를 사용해 지정된 수의 연속 요소를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

int[] integerArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

IEnumerable<int> result = integerArray.Take(3);

foreach(int integer in result)
{
    Console.WriteLine(integer);
}

using System;

using System.Collections.Generic;

using System.Linq;

int[] integerArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

IEnumerable<int> result = integerArray.Take(3);

foreach(int integer in result)

{

Console.WriteLine(integer);

}

[C#/LINQ] Enumerable 클래스 : SkipWhile 확장 메소드를 사용해 지정된 조건이 true이면 시퀀스에 있는 요소를 무시하고 나머지 요소 반환하기

■ Enumerable 클래스의 SkipWhile<T> 확장 메소드를 사용해 지정된 조건이 true이면 시퀀스에 있는 요소를 무시하고 나머지 요소를 반환하는 방법을 보여준다. ▶ 예제 코드

[C#/LINQ] Enumerable 클래스 : Skip 확장 메소드를 사용해 지정된 수의 요소를 건너뛰고 다음 결과 반환하기

■ Enumerable 클래스의 Skip<T> 확장 메소드를 사용해 지정된 수의 요소를 건너뛰고 다음 결과를 반환하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Collections.Generic;
using System.Linq;

int[] integerArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

IEnumerable<int> result = integerArray.Skip(3);

foreach(int integer in result)
{
    Console.WriteLine(integer);
}

using System;

using System.Collections.Generic;

using System.Linq;

int[] integerArray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

IEnumerable<int> result = integerArray.Skip(3);

foreach(int integer in result)

{

Console.WriteLine(integer);

}