Software Engineer / Developer

MongoDB를 C#에서 CRUD 형태로 조작해보는 간단한 샘플 예제이다. Visual Studio 2019에서 .NET Core 콘솔 프로젝트를 생성하고 Nuget에서 MongoDB.Driver 패키지를 추가한다.

대상 프레임워크는 3.1이며 Visual Studio 버전은 16.5.3이다.

BoardModel.cs

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

namespace ConsoleMongo
{
    //[BsonIgnoreExtraElements]
    public class BoardModel
    {
        [BsonId]
        // [BsonIgnoreIfDefault]
        [BsonElement("_id")]
        public ObjectId ID { get; set; }
        public string UserID { get; set; }
        public string UserName { get; set; }
        //[BsonElement("userkind")]
        public string UserKind { get; set; }
        public AddressModel Address { get; set; }
    }

    public class AddressModel
    {
        public string StreetAddress { get; set; }
        public string ZipCode { get; set; }
    }
}

[[more]]

MongoCRUD.cs

using MongoDB.Bson;
using MongoDB.Driver;
using System.Collections.Generic;

namespace ConsoleMongo
{
    public class MongoCRUD
    {
        private readonly IMongoDatabase db;

        public MongoCRUD()
        {
            var client = new MongoClient(@"mongodb://아이디:패스워드@192.168.1.33:27017/testdb");
            db = client.GetDatabase("testdb");
        }

        // insert
        public void InsertRecord<T>(string table, T record)
        {
            var collection = db.GetCollection<T>(table);
            collection.InsertOne(record);
        }

        // select list
        public List<T> LoadRecord<T>(string table)
        {
            var collection = db.GetCollection<T>(table);
            return collection.Find(new BsonDocument()).ToList();
        }

        // select one field
        public T LoadRecordById<T>(string table, string userID)
        {
            var collection = db.GetCollection<T>(table);
            var filter = Builders<T>.Filter.Eq("UserID", userID);
            return collection.Find(filter).First();
        }

        // insert, update
        public void UpsertRecord<T>(string table, ObjectId id, T record)
        {
            var collection = db.GetCollection<T>(table);
            collection.ReplaceOne(new BsonDocument("_id", id), record, new ReplaceOptions { IsUpsert = true });
        }

        // delete
        public void DeleteRecord<T>(string table, ObjectId id)
        {
            var collection = db.GetCollection<T>(table);
            var filter = Builders<T>.Filter.Eq("_id", id);
            collection.DeleteOne(filter);
        }
    }
}

Program.cs

using System;

namespace ConsoleMongo
{
    internal class Program
    {
        private static void Main()
        {
            MongoCRUD db = new MongoCRUD();

            // Insert One
            db.InsertRecord("board", new BoardModel { UserID = "1004", UserName = "가나닭", UserKind = "C" });

            // Insert Embedded Documents
            BoardModel board = new BoardModel
            {
                UserID = "1003",
                UserName = "홍길북",
                UserKind = "D",
                Address = new AddressModel
                {
                    StreetAddress = "서울특별시",
                    ZipCode = "12345"
                }
            };
            db.InsertRecord("board", board);

            // Upsert
            var upsertRec = db.LoadRecordById<BoardModel>("board", "1003");
            upsertRec.UserKind = "A";
            upsertRec.Address = new AddressModel
            {
                StreetAddress = "서울특별시",
                ZipCode = "12345"
            };
            db.UpsertRecord("board", upsertRec.ID, upsertRec);

            // Delete
            var deleteRec = db.LoadRecordById<BoardModel>("board", "1004");
            db.DeleteRecord<BoardModel>("board", deleteRec.ID);

            // Select list
            var recs = db.LoadRecord<BoardModel>("board");
            foreach (var item in recs)
            {
                Console.WriteLine($"{item.UserID}: {item.ID}, {item.UserName}, {item.UserKind}");
                if (item.Address != null)
                {
                    Console.WriteLine($"{item.Address.StreetAddress}, {item.Address.ZipCode}");
                }
            }

            // Select One Field (by UserID)
            var oneRec = db.LoadRecordById<BoardModel>("board", "1003");
            Console.WriteLine($"{oneRec.UserID}: {oneRec.ID}, {oneRec.UserName}, {oneRec.UserKind}");
            if (oneRec.Address != null)
            {
                Console.WriteLine($"{oneRec.Address.StreetAddress}, {oneRec.Address.ZipCode}");
            }
        }
    }
}

Sequence Field

db.counters.insert(
   {
      _id: "userid",
      seq: 0
   }
)

function getNextSequence(name) {
   var ret = db.counters.findAndModify(
          {
            query: { _id: name },
            update: { $inc: { seq: 1 } },
            new: true
          }
   );
   return ret.seq;
}

db.users.insert(
   {
     _id: getNextSequence("userid"),
     name: "Sarah C."
   }
)

// getDate
new Date().toLocaleDateString('ko-KR').replace('x', 'y')

// getDateString
function GetDate() {
    return new Date(+new Date() + 3240 * 10000).toISOString().replace("T", "").replace("Z", "").replace(/-/g, "").replace(/:/g, "").replace(/\./g, "") + Math.floor((Math.random() * (999 - 100) + 100));
}

Reference

• Learn what NoSQL is, why it is different than SQL and how to use it in C#
• MongoDB - C# insert, update, delete
• Create an Auto-Incrementing Sequence Field
• ASP.NET Core 및 MongoDB를 사용하여 웹 API 만들기
  • Create a CRUD repository using MongoDB and C#

Ξ 2020.04.12

Autofac is an IoC container for Microsoft .NET. It manages the dependencies between classes so that applications stay easy to change as they grow in size and complexity(GitHub-Autofac 2019).

Autofac is an addictive Inversion of Control container for .NET Core, ASP.NET Core, .NET 4.5.1+, Universal Windows apps, and more(autofac.org 2019).

닷넷 프레임워크를 사용하다 보면 의존성 주입이란 단어가 자주 등장한다. ASP.NET Core MVC, WPF MVVM 그리고 Caliburn.Micro에서 Ioc.Get<T>() 에서 DI를 사용하는 예를 볼 수 있는 데 이번 글에서는 일반적인 개발환경에서 DI를 자동으로 그리고 쉽게 사용할 수 있는 Autofac 패키지의 사용법을 간단하게 작성해보았다. 참고 : 일반적인 DI, Interface 사용법 보기

메인 프로그램

// Program.cs
using Autofac;
using System;

namespace ConsoleUI
{
    class Program
    {
        static void Main()
        {
            var container = ContainerConfig.Configure();

            using(var scope = container.BeginLifetimeScope())
            {
                var app = scope.Resolve<IApplication>();
                app.Execute();
            }

            Console.ReadLine();
        }
    }
}

[[more]]

// other Main
namespace ConsoleUI
{
    class Program
    {
        static void Main()
        {
            var container = BuildContainer();
            using(var scope = container.BeginLifetimeScope())
            {
               scope.Resolve<IApplication>().Run(); // Run()함수실행
            }
        }

        private static IContainer BuildContainer()
        {
            var builder =- new ContainderBuilder();
            builder.RegisterAssemblyTypes(Assembly.GetExcutingAssembly()).AsSelf().AsImplementedInterfaces();
            return builder.Build();
        }
    }
}

Autofac 설정 파일

// 인테페이스 연결
// ContainerConfig.cs
using Autofac;
using System.Linq;
using System.Reflection;

namespace ConsoleUI
{
    public static class ContainerConfig
    {
        public static IContainer Configure()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<Application>().As<IApplication>();

            //builder.RegisterType<DBHelper>().As<IDBHelper>();
            //DBHelper -> DBHelperOther로 간단하게 로직 변경
            builder.RegisterType<DBHelperOther>().As<IDBHelper>();

            //Services 폴더의 인테페이스 파일 자동등록
            builder.RegisterAssemblyTypes(Assembly.Load(nameof(ConsoleUI)))
                .Where(t => t.Namespace.Contains("Services"))
                .As(t => t.GetInterfaces().FirstOrDefault(i => i.Name == "I" + t.Name));

            return builder.Build();
        }
    }
}

Application 파일

// 메인프로그램에서 사용한다.
// Application.cs
namespace ConsoleUI
{
    public class Application : IApplication
    {
        private readonly IDBHelper _dbHelper;

        public Application(IDBHelper dbHelper)
        {
            _dbHelper = dbHelper;
        }

        public void Execute()
        {
            _dbHelper.ProcessDB();
        }
    }
}

// IApplication.cs
namespace ConsoleUI
{
    public interface IApplication
    {
        void Execute();
    }
}

DBHelper.cs

using ConsoleUI.Services;
using System;

namespace ConsoleUI
{
    public class DBHelper : IDBHelper
    {
        private readonly IDBConnection _dbConnection;
        private readonly ILogger _logger;

        public DBHelper(IDBConnection dbConnection, ILogger logger)
        {
            _logger = logger;
            _dbConnection = dbConnection;
        }

        public void ProcessDB()
        {
            _logger.Log("Starting DB...");
            Console.WriteLine("데이터 처리");
            _dbConnection.DBOpen("SQL Server");
            _dbConnection.DBClose();
            _logger.Log("Finished DB...");
        }
    }

    public class DBHelperOther : IDBHelper
    {
        private readonly IDBConnection _dbConnection;
        private readonly ILogger _logger;

        public DBHelperOther(IDBConnection dbConnection, ILogger logger)
        {
            _logger = logger;
            _dbConnection = dbConnection;
        }

        public void ProcessDB()
        {
            _logger.Log("Starting OtherDB...");
            Console.WriteLine("Other 데이터 처리");
            _dbConnection.DBOpen("Other Database");
            _dbConnection.DBClose();
            _logger.Log("Finished OtherDB...");
        }
    }
}

// IDBHelper.cs
namespace ConsoleUI
{
    public interface IDBHelper
    {
        void ProcessDB();
    }
}

기타 파일

// Services 폴더에 작성한다.
// DBConnection.cs
using System;

namespace ConsoleUI.Services
{
    class DBConnection : IDBConnection
    {
        public void DBOpen(string name)
        {
            Console.WriteLine($"Open Database - {name}");
        }

        public void DBClose()
        {
            Console.WriteLine("Close Database");
        }
    }
}

// IDBConnection.cs
namespace ConsoleUI.Services
{
    public interface IDBConnection
    {
        void DBOpen(string name);
        void DBClose();
    }
}

// Logger.cs
using System;

namespace ConsoleUI.Services
{
    public class Logger : ILogger
    {
        public void Log(string message)
        {
            Console.WriteLine($"Logging - {message}");
        }
    }
}

// ILogger.cs
namespace ConsoleUI.Services
{
    public interface ILogger
    {
        void Log(string message);
    }
}

Ξ 2019.09.23