FILE Archives - 19 중 18 번째 페이지

[C#/COMMON] 파일 아카이브 속성 보유 여부 조사하기

■ 파일의 아카이브 속성 보유 여부를 조사하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일 아카이브 속성 보유 여부 조사하기 - CheckFileHasArchiveAttribute(filePath)

/// <summary>
/// 파일 아카이브 속성 보유 여부 조사하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>파일 아카이브 속성 보유 여부</returns>
public bool CheckFileHasArchiveAttribute(string filePath)
{
    FileAttributes fileAttributes = GetFileAttribute(filePath);

    return (fileAttributes & FileAttributes.Archive) ==  FileAttributes.Archive;
}

#endregion

using System.IO;

#region 파일 아카이브 속성 보유 여부 조사하기 - CheckFileHasArchiveAttribute(filePath)

/// <summary>

/// 파일 아카이브 속성 보유 여부 조사하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>파일 아카이브 속성 보유 여부</returns>

public bool CheckFileHasArchiveAttribute(string filePath)

{

FileAttributes fileAttributes = GetFileAttribute(filePath);

return (fileAttributes & FileAttributes.Archive) == FileAttributes.Archive;

}

#endregion

[C#/COMMON] 파일 히든 속성 보유 여부 조사하기

■ 파일의 히든 속성 보유 여부를 조사하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일 히든 속성 보유 여부 조사하기 - CheckFileHasHiddenAttribute(filePath)

/// <summary>
/// 파일 히든 속성 보유 여부 조사하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>파일 히든 속성 보유 여부</returns>
public bool CheckFileHasHiddenAttribute(string filePath)
{
    FileAttributes fileAttributes = GetFileAttribute(filePath);

    return (fileAttributes & FileAttributes.Hidden) ==  FileAttributes.Hidden;
}

#endregion

using System.IO;

#region 파일 히든 속성 보유 여부 조사하기 - CheckFileHasHiddenAttribute(filePath)

/// <summary>

/// 파일 히든 속성 보유 여부 조사하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>파일 히든 속성 보유 여부</returns>

public bool CheckFileHasHiddenAttribute(string filePath)

{

FileAttributes fileAttributes = GetFileAttribute(filePath);

return (fileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden;

}

#endregion

[C#/COMMON] 파일 읽기 전용 속성 보유 여부 조사하기

■ 파일의 읽기 전용 속성 보유 여부를 조사하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일 읽기 전용 속성 보유 여부 조사하기 - CheckFileHasReadOnlyAttribute(filePath)

/// <summary>
/// 파일 읽기 전용 속성 보유 여부 조사하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>파일 읽기 전용 속성 보유 여부</returns>
public bool CheckFileHasReadOnlyAttribute(string filePath)
{
    FileAttributes fileAttributes = GetFileAttribute(filePath);

    return (fileAttributes & FileAttributes.ReadOnly) ==  FileAttributes.ReadOnly;
}

#endregion

using System.IO;

#region 파일 읽기 전용 속성 보유 여부 조사하기 - CheckFileHasReadOnlyAttribute(filePath)

/// <summary>

/// 파일 읽기 전용 속성 보유 여부 조사하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>파일 읽기 전용 속성 보유 여부</returns>

public bool CheckFileHasReadOnlyAttribute(string filePath)

{

FileAttributes fileAttributes = GetFileAttribute(filePath);

return (fileAttributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly;

}

#endregion

[C#/COMMON] Environment 클래스 : GetFolderPath 정적 메소드를 사용해 로컬 애플리케이션 데이터 디렉토리 경로 구하기

■ Environment 클래스의 GetFolderPath 정적 메소드를 사용해 로컬 애플리케이션의 데이터 디렉토리 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;

#region 로컬 애플리케이션 데이터 디렉토리 경로 구하기 - GetLocalApplicationDataDirectoryPath()

/// <summary>
/// 로컬 애플리케이션 데이터 디렉토리 경로 구하기
/// </summary>
/// <returns>로컬 애플리케이션 데이터 디렉토리 경로</returns>
public string GetLocalApplicationDataDirectoryPath()
{
    return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
}

#endregion

using System;

#region 로컬 애플리케이션 데이터 디렉토리 경로 구하기 - GetLocalApplicationDataDirectoryPath()

/// <summary>

/// 로컬 애플리케이션 데이터 디렉토리 경로 구하기

/// </summary>

/// <returns>로컬 애플리케이션 데이터 디렉토리 경로</returns>

public string GetLocalApplicationDataDirectoryPath()

{

return Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

}

#endregion

※ 본인의

[C#/COMMON] 디렉토리 크기 구하기

■ 디렉토리 크기를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.IO;

#region 디렉토리 크기 구하기 - GetDirectorySize(directoryPath)

/// <summary>
/// 디렉토리 크기 구하기
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <returns>디렉토리 크기</returns>
public long GetDirectorySize(string directoryPath)
{
    DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);

    FileSystemInfo[] fileSystemInfoArray = directoryInfo.GetFileSystemInfos();

    long directorySize = 0L;

    for(int i = 0; i < fileSystemInfoArray.Length; i++)
    {
        FileInfo fileInfo = fileSystemInfoArray[i] as FileInfo;

        if(fileInfo != null)
        {
            directorySize += fileInfo.Length;
        }
    }

    return directorySize;
}

#endregion

using System;

using System.IO;

#region 디렉토리 크기 구하기 - GetDirectorySize(directoryPath)

/// <summary>

/// 디렉토리 크기 구하기

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>디렉토리 크기</returns>

public long GetDirectorySize(string directoryPath)

{

DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);

FileSystemInfo[] fileSystemInfoArray = directoryInfo.GetFileSystemInfos();

long directorySize = 0L;

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

{

FileInfo fileInfo = fileSystemInfoArray[i] as FileInfo;

if(fileInfo != null)

{

directorySize += fileInfo.Length;

}

return directorySize;

}

#endregion

[C#/COMMON] 이진 파일 관리자 사용하기

■ 이진 파일 관리자를 사용하는 방법을 보여준다. ▶ BinaryFileManager.cs


using System;
using System.IO;

/// <summary>
/// 이진 파일 관리자
/// </summary>
public class BinaryFileManager : IDisposable
{
    //////////////////////////////////////////////////////////////////////////////////////////////////// Field
    ////////////////////////////////////////////////////////////////////////////////////////// Public

    #region Field

    /// <summary>
    /// 파일 스트림
    /// </summary>
    private FileStream fileStream;

    #endregion

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

    #region 파일 스트림 - FileStream

    /// <summary>
    /// 파일 스트림
    /// </summary>
    public FileStream FileStream
    {
        get
        {
            return this.fileStream;
        }
    }

    #endregion

    #region 파일 길이 - FileLength

    /// <summary>
    /// 파일 길이
    /// </summary>
    public long FileLength
    {
        get
        {
            if(this.fileStream != null)
            {
                return this.fileStream.Length;
            }
            else
            {
                return 0L;
            }
        }
    }

    #endregion

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

    #region 생성자 - BinaryFileManager(fileStream)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="fileStream">파일 스트림</param>
    public BinaryFileManager(FileStream fileStream)
    {
        this.fileStream = fileStream;
    }

    #endregion

    #region 생성자 - BinaryFileManager(filePath, fileMode, fileAccess)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="filePath">파일 경로</param>
    /// <param name="fileMode">파일 모드</param>
    /// <param name="fileAccess">파일 액세스</param>
    public BinaryFileManager(string filePath, FileMode fileMode, FileAccess fileAccess)
    {
        this.fileStream = new FileStream(filePath, fileMode, fileAccess);
    }

    #endregion

    #region 생성자 - BinaryFileManager(filePath)

    /// <summary>
    /// 생성자
    /// </summary>
    /// <param name="filePath">파일 경로</param>
    public BinaryFileManager(string filePath) : this(filePath, FileMode.Open, FileAccess.Read)
    {
    }

    #endregion

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

    #region 생성자 - BinaryFileManager()

    /// <summary>
    /// 생성자
    /// </summary>
    private BinaryFileManager()
    {
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Destructor

    #region 소멸자 - ~BinaryFileManager()

    /// <summary>
    /// 소멸자
    /// </summary>
    ~BinaryFileManager()
    {
        Close();
    }

    #endregion

    //////////////////////////////////////////////////////////////////////////////////////////////////// Method
    ////////////////////////////////////////////////////////////////////////////////////////// Static

    #region 파일 읽기 - ReadFile(filePath)

    /// <summary>
    /// 파일 읽기
    /// </summary>
    /// <param name="filePath">파일 경로</param>
    /// <returns>읽기 바이트 배열</returns>
    public static byte[] ReadFile(string filePath)
    {
        FileStream fileStream      = null;
        byte[]     bufferByteArray = null;

        try
        {
            fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);

            int fileLength = (int)fileStream.Length;

            bufferByteArray = new byte[fileLength];

            int countRead;
            int totalCountRead = 0;

            while((countRead = fileStream.Read(bufferByteArray, totalCountRead, fileLength - totalCountRead)) > 0)
            {
                totalCountRead += countRead;
            }
        }
        finally
        {
            if(fileStream != null)
            {
                fileStream.Close();

                fileStream.Dispose();

                fileStream = null;
            }
        }

        return bufferByteArray;
    }

    #endregion

    ////////////////////////////////////////////////////////////////////////////////////////// Instance
    //////////////////////////////////////////////////////////////////////////////// Public

    #region 쓰기 - Write(seekOrigin, startPosition, sourceByteArray, sourceByteArrayOffset, writeLength)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="seekOrigin">탐색 기준</param>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="sourceByteArray">소스 바이트 배열</param>
    /// <param name="sourceByteArrayOffset">소스 바이트 배열 오프셋</param>
    /// <param name="writeLength">쓰기 길이</param>
    public void Write(SeekOrigin seekOrigin, long startPosition, byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)
    {
        this.fileStream.Seek(startPosition, seekOrigin);

        this.fileStream.Write(sourceByteArray, sourceByteArrayOffset, writeLength);
    }

    #endregion

    #region 쓰기 - Write(seekOrigin, startPosition, sourceByteArray)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="seekOrigin">탐색 기준</param>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="sourceByteArray">소스 바이트 배열</param>
    public void Write(SeekOrigin seekOrigin, long startPosition, byte[] sourceByteArray)
    {
        Write(seekOrigin, startPosition, sourceByteArray, 0, sourceByteArray.Length);
    }

    #endregion

    #region 쓰기 - Write(startPosition, sourceByteArray, sourceByteArrayOffset, writeLength)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="lStartPosition">시작 위치</param>
    /// <param name="pSourceByteArray">소스 바이트 배열<param>
    /// <param name="nBufferOffset">소스 바이트 배열 오프셋</param>
    /// <param name="nWriteLength">쓰기 길이</param>
    public void Write(long startPosition, byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)
    {
        Write(SeekOrigin.Begin, startPosition, sourceByteArray, sourceByteArrayOffset, writeLength);
    }

    #endregion

    #region 쓰기 - Write(startPosition, sourceByteArray)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="sourceByteArray">소스 바이트 배열</param>
    public void Write(long startPosition, byte[] sourceByteArray)
    {
        Write(SeekOrigin.Begin, startPosition, sourceByteArray, 0, sourceByteArray.Length);
    }

    #endregion

    #region 쓰기 - Write(sourceByteArray, sourceByteArrayOffset, writeLength)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="sourceByteArray">소스 바이트 배열</param>
    /// <param name="sourceByteArrayOffset">소스 바이트 배열 오프셋</param>
    /// <param name="writeLength">쓰기 길이</param>
    public void Write(byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)
    {
        Write(SeekOrigin.Begin, 0L, sourceByteArray, sourceByteArrayOffset, writeLength);
    }

    #endregion

    #region 쓰기 - Write(sourceByteArray)

    /// <summary>
    /// 쓰기
    /// </summary>
    /// <param name="sourceByteArray">소스 바이트 배열</param>
    public void Write(byte[] sourceByteArray)
    {
        Write(SeekOrigin.Begin, 0L, sourceByteArray, 0, sourceByteArray.Length);
    }

    #endregion

    #region 읽기 - Read(seekOrigin, startPosition, targetByteArray, targetByteArrayOffset, readLength)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="seekOrigin">탐색 기준</param>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>
    /// <param name="readLength">읽기 길이</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(SeekOrigin seekOrigin, long startPosition, byte[] targetByteArray, int targetByteArrayOffset, int readLength)
    {
        this.fileStream.Seek(startPosition, seekOrigin);

        return this.fileStream.Read(targetByteArray, targetByteArrayOffset, readLength);
    }

    #endregion

    #region 읽기 - Read(seekOrigin, startPosition, targetByteArray)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="seekOrigin">탐색 기준</param>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(SeekOrigin seekOrigin, long startPosition, byte[] targetByteArray)
    {
        return Read(seekOrigin, startPosition, targetByteArray, 0, targetByteArray.Length);
    }

    #endregion

    #region 읽기 - Read(startPosition, targetByteArray, targetByteArrayOffset, readLength)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>
    /// <param name="readLength">읽기 길이</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(long startPosition, byte[] targetByteArray, int targetByteArrayOffset, int readLength)
    {
        return Read(SeekOrigin.Begin, startPosition, targetByteArray, targetByteArrayOffset, readLength);
    }

    #endregion

    #region 읽기 - Read(startPosition, targetByteArray)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="startPosition">시작 위치</param>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(long startPosition, byte[] targetByteArray)
    {
        return Read(SeekOrigin.Begin, startPosition, targetByteArray, 0, targetByteArray.Length);
    }

    #endregion

    #region 읽기 - Read(targetByteArray, targetByteArrayOffset, readLength)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>
    /// <param name="readLength">읽기 길이</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(byte[] targetByteArray, int targetByteArrayOffset, int readLength)
    {
        return Read(SeekOrigin.Begin, 0L, targetByteArray, targetByteArrayOffset, readLength);
    }

    #endregion

    #region 읽기 - Read(targetByteArray)

    /// <summary>
    /// 읽기
    /// </summary>
    /// <param name="targetByteArray">타겟 바이트 배열</param>
    /// <returns>실제 읽은 길이</returns>
    public int Read(byte[] targetByteArray)
    {
        return Read(SeekOrigin.Begin, 0L, targetByteArray, 0, targetByteArray.Length);
    }

    #endregion

    #region 닫기 - Close()

    /// <summary>
    /// 닫기
    /// </summary>
    public void Close()
    {
        if(this.fileStream != null)
        {
            this.fileStream.Close();

            this.fileStream.Dispose();

            this.fileStream = null;
        }
    }

    #endregion

    #region 해제하기 - Dispose()

    /// <summary>
    /// 해제하기
    /// </summary>
    public void Dispose()
    {
        Close();
    }

    #endregion
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

using System;

using System.IO;

/// <summary>

/// 이진 파일 관리자

/// </summary>

public class BinaryFileManager : IDisposable

{

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

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

#region Field

/// <summary>

/// 파일 스트림

/// </summary>

private FileStream fileStream;

#endregion

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

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

#region 파일 스트림 - FileStream

/// <summary>

/// 파일 스트림

/// </summary>

public FileStream FileStream

{

get

{

return this.fileStream;

}

#endregion

#region 파일 길이 - FileLength

/// <summary>

/// 파일 길이

/// </summary>

public long FileLength

{

get

{

if(this.fileStream != null)

{

return this.fileStream.Length;

}

else

{

return 0L;

}

#endregion

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

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

#region 생성자 - BinaryFileManager(fileStream)

/// <summary>

/// 생성자

/// </summary>

/// <param name="fileStream">파일 스트림</param>

public BinaryFileManager(FileStream fileStream)

{

this.fileStream = fileStream;

}

#endregion

#region 생성자 - BinaryFileManager(filePath, fileMode, fileAccess)

/// <summary>

/// 생성자

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <param name="fileMode">파일 모드</param>

/// <param name="fileAccess">파일 액세스</param>

public BinaryFileManager(string filePath, FileMode fileMode, FileAccess fileAccess)

{

this.fileStream = new FileStream(filePath, fileMode, fileAccess);

}

#endregion

#region 생성자 - BinaryFileManager(filePath)

/// <summary>

/// 생성자

/// </summary>

/// <param name="filePath">파일 경로</param>

public BinaryFileManager(string filePath) : this(filePath, FileMode.Open, FileAccess.Read)

{

}

#endregion

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

#region 생성자 - BinaryFileManager()

/// <summary>

/// 생성자

/// </summary>

private BinaryFileManager()

{

}

#endregion

//////////////////////////////////////////////////////////////////////////////////////////////////// Destructor

#region 소멸자 - ~BinaryFileManager()

/// <summary>

/// 소멸자

/// </summary>

~BinaryFileManager()

{

Close();

}

#endregion

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

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

#region 파일 읽기 - ReadFile(filePath)

/// <summary>

/// 파일 읽기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>읽기 바이트 배열</returns>

public static byte[] ReadFile(string filePath)

{

FileStream fileStream = null;

byte[] bufferByteArray = null;

try

{

fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);

int fileLength = (int)fileStream.Length;

bufferByteArray = new byte[fileLength];

int countRead;

int totalCountRead = 0;

while((countRead = fileStream.Read(bufferByteArray, totalCountRead, fileLength - totalCountRead)) > 0)

{

totalCountRead += countRead;

}

finally

{

if(fileStream != null)

{

fileStream.Close();

fileStream.Dispose();

fileStream = null;

}

return bufferByteArray;

}

#endregion

////////////////////////////////////////////////////////////////////////////////////////// Instance

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

#region 쓰기 - Write(seekOrigin, startPosition, sourceByteArray, sourceByteArrayOffset, writeLength)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="seekOrigin">탐색 기준</param>

/// <param name="startPosition">시작 위치</param>

/// <param name="sourceByteArray">소스 바이트 배열</param>

/// <param name="sourceByteArrayOffset">소스 바이트 배열 오프셋</param>

/// <param name="writeLength">쓰기 길이</param>

public void Write(SeekOrigin seekOrigin, long startPosition, byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)

{

this.fileStream.Seek(startPosition, seekOrigin);

this.fileStream.Write(sourceByteArray, sourceByteArrayOffset, writeLength);

}

#endregion

#region 쓰기 - Write(seekOrigin, startPosition, sourceByteArray)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="seekOrigin">탐색 기준</param>

/// <param name="startPosition">시작 위치</param>

/// <param name="sourceByteArray">소스 바이트 배열</param>

public void Write(SeekOrigin seekOrigin, long startPosition, byte[] sourceByteArray)

{

Write(seekOrigin, startPosition, sourceByteArray, 0, sourceByteArray.Length);

}

#endregion

#region 쓰기 - Write(startPosition, sourceByteArray, sourceByteArrayOffset, writeLength)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="lStartPosition">시작 위치</param>

/// <param name="pSourceByteArray">소스 바이트 배열<param>

/// <param name="nBufferOffset">소스 바이트 배열 오프셋</param>

/// <param name="nWriteLength">쓰기 길이</param>

public void Write(long startPosition, byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)

{

Write(SeekOrigin.Begin, startPosition, sourceByteArray, sourceByteArrayOffset, writeLength);

}

#endregion

#region 쓰기 - Write(startPosition, sourceByteArray)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="startPosition">시작 위치</param>

/// <param name="sourceByteArray">소스 바이트 배열</param>

public void Write(long startPosition, byte[] sourceByteArray)

{

Write(SeekOrigin.Begin, startPosition, sourceByteArray, 0, sourceByteArray.Length);

}

#endregion

#region 쓰기 - Write(sourceByteArray, sourceByteArrayOffset, writeLength)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="sourceByteArray">소스 바이트 배열</param>

/// <param name="sourceByteArrayOffset">소스 바이트 배열 오프셋</param>

/// <param name="writeLength">쓰기 길이</param>

public void Write(byte[] sourceByteArray, int sourceByteArrayOffset, int writeLength)

{

Write(SeekOrigin.Begin, 0L, sourceByteArray, sourceByteArrayOffset, writeLength);

}

#endregion

#region 쓰기 - Write(sourceByteArray)

/// <summary>

/// 쓰기

/// </summary>

/// <param name="sourceByteArray">소스 바이트 배열</param>

public void Write(byte[] sourceByteArray)

{

Write(SeekOrigin.Begin, 0L, sourceByteArray, 0, sourceByteArray.Length);

}

#endregion

#region 읽기 - Read(seekOrigin, startPosition, targetByteArray, targetByteArrayOffset, readLength)

/// <summary>

/// 읽기

/// </summary>

/// <param name="seekOrigin">탐색 기준</param>

/// <param name="startPosition">시작 위치</param>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>

/// <param name="readLength">읽기 길이</param>

/// <returns>실제 읽은 길이</returns>

public int Read(SeekOrigin seekOrigin, long startPosition, byte[] targetByteArray, int targetByteArrayOffset, int readLength)

{

this.fileStream.Seek(startPosition, seekOrigin);

return this.fileStream.Read(targetByteArray, targetByteArrayOffset, readLength);

}

#endregion

#region 읽기 - Read(seekOrigin, startPosition, targetByteArray)

/// <summary>

/// 읽기

/// </summary>

/// <param name="seekOrigin">탐색 기준</param>

/// <param name="startPosition">시작 위치</param>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <returns>실제 읽은 길이</returns>

public int Read(SeekOrigin seekOrigin, long startPosition, byte[] targetByteArray)

{

return Read(seekOrigin, startPosition, targetByteArray, 0, targetByteArray.Length);

}

#endregion

#region 읽기 - Read(startPosition, targetByteArray, targetByteArrayOffset, readLength)

/// <summary>

/// 읽기

/// </summary>

/// <param name="startPosition">시작 위치</param>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>

/// <param name="readLength">읽기 길이</param>

/// <returns>실제 읽은 길이</returns>

public int Read(long startPosition, byte[] targetByteArray, int targetByteArrayOffset, int readLength)

{

return Read(SeekOrigin.Begin, startPosition, targetByteArray, targetByteArrayOffset, readLength);

}

#endregion

#region 읽기 - Read(startPosition, targetByteArray)

/// <summary>

/// 읽기

/// </summary>

/// <param name="startPosition">시작 위치</param>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <returns>실제 읽은 길이</returns>

public int Read(long startPosition, byte[] targetByteArray)

{

return Read(SeekOrigin.Begin, startPosition, targetByteArray, 0, targetByteArray.Length);

}

#endregion

#region 읽기 - Read(targetByteArray, targetByteArrayOffset, readLength)

/// <summary>

/// 읽기

/// </summary>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <param name="targetByteArrayOffset">타겟 바이트 배열 오프셋</param>

/// <param name="readLength">읽기 길이</param>

/// <returns>실제 읽은 길이</returns>

public int Read(byte[] targetByteArray, int targetByteArrayOffset, int readLength)

{

return Read(SeekOrigin.Begin, 0L, targetByteArray, targetByteArrayOffset, readLength);

}

#endregion

#region 읽기 - Read(targetByteArray)

/// <summary>

/// 읽기

/// </summary>

/// <param name="targetByteArray">타겟 바이트 배열</param>

/// <returns>실제 읽은 길이</returns>

public int Read(byte[] targetByteArray)

{

return Read(SeekOrigin.Begin, 0L, targetByteArray, 0, targetByteArray.Length);

}

#endregion

#region 닫기 - Close()

/// <summary>

/// 닫기

/// </summary>

public void Close()

{

if(this.fileStream != null)

{

this.fileStream.Close();

this.fileStream.Dispose();

this.fileStream = null;

}

#endregion

#region 해제하기 - Dispose()

/// <summary>

/// 해제하기

/// </summary>

public void Dispose()

{

Close();

}

#endregion

}

[C#/COMMON] 논리적 드라이브 타입 구하기

■ 논리적 드라이브 타입을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Runtime.InteropServices;

...

/// <summary>
/// 드라이브 타입
/// </summary>
public enum DriveType
{
    /// <summary>
    /// DRIVE_UNKNOWN
    /// </summary>
    Unknown = 0,

    /// <summary>
    /// DRIVE_NO_ROOT_DIR
    /// </summary>
    NoRootDirectory = 1,

    /// <summary>
    /// DRIVE_REMOVABLE
    /// </summary>
    Removable = 2,

    /// <summary>
    /// DRIVE_FIXED
    /// </summary>
    Fixed = 3,

    /// <summary>
    /// DRIVE_REMOTE
    /// </summary>
    Remote = 4,

    /// <summary>
    /// DRIVE_CDROM
    /// </summary>
    CDROM = 5,

    /// <summary>
    /// DRIVE_RAMDISK
    /// </summary>
    RAMDisk = 6
}

...

#region 논리적 드라이브 타입 구하기 - GetDriveType(rootPath)

/// <summary>
/// 논리적 드라이브 타입 구하기
/// </summary>
/// <param name="rootPath">루트 경로</param>
/// <returns>드라이브 타입</returns>
[DllImport("kernel32")]
public static extern DriveType GetDriveType(string rootPath);

#endregion

...

DriveType driveType = GetDriveType("C:\\");

Console.WriteLine("Drive {0} is type {1}", "C:\\", driveType);

using System;

using System.Runtime.InteropServices;

...

/// <summary>

/// 드라이브 타입

/// </summary>

public enum DriveType

{

/// <summary>

/// DRIVE_UNKNOWN

/// </summary>

Unknown = 0,

/// <summary>

/// DRIVE_NO_ROOT_DIR

/// </summary>

NoRootDirectory = 1,

/// <summary>

/// DRIVE_REMOVABLE

/// </summary>

Removable = 2,

/// <summary>

/// DRIVE_FIXED

/// </summary>

Fixed = 3,

/// <summary>

/// DRIVE_REMOTE

/// </summary>

Remote = 4,

/// <summary>

/// DRIVE_CDROM

/// </summary>

CDROM = 5,

/// <summary>

/// DRIVE_RAMDISK

/// </summary>

RAMDisk = 6

}

...

#region 논리적 드라이브 타입 구하기 - GetDriveType(rootPath)

/// <summary>

/// 논리적 드라이브 타입 구하기

/// </summary>

/// <param name="rootPath">루트 경로</param>

/// <returns>드라이브 타입</returns>

[DllImport("kernel32")]

public static extern DriveType GetDriveType(string rootPath);

#endregion

...

DriveType driveType = GetDriveType("C:\\");

Console.WriteLine("Drive {0} is type {1}", "C:\\", driveType);

[C#/COMMON] PathCanonicalize API 함수 : 표준 경로 구하기

■ PathCanonicalize API 함수를 사용해 표준 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Runtime.InteropServices;
using System.Text;

#region 표준 경로 구하기 - PathCanonicalize(targetPathStringBuilder, sourcePath)

/// <summary>
/// 표준 경로 구하기
/// </summary>
/// <param name="targetPathStringBuilder">타겟 경로 StringBuilder</param>
/// <param name="sourcePath">소스 경로</param>
/// <returns>처리 결과</returns>
[DllImport("shlwapi.dll", CharSet = CharSet.Auto)]
public static extern int PathCanonicalize([Out] StringBuilder targetPathStringBuilder, string sourcePath);

#endregion

...

string        sourcePath              = @"c:\windows\system32\drivers\..\notepad.exe";
StringBuilder targetPathStringBuilder = new StringBuilder();

PathCanonicalize(targetPathStringBuilder, sourcePath);

Console.WriteLine(targetPathStringBuilder.ToString());

using System.Runtime.InteropServices;

using System.Text;

#region 표준 경로 구하기 - PathCanonicalize(targetPathStringBuilder, sourcePath)

/// <summary>

/// 표준 경로 구하기

/// </summary>

/// <param name="targetPathStringBuilder">타겟 경로 StringBuilder</param>

/// <param name="sourcePath">소스 경로</param>

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

[DllImport("shlwapi.dll", CharSet = CharSet.Auto)]

public static extern int PathCanonicalize([Out] StringBuilder targetPathStringBuilder, string sourcePath);

#endregion

...

string sourcePath = @"c:\windows\system32\drivers\..\notepad.exe";

StringBuilder targetPathStringBuilder = new StringBuilder();

PathCanonicalize(targetPathStringBuilder, sourcePath);

Console.WriteLine(targetPathStringBuilder.ToString());

※ 'c:\windows\system32\drivers\..\notepad.exe' → 'c:\windows\system32\notepad.exe' 값이 변환될 것으로

[C#/COMMON] Directory 클래스 : GetLogicalDrives 정적 메소드를 사용해 논리적 드라이브명 배열 구하기

■ Directory 클래스의 GetLogicalDrives 정적 메소드를 사용해 논리적 드라이브명 배열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 논리 드라이브명 배열 구하기 - GetLogicalDriveNameArray()

/// <summary>
/// 논리 드라이브명 배열 구하기
/// </summary>
/// <returns>논리 드라이브명 배열</returns>
public string[] GetLogicalDriveNameArray()
{
    return Directory.GetLogicalDrives();
}

#endregion

using System.IO;

#region 논리 드라이브명 배열 구하기 - GetLogicalDriveNameArray()

/// <summary>

/// 논리 드라이브명 배열 구하기

/// </summary>

/// <returns>논리 드라이브명 배열</returns>

public string[] GetLogicalDriveNameArray()

{

return Directory.GetLogicalDrives();

}

#endregion

[C#/COMMON] Directory 클래스 : 자식 디렉토리 경로 배열 구하기

■ Directory 클래스를 사용해 자식 디렉토리 경로 배열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 자식 디렉토리 경로 배열 구하기 - GetDirectoryPathArray(directoryPath)

/// <summary>
/// 자식 디렉토리 경로 배열 구하기
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <returns>자식 디렉토리 경로 배열</returns>
public string[] GetDirectoryPathArray(string directoryPath)
{
    return Directory.GetDirectories(directoryPath);
}

#endregion

using System.IO;

#region 자식 디렉토리 경로 배열 구하기 - GetDirectoryPathArray(directoryPath)

/// <summary>

/// 자식 디렉토리 경로 배열 구하기

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>자식 디렉토리 경로 배열</returns>

public string[] GetDirectoryPathArray(string directoryPath)

{

return Directory.GetDirectories(directoryPath);

}

#endregion

[C#/COMMON] Directory 클래스 : 파일 경로 배열 구하기

■ Directory 클래스를 사용해 파일 경로 배열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일 경로 배열 구하기 - GetFilePathArray(directoryPath)

/// <summary>
/// 파일 경로 배열 구하기
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <returns>파일 경로 배열</returns>
public string[] GetFilePathArray(string directoryPath)
{
    return Directory.GetFiles(directoryPath);
}

#endregion

using System.IO;

#region 파일 경로 배열 구하기 - GetFilePathArray(directoryPath)

/// <summary>

/// 파일 경로 배열 구하기

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>파일 경로 배열</returns>

public string[] GetFilePathArray(string directoryPath)

{

return Directory.GetFiles(directoryPath);

}

#endregion

[C#/COMMON] DirectoryInfo 클래스 : Name 속성을 사용해 디렉토리명 구하기

■ DirectoryInfo 클래스의 Name 속성을 사용해 디렉토리명을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 디렉토리명 구하기 - GetDirectoryName(directoryPath)

/// <summary>
/// 디렉토리명 구하기
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <returns>디렉토리명</returns>
public string GetDirectoryName(string directoryPath)
{
    return new DirectoryInfo(directoryPath).Name;
}

#endregion

using System.IO;

#region 디렉토리명 구하기 - GetDirectoryName(directoryPath)

/// <summary>

/// 디렉토리명 구하기

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <returns>디렉토리명</returns>

public string GetDirectoryName(string directoryPath)

{

return new DirectoryInfo(directoryPath).Name;

}

#endregion

[C#/COMMON] FileInfo 클래스 : Name 속성을 사용해 파일명 구하기

■ FileInfo 클래스의 Name 속성을 사용해 파일명을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일명 구하기 - GetFileName(filePath)

/// <summary>
/// 파일명 구하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>파일명</returns>
public string GetFileName(string filePath)
{
    return new FileInfo(filePath).Name;
}

#endregion

using System.IO;

#region 파일명 구하기 - GetFileName(filePath)

/// <summary>

/// 파일명 구하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>파일명</returns>

public string GetFileName(string filePath)

{

return new FileInfo(filePath).Name;

}

#endregion

[C#/COMMON] File 클래스 : GetLastWriteTime 정적 메소드를 사용해 기한 만기 파일 삭제하기

■ File 클래스의 GetLastWriteTime 정적 메소드를 사용해 기한 만기 파일을 삭제하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.IO;

#region 기한 만기 파일 삭제하기 - DeleteExpiredFile(filePath, expiredDayCount)

/// <summary>
/// 기한 만기 파일 삭제하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <param name="expiredDayCount">기한 만기 일 수</param>
public void DeleteExpiredFile(string filePath, int expiredDayCount)
{
    DateTime fileDate = File.GetLastWriteTime(filePath);

    int dayCount = (DateTime.Now.Year - fileDate.Year) * 365;

    dayCount += DateTime.Now.DayOfYear - fileDate.DayOfYear;

    if(dayCount > expiredDayCount)
    {
        File.Delete(filePath);
    }
}

#endregion

using System;

using System.IO;

#region 기한 만기 파일 삭제하기 - DeleteExpiredFile(filePath, expiredDayCount)

/// <summary>

/// 기한 만기 파일 삭제하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <param name="expiredDayCount">기한 만기 일 수</param>

public void DeleteExpiredFile(string filePath, int expiredDayCount)

{

DateTime fileDate = File.GetLastWriteTime(filePath);

int dayCount = (DateTime.Now.Year - fileDate.Year) * 365;

dayCount += DateTime.Now.DayOfYear - fileDate.DayOfYear;

if(dayCount > expiredDayCount)

{

File.Delete(filePath);

}

#endregion

[C#/COMMON] FileInfo 클래스 : Length 속성을 사용해 파일 크기 구하기

■ FileInfo 클래스의 Length 속성을 사용해 파일 크기를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 파일 크기 구하기 - GetFileSize(filePath)

/// <summary>
/// 파일 크기 구하기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>파일 크기</returns>
public long GetFileSize(string filePath)
{
    return new FileInfo(filePath).Length;
}

#endregion

using System.IO;

#region 파일 크기 구하기 - GetFileSize(filePath)

/// <summary>

/// 파일 크기 구하기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>파일 크기</returns>

public long GetFileSize(string filePath)

{

return new FileInfo(filePath).Length;

}

#endregion

[C#/COMMON] DriveInfo 클래스 : GetDrives 정적 메소드를 사용해 논리적 드라이브 정보 표시하기

■ DriveInfo 클래스 : GetDrives 정적 메소드를 사용해 논리적 드라이브 정보 표시하기 ———————————————————————————————————————— using System; using System.IO; #region 모든 드라이브 정보 표시하기

[C#/COMMON] FileSystem 클래스 : DeleteFile 정적 메소드를 사용해 휴지통으로 파일 보내기

■ FileSystem 클래스의 DeleteFile 정적 메소드를 사용해 휴지통으로 파일을 보내는 방법을 보여준다. ▶ 예제 코드 (C#)


using Microsoft.VisualBasic.FileIO;

#region 휴지통으로 파일 보내기 - SendFileToWastebasket(filePath, showConfirmDialog)

/// <summary>
/// 휴지통으로 파일 보내기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <param name="showConfirmDialog">확인 대화 상자 표시 여부</param>
/// <returns>처리 결과</returns>
public static bool SendFileToWastebasket(string filePath, bool showConfirmDialog)
{
    try
    {
        FileSystem.DeleteFile
        (
            filePath,
            showConfirmDialog ? UIOption.AllDialogs : UIOption.OnlyErrorDialogs,
            RecycleOption.SendToRecycleBin
        );

        return true;
    }
    catch
    {
        return false;
    }
}

#endregion

using Microsoft.VisualBasic.FileIO;

#region 휴지통으로 파일 보내기 - SendFileToWastebasket(filePath, showConfirmDialog)

/// <summary>

/// 휴지통으로 파일 보내기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <param name="showConfirmDialog">확인 대화 상자 표시 여부</param>

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

public static bool SendFileToWastebasket(string filePath, bool showConfirmDialog)

{

try

{

FileSystem.DeleteFile

(

filePath,

showConfirmDialog ? UIOption.AllDialogs : UIOption.OnlyErrorDialogs,

RecycleOption.SendToRecycleBin

);

return true;

}

catch

{

return false;

}

#endregion

[C#/COMMON] FileSystem 클래스 : DeleteDirectory 정적 메소드를 사용해 휴지통으로 디렉토리 보내기

■ FileSystem 클래스의 DeleteDirectory 정적 메소드를 사용해 휴지통으로 디렉토리를 보내는 방법을 보여준다. ▶ 예제 코드 (C#)


using Microsoft.VisualBasic.FileIO;

#region 휴지통으로 디렉토리 보내기 - SendDirectoryToWastebasket(directoryPath, showConfirmDialog)

/// <summary>
/// 휴지통으로 디렉토리 보내기
/// </summary>
/// <param name="directoryPath">디렉토리 경로</param>
/// <param name="showConfirmDialog">확인 대화 상자 표시 여부</param>
/// <returns>처리 결과</returns>
public bool SendDirectoryToWastebasket(string directoryPath, bool showConfirmDialog)
{
    try
    {
        FileSystem.DeleteDirectory
        (
            directoryPath,
            showConfirmDialog ? UIOption.AllDialogs : UIOption.OnlyErrorDialogs,
            RecycleOption.SendToRecycleBin,
            UICancelOption.DoNothing
        );

        return true;
    }
    catch
    {
        return false;
    }
}

#endregion

using Microsoft.VisualBasic.FileIO;

#region 휴지통으로 디렉토리 보내기 - SendDirectoryToWastebasket(directoryPath, showConfirmDialog)

/// <summary>

/// 휴지통으로 디렉토리 보내기

/// </summary>

/// <param name="directoryPath">디렉토리 경로</param>

/// <param name="showConfirmDialog">확인 대화 상자 표시 여부</param>

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

public bool SendDirectoryToWastebasket(string directoryPath, bool showConfirmDialog)

{

try

{

FileSystem.DeleteDirectory

(

directoryPath,

showConfirmDialog ? UIOption.AllDialogs : UIOption.OnlyErrorDialogs,

RecycleOption.SendToRecycleBin,

UICancelOption.DoNothing

);

return true;

}

catch

{

return false;

}

#endregion

[C#/COMMON] 텍스트 파일 읽기

■ 텍스트 파일을 읽는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 텍스트 파일 읽기 - ReadTextFile(filePath)

/// <summary>
/// 텍스트 파일 읽기
/// </summary>
/// <param name="filePath">파일 경로</param>
/// <returns>텍스트 파일</returns>
public string ReadTextFile(string filePath)
{
    StreamReader streamReader = null;
    string       fileData     = null;

    try
    {
        streamReader = new StreamReader(filePath);

        fileData = streamReader.ReadToEnd();
    }
    finally
    {
        if(streamReader != null)
        {
            streamReader.Close();

            streamReader.Dispose();

            streamReader = null;
        }
    }

    return fileData;
}

#endregion

using System.IO;

#region 텍스트 파일 읽기 - ReadTextFile(filePath)

/// <summary>

/// 텍스트 파일 읽기

/// </summary>

/// <param name="filePath">파일 경로</param>

/// <returns>텍스트 파일</returns>

public string ReadTextFile(string filePath)

{

StreamReader streamReader = null;

string fileData = null;

try

{

streamReader = new StreamReader(filePath);

fileData = streamReader.ReadToEnd();

}

finally

{

if(streamReader != null)

{

streamReader.Close();

streamReader.Dispose();

streamReader = null;

}

return fileData;

}

#endregion

[C#/COMMON] 바이트 배열 구하기

■ 바이트 배열을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.IO;

#region 바이트 배열 구하기 - GetByteArray(sourceStream)

/// <summary>
/// 바이트 배열 구하기
/// </summary>
/// <param name="sourceStream">소스 스트림</param>
/// <returns>바이트 배열</returns>
public byte[] GetByteArray(Stream sourceStream)
{
    try
    {
        using(MemoryStream memoryStream = new MemoryStream())
        {
            if(Write(sourceStream, memoryStream) == -1L)
            {
                return null;
            }

            return memoryStream.ToArray();
        }
    }
    catch
    {
        return null;
    }
}

#endregion

using System.IO;

#region 바이트 배열 구하기 - GetByteArray(sourceStream)

/// <summary>

/// 바이트 배열 구하기

/// </summary>

/// <param name="sourceStream">소스 스트림</param>

/// <returns>바이트 배열</returns>

public byte[] GetByteArray(Stream sourceStream)

{

try

{

using(MemoryStream memoryStream = new MemoryStream())

{

if(Write(sourceStream, memoryStream) == -1L)

{

return null;

}

return memoryStream.ToArray();

}

catch

{

return null;

}

#endregion

[C#/WINFORM] Application 클래스 : StartupPath 정적 속성을 사용해 애플리케이션 실행 경로 구하기

■ Application 클래스의 StartupPath 정적 속성을 사용해 애플리케이션 실행 경로를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System.Windows.Forms;

#region 애플리케이션 실행 경로 구하기 - GetApplicationExecutablePath()

/// <summary>
/// 애플리케이션 실행 경로 구하기
/// </summary>
/// <returns>애플리케이션 실행 경로</returns>
public string GetApplicationExecutablePath()
{
    return Application.StartupPath;
}

#endregion

using System.Windows.Forms;

#region 애플리케이션 실행 경로 구하기 - GetApplicationExecutablePath()

/// <summary>

/// 애플리케이션 실행 경로 구하기

/// </summary>

/// <returns>애플리케이션 실행 경로</returns>

public string GetApplicationExecutablePath()

{

return Application.StartupPath;

}

#endregion

[C#/COMMON] 논리적 볼륨 시리얼 번호 구하기

■ 논리적 볼륨 시리얼 번호를 구하는 방법을 보여준다. ▶ 논리적 볼륨 시리얼 번호 구하기 예제 (C#)


using System;

Console.WriteLine(GetLogicalVolumeSerialNumber("C"));

using System;

Console.WriteLine(GetLogicalVolumeSerialNumber("C"));

▶ 논리적 볼륨 시리얼 번호

[C#/COMMON] 물리적 볼륨 시리얼 번호 구하기

■ 물리적 볼륨 시리얼 번호를 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


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

#region 물리적 볼륨 시리얼 번호 리스트 구하기 - GetPhysicalVolumeSerialNumberList()

/// <summary>
/// 물리적 볼륨 시리얼 번호 리스트 구하기
/// </summary>
/// <returns>물리적 볼륨 시리얼 번호 리스트</returns>
public List<string> GetPhysicalVolumeSerialNumberList()
{
    List<string> list = new List<string>();

    ManagementScope managementScope = new ManagementScope( "\\\\" + Environment.MachineName + "\\root\\cimv2");

    SelectQuery selectQuery = new SelectQuery("SELECT * FROM Win32_PhysicalMedia");

    ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(managementScope, selectQuery);

    foreach(ManagementObject managementObject in managementObjectSearcher.Get())
    {
        foreach(PropertyData propertyData in managementObject.Properties)
        {
            if(propertyData.Value != null && propertyData.Name == "SerialNumber")
            {
                list.Add(propertyData.Value.ToString().Trim());
            }
        }
    }

    return list;
}

#endregion

using System;

using System.Collections.Generic;

using System.Management;

#region 물리적 볼륨 시리얼 번호 리스트 구하기 - GetPhysicalVolumeSerialNumberList()

/// <summary>

/// 물리적 볼륨 시리얼 번호 리스트 구하기

/// </summary>

/// <returns>물리적 볼륨 시리얼 번호 리스트</returns>

public List<string> GetPhysicalVolumeSerialNumberList()

{

List<string> list = new List<string>();

ManagementScope managementScope = new ManagementScope( "\\\\" + Environment.MachineName + "\\root\\cimv2");

SelectQuery selectQuery = new SelectQuery("SELECT * FROM Win32_PhysicalMedia");

ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(managementScope, selectQuery);

foreach(ManagementObject managementObject in managementObjectSearcher.Get())

{

foreach(PropertyData propertyData in managementObject.Properties)

{

if(propertyData.Value != null && propertyData.Name == "SerialNumber")

{

list.Add(propertyData.Value.ToString().Trim());

}

return list;

}

#endregion

[C#/COMMON] 하드 디스크 사용량 구하기

■ 하드 디스크 사용량을 구하는 방법을 보여준다. ▶ 예제 코드 (C#)


using System;
using System.Runtime.InteropServices;

[DllImport("kernel32", SetLastError = true, CharSet = CharSet.Auto)]
static extern bool GetDiskFreeSpaceEx
(
    string    directoryName     , // 디렉토리명
    out ulong userFreeByteCount , // 사용자 잔여 바이트 카운트
    out ulong userTotalByteCount, // 사용자 전체 바이트 카운트
    out ulong totalFreeByteCount  // 전체 잔여 바이트 카운트
);

string directory = "c:\\";
ulong  userFreeByteCount;
ulong  userTotalByteCount;
ulong  totalFreeByteCount;

GetDiskFreeSpaceEx(directory, out userFreeByteCount, out userTotalByteCount, out totalFreeByteCount);

Console.WriteLine(string.Format("전체 공간 : {0} 바이트", userTotalByteCount    ));
Console.WriteLine(string.Format("잔여 공간 : {0} 바이트", userAvailableByteCount));

using System;

using System.Runtime.InteropServices;

[DllImport("kernel32", SetLastError = true, CharSet = CharSet.Auto)]

static extern bool GetDiskFreeSpaceEx

(

string directoryName , // 디렉토리명

out ulong userFreeByteCount , // 사용자 잔여 바이트 카운트

out ulong userTotalByteCount, // 사용자 전체 바이트 카운트

out ulong totalFreeByteCount // 전체 잔여 바이트 카운트

);

string directory = "c:\\";

ulong userFreeByteCount;

ulong userTotalByteCount;

ulong totalFreeByteCount;

GetDiskFreeSpaceEx(directory, out userFreeByteCount, out userTotalByteCount, out totalFreeByteCount);

Console.WriteLine(string.Format("전체 공간 : {0} 바이트", userTotalByteCount ));

Console.WriteLine(string.Format("잔여 공간 : {0} 바이트", userAvailableByteCount));

[C#/COMMON] DirectoryInfo 클래스 : 디렉토리 삭제하기 (읽기 전용 파일까지 포함)

■ DirectoryInfo 클래스를 사용해 디렉토리를 삭제하는 방법을 보여준다. (읽기 전용 파일까지 포함) ▶ 예제 코드 (C#)


using System.IO;

#region 디렉토리 삭제하기 - DeleteDirectory(directoryPath)

/// <summary>
/// 디렉토리 삭제하기
/// </summary>
/// <param name="dicrectoryPath">디렉토리 경로</param>
/// <remarks>읽기 전용 파일까지 포함해 삭제한다.</remarks>
public void DeleteDirectory(string directoryPath)
{
    DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);

    if(directoryInfo.Exists)
    {
        foreach(DirectoryInfo subsidaryDirectoryInfo in directoryInfo.GetDirectories())
        {
            foreach(FileInfo fileInfo in subsidaryDirectoryInfo.GetFiles())
            {
                if((fileInfo.Attributes & FileAttributes.ReadOnly) > 0)
                {
                    fileInfo.Attributes = FileAttributes.Normal;
                }
            }
        }

        directoryInfo.Delete(true);
    }
}

#endregion

using System.IO;

#region 디렉토리 삭제하기 - DeleteDirectory(directoryPath)

/// <summary>

/// 디렉토리 삭제하기

/// </summary>

/// <param name="dicrectoryPath">디렉토리 경로</param>

/// <remarks>읽기 전용 파일까지 포함해 삭제한다.</remarks>

public void DeleteDirectory(string directoryPath)

{

DirectoryInfo directoryInfo = new DirectoryInfo(directoryPath);

if(directoryInfo.Exists)

{

foreach(DirectoryInfo subsidaryDirectoryInfo in directoryInfo.GetDirectories())

{

foreach(FileInfo fileInfo in subsidaryDirectoryInfo.GetFiles())

{

if((fileInfo.Attributes & FileAttributes.ReadOnly) > 0)

{

fileInfo.Attributes = FileAttributes.Normal;

}

directoryInfo.Delete(true);

}

#endregion