DATA Archives - 46 중 45 번째 페이지

[C#/COMMON] 스무스 정렬하기

■ 스무스 정렬하는 방법을 보여준다. ▶ 스무스 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

SmoothSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

SmoothSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 스무스 정렬하기 (C#)


using System;

#region Field

/// <summary>
/// 논리적 포인트 배열
/// </summary>
[NonSerialized]
private static int[] _logicalPointArray = new int[]
{
    1        , 1        , 3        , 5       , 9       , 15      , 25      , 41      , 67       , 109      ,
    177      , 287      , 465      , 753     , 1219    , 1973    , 3193    , 5167    , 8361     , 13529    ,
    21891    , 35421    , 57313    , 92735   , 150049  , 242785  , 392835  , 635621  , 1028457  , 1664079  ,
    2692537  , 4356617  , 7049155  , 11405773, 18454929, 29860703, 48315633, 78176337, 126491971, 204668309,
    331160281, 535828591, 866988873
};

#endregion

#region 스무스 정렬하기 - SmoothSort<T>(itemArray, lowIndex, highIndex)

/// <summary>/// 스무스 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="lowIndex">하위 인덱스</param>
/// <param name="highIndex">상위 인덱스</param>
public void SmoothSort<T>(T[] itemArray, int lowIndex, int highIndex) where T : IComparable
{
    int headIndex  = lowIndex;
    int index      = 1;
    int shiftIndex = 1;

    while(headIndex < highIndex)
    {
        if((index & 3) == 3)
        {
            Sift(itemArray, shiftIndex, headIndex);

            index >>= 2;

            shiftIndex += 2;
        }
        else
        {
            if(_logicalPointArray[shiftIndex - 1] >= highIndex - headIndex)
            {
                Trinkle(itemArray, index, shiftIndex, headIndex, false);
            }
            else
            {
                Sift(itemArray, shiftIndex, headIndex);
            }

            if(shiftIndex == 1)
            {
                index <<= 1;

                shiftIndex--;
            }
            else
            {
                index <<= (shiftIndex - 1);

                shiftIndex = 1;
            }
        }

        index |= 1;

        headIndex++;
    }

    Trinkle(itemArray, index, shiftIndex, headIndex, false);

    while(shiftIndex != 1 || index != 1)
    {
        if(shiftIndex <= 1)
        {
            int trail = GetNumberOfTrailingZeros((uint)(index & ~1));

            index >>= trail;

            shiftIndex += trail;
        }
        else
        {
            index <<= 2;

            index ^= 7;

            shiftIndex -= 2;

            Trinkle(itemArray, index >> 1, shiftIndex + 1, headIndex - _logicalPointArray[shiftIndex] - 1, true);

            Trinkle(itemArray, index, shiftIndex, headIndex - 1, true);
        }

        headIndex--;
    }
}

#endregion

#region 스무스 정렬하기 - SmoothSort<T>(itemArray)

/// <summary>
/// 스무스 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void SmoothSort<T>(T[] itemArray) where T : IComparable
{
    SmoothSort(itemArray, 0, itemArray.Length - 1);
}

#endregion

#region 분류하기 - Sift<T>(itemArray, shiftIndex, headIndex)

/// <summary>
/// 분류하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="shiftIndex">이동 인덱스</param>
/// <param name="headIndex">헤드 인덱스</param>
private void Sift<T>(T[] itemArray, int shiftIndex, int headIndex) where T : IComparable
{
    T item = itemArray[headIndex];

    while(shiftIndex > 1)
    {
        int rootIndex = headIndex - 1;
        int leafIndex = headIndex - 1 - _logicalPointArray[shiftIndex - 2];

        if(item.CompareTo(itemArray[leafIndex]) >= 0 && item.CompareTo(itemArray[rootIndex]) >= 0)
        {
            break;
        }

        if(itemArray[leafIndex].CompareTo(itemArray[rootIndex]) >= 0)
        {
            itemArray[headIndex] = itemArray[leafIndex];

            headIndex = leafIndex;

            shiftIndex -= 1;
        }
        else
        {
            itemArray[headIndex] = itemArray[rootIndex];

            headIndex = rootIndex;

            shiftIndex -= 2;
        }
    }

    itemArray[headIndex] = item;
}

#endregion

#region 후행 0 수 구하기 - GetNumberOfTrailingZeros(value)

/// <summary>
/// 후행 0 수 구하기
/// </summary>
/// <param name="value">값</param>
/// <returns>후행 0 수</returns>
private int GetNumberOfTrailingZeros(uint value)
{
    int i = 32;

    while(value != 0u)
    {
        i--;

        value += value;
    }

    return i;
}

#endregion

#region 트링클 - Trinkle<TItem>(itemArray, index, shiftIndex, headIndex, isTrusty)

/// <summary>
/// 트링클
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="index">인덱스</param>
/// <param name="shiftIndex">이동 인덱스</param>
/// <param name="headIndex">헤드 인덱스</param>
/// <param name="isTrusty">신뢰 여부</param>
private void Trinkle<T>(T[] itemArray, int index, int shiftIndex, int headIndex, bool isTrusty) where T : IComparable
{
    T item = itemArray[headIndex];

    while(index != 1)
    {
        int stepIndex = headIndex - _logicalPointArray[shiftIndex];

        if(itemArray[stepIndex].CompareTo(item) <= 0)
        {
            break;
        }

        if(!isTrusty && shiftIndex > 1)
        {
            int rootIndex = headIndex - 1;
            int leafIndex = headIndex - 1 - _logicalPointArray[shiftIndex - 2];

            if(itemArray[rootIndex].CompareTo(itemArray[stepIndex]) >= 0 || itemArray[leafIndex].CompareTo(itemArray[stepIndex]) >= 0)
            {
                break;
            }
        }

        itemArray[headIndex] = itemArray[stepIndex];

        headIndex = stepIndex;

        int trail = GetNumberOfTrailingZeros((uint)(index & ~1));

        index >>= trail;

        shiftIndex += trail;

        isTrusty = false;
    }

    if(!isTrusty)
    {
        itemArray[headIndex] = item;

        Sift(itemArray, shiftIndex, headIndex);
    }
}

#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

using System;

#region Field

/// <summary>

/// 논리적 포인트 배열

/// </summary>

[NonSerialized]

private static int[] _logicalPointArray = new int[]

{

1 , 1 , 3 , 5 , 9 , 15 , 25 , 41 , 67 , 109 ,

177 , 287 , 465 , 753 , 1219 , 1973 , 3193 , 5167 , 8361 , 13529 ,

21891 , 35421 , 57313 , 92735 , 150049 , 242785 , 392835 , 635621 , 1028457 , 1664079 ,

2692537 , 4356617 , 7049155 , 11405773, 18454929, 29860703, 48315633, 78176337, 126491971, 204668309,

331160281, 535828591, 866988873

};

#endregion

#region 스무스 정렬하기 - SmoothSort<T>(itemArray, lowIndex, highIndex)

/// <summary>/// 스무스 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="lowIndex">하위 인덱스</param>

/// <param name="highIndex">상위 인덱스</param>

public void SmoothSort<T>(T[] itemArray, int lowIndex, int highIndex) where T : IComparable

{

int headIndex = lowIndex;

int index = 1;

int shiftIndex = 1;

while(headIndex < highIndex)

{

if((index & 3) == 3)

{

Sift(itemArray, shiftIndex, headIndex);

index >>= 2;

shiftIndex += 2;

}

else

{

if(_logicalPointArray[shiftIndex - 1] >= highIndex - headIndex)

{

Trinkle(itemArray, index, shiftIndex, headIndex, false);

}

else

{

Sift(itemArray, shiftIndex, headIndex);

}

if(shiftIndex == 1)

{

index <<= 1;

shiftIndex--;

}

else

{

index <<= (shiftIndex - 1);

shiftIndex = 1;

}

index |= 1;

headIndex++;

}

Trinkle(itemArray, index, shiftIndex, headIndex, false);

while(shiftIndex != 1 || index != 1)

{

if(shiftIndex <= 1)

{

int trail = GetNumberOfTrailingZeros((uint)(index & ~1));

index >>= trail;

shiftIndex += trail;

}

else

{

index <<= 2;

index ^= 7;

shiftIndex -= 2;

Trinkle(itemArray, index >> 1, shiftIndex + 1, headIndex - _logicalPointArray[shiftIndex] - 1, true);

Trinkle(itemArray, index, shiftIndex, headIndex - 1, true);

}

headIndex--;

}

#endregion

#region 스무스 정렬하기 - SmoothSort<T>(itemArray)

/// <summary>

/// 스무스 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void SmoothSort<T>(T[] itemArray) where T : IComparable

{

SmoothSort(itemArray, 0, itemArray.Length - 1);

}

#endregion

#region 분류하기 - Sift<T>(itemArray, shiftIndex, headIndex)

/// <summary>

/// 분류하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="shiftIndex">이동 인덱스</param>

/// <param name="headIndex">헤드 인덱스</param>

private void Sift<T>(T[] itemArray, int shiftIndex, int headIndex) where T : IComparable

{

T item = itemArray[headIndex];

while(shiftIndex > 1)

{

int rootIndex = headIndex - 1;

int leafIndex = headIndex - 1 - _logicalPointArray[shiftIndex - 2];

if(item.CompareTo(itemArray[leafIndex]) >= 0 && item.CompareTo(itemArray[rootIndex]) >= 0)

{

break;

}

if(itemArray[leafIndex].CompareTo(itemArray[rootIndex]) >= 0)

{

itemArray[headIndex] = itemArray[leafIndex];

headIndex = leafIndex;

shiftIndex -= 1;

}

else

{

itemArray[headIndex] = itemArray[rootIndex];

headIndex = rootIndex;

shiftIndex -= 2;

}

itemArray[headIndex] = item;

}

#endregion

#region 후행 0 수 구하기 - GetNumberOfTrailingZeros(value)

/// <summary>

/// 후행 0 수 구하기

/// </summary>

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

/// <returns>후행 0 수</returns>

private int GetNumberOfTrailingZeros(uint value)

{

int i = 32;

while(value != 0u)

{

i--;

value += value;

}

return i;

}

#endregion

#region 트링클 - Trinkle<TItem>(itemArray, index, shiftIndex, headIndex, isTrusty)

/// <summary>

/// 트링클

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

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

/// <param name="shiftIndex">이동 인덱스</param>

/// <param name="headIndex">헤드 인덱스</param>

/// <param name="isTrusty">신뢰 여부</param>

private void Trinkle<T>(T[] itemArray, int index, int shiftIndex, int headIndex, bool isTrusty) where T : IComparable

{

T item = itemArray[headIndex];

while(index != 1)

{

int stepIndex = headIndex - _logicalPointArray[shiftIndex];

if(itemArray[stepIndex].CompareTo(item) <= 0)

{

break;

}

if(!isTrusty && shiftIndex > 1)

{

int rootIndex = headIndex - 1;

int leafIndex = headIndex - 1 - _logicalPointArray[shiftIndex - 2];

if(itemArray[rootIndex].CompareTo(itemArray[stepIndex]) >= 0 || itemArray[leafIndex].CompareTo(itemArray[stepIndex]) >= 0)

{

break;

}

itemArray[headIndex] = itemArray[stepIndex];

headIndex = stepIndex;

int trail = GetNumberOfTrailingZeros((uint)(index & ~1));

index >>= trail;

shiftIndex += trail;

isTrusty = false;

}

if(!isTrusty)

{

itemArray[headIndex] = item;

Sift(itemArray, shiftIndex, headIndex);

}

#endregion

[C#/COMMON] 힙 정렬하기

■ 힙 정렬하는 방법을 보여준다. ▶ 힙 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

HeapSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

HeapSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 힙 정렬하기 (C#)


using System;

#region 힙 정렬하기 - HeapSort<TItem>(itemArray, count)

/// <summary>
/// 힙 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="count">횟수</param>
public void HeapSort<T>(T[] itemArray, int count) where T : IComparable
{
    HeapDown(itemArray, count);

    int endIndex = count - 1;

    while(endIndex > 0)
    {
        T temporaryItem = itemArray[endIndex];

        itemArray[endIndex] = itemArray[0];
        itemArray[0       ] = temporaryItem;

        SiftDown(itemArray, 0, endIndex - 1);

        endIndex--;
    }
}

#endregion

#region 힙 정렬하기 - HeapSort<T>(itemArray)

/// <summary>
/// 힙 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void HeapSort<T>(T[] itemArray) where T : IComparable
{
    HeapSort(itemArray, itemArray.Length);
}

#endregion

#region 아래로 이동하기 - SiftDown<T>(itemArray, startIndex, endIndex)

/// <summary>
/// 아래로 이동하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="startIndex">시작 인덱스</param>
/// <param name="endIndex">종료 인덱스</param>
private void SiftDown<T>(T[] itemArray, int startIndex, int endIndex) where T : IComparable
{
    int rootIndex = startIndex;

    while(rootIndex * 2 + 1 <= endIndex)
    {
        int childIndex = rootIndex * 2 + 1;

        if(childIndex < endIndex && itemArray[childIndex].CompareTo(itemArray[childIndex + 1]) < 0)
        {
            childIndex++;
        }

        if(itemArray[rootIndex].CompareTo(itemArray[childIndex]) < 0)
        {
            T temporaryItem = itemArray[rootIndex];

            itemArray[rootIndex ] = itemArray[childIndex];
            itemArray[childIndex] = temporaryItem;

            rootIndex = childIndex;
        }
        else
        {
            return;
        }
    }
}

#endregion

#region 아래로 쌓기 - HeapDown<T>(itemArray, count)

/// <summary>
/// 아래로 쌓기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="count">횟수</param>
private void HeapDown<T>(T[] itemArray, int count) where T : IComparable
{
    int startIndex = (count - 2) / 2;

    while(startIndex >= 0)
    {
        SiftDown(itemArray, startIndex, count - 1);

        startIndex--;
    }
}

#endregion

100

101

102

103

104

105

106

107

108

using System;

#region 힙 정렬하기 - HeapSort<TItem>(itemArray, count)

/// <summary>

/// 힙 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="count">횟수</param>

public void HeapSort<T>(T[] itemArray, int count) where T : IComparable

{

HeapDown(itemArray, count);

int endIndex = count - 1;

while(endIndex > 0)

{

T temporaryItem = itemArray[endIndex];

itemArray[endIndex] = itemArray[0];

itemArray[0 ] = temporaryItem;

SiftDown(itemArray, 0, endIndex - 1);

endIndex--;

}

#endregion

#region 힙 정렬하기 - HeapSort<T>(itemArray)

/// <summary>

/// 힙 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void HeapSort<T>(T[] itemArray) where T : IComparable

{

HeapSort(itemArray, itemArray.Length);

}

#endregion

#region 아래로 이동하기 - SiftDown<T>(itemArray, startIndex, endIndex)

/// <summary>

/// 아래로 이동하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="startIndex">시작 인덱스</param>

/// <param name="endIndex">종료 인덱스</param>

private void SiftDown<T>(T[] itemArray, int startIndex, int endIndex) where T : IComparable

{

int rootIndex = startIndex;

while(rootIndex * 2 + 1 <= endIndex)

{

int childIndex = rootIndex * 2 + 1;

if(childIndex < endIndex && itemArray[childIndex].CompareTo(itemArray[childIndex + 1]) < 0)

{

childIndex++;

}

if(itemArray[rootIndex].CompareTo(itemArray[childIndex]) < 0)

{

T temporaryItem = itemArray[rootIndex];

itemArray[rootIndex ] = itemArray[childIndex];

itemArray[childIndex] = temporaryItem;

rootIndex = childIndex;

}

else

{

return;

}

#endregion

#region 아래로 쌓기 - HeapDown<T>(itemArray, count)

/// <summary>

/// 아래로 쌓기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="count">횟수</param>

private void HeapDown<T>(T[] itemArray, int count) where T : IComparable

{

int startIndex = (count - 2) / 2;

while(startIndex >= 0)

{

SiftDown(itemArray, startIndex, count - 1);

startIndex--;

}

#endregion

[C#/COMMON] 쉘 정렬하기

■ 쉘 정렬하는 방법을 보여준다. ▶ 쉘 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

ShellSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

ShellSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 쉘 정렬하기 (C#)


using System;

#region 쉘 정렬하기 - ShellSort<T>(itemArray)

/// <summary>
/// 쉘 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void ShellSort<T>(T[] itemArray) where T : IComparable
{
    int half = (int)Math.Round(itemArray.Length / 2d);

    while(half > 0)
    {
        for(int i = half; i < itemArray.Length; i++)
        {
            T temporaryItem = itemArray[i];

            int j = i;

            while(j >= half && itemArray[j - half].CompareTo(temporaryItem) > 0)
            {
                itemArray[j] = itemArray[j - half];

                j -= half;
            }

            itemArray[j] = temporaryItem;
        }

        half = (int)Math.Round(half / 2.2d);
    }
}

#endregion

using System;

#region 쉘 정렬하기 - ShellSort<T>(itemArray)

/// <summary>

/// 쉘 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void ShellSort<T>(T[] itemArray) where T : IComparable

{

int half = (int)Math.Round(itemArray.Length / 2d);

while(half > 0)

{

for(int i = half; i < itemArray.Length; i++)

{

T temporaryItem = itemArray[i];

int j = i;

while(j >= half && itemArray[j - half].CompareTo(temporaryItem) > 0)

{

itemArray[j] = itemArray[j - half];

j -= half;

}

itemArray[j] = temporaryItem;

}

half = (int)Math.Round(half / 2.2d);

}

#endregion

[C#/COMMON] 삽입 정렬하기

■ 삽입 정렬하는 방법을 보여준다. ▶ 삽입 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

InsertionSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

InsertionSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 삽입 정렬하기 (C#)


using System;

#region 삽입 정렬하기 - InsertionSort<T>(itemArray)

/// <summary>
/// 삽입 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void InsertionSort<T>(T[] itemArray) where T : IComparable
{
    for(int i = 1; i < itemArray.Length; i++)
    {
        T item = itemArray[i];

        int j = i - 1;

        bool isDone = false;

        do
        {
            if(itemArray[j].CompareTo(item) > 0)
            {
                itemArray[j + 1] = itemArray[j];

                j--;

                if(j < 0)
                {
                    isDone = true;
                }
            }
            else
            {
                isDone = true;
            }
        }
        while(!isDone);

        itemArray[j + 1] = item;
    }
}

#endregion

using System;

#region 삽입 정렬하기 - InsertionSort<T>(itemArray)

/// <summary>

/// 삽입 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void InsertionSort<T>(T[] itemArray) where T : IComparable

{

for(int i = 1; i < itemArray.Length; i++)

{

T item = itemArray[i];

int j = i - 1;

bool isDone = false;

{

if(itemArray[j].CompareTo(item) > 0)

{

itemArray[j + 1] = itemArray[j];

j--;

if(j < 0)

{

isDone = true;

}

else

{

isDone = true;

}

while(!isDone);

itemArray[j + 1] = item;

}

#endregion

[C#/COMMON] 퀵 정렬하기

■ 퀵 정렬하는 방법을 보여준다. ▶ 퀵 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

QuickSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

QuickSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 퀵 정렬하기 (C#)


using System;

#region 퀵 정렬하기 - QuickSort<T>(itemArray, leftIndex, rightIndex)

/// <summary>
/// 퀵 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="leftIndex">왼쪽 인덱스</param>
/// <param name="rightIndex">오른쪽 인덱스</param>
public void QuickSort<T>(T[] itemArray, int leftIndex, int rightIndex) where T : IComparable
{
    if(rightIndex > leftIndex)
    {
        int pivotIndex    = (leftIndex + rightIndex) / 2;
        int newPivotIndex = Partition(itemArray, leftIndex, rightIndex, pivotIndex);

        QuickSort(itemArray, leftIndex        , newPivotIndex - 1);
        QuickSort(itemArray, newPivotIndex + 1, rightIndex       );
    }
}

#endregion

#region 퀵 정렬하기 - QuickSort<T>(itemArray)

/// <summary>
/// 퀵 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void QuickSort<T>(T[] itemArray) where T : IComparable
{
    QuickSort(itemArray, 0, itemArray.Length - 1);
}

#endregion

#region 분리하기 - Partition<T>(itemArray, leftIndex, rightIndex, pivotIndex)

/// <summary>
/// 분리하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
/// <param name="leftIndex">왼쪽 인덱스</param>
/// <param name="rightIndex">오른쪽 인덱스</param>
/// <param name="pivotIndex">피벗 인덱스</param>
/// <returns>인덱스</returns>
private int Partition<T>(T[] itemArray, int leftIndex, int rightIndex, int pivotIndex) where T : IComparable
{
    T pivotItem     = itemArray[pivotIndex];
    T temporaryItem = itemArray[pivotIndex];

    itemArray[pivotIndex] = itemArray[rightIndex];
    itemArray[rightIndex] = temporaryItem;

    int storeIndex = leftIndex;

    for(int i = leftIndex; i < rightIndex; i++)
    {
        if(itemArray[i].CompareTo(pivotItem) <= 0)
        {
            temporaryItem = itemArray[i];

            itemArray[i          ] = itemArray[storeIndex];
            itemArray[storeIndex] = temporaryItem;

            storeIndex++;
        }
    }

    temporaryItem = itemArray[storeIndex];

    itemArray[storeIndex] = itemArray[rightIndex];
    itemArray[rightIndex] = temporaryItem;

    return storeIndex;
}

#endregion

using System;

#region 퀵 정렬하기 - QuickSort<T>(itemArray, leftIndex, rightIndex)

/// <summary>

/// 퀵 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="leftIndex">왼쪽 인덱스</param>

/// <param name="rightIndex">오른쪽 인덱스</param>

public void QuickSort<T>(T[] itemArray, int leftIndex, int rightIndex) where T : IComparable

{

if(rightIndex > leftIndex)

{

int pivotIndex = (leftIndex + rightIndex) / 2;

int newPivotIndex = Partition(itemArray, leftIndex, rightIndex, pivotIndex);

QuickSort(itemArray, leftIndex , newPivotIndex - 1);

QuickSort(itemArray, newPivotIndex + 1, rightIndex );

}

#endregion

#region 퀵 정렬하기 - QuickSort<T>(itemArray)

/// <summary>

/// 퀵 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void QuickSort<T>(T[] itemArray) where T : IComparable

{

QuickSort(itemArray, 0, itemArray.Length - 1);

}

#endregion

#region 분리하기 - Partition<T>(itemArray, leftIndex, rightIndex, pivotIndex)

/// <summary>

/// 분리하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

/// <param name="leftIndex">왼쪽 인덱스</param>

/// <param name="rightIndex">오른쪽 인덱스</param>

/// <param name="pivotIndex">피벗 인덱스</param>

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

private int Partition<T>(T[] itemArray, int leftIndex, int rightIndex, int pivotIndex) where T : IComparable

{

T pivotItem = itemArray[pivotIndex];

T temporaryItem = itemArray[pivotIndex];

itemArray[pivotIndex] = itemArray[rightIndex];

itemArray[rightIndex] = temporaryItem;

int storeIndex = leftIndex;

for(int i = leftIndex; i < rightIndex; i++)

{

if(itemArray[i].CompareTo(pivotItem) <= 0)

{

temporaryItem = itemArray[i];

itemArray[i ] = itemArray[storeIndex];

itemArray[storeIndex] = temporaryItem;

storeIndex++;

}

temporaryItem = itemArray[storeIndex];

itemArray[storeIndex] = itemArray[rightIndex];

itemArray[rightIndex] = temporaryItem;

return storeIndex;

}

#endregion

[C#/COMMON] 홀수/짝수 정렬하기

■ 홀수/짝수 정렬하는 방법을 보여준다. ▶ 홀수/짝수 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

OddEvenSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

OddEvenSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 홀수/짝수 정렬하기 (C#)


using System;

#region 홀수/짝수 정렬하기 - OddEvenSort<T>(itemArray)

/// <summary>
/// 홀수/짝수 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void OddEvenSort<T>(T[] itemArray) where T : IComparable
{
    bool isSorted = false;

    while(!isSorted)
    {
        isSorted = true;

        for(int i = 1; i < itemArray.Length - 1; i += 2)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                isSorted = false;
            }
        }

        for(int i = 0; i < itemArray.Length - 1; i += 2)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                isSorted = false;
            }
        }
    }
}

#endregion

using System;

#region 홀수/짝수 정렬하기 - OddEvenSort<T>(itemArray)

/// <summary>

/// 홀수/짝수 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void OddEvenSort<T>(T[] itemArray) where T : IComparable

{

bool isSorted = false;

while(!isSorted)

{

isSorted = true;

for(int i = 1; i < itemArray.Length - 1; i += 2)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

isSorted = false;

}

for(int i = 0; i < itemArray.Length - 1; i += 2)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

isSorted = false;

}

#endregion

[C#/COMMON] 난장이 정렬하기

■ 난장이 정렬하는 방법을 보여준다. ▶ 난장이 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

GnomeSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

GnomeSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 난장이 정렬하기 (C#)


using System;

#region 난장이 정렬하기 - GnomeSort<T>(itemArray)

/// <summary>
/// 난장이 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void GnomeSort<T>(T[] itemArray) where T : IComparable
{
    int position = 0;

    while(position < itemArray.Length)
    {
        if(position == 0 || itemArray[position].CompareTo(itemArray[position - 1]) >= 0)
        {
            position++;
        }
        else
        {
            T temporaryItem = itemArray[position];

            itemArray[position    ] = itemArray[position - 1];
            itemArray[position - 1] = temporaryItem;

            position--;
        }
    }
}

#endregion

using System;

#region 난장이 정렬하기 - GnomeSort<T>(itemArray)

/// <summary>

/// 난장이 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void GnomeSort<T>(T[] itemArray) where T : IComparable

{

int position = 0;

while(position < itemArray.Length)

{

if(position == 0 || itemArray[position].CompareTo(itemArray[position - 1]) >= 0)

{

position++;

}

else

{

T temporaryItem = itemArray[position];

itemArray[position ] = itemArray[position - 1];

itemArray[position - 1] = temporaryItem;

position--;

}

#endregion

[C#/COMMON] DataTable 클래스 : 트리 테이블 구하기

■ DataTable 클래스를 사용해 트리 테이블을 구하는 방법을 보여준다. ▶ DataTable 클래스 : 트리 테이블 구하기 예제 (C#)


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

#region 소스 테이블 구하기 - GetSourceTable()

/// <summary>
/// 소스 테이블 구하기
/// </summary>
/// <returns>소스 데이터 테이블</returns>
public DataTable GetSourceTable()
{
    DataTable table = new DataTable();

    table.Columns.Add("ID1"  , typeof(string)); // 대분류 ID
    table.Columns.Add("Name1", typeof(string)); // 대분류명
    table.Columns.Add("ID2"  , typeof(string)); // 중분류 ID
    table.Columns.Add("Name2", typeof(string)); // 중분류명
    table.Columns.Add("ID3"  , typeof(string)); // 소분류 ID
    table.Columns.Add("Name3", typeof(string)); // 소분류명

    table.Rows.Add("A", "A", "B", "B", "C", "C");
    table.Rows.Add("A", "A", "B", "B", "C", "C");
    table.Rows.Add("A", "A", "B", "B", "C", "C");
    table.Rows.Add("A", "A", "B", "B", "D", "D");
    table.Rows.Add("A", "A", "B", "B", "E", "E");
    table.Rows.Add("A", "A", "B", "B", "E", "E");
    table.Rows.Add("A", "A", "B", "B", "F", "F");
    table.Rows.Add("G", "G", "H", "H", "I", "I");
    table.Rows.Add("G", "G", "H", "H", "J", "J");

    table.AcceptChanges();

    return table;
}

#endregion

...

DataTable sourceTable = GetSourceTable();

List<NodeFieldData> nodeFieldDataList = new List<NodeFieldData>();

nodeFieldDataList.Add(new NodeFieldData("ID1", "Name1")); // 대분류 ID, 대분류명
nodeFieldDataList.Add(new NodeFieldData("ID2", "Name2")); // 중분류 ID, 중분류명
nodeFieldDataList.Add(new NodeFieldData("ID3", "Name3")); // 소분류 ID, 소분류명

DataTable treeTable = GetTreeTable(sourceTable, nodeFieldDataList, "ParentID", "ID", "Name", "Path", false);

/*
결과 트리 데이터 테이블
-----------------------
ParentID ID Name Path
-------- -- ---- ------
(NULL)   A  A    A
(NULL)   G  G    G
A        B  B    A/B
G        H  H    G/H
B        C  C    A/B/C
B        D  D    A/B/D
B        E  E    A/B/E
B        F  F    A/B/F
H        I  I    G/H/I
H        J  J    G/H/J
----------------------
*/

using System;

using System.Collections.Generic;

using System.Data;

#region 소스 테이블 구하기 - GetSourceTable()

/// <summary>

/// 소스 테이블 구하기

/// </summary>

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

public DataTable GetSourceTable()

{

DataTable table = new DataTable();

table.Columns.Add("ID1" , typeof(string)); // 대분류 ID

table.Columns.Add("Name1", typeof(string)); // 대분류명

table.Columns.Add("ID2" , typeof(string)); // 중분류 ID

table.Columns.Add("Name2", typeof(string)); // 중분류명

table.Columns.Add("ID3" , typeof(string)); // 소분류 ID

table.Columns.Add("Name3", typeof(string)); // 소분류명

table.Rows.Add("A", "A", "B", "B", "C", "C");

table.Rows.Add("A", "A", "B", "B", "D", "D");

table.Rows.Add("A", "A", "B", "B", "E", "E");

table.Rows.Add("A", "A", "B", "B", "F", "F");

table.Rows.Add("G", "G", "H", "H", "I", "I");

table.Rows.Add("G", "G", "H", "H", "J", "J");

table.AcceptChanges();

return table;

}

#endregion

...

DataTable sourceTable = GetSourceTable();

List<NodeFieldData> nodeFieldDataList = new List<NodeFieldData>();

nodeFieldDataList.Add(new NodeFieldData("ID1", "Name1")); // 대분류 ID, 대분류명

nodeFieldDataList.Add(new NodeFieldData("ID2", "Name2")); // 중분류 ID, 중분류명

nodeFieldDataList.Add(new NodeFieldData("ID3", "Name3")); // 소분류 ID, 소분류명

DataTable treeTable = GetTreeTable(sourceTable, nodeFieldDataList, "ParentID", "ID", "Name", "Path", false);

결과 트리 데이터 테이블

-----------------------

ParentID ID Name Path

-------- -- ---- ------

(NULL) A A A

(NULL) G G G

A B B A/B

G H H G/H

B C C A/B/C

B D D A/B/D

B E E A/B/E

B F F A/B/F

H I I G/H/I

H J J G/H/J

----------------------

▶ DataTable 클래스

[C#/COMMON] 조합 정렬하기

■ 조합 정렬하는 방법을 보여준다. ▶ 조합 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

CombinationSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

CombinationSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 조합 정렬하기 (C#)


using System;

#region 조합 정렬하기 - CombinationSort<T>(itemArray)

/// <summary>
/// 조합 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void CombinationSort<T>(T[] itemArray) where T : IComparable
{
    int  gap     = itemArray.Length;
    bool swapped = true;

    while(gap > 1 || swapped)
    {
        if(gap > 1)
        {
            gap = (int)(gap / 1.3d);
        }

        int i = 0;

        swapped = false;

        while(i + gap < itemArray.Length)
        {
            if(itemArray[i].CompareTo(itemArray[i + gap]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i      ] = itemArray[i + gap];
                itemArray[i + gap] = temporaryItem;

                swapped = true;
            }

            i++;
        }
    }
}

#endregion

using System;

#region 조합 정렬하기 - CombinationSort<T>(itemArray)

/// <summary>

/// 조합 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void CombinationSort<T>(T[] itemArray) where T : IComparable

{

int gap = itemArray.Length;

bool swapped = true;

while(gap > 1 || swapped)

{

if(gap > 1)

{

gap = (int)(gap / 1.3d);

}

int i = 0;

swapped = false;

while(i + gap < itemArray.Length)

{

if(itemArray[i].CompareTo(itemArray[i + gap]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + gap];

itemArray[i + gap] = temporaryItem;

swapped = true;

}

i++;

}

#endregion

[C#/COMMON] 칵테일 정렬하기

■ 칵테일 정렬하는 방법을 보여준다. ▶ 칵테일 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

CocktailSort1<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

CocktailSort1<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 칵테일 정렬하기 (C#)


using System;

#region 칵테일 정렬하기 1 - CocktailSort1<T>(itemArray)

/// <summary>
/// 칵테일 정렬하기 1
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void CocktailSort1<T>(T[] itemArray) where T : IComparable
{
    bool swapped;

    do
    {
        swapped = false;

        for(int i = 0; i < itemArray.Length - 1; i++)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                swapped = true;
            }
        }

        if(!swapped)
        {
            break;
        }

        swapped = false;

        for(int i = 0; i < itemArray.Length - 1; i++)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                swapped = true;
            }
        }
    }
    while(swapped);
}

#endregion

#region 칵테일 정렬하기 2 - CocktailSort2<T>(itemArray)

/// <summary>
/// 칵테일 정렬하기 2
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void CocktailSort2<T>(T[] itemArray) where T : IComparable
{
    bool swapped;
    int  start = (-1);
    int  end   = itemArray.Length - 1;

    do
    {
        swapped = false;

        start++;

        for(int i = start; i < end; i++)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                swapped = true;
            }
        }

        if(!swapped)
        {
            break;
        }

        swapped = false;

        end--;

        for(int i = end; i >= start; i--)
        {
            if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)
            {
                T temporaryItem = itemArray[i];

                itemArray[i    ] = itemArray[i + 1];
                itemArray[i + 1] = temporaryItem;

                swapped = true;
            }
        }
    }
    while(swapped);
}

#endregion

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

using System;

#region 칵테일 정렬하기 1 - CocktailSort1<T>(itemArray)

/// <summary>

/// 칵테일 정렬하기 1

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void CocktailSort1<T>(T[] itemArray) where T : IComparable

{

bool swapped;

{

swapped = false;

for(int i = 0; i < itemArray.Length - 1; i++)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

swapped = true;

}

if(!swapped)

{

break;

}

swapped = false;

for(int i = 0; i < itemArray.Length - 1; i++)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

swapped = true;

}

while(swapped);

}

#endregion

#region 칵테일 정렬하기 2 - CocktailSort2<T>(itemArray)

/// <summary>

/// 칵테일 정렬하기 2

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void CocktailSort2<T>(T[] itemArray) where T : IComparable

{

bool swapped;

int start = (-1);

int end = itemArray.Length - 1;

{

swapped = false;

start++;

for(int i = start; i < end; i++)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

swapped = true;

}

if(!swapped)

{

break;

}

swapped = false;

end--;

for(int i = end; i >= start; i--)

{

if(itemArray[i].CompareTo(itemArray[i + 1]) > 0)

{

T temporaryItem = itemArray[i];

itemArray[i ] = itemArray[i + 1];

itemArray[i + 1] = temporaryItem;

swapped = true;

}

while(swapped);

}

#endregion

[C#/COMMON] 버블 정렬하기

■ 버블 정렬하는 방법을 보여준다. ▶ 버블 정렬하기 예제 (C#)


using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

BubbleSort<int>(array);

for(int i = 0; i < array.Length; i++)
{
    Console.Write(array[i]);
    Console.Write(" ");
}

using System;

int[] array = new int[] { 10, 50, 30, 20, 90, 80, 15, 20 };

BubbleSort<int>(array);

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

{

Console.Write(array[i]);

Console.Write(" ");

}

▶ 버블 정렬하기 (C#)


using System;

#region 버블 정렬하기 - BubbleSort<T>(itemArray)

/// <summary>
/// 버블 정렬하기
/// </summary>
/// <typeparam name="T">항목 타입</typeparam>
/// <param name="itemArray">항목 배열</param>
public void BubbleSort<T>(T[] itemArray) where T : IComparable
{
    T temporaryItem;

    for(int i = 0; i < itemArray.Length - 1; i++)
    {
        for(int j = 0; j < itemArray.Length - i - 1; j++)
        {
            if(itemArray[j].CompareTo(itemArray[j + 1]) > 0)
            {
                temporaryItem = itemArray[j];

                itemArray[j] = itemArray[j + 1];

                itemArray[j + 1] = temporaryItem;
            }
        }
    }
}

#endregion

using System;

#region 버블 정렬하기 - BubbleSort<T>(itemArray)

/// <summary>

/// 버블 정렬하기

/// </summary>

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

/// <param name="itemArray">항목 배열</param>

public void BubbleSort<T>(T[] itemArray) where T : IComparable

{

T temporaryItem;

for(int i = 0; i < itemArray.Length - 1; i++)

{

for(int j = 0; j < itemArray.Length - i - 1; j++)

{

if(itemArray[j].CompareTo(itemArray[j + 1]) > 0)

{

temporaryItem = itemArray[j];

itemArray[j] = itemArray[j + 1];

itemArray[j + 1] = temporaryItem;

}

#endregion

[C#/COMMON] DataViewManager 클래스 : DataView 구하기

■ DataViewManager 클래스를 사용해 DataView를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Data;

#region DataView 구하기 - GetDataView(dataSet, tableName)

/// <summary>
/// DataView 구하기
/// </summary>
/// <param name="dataSet">DataSet</param>
/// <param name="tableName">테이블명</param>
/// <returns>DataView</returns>
public DataView GetDataView(DataSet dataSet, string tableName)
{
    DataViewManager dataViewManager = new DataViewManager(dataSet);

    return dataViewManager.CreateDataView(dataSet.Tables[tableName]);
}

#endregion

#region DataView 구하기 - GetDataView(dataSet, tableIndex)

/// <summary>
/// DataView 구하기
/// </summary>
/// <param name="dataSet">DataSet</param>
/// <param name="tableIndex">테이블 인덱스</param>
/// <returns>DataView</returns>
public DataView GetDataView(DataSet dataSet, int tableIndex)
{
    DataViewManager dataViewManager = new DataViewManager(dataSet);

    return dataViewManager.CreateDataView(dataSet.Tables[tableIndex]);
}

#endregion

using System.Data;

#region DataView 구하기 - GetDataView(dataSet, tableName)

/// <summary>

/// DataView 구하기

/// </summary>

/// <param name="dataSet">DataSet</param>

/// <param name="tableName">테이블명</param>

/// <returns>DataView</returns>

public DataView GetDataView(DataSet dataSet, string tableName)

{

DataViewManager dataViewManager = new DataViewManager(dataSet);

return dataViewManager.CreateDataView(dataSet.Tables[tableName]);

}

#endregion

#region DataView 구하기 - GetDataView(dataSet, tableIndex)

/// <summary>

/// DataView 구하기

/// </summary>

/// <param name="dataSet">DataSet</param>

/// <param name="tableIndex">테이블 인덱스</param>

/// <returns>DataView</returns>

public DataView GetDataView(DataSet dataSet, int tableIndex)

{

DataViewManager dataViewManager = new DataViewManager(dataSet);

return dataViewManager.CreateDataView(dataSet.Tables[tableIndex]);

}

#endregion

[DATABASE/SQLSERVER] 데이터가 없으면 추가하고 있으면 수정하기 #2

■ 데이터가 없으면 추가하고 있으면 수정하는 방법을 보여준다. ▶ 예제 코드 (SQL)


-- 사용자 카운트 테이블을 생성한다.
CREATE TABLE dbo.UserCount
(
    UserID    VARCHAR(20)
   ,UserCount INT
);

INSERT INTO dbo.UserCount VALUES ('a', 10);

-- 'a' 사용자 ID를 INSERT/UPDATE 한다.
UPDATE dbo.UserCount
SET    UserCount = UserCount + 10
WHERE  UserID = 'a';

IF @@ROWCOUNT = 0
BEGIN
    INSERT INTO dbo.UserCount VALUES ('a', 10);
END

-- 'b' 사용자 ID를 INSERT/UPDATE 한다.
UPDATE dbo.UserCount
SET    UserCount = UserCount + 10
WHERE  UserID = 'b';

IF @@ROWCOUNT = 0
BEGIN
    INSERT INTO dbo.UserCount VALUES ('b', 30);
END

-- 사용자 카운트 테이블을 출력한다.
SELECT * FROM dbo.UserCount;

-- 테스트 테이블을 삭제한다.
DROP TABLE dbo.UserCount;

-- 사용자 카운트 테이블을 생성한다.

CREATE TABLE dbo.UserCount

(

UserID VARCHAR(20)

,UserCount INT

);

INSERT INTO dbo.UserCount VALUES ('a', 10);

-- 'a' 사용자 ID를 INSERT/UPDATE 한다.

UPDATE dbo.UserCount

SET UserCount = UserCount + 10

WHERE UserID = 'a';

IF @@ROWCOUNT = 0

BEGIN

INSERT INTO dbo.UserCount VALUES ('a', 10);

END

-- 'b' 사용자 ID를 INSERT/UPDATE 한다.

UPDATE dbo.UserCount

SET UserCount = UserCount + 10

WHERE UserID = 'b';

IF @@ROWCOUNT = 0

BEGIN

INSERT INTO dbo.UserCount VALUES ('b', 30);

END

-- 사용자 카운트 테이블을 출력한다.

SELECT * FROM dbo.UserCount;

-- 테스트 테이블을 삭제한다.

DROP TABLE dbo.UserCount;

[DATABASE/SQLSERVER] 데이터가 없으면 추가하고 있으면 수정하기 #1

■ 데이터가 없으면 추가하고 있으면 수정하는 방법을 보여준다. ▶ 예제 코드 (SQL)


-- 사용자 카운트 테이블을 생성한다.
CREATE TABLE dbo.UserCount
(
    UserID    VARCHAR(20)
   ,UserCount INT
);

INSERT INTO dbo.UserCount VALUES ('a', 10);

-- 'a' 사용자 ID를 INSERT/UPDATE 한다.
IF EXISTS(SELECT * FROM dbo.UserCount AS A WITH(NOLOCK) WHERE A.UserID = 'a')
BEGIN
    UPDATE dbo.UserCount
    SET    UserCount = UserCount + 10
    WHERE  UserID = 'a';
END
ELSE
BEGIN
    INSERT INTO dbo.UserCount VALUES ('a', 10);
END

-- 'b' 사용자 ID를 INSERT/UPDATE 한다.
IF EXISTS(SELECT * FROM dbo.UserCount AS A WITH(NOLOCK) WHERE A.UserID = 'b')
BEGIN
    UPDATE dbo.UserCount
    SET    UserCount = UserCount + 10
    WHERE  UserID = 'b';
END
ELSE
BEGIN
    INSERT INTO dbo.UserCount VALUES ('b', 30);
END

-- 사용자 카운트 테이블을 출력한다.
SELECT * FROM dbo.UserCount;

-- 테스트 테이블을 삭제한다.
DROP TABLE dbo.UserCount;

-- 사용자 카운트 테이블을 생성한다.

CREATE TABLE dbo.UserCount

(

UserID VARCHAR(20)

,UserCount INT

);

INSERT INTO dbo.UserCount VALUES ('a', 10);

-- 'a' 사용자 ID를 INSERT/UPDATE 한다.

IF EXISTS(SELECT * FROM dbo.UserCount AS A WITH(NOLOCK) WHERE A.UserID = 'a')

BEGIN

UPDATE dbo.UserCount

SET UserCount = UserCount + 10

WHERE UserID = 'a';

END

ELSE

BEGIN

INSERT INTO dbo.UserCount VALUES ('a', 10);

END

-- 'b' 사용자 ID를 INSERT/UPDATE 한다.

IF EXISTS(SELECT * FROM dbo.UserCount AS A WITH(NOLOCK) WHERE A.UserID = 'b')

BEGIN

UPDATE dbo.UserCount

SET UserCount = UserCount + 10

WHERE UserID = 'b';

END

ELSE

BEGIN

INSERT INTO dbo.UserCount VALUES ('b', 30);

END

-- 사용자 카운트 테이블을 출력한다.

SELECT * FROM dbo.UserCount;

-- 테스트 테이블을 삭제한다.

DROP TABLE dbo.UserCount;

[C#/COMMON] BindingList 클래스 : 속성 값 검색 기능 추가하기

■ BindingList<T> 클래스를 사용해 속성 값 검색 기능을 추가하는 방법을 보여준다. ▶ 예제 코드 (C#)


/// <summary>
/// 학생
/// </summary>
public class Student
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 학번 - ID

    /// <summary>
    /// 학번
    /// </summary>
    public int ID { get; set; }

    #endregion

    #region 성명 - Name

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

    #endregion

    #region 학년 - Grade

    /// <summary>
    /// 학년
    /// </summary>
    public int Grade { get; set; }

    #endregion
}

CustomBindingList<Student> customBindingList = new CustomBindingList<Student>();

customBindingList.Add(new Student() { ID = 1, Name = "홍길동", Grade = 3 });
customBindingList.Add(new Student() { ID = 2, Name = "홍길숙", Grade = 3 });
customBindingList.Add(new Student() { ID = 3, Name = "홍길도", Grade = 2 });
customBindingList.Add(new Student() { ID = 4, Name = "홍길자", Grade = 1 });
customBindingList.Add(new Student() { ID = 5, Name = "홍길수", Grade = 1 });

this.dataGridView.DataSource = customBindingList;

int index = customBindingList.Find("Name", "홍길수");

/// <summary>

/// 학생

/// </summary>

public class Student

{

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

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

#region 학번 - ID

/// <summary>

/// 학번

/// </summary>

public int ID { get; set; }

#endregion

#region 성명 - Name

/// <summary>

/// 성명

/// </summary>

public string Name { get; set; }

#endregion

#region 학년 - Grade

/// <summary>

/// 학년

/// </summary>

public int Grade { get; set; }

#endregion

}

CustomBindingList<Student> customBindingList = new CustomBindingList<Student>();

customBindingList.Add(new Student() { ID = 1, Name = "홍길동", Grade = 3 });

customBindingList.Add(new Student() { ID = 2, Name = "홍길숙", Grade = 3 });

customBindingList.Add(new Student() { ID = 3, Name = "홍길도", Grade = 2 });

customBindingList.Add(new Student() { ID = 4, Name = "홍길자", Grade = 1 });

customBindingList.Add(new Student() { ID = 5, Name = "홍길수", Grade = 1 });

this.dataGridView.DataSource = customBindingList;

int index = customBindingList.Find("Name", "홍길수");

▶ CustomBindingList.cs


using System.ComponentModel;
using System.Reflection;

/// <summary>
/// 커스텀 바인딩 리스트
/// </summary>
/// <typeparam name="T">타입</typeparam>
public class CustomBindingList<T> : BindingList<T>
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Protected

    #region 코어 검색 지원 여부 - SupportsSearchingCore

    /// <summary>
    /// 코어 검색 지원 여부
    /// </summary>
    protected override bool SupportsSearchingCore
    {
        get
        {
            return true;
        }
    }

    #endregion

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

    #region 찾기 - Find(propertyName, key)

    /// <summary>
    /// 찾기
    /// </summary>
    /// <param name="propertyName">속성명</param>
    /// <param name="key">키</param>
    /// <returns>처리 결과</returns>
    public int Find(string propertyName, object key)
    {
        PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(typeof(T));

        PropertyDescriptor propertyDescriptor = propertyDescriptorCollection.Find(propertyName, true);

        if(propertyDescriptor == null)
        {
            return -1;
        }
        else
        {
            return FindCore(propertyDescriptor, key);
        }
    }

    #endregion

    ////////////////////////////////////////////////////////////////////////////////////////// Protected

    #region 코어 찾기 - FindCore(propertyDescriptor, key)

    /// <summary>
    /// 코어 찾기
    /// </summary>
    /// <param name="propertyDescriptor">속성 설명자</param>
    /// <param name="key">키</param>
    /// <returns>처리 결과</returns>
    protected override int FindCore(PropertyDescriptor propertyDescriptor, object key)
    {
        PropertyInfo propertyInfo = typeof(T).GetProperty(propertyDescriptor.Name);

        T item;

        if(key != null)
        {
            for(int i = 0; i < Count; ++i)
            {
                item = (T)Items[i];

                if(propertyInfo.GetValue(item, null).Equals(key))
                {
                    return i;
                }
            }
        }

        return -1;
    }

    #endregion
}

using System.ComponentModel;

using System.Reflection;

/// <summary>

/// 커스텀 바인딩 리스트

/// </summary>

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

public class CustomBindingList<T> : BindingList<T>

{

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

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region 코어 검색 지원 여부 - SupportsSearchingCore

/// <summary>

/// 코어 검색 지원 여부

/// </summary>

protected override bool SupportsSearchingCore

{

get

{

return true;

}

#endregion

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

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

#region 찾기 - Find(propertyName, key)

/// <summary>

/// 찾기

/// </summary>

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

/// <param name="key">키</param>

/// <returns>처리 결과</returns>

public int Find(string propertyName, object key)

{

PropertyDescriptorCollection propertyDescriptorCollection = TypeDescriptor.GetProperties(typeof(T));

PropertyDescriptor propertyDescriptor = propertyDescriptorCollection.Find(propertyName, true);

if(propertyDescriptor == null)

{

return -1;

}

else

{

return FindCore(propertyDescriptor, key);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region 코어 찾기 - FindCore(propertyDescriptor, key)

/// <summary>

/// 코어 찾기

/// </summary>

/// <param name="propertyDescriptor">속성 설명자</param>

/// <param name="key">키</param>

/// <returns>처리 결과</returns>

protected override int FindCore(PropertyDescriptor propertyDescriptor, object key)

{

PropertyInfo propertyInfo = typeof(T).GetProperty(propertyDescriptor.Name);

T item;

if(key != null)

{

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

{

item = (T)Items[i];

if(propertyInfo.GetValue(item, null).Equals(key))

{

return i;

}

return -1;

}

#endregion

}

[DATABASE/ORACLE] 자동으로 합계/소계 만들기

■ 자동으로 합계/소계를 만드는 방법을 보여준다. ▶ 예제 코드 (SQL)


SELECT
    COURSE_ID
   ,STUDENT_ID
   ,SUM(SCORE)
FROM  TBL_SCORE
WHERE COURSE_ID = 'L0011'
GROUP BY
    COURSE_ID
   ,STUDENT_ID;
/*

COURSE_ID STUDENT_ID SUM(SCORE)
--------- ---------- ----------
L0011     C0801              68
L0011     C0802              98
*/

SELECT

COURSE_ID

,STUDENT_ID

,SUM(SCORE)

FROM TBL_SCORE

WHERE COURSE_ID = 'L0011'

GROUP BY

COURSE_ID

,STUDENT_ID;

COURSE_ID STUDENT_ID SUM(SCORE)

--------- ---------- ----------

L0011 C0801 68

L0011 C0802 98

[C#/COMMON] 컬렉션 이니셜라이저 사용하기

■ 컬렉션 이니셜라이저를 사용하는 방법을 보여준다. ▶ 예제 코드 (XAML)


/// <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
}

...

List<Employee> employeeList = new List<Employee>
{
    new Employee { ID = "1", Name = "홍길동" },
    new Employee { ID = "2", Name = "김철수" },
    new Employee { ID = "3", Name = "이영희" }
};

/// <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

}

...

List<Employee> employeeList = new List<Employee>

{

new Employee { ID = "1", Name = "홍길동" },

new Employee { ID = "2", Name = "김철수" },

new Employee { ID = "3", Name = "이영희" }

};

[C#/COMMON/DEVEXPRESS] UnitOfWork 클래스 : CommitChanges 메소드를 사용해 데이터 추가하기

■ UnitOfWork 클래스의 CommitChanges 메소드를 사용해 데이터를 추가하는 방법을 보여준다. ▶ 예제 코드 (C#)


using DevExpress.Xpo;

/// <summary>
/// 제품 데이터 객체
/// </summary>
public class ProductDataObject : XPObject
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Private

    #region Field

    /// <summary>
    /// 제품명
    /// </summary>
    private string productName;

    /// <summary>
    /// 단가
    /// </summary>
    private int unitPrice;

    #endregion

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

    #region 제품명 - ProductName

    /// <summary>
    /// 제품명
    /// </summary>
    public string ProductName
    {
        get
        {
            return this.productName;
        }
        set
        {
            SetPropertyValue<string>("ProductName", ref this.productName, value);
        }
    }

    #endregion

    #region 단가 - UnitPrice

    /// <summary>
    /// 단가
    /// </summary>
    public int UnitPrice
    {
        get
        {
            return this.unitPrice;
        }
        set
        {
            SetPropertyValue<int>("UnitPrice", ref this.unitPrice, value);
        }
    }

    #endregion

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

    #region 생성자 - ProductDataObject()

    /// <summary>
    /// 생성자
    /// </summary>
    public ProductDataObject() : base()
    {
    }

    #endregion

    #region 생성자 - ProductDataObject(session)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="session">Session 객체</param>
    public ProductDataObject(Session session) : base(session)
    {
    }

    #endregion

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

    #region 생성 후 처리하기 - AfterConstruction()

    /// <summary>
    /// 생성 후 처리하기
    /// </summary>
    public override void AfterConstruction()
    {
        base.AfterConstruction();
    }

    #endregion
}

...

// ProductDataObject 타입의 데이터가 존재하는지 조사한다.
if(Session.DefaultSession.FindObject<ProductDataObject>(null) != null)
{
    return;
}

// 2건의 ProductDataObject를 생성해 추가한다.
using(UnitOfWork unitOfWork = new UnitOfWork())
{
    ProductDataObject productDataObject1 = new ProductDataObject(unitOfWork) { ProductName = "Product A", UnitPrice = 99  };
    ProductDataObject productDataObject2 = new ProductDataObject(unitOfWork) { ProductName = "Product B", UnitPrice = 199 };

    unitOfWork.CommitChanges();
}

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

using DevExpress.Xpo;

/// <summary>

/// 제품 데이터 객체

/// </summary>

public class ProductDataObject : XPObject

{

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

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

#region Field

/// <summary>

/// 제품명

/// </summary>

private string productName;

/// <summary>

/// 단가

/// </summary>

private int unitPrice;

#endregion

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

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

#region 제품명 - ProductName

/// <summary>

/// 제품명

/// </summary>

public string ProductName

{

get

{

return this.productName;

}

set

{

SetPropertyValue<string>("ProductName", ref this.productName, value);

}

#endregion

#region 단가 - UnitPrice

/// <summary>

/// 단가

/// </summary>

public int UnitPrice

{

get

{

return this.unitPrice;

}

set

{

SetPropertyValue<int>("UnitPrice", ref this.unitPrice, value);

}

#endregion

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

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

#region 생성자 - ProductDataObject()

/// <summary>

/// 생성자

/// </summary>

public ProductDataObject() : base()

{

}

#endregion

#region 생성자 - ProductDataObject(session)

/// <summary>

/// 생성자

/// </summary>

/// <param name="session">Session 객체</param>

public ProductDataObject(Session session) : base(session)

{

}

#endregion

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

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

#region 생성 후 처리하기 - AfterConstruction()

/// <summary>

/// 생성 후 처리하기

/// </summary>

public override void AfterConstruction()

{

base.AfterConstruction();

}

#endregion

}

...

// ProductDataObject 타입의 데이터가 존재하는지 조사한다.

if(Session.DefaultSession.FindObject<ProductDataObject>(null) != null)

{

return;

}

// 2건의 ProductDataObject를 생성해 추가한다.

using(UnitOfWork unitOfWork = new UnitOfWork())

{

ProductDataObject productDataObject1 = new ProductDataObject(unitOfWork) { ProductName = "Product A", UnitPrice = 99 };

ProductDataObject productDataObject2 = new ProductDataObject(unitOfWork) { ProductName = "Product B", UnitPrice = 199 };

unitOfWork.CommitChanges();

}

[C#/COMMON/DEVEXPRESS] ValueConverter 클래스 : 일시↔문자열 값 변환자 만들기

■ ValueConverter 클래스에서 일시↔문자열 값 변환자를 만드는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;

using DevExpress.Xpo.Metadata;

/// <summary>
/// 일시↔문자열 값 변환자
/// </summary>
public class DateTimeToStringValueConverter : ValueConverter
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Property
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region 저장소 타입 - StorageType

    /// <summary>
    /// 저장소 타입
    /// </summary>
    public override Type StorageType
    {
        get
        {
            return typeof(string);
        }
    }

    #endregion

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

    #region 저장소 타입으로 변환하기 - ConvertToStorageType(value)

    /// <summary>
    /// 저장소 타입으로 변환하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns>변환 값</returns>
    public override object ConvertToStorageType(object value)
    {
        return value.ToString();
    }

    #endregion

    #region 저장소 타입에서 변환하기 - ConvertFromStorageType(value)

    /// <summary>
    /// 저장소 타입에서 변환하기
    /// </summary>
    /// <param name="value">값</param>
    /// <returns>변환 값</returns>
    public override object ConvertFromStorageType(object value)
    {
        return Convert.ToDateTime(value);
    }

    #endregion
}

using System;

using DevExpress.Xpo.Metadata;

/// <summary>

/// 일시↔문자열 값 변환자

/// </summary>

public class DateTimeToStringValueConverter : ValueConverter

{

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

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

#region 저장소 타입 - StorageType

/// <summary>

/// 저장소 타입

/// </summary>

public override Type StorageType

{

get

{

return typeof(string);

}

#endregion

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

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

#region 저장소 타입으로 변환하기 - ConvertToStorageType(value)

/// <summary>

/// 저장소 타입으로 변환하기

/// </summary>

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

/// <returns>변환 값</returns>

public override object ConvertToStorageType(object value)

{

return value.ToString();

}

#endregion

#region 저장소 타입에서 변환하기 - ConvertFromStorageType(value)

/// <summary>

/// 저장소 타입에서 변환하기

/// </summary>

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

/// <returns>변환 값</returns>

public override object ConvertFromStorageType(object value)

{

return Convert.ToDateTime(value);

}

#endregion

}

[C#/COMMON/DEVEXPRESS] Session 클래스 : 디폴트 세션을 사용해 MS Access 데이터베이스 연결하기

■ Session 클래스에서 디폴트 세션을 사용해 MS Access 데이터베이스를 연결하는 방법을 보여준다. ▶ 예제 코드 (C#)


using DevExpress.Xpo;
using DevExpress.Xpo.DB;

if(Session.DefaultSession.IsConnected)
{
    Session.DefaultSession.Disconnect();
}

Session.DefaultSession.ConnectionString = AccessConnectionProvider.GetConnectionString("sample.mdb", "user", "password");

Session.DefaultSession.Connect();

using DevExpress.Xpo;

using DevExpress.Xpo.DB;

if(Session.DefaultSession.IsConnected)

{

Session.DefaultSession.Disconnect();

}

Session.DefaultSession.ConnectionString = AccessConnectionProvider.GetConnectionString("sample.mdb", "user", "password");

Session.DefaultSession.Connect();

[C#/COMMON/DEVEXPRESS] AccessConnectionProvider 클래스 : GetConnectionString 정적 메소드를 사용해 특정 MS Access 데이터베이스에 대한 연결 문자열 구하기

■ AccessConnectionProvider 클래스의 GetConnectionString 정적 메소드를 사용해 특정 MS Access 데이터베이스에 대한 연결 문자열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using DevExpress.Xpo.DB;

string connectionString = AccessConnectionProvider.GetConnectionString("sample.mdb", "user", "password");

또는

string connectionString = AccessConnectionProvider.GetConnectionString(@"c:\database\product.mdb");

using DevExpress.Xpo.DB;

string connectionString = AccessConnectionProvider.GetConnectionString("sample.mdb", "user", "password");

또는

string connectionString = AccessConnectionProvider.GetConnectionString(@"c:\database\product.mdb");

[C#/COMMON/DEVEXPRESS] XpoDefault 클래스 : DataLayer 정적 속성을 사용해 데이터 저장소 액세스를 위한, 디폴트로 세션 객체에 의해 사용되는 디폴트 데이터 액세스 레이어 구하기

■ XpoDefault 클래스의 DataLayer 정적 속성을 사용해 데이터 저장소 액세스를 위한, 디폴트로 세션 객체에 의해 사용되는 디폴트 데이터 액세스 레이어를 구하는 방법을

[C#/COMMON/DEVEXPRESS] XpoDefault 클래스 : GetDataLayer 정적 메소드를 사용해 특정 연결 문자열과 디폴트 메타 데이터를 위한 데이터 레이어 생성하기

■ XpoDefault 클래스의 GetDataLayer 정적 메소드를 사용해 특정 연결 문자열과 디폴트 메타 데이터를 위한 데이터 레이어를 생성하는 방법을 보여준다. ▶ 예제 코드

[C#/WPF/DEVEXPRESS] TableView 클래스 : 데이터 주석 어트리뷰트를 사용해 검증하기

■ TableView 클래스에서 데이터 주석 어트리뷰트를 사용해 검증하는 방법을 보여준다. ▶ Employee.cs


using System.ComponentModel.DataAnnotations;

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

        #region ID - ID

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

        #endregion

        #region 상급자 ID - ParentID

        /// <summary>
        /// 상급자 ID
        /// </summary>
        public int ParentID { get; set; }

        #endregion

        #region 성명 - Name

        /// <summary>
        /// 성명
        /// </summary>
        [Required(AllowEmptyStrings = false, ErrorMessage = "The Name cannot be empty. Please correct.")]
        public string Name { get; set; }

        #endregion

        #region 직위 - Position

        /// <summary>
        /// 직위
        /// </summary>
        [StringLength(20)]
        public string Position { get; set; }

        #endregion

        #region 부서 - Department

        /// <summary>
        /// 부서
        /// </summary>
        [Required(AllowEmptyStrings = false, ErrorMessage = "The Department cannot be empty. Please correct.")]
        public string Department { get; set; }

        #endregion
    }
}

using System.ComponentModel.DataAnnotations;

namespace TestProject

{

/// <summary>

/// 직원

/// </summary>

public class Employee

{

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

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

#region ID - ID

/// <summary>

/// ID

/// </summary>

public int ID { get; set; }

#endregion

#region 상급자 ID - ParentID

/// <summary>

/// 상급자 ID

/// </summary>

public int ParentID { get; set; }

#endregion

#region 성명 - Name

/// <summary>

/// 성명

/// </summary>

[Required(AllowEmptyStrings = false, ErrorMessage = "The Name cannot be empty. Please correct.")]

public string Name { get; set; }

#endregion

#region 직위 - Position

/// <summary>

/// 직위

/// </summary>

[StringLength(20)]

public string Position { get; set; }

#endregion

#region 부서 - Department

/// <summary>

/// 부서

/// </summary>

[Required(AllowEmptyStrings = false, ErrorMessage = "The Department cannot be empty. Please correct.")]

public string Department { get; set; }

#endregion

}

▶ MainPage.xaml


<Window x:Class="TestProject.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid"
    Width="600"
    Height="450"
    Title="TableView 클래스 : 데이터 주석 어트리뷰트를 사용해 검증하기">
    <Grid>
        <dxg:GridControl Name="gridControl" >
            <dxg:GridControl.Columns>
                <dxg:GridColumn FieldName="Name"       />
                <dxg:GridColumn FieldName="Position"   />
                <dxg:GridColumn FieldName="Department" />
            </dxg:GridControl.Columns>
            <dxg:GridControl.View>
                <dxg:TableView Name="tableView"
                    ShowValidationAttributeErrors="True"
                    AllowCommitOnValidationAttributeError="False" />
            </dxg:GridControl.View>
        </dxg:GridControl>
    </Grid>
</Window>

<Window x:Class="TestProject.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid"

Width="600"

Height="450"

Title="TableView 클래스 : 데이터 주석 어트리뷰트를 사용해 검증하기">

<Grid>

<dxg:GridControl Name="gridControl" >

<dxg:GridControl.Columns>

<dxg:GridColumn FieldName="Name" />

<dxg:GridColumn FieldName="Position" />

<dxg:GridColumn FieldName="Department" />

</dxg:GridControl.Columns>

<dxg:GridControl.View>

<dxg:TableView Name="tableView"

ShowValidationAttributeErrors="True"

AllowCommitOnValidationAttributeError="False" />

</dxg:GridControl.View>

</dxg:GridControl>

</Grid>

</Window>

[C#/WPF/DEVEXPRESS] PLinqInstantFeedbackDataSource 엘리먼트 사용하기

■ PLinqInstantFeedbackDataSource 엘리먼트를 사용하는 방법을 보여준다. ▶ Data.cs


using System;
using System.Collections.Generic;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData
{
    /// <summary>
    /// 데이터
    /// </summary>
    public static class Data
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 고객 리스트
        /// </summary>
        private static List<string> customerList;

        /// <summary>
        /// 제품 리스트
        /// </summary>
        private static List<KeyValuePair<string, decimal>> productList;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Public

        #region 고객 리스트 - CustomerList

        /// <summary>
        /// 고객 리스트
        /// </summary>
        public static List<string> CustomerList
        {
            get
            {
                if(this.customerList == null)
                {
                    this.customerList = new List<string>();

                    this.customerList.AddRange
                    (
                        new string[]
                        {
                            "Maria Anders"      , "Ana Trujillo"       , "Antonio Moreno"    , "Thomas Hardy"        ,
                            "Christina Berglund", "Hanna Moos"         , "Frédérique Citeaux"  , "Martín Sommer"        ,
                            "Laurence Lebihan"  , "Elizabeth Lincoln"  , "Victoria Ashworth" , "Patricio Simpson"    ,
                            "Francisco Chang"   , "Yang Wang"          , "Pedro Afonso"      , "Elizabeth Brown"     ,
                            "Sven Ottlieb"      , "Janine Labrune"     , "Ann Devon"         , "Roland Mendel"       ,
                            "Aria Cruz"         , "Diego Roel"         , "Martine Rancé"      , "Maria Larsson"       ,
                            "Peter Franken"     , "Carine Schmitt"     , "Paolo Accorti"     , "Lino Rodriguez "     ,
                            "Eduardo Saavedra"  , "José Pedro Freyre"   , "André Fonseca"      , "Howard Snyder"       ,
                            "Manuel Pereira"    , "Mario Pontes"       , "Carlos Hernández"   , "Yoshi Latimer"       ,
                            "Patricia McKenna"  , "Helen Bennett"      , "Philip Cramer"     , "Daniel Tonini"       ,
                            "Annette Roulet"    , "Yoshi Tannamuri"    , "John Steel"        , "Renate Messner"      ,
                            "Jaime Yorres"      , "Carlos González"     , "Felipe Izquierdo"  , "Fran Wilson"         ,
                            "Giovanni Rovelli"  , "Catherine Dewey"    , "Jean Fresnière"     , "Alexander Feuer"     ,
                            "Simon Crowther"    , "Yvonne Moncada"     , "Rene Phillips"     , "Henriette Pfalzheim" ,
                            "Marie Bertrand"    , "Guillermo Fernández" , "Georg Pipps"       , "Isabel de Castro"    ,
                            "Bernardo Batista"  , "Lúcia Carvalho"      , "Horst Kloss"       , "Sergio Gutiérrez"     ,
                            "Paula Wilson"      , "Maurizio Moroni"    , "Janete Limeira"    ,"Michael Holz"         ,
                            "Alejandra Camino"  , "Jonas Bergulfsen"   , "Jose Pavarotti"    , "Hari Kumar"          ,
                            "Jytte Petersen"    , "Dominique Perrier"  , "Art Braunschweiger", "Pascale Cartrain"    ,
                            "Liz Nixon"         , "Liu Wong"           , "Karin Josephs"     , "Miguel Angel Paolino",
                            "Anabela Domingues" , "Helvetius Nagy"     , "Palle Ibsen"       , "Mary Saveley"        ,
                            "Paul Henriot"      , "Rita Müller"         , "Pirkko Koskitalo"  , "Paula Parente"       ,
                            "Karl Jablonski"    , "Matti Karttunen"    , "Zbyszek Piestrzeniewicz"
                        }
                    );
                }

                return this.customerList;
            }
        }

        #endregion

        #region 제품 리스트 - ProductList

        /// <summary>
        /// 제품 리스트
        /// </summary>
        public static List<KeyValuePair<string, decimal>> ProductList
        {
            get
            {
                if(this.productList == null)
                {
                    this.productList = new List<KeyValuePair<string, decimal>>();

                    this.productList.Add(new KeyValuePair<string,decimal>("Chai"                            , 18.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Chang"                           , 19.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Aniseed Syrup"                   , 10.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Chef Anton's Cajun Seasoning"    , 22.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Chef Anton's Gumbo Mix"          , 21.35m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Grandma's Boysenberry Spread"    , 25.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Uncle Bob's Organic Dried Pears" , 30.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Northwoods Cranberry Sauce"      , 40.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Mishi Kobe Niku"                 , 97.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Ikura"                           , 31.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Queso Cabrales"                  , 21.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Queso Manchego La Pastora"       , 38.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Konbu"                           , 6.0m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Tofu"                            , 23.25m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Genen Shouyu"                    , 15.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Pavlova"                         , 17.45m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Alice Mutton"                    , 39.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Carnarvon Tigers"                , 62.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Teatime Chocolate Biscuits"      , 9.2m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Sir Rodney's Marmalade"          , 81.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Sir Rodney's Scones"             , 10.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gustaf's Knäckebröd"               , 21.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Tunnbröd"                         , 9.0m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Guaraná Fantástica"                , 4.5m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("NuNuCa Nuß-Nougat-Creme"        , 14.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gumbär Gummibärchen"               , 31.23m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Schoggi Schokolade"              , 43.9m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Rössle Sauerkraut"                , 45.6m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Thüringer Rostbratwurst"          , 123.79m));
                    this.productList.Add(new KeyValuePair<string,decimal>("Nord-Ost Matjeshering"           , 25.89m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gorgonzola Telino"               , 12.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Mascarpone Fabioli"              , 32.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Geitost"                         , 2.5m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Sasquatch Ale"                   , 14.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Steeleye Stout"                  , 18.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Inlagd Sill"                     , 19.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gravad lax"                      , 26.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Côte de Blaye"                    , 263.5m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Chartreuse verte"                , 18.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Boston Crab Meat"                , 18.4m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Jack's New England Clam Chowder" , 9.65m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Singaporean Hokkien Fried Mee"   , 14.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Ipoh Coffee"                     , 46.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gula Malacca"                    , 19.45m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Røgede sild"                    , 9.5m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Spegesild"                       , 12.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Zaanse koeken"                   , 9.5m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Chocolade"                       , 12.75m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Maxilaku"                        , 20.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Valkoinen suklaa"                , 16.25m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Manjimup Dried Apples"           , 53.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Filo Mix"                        , 7.0m   ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Perth Pasties"                   , 32.8m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Tourtière"                        , 7.45m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Pâté chinois"                      , 24.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gnocchi di nonna Alice"          , 38.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Ravioli Angelo"                  , 19.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Escargots de Bourgogne"          , 13.25m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Raclette Courdavault"            , 55.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Camembert Pierrot"               , 34.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Sirop d'érable"                   , 28.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Tarte au sucre"                  , 49.3m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Vegie-spread"                    , 43.9m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Wimmers gute Semmelknödel"        , 33.25m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Louisiana Fiery Hot Pepper Sauce", 21.05m ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Louisiana Hot Spiced Okra"       , 17.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Laughing Lumberjack Lager"       , 14.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Scottish Longbreads"             , 12.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Gudbrandsdalsost"                , 36.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Outback Lager"                   , 15.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Fløtemysost"                    , 21.5m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Mozzarella di Giovanni"          , 34.8m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Röd Kaviar"                       , 15.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Longlife Tofu"                   , 10.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Rhönbräu Klosterbier"              , 7.75m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Lakkalikööri"                      , 18.0m  ));
                    this.productList.Add(new KeyValuePair<string,decimal>("Original Frankfurter grüne Soße" , 13.0m  ));
                }

                return this.productList;
            }
        }

        #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

using System;

using System.Collections.Generic;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData

{

/// <summary>

/// 데이터

/// </summary>

public static class Data

{

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

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

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

#region Field

/// <summary>

/// 고객 리스트

/// </summary>

private static List<string> customerList;

/// <summary>

/// 제품 리스트

/// </summary>

private static List<KeyValuePair<string, decimal>> productList;

#endregion

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

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

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

#region 고객 리스트 - CustomerList

/// <summary>

/// 고객 리스트

/// </summary>

public static List<string> CustomerList

{

get

{

if(this.customerList == null)

{

this.customerList = new List<string>();

this.customerList.AddRange

(

new string[]

{

"Maria Anders" , "Ana Trujillo" , "Antonio Moreno" , "Thomas Hardy" ,

"Christina Berglund", "Hanna Moos" , "Frédérique Citeaux" , "Martín Sommer" ,

"Laurence Lebihan" , "Elizabeth Lincoln" , "Victoria Ashworth" , "Patricio Simpson" ,

"Francisco Chang" , "Yang Wang" , "Pedro Afonso" , "Elizabeth Brown" ,

"Sven Ottlieb" , "Janine Labrune" , "Ann Devon" , "Roland Mendel" ,

"Aria Cruz" , "Diego Roel" , "Martine Rancé" , "Maria Larsson" ,

"Peter Franken" , "Carine Schmitt" , "Paolo Accorti" , "Lino Rodriguez " ,

"Eduardo Saavedra" , "José Pedro Freyre" , "André Fonseca" , "Howard Snyder" ,

"Manuel Pereira" , "Mario Pontes" , "Carlos Hernández" , "Yoshi Latimer" ,

"Patricia McKenna" , "Helen Bennett" , "Philip Cramer" , "Daniel Tonini" ,

"Annette Roulet" , "Yoshi Tannamuri" , "John Steel" , "Renate Messner" ,

"Jaime Yorres" , "Carlos González" , "Felipe Izquierdo" , "Fran Wilson" ,

"Giovanni Rovelli" , "Catherine Dewey" , "Jean Fresnière" , "Alexander Feuer" ,

"Simon Crowther" , "Yvonne Moncada" , "Rene Phillips" , "Henriette Pfalzheim" ,

"Marie Bertrand" , "Guillermo Fernández" , "Georg Pipps" , "Isabel de Castro" ,

"Bernardo Batista" , "Lúcia Carvalho" , "Horst Kloss" , "Sergio Gutiérrez" ,

"Paula Wilson" , "Maurizio Moroni" , "Janete Limeira" ,"Michael Holz" ,

"Alejandra Camino" , "Jonas Bergulfsen" , "Jose Pavarotti" , "Hari Kumar" ,

"Jytte Petersen" , "Dominique Perrier" , "Art Braunschweiger", "Pascale Cartrain" ,

"Liz Nixon" , "Liu Wong" , "Karin Josephs" , "Miguel Angel Paolino",

"Anabela Domingues" , "Helvetius Nagy" , "Palle Ibsen" , "Mary Saveley" ,

"Paul Henriot" , "Rita Müller" , "Pirkko Koskitalo" , "Paula Parente" ,

"Karl Jablonski" , "Matti Karttunen" , "Zbyszek Piestrzeniewicz"

}

);

}

return this.customerList;

}

#endregion

#region 제품 리스트 - ProductList

/// <summary>

/// 제품 리스트

/// </summary>

public static List<KeyValuePair<string, decimal>> ProductList

{

get

{

if(this.productList == null)

{

this.productList = new List<KeyValuePair<string, decimal>>();

this.productList.Add(new KeyValuePair<string,decimal>("Chai" , 18.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Chang" , 19.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Aniseed Syrup" , 10.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Chef Anton's Cajun Seasoning" , 22.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Chef Anton's Gumbo Mix" , 21.35m ));

this.productList.Add(new KeyValuePair<string,decimal>("Grandma's Boysenberry Spread" , 25.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Uncle Bob's Organic Dried Pears" , 30.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Northwoods Cranberry Sauce" , 40.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Mishi Kobe Niku" , 97.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Ikura" , 31.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Queso Cabrales" , 21.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Queso Manchego La Pastora" , 38.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Konbu" , 6.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Tofu" , 23.25m ));

this.productList.Add(new KeyValuePair<string,decimal>("Genen Shouyu" , 15.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Pavlova" , 17.45m ));

this.productList.Add(new KeyValuePair<string,decimal>("Alice Mutton" , 39.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Carnarvon Tigers" , 62.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Teatime Chocolate Biscuits" , 9.2m ));

this.productList.Add(new KeyValuePair<string,decimal>("Sir Rodney's Marmalade" , 81.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Sir Rodney's Scones" , 10.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gustaf's Knäckebröd" , 21.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Tunnbröd" , 9.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Guaraná Fantástica" , 4.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("NuNuCa Nuß-Nougat-Creme" , 14.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gumbär Gummibärchen" , 31.23m ));

this.productList.Add(new KeyValuePair<string,decimal>("Schoggi Schokolade" , 43.9m ));

this.productList.Add(new KeyValuePair<string,decimal>("Rössle Sauerkraut" , 45.6m ));

this.productList.Add(new KeyValuePair<string,decimal>("Thüringer Rostbratwurst" , 123.79m));

this.productList.Add(new KeyValuePair<string,decimal>("Nord-Ost Matjeshering" , 25.89m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gorgonzola Telino" , 12.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Mascarpone Fabioli" , 32.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Geitost" , 2.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Sasquatch Ale" , 14.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Steeleye Stout" , 18.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Inlagd Sill" , 19.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gravad lax" , 26.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Côte de Blaye" , 263.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Chartreuse verte" , 18.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Boston Crab Meat" , 18.4m ));

this.productList.Add(new KeyValuePair<string,decimal>("Jack's New England Clam Chowder" , 9.65m ));

this.productList.Add(new KeyValuePair<string,decimal>("Singaporean Hokkien Fried Mee" , 14.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Ipoh Coffee" , 46.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gula Malacca" , 19.45m ));

this.productList.Add(new KeyValuePair<string,decimal>("Røgede sild" , 9.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Spegesild" , 12.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Zaanse koeken" , 9.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Chocolade" , 12.75m ));

this.productList.Add(new KeyValuePair<string,decimal>("Maxilaku" , 20.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Valkoinen suklaa" , 16.25m ));

this.productList.Add(new KeyValuePair<string,decimal>("Manjimup Dried Apples" , 53.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Filo Mix" , 7.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Perth Pasties" , 32.8m ));

this.productList.Add(new KeyValuePair<string,decimal>("Tourtière" , 7.45m ));

this.productList.Add(new KeyValuePair<string,decimal>("Pâté chinois" , 24.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gnocchi di nonna Alice" , 38.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Ravioli Angelo" , 19.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Escargots de Bourgogne" , 13.25m ));

this.productList.Add(new KeyValuePair<string,decimal>("Raclette Courdavault" , 55.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Camembert Pierrot" , 34.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Sirop d'érable" , 28.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Tarte au sucre" , 49.3m ));

this.productList.Add(new KeyValuePair<string,decimal>("Vegie-spread" , 43.9m ));

this.productList.Add(new KeyValuePair<string,decimal>("Wimmers gute Semmelknödel" , 33.25m ));

this.productList.Add(new KeyValuePair<string,decimal>("Louisiana Fiery Hot Pepper Sauce", 21.05m ));

this.productList.Add(new KeyValuePair<string,decimal>("Louisiana Hot Spiced Okra" , 17.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Laughing Lumberjack Lager" , 14.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Scottish Longbreads" , 12.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Gudbrandsdalsost" , 36.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Outback Lager" , 15.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Fløtemysost" , 21.5m ));

this.productList.Add(new KeyValuePair<string,decimal>("Mozzarella di Giovanni" , 34.8m ));

this.productList.Add(new KeyValuePair<string,decimal>("Röd Kaviar" , 15.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Longlife Tofu" , 10.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Rhönbräu Klosterbier" , 7.75m ));

this.productList.Add(new KeyValuePair<string,decimal>("Lakkalikööri" , 18.0m ));

this.productList.Add(new KeyValuePair<string,decimal>("Original Frankfurter grüne Soße" , 13.0m ));

}

return this.productList;

}

#endregion

}

▶ OrderData.cs


using System;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData
{
    /// <summary>
    /// 주문 데이터
    /// </summary>
    public class OrderData
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Property
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 주문 ID - OrderID

        /// <summary>
        /// 주문 ID
        /// </summary>
        public int OrderID { get; set; }

        #endregion

        #region 고객명 - CustomerName

        /// <summary>
        /// 고객명
        /// </summary>
        public string CustomerName { get; set; }

        #endregion

        #region 주문일 - OrderDate

        /// <summary>
        /// 주문일
        /// </summary>
        public DateTime OrderDate { get; set; }

        #endregion

        #region 제품명 - ProductName

        /// <summary>
        /// 제품명
        /// </summary>
        public string ProductName { get; set; }

        #endregion

        #region 가격 - Price

        /// <summary>
        /// 가격
        /// </summary>
        public decimal Price { get; set; }

        #endregion

        #region 수량 - Quantity

        /// <summary>
        /// 수량
        /// </summary>
        public int Quantity { get; set; }

        #endregion
    }
}

using System;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData

{

/// <summary>

/// 주문 데이터

/// </summary>

public class OrderData

{

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

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

#region 주문 ID - OrderID

/// <summary>

/// 주문 ID

/// </summary>

public int OrderID { get; set; }

#endregion

#region 고객명 - CustomerName

/// <summary>

/// 고객명

/// </summary>

public string CustomerName { get; set; }

#endregion

#region 주문일 - OrderDate

/// <summary>

/// 주문일

/// </summary>

public DateTime OrderDate { get; set; }

#endregion

#region 제품명 - ProductName

/// <summary>

/// 제품명

/// </summary>

public string ProductName { get; set; }

#endregion

#region 가격 - Price

/// <summary>

/// 가격

/// </summary>

public decimal Price { get; set; }

#endregion

#region 수량 - Quantity

/// <summary>

/// 수량

/// </summary>

public int Quantity { get; set; }

#endregion

}

▶ OrderDataListSource.cs


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

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData
{
    /// <summary>
    /// 주문 데이터 리스트 소스
    /// </summary>
    public class OrderDataListSource : IListSource
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 잠금자
        /// </summary>
        private static object locker = new object();

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Static
        //////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 주문 데이터 리스트
        /// </summary>
        private List<OrderData> orderDataList;

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

        #endregion

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

        #region 리스트 컬렉션 포함 여부 - ContainsListCollection

        /// <summary>
        /// 리스트 컬렉션 포함 여부
        /// </summary>
        public bool ContainsListCollection
        {
            get
            {
                return false;
            }
        }

        #endregion

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

        #region 생성자 - OrderDataListSource(count)

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="count">카운트</param>
        public OrderDataListSource(int count)
        {
            this.count = count;
        }

        #endregion

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

        #region 리스트 구하기 - GetList()

        /// <summary>
        /// 리스트 구하기
        /// </summary>
        /// <returns>리스트</returns>
        public IList GetList()
        {
            if(this.orderDataList == null)
            {
                lock(this.locker)
                {
                    if(this.orderDataList == null)
                    {
                        GenerateOrderData();
                    }
                }
            }

            return this.orderDataList;
        }

        #endregion

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

        #region 주문 데이터 생성하기 - GenerateOrderData()

        /// <summary>
        /// 주문 데이터 생성하기
        /// </summary>
        private void GenerateOrderData()
        {
            this.orderDataList = new List<OrderData>(this.count);

            Random random = new Random();

            int customerCount = Data.CustomerList.Count;
            int productCount  = Data.ProductList.Count;

            for(int i = 0; i < this.count; i++)
            {
                OrderData orderData = new OrderData();

                orderData.OrderID      = i + 1;
                orderData.CustomerName = Data.CustomerList[pRandom.Next(customerCount)];
                orderData.OrderDate    = DateTime.Today.Subtract(TimeSpan.FromDays(random.Next(180)));

                KeyValuePair<string, decimal> productKeyValuePair = Data.ProductList[random.Next(productCount)];

                orderData.ProductName = productKeyValuePair.Key;
                orderData.Price       = productKeyValuePair.Value;
                orderData.Quantity    = random.Next(200) + 1;

                this.orderDataList.Add(orderData);
            }
        }

        #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

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData

{

/// <summary>

/// 주문 데이터 리스트 소스

/// </summary>

public class OrderDataListSource : IListSource

{

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

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

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

#region Field

/// <summary>

/// 잠금자

/// </summary>

private static object locker = new object();

#endregion

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

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

#region Field

/// <summary>

/// 주문 데이터 리스트

/// </summary>

private List<OrderData> orderDataList;

/// <summary>

/// 카운트

/// </summary>

private int count = 0;

#endregion

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

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

#region 리스트 컬렉션 포함 여부 - ContainsListCollection

/// <summary>

/// 리스트 컬렉션 포함 여부

/// </summary>

public bool ContainsListCollection

{

get

{

return false;

}

#endregion

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

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

#region 생성자 - OrderDataListSource(count)

/// <summary>

/// 생성자

/// </summary>

/// <param name="count">카운트</param>

public OrderDataListSource(int count)

{

this.count = count;

}

#endregion

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

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

#region 리스트 구하기 - GetList()

/// <summary>

/// 리스트 구하기

/// </summary>

/// <returns>리스트</returns>

public IList GetList()

{

if(this.orderDataList == null)

{

lock(this.locker)

{

if(this.orderDataList == null)

{

GenerateOrderData();

}

return this.orderDataList;

}

#endregion

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

#region 주문 데이터 생성하기 - GenerateOrderData()

/// <summary>

/// 주문 데이터 생성하기

/// </summary>

private void GenerateOrderData()

{

this.orderDataList = new List<OrderData>(this.count);

Random random = new Random();

int customerCount = Data.CustomerList.Count;

int productCount = Data.ProductList.Count;

for(int i = 0; i < this.count; i++)

{

OrderData orderData = new OrderData();

orderData.OrderID = i + 1;

orderData.CustomerName = Data.CustomerList[pRandom.Next(customerCount)];

orderData.OrderDate = DateTime.Today.Subtract(TimeSpan.FromDays(random.Next(180)));

KeyValuePair<string, decimal> productKeyValuePair = Data.ProductList[random.Next(productCount)];

orderData.ProductName = productKeyValuePair.Key;

orderData.Price = productKeyValuePair.Value;

orderData.Quantity = random.Next(200) + 1;

this.orderDataList.Add(orderData);

}

#endregion

}

▶ ViewModel.cs


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

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData
{
    /// <summary>
    /// 뷰 모델
    /// </summary>
    public class ViewModel : INotifyPropertyChanged
    {
        //////////////////////////////////////////////////////////////////////////////////////////////////// Event
        ////////////////////////////////////////////////////////////////////////////////////////// Public

        #region 속성 변경시 - PropertyChanged

        /// <summary>
        /// 속성 변경시
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        //////////////////////////////////////////////////////////////////////////////////////////////////// Field
        ////////////////////////////////////////////////////////////////////////////////////////// Private

        #region Field

        /// <summary>
        /// 주문 데이터 리스트 소스
        /// </summary>
        private OrderDataListSource orderDataListSource;

        #endregion

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

        #region 주문 데이터 리스트 소스 - OrderDataListSource

        /// <summary>
        /// 주문 데이터 리스트 소스
        /// </summary>
        public OrderDataListSource OrderDataListSource
        {
            get
            {
                return this.orderDataListSource;
            }
            set
            {
                if(this.orderDataListSource == value)
                {
                    return;
                }

                this.orderDataListSource = value;

                OnPropertyChanged("ListSource");
            }
        }

        #endregion

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

        #region 생성자 - ViewModel()

        /// <summary>
        /// 생성자
        /// </summary>
        public ViewModel()
        {
            OrderDataListSource = new OrderDataListSource(1000000);
        }

        #endregion

        ////////////////////////////////////////////////////////////////////////////////////////// Protected

        #region 속성 변경시 처리하기 - OnPropertyChanged(propertyName)

        /// <summary>
        /// 속성 변경시 처리하기
        /// </summary>
        /// <param name="propertyName">속성명</param>
        protected virtual void OnPropertyChanged(string propertyName)
        {
            if(PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        #endregion
    }
}

100

101

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

namespace HowToParallelizeDataIntensiveOperationsOnInMemoryData

{

/// <summary>

/// 뷰 모델

/// </summary>

public class ViewModel : INotifyPropertyChanged

{

//////////////////////////////////////////////////////////////////////////////////////////////////// Event

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

#region 속성 변경시 - PropertyChanged

/// <summary>

/// 속성 변경시

/// </summary>

public event PropertyChangedEventHandler PropertyChanged;

#endregion

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

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

#region Field

/// <summary>

/// 주문 데이터 리스트 소스

/// </summary>

private OrderDataListSource orderDataListSource;

#endregion

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

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

#region 주문 데이터 리스트 소스 - OrderDataListSource

/// <summary>

/// 주문 데이터 리스트 소스

/// </summary>

public OrderDataListSource OrderDataListSource

{

get

{

return this.orderDataListSource;

}

set

{

if(this.orderDataListSource == value)

{

return;

}

this.orderDataListSource = value;

OnPropertyChanged("ListSource");

}

#endregion

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

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

#region 생성자 - ViewModel()

/// <summary>

/// 생성자

/// </summary>

public ViewModel()

{

OrderDataListSource = new OrderDataListSource(1000000);

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Protected

#region 속성 변경시 처리하기 - OnPropertyChanged(propertyName)

/// <summary>

/// 속성 변경시 처리하기

/// </summary>

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

protected virtual void OnPropertyChanged(string propertyName)

{

if(PropertyChanged != null)

{

PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

}

#endregion

}

▶ MainWindow.xaml


<Window
    x:Class="HowToParallelizeDataIntensiveOperationsOnInMemoryData.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
    xmlns:dx="http://schemas.devexpress.com/winfx/2008/xaml/core"
    xmlns:dxe="http://schemas.devexpress.com/winfx/2008/xaml/editors"
    xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid"
    xmlns:local="clr-namespace:HowToParallelizeDataIntensiveOperationsOnInMemoryData"
    Width="800"
    Height="600"
    Title="MainWindow">
    <Window.DataContext>
        <local:ViewModel />
    </Window.DataContext>
    <Grid>
        <dx:PLinqInstantFeedbackDataSource x:Name="pLinqInstantFeedbackDataSource"
            ListSource="{Binding Path=OrderDataListSource}" />
        <dxg:GridControl x:Name="gridControl"
            ItemsSource="{Binding ElementName=pLinqInstantFeedbackDataSource, Path=Data}">
            <dxg:GridControl.Columns>
                <dxg:GridColumn x:Name="idGridColumn"
                    FieldName="OrderID"
                    Header="ID"
                    Width="60"
                    MinWidth="60"
                    AllowColumnFiltering="False"
                    AllowGrouping="False" />
                <dxg:GridColumn x:Name="customerNameGridColumn"
                    FieldName="CustomerName"
                    Width="200" />
                <dxg:GridColumn x:Name="orderDateGridColumn"
                    FieldName="OrderDate"
                    Width="100"
                    AllowColumnFiltering="False">
                    <dxg:GridColumn.EditSettings>
                        <dxe:DateEditSettings DisplayFormat="d" />
                    </dxg:GridColumn.EditSettings>
                </dxg:GridColumn>
                <dxg:GridColumn x:Name="productNameGridColumn"
                    FieldName="ProductName"
                    Width="200" />
                <dxg:GridColumn x:Name="priceGridColumn"
                    FieldName="Price"
                    Width="60" />
                <dxg:GridColumn x:Name="quantityGridColumn"
                    FieldName="Quantity"
                    Width="60" />
            </dxg:GridControl.Columns>
            <dxg:GridControl.View>
                <dxg:TableView
                    AutoWidth="False"
                    ShowTotalSummary="False"
                    RowAnimationKind="Opacity" />
            </dxg:GridControl.View>
        </dxg:GridControl>
    </Grid>
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="Closed">
            <i:InvokeCommandAction Command="{Binding ElementName=pLinqInstantFeedbackDataSource, Path=DisposeCommand}" />
        </i:EventTrigger>
    </i:Interaction.Triggers>
</Window>

<Window

x:Class="HowToParallelizeDataIntensiveOperationsOnInMemoryData.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"

xmlns:dx="http://schemas.devexpress.com/winfx/2008/xaml/core"

xmlns:dxe="http://schemas.devexpress.com/winfx/2008/xaml/editors"

xmlns:dxg="http://schemas.devexpress.com/winfx/2008/xaml/grid"

xmlns:local="clr-namespace:HowToParallelizeDataIntensiveOperationsOnInMemoryData"

Width="800"

Height="600"

Title="MainWindow">

<Window.DataContext>

<local:ViewModel />

</Window.DataContext>

<Grid>

<dx:PLinqInstantFeedbackDataSource x:Name="pLinqInstantFeedbackDataSource"

ListSource="{Binding Path=OrderDataListSource}" />

<dxg:GridControl x:Name="gridControl"

ItemsSource="{Binding ElementName=pLinqInstantFeedbackDataSource, Path=Data}">

<dxg:GridControl.Columns>

<dxg:GridColumn x:Name="idGridColumn"

FieldName="OrderID"

Header="ID"

Width="60"

MinWidth="60"

AllowColumnFiltering="False"

AllowGrouping="False" />

<dxg:GridColumn x:Name="customerNameGridColumn"

FieldName="CustomerName"

Width="200" />

<dxg:GridColumn x:Name="orderDateGridColumn"

FieldName="OrderDate"

Width="100"

AllowColumnFiltering="False">

<dxg:GridColumn.EditSettings>

<dxe:DateEditSettings DisplayFormat="d" />

</dxg:GridColumn.EditSettings>

</dxg:GridColumn>

<dxg:GridColumn x:Name="productNameGridColumn"

FieldName="ProductName"

Width="200" />

<dxg:GridColumn x:Name="priceGridColumn"

FieldName="Price"

Width="60" />

<dxg:GridColumn x:Name="quantityGridColumn"

FieldName="Quantity"

Width="60" />

</dxg:GridControl.Columns>

<dxg:GridControl.View>

<dxg:TableView

AutoWidth="False"

ShowTotalSummary="False"

RowAnimationKind="Opacity" />

</dxg:GridControl.View>

</dxg:GridControl>

</Grid>

<i:Interaction.Triggers>

<i:EventTrigger EventName="Closed">

<i:InvokeCommandAction Command="{Binding ElementName=pLinqInstantFeedbackDataSource, Path=DisposeCommand}" />

</i:EventTrigger>

</i:Interaction.Triggers>

</Window>