MongoDB compass

MongoDB UI 管理 

MongoDB Compass Download (GUI) | MongoDB 下载

 

mongo IP:端口/数据库名 -u 用户名 -p 密码
192.168.0.168:27017/test -u admin -p 123456

.net 项目

 

.net 连接 

mongodb://localhost:27017

mongodb://用户名:密码@IP:端口号

mongodb://admin:123456@192.168.0.196:27017

.net nuget下载 MongoDB.Driver

以下 是console测试项目

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using MongoDB.Driver;
using PoemGame.Domain.GameAggregate;
using PoemGame.Domain.PlayerAggregate;
using PoemGame.Repository.MongoDb.Test;
using PoemGame.Repository.MongoDB;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class Utility
    {
        public static IConfigurationRoot GetConfiguration()
        {
            IConfigurationBuilder builder = new ConfigurationBuilder();
            builder.SetBasePath(AppDomain.CurrentDomain.BaseDirectory);
            builder.AddJsonFile("appsettings.json", true, true);
            return builder.Build();
        }
        public static IMongoDatabase GetDb(IConfigurationRoot configuration)
        {
            MongoDbConnection dbConnection = new MongoDbConnection();
            configuration.Bind("MongoDbConnection", dbConnection);
            MongoClient mongoClient = new MongoClient(dbConnection.Connection);
            return mongoClient.GetDatabase(dbConnection.DbName);
        }


        public static IServiceProvider GetService()
        {
            IConfigurationRoot config = GetConfiguration();
            IServiceCollection collection = new ServiceCollection();
            collection.AddScoped<IMongoDatabase>(sp => GetDb(config));
            collection
                .AddScoped<IGameRepository, GameRepository>()
                .AddScoped<IPlayerRepository, PlayerRepository>();
            return collection.BuildServiceProvider();
        }
    }
}

　　

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PoemGame.Repository.MongoDb.Test
{
    public class MongoDbConnection
    {
        public string Connection { get; set; }
        public string DbName { get; set; }
    }
}

　　

appsettings.json

{
  "MongoDbConnection": {
    "Connection": "mongodb://admin:123456@192.168.0.196:27017",
    "DbName": "poemgame"
  }
}

 

// See https://aka.ms/new-console-template for more information
using ConsoleApp1;
using Microsoft.Extensions.DependencyInjection;
using PoemGame.Domain.PlayerAggregate;

Console.WriteLine("Hello, World!");
IPlayerRepository repository = Utility.GetService().GetService<IPlayerRepository>();

var list = await repository.GetAllAsync();
foreach (var item in list)
{
    Console.WriteLine(item.UserName);
}

　　

以下是仓储实现项目

using MongoDB.Driver;
using MongoDB.Driver.Linq;
using PoemGame.Domain.GameAggregate;
using PoemGame.Domain.PlayerAggregate;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace PoemGame.Repository.MongoDB
{
    public class GameRepository : IGameRepository
    {
        private readonly IMongoDatabase mongoDatabase;

        public GameRepository(IMongoDatabase mongoDatabase)
        {
            this.mongoDatabase = mongoDatabase;
        }

        public async Task<Guid> AddAsync(Game game)
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            await collection.InsertOneAsync(game);
            return game.Id;
        }

        public async Task<IEnumerable<Game>> GetAllAsync()
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            return await collection.AsQueryable().ToListAsync();
        }

        public async Task<Game?> GetAsync(Guid id)
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            return await collection.FindAsync<Game>(x => x.Id == id).Result.FirstOrDefaultAsync();
        }

        public async Task<IEnumerable<Game>> GetByConditionAsync(Expression<Func<Game, bool>> predicate)
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            return await collection.AsQueryable().Where<Game>(predicate).ToListAsync();
        }

        public async Task RemoveAsync(Game game)
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            await collection.DeleteOneAsync(filter => filter.Id == game.Id);
        }

        public async Task UpdateAsync(Game game)
        {
            var collection = this.mongoDatabase.GetCollection<Game>(nameof(Game));
            await collection.ReplaceOneAsync(filter => filter.Id == game.Id,game);
        }
    }
}

　　

using MongoDB.Driver;
using MongoDB.Driver.Linq;
using PoemGame.Domain.GameAggregate;
using PoemGame.Domain.PlayerAggregate;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace PoemGame.Repository.MongoDB
{
    public class PlayerRepository : IPlayerRepository
    {
        private readonly IMongoDatabase mongoDatabase;

        public PlayerRepository(IMongoDatabase mongoDatabase)
        {
            this.mongoDatabase = mongoDatabase;
        }
        public async Task<Guid> AddAsync(Player player)
        {
            var collection = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            await collection.InsertOneAsync(player);
            return player.Id;

        }

        public async Task<IEnumerable<Player>> GetAllAsync()
        {
            var collection = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            return await collection.AsQueryable().ToListAsync();

        }
        public async Task<IEnumerable<Player>> GetByConditionAsync(Expression<Func<Player, bool>> predicate)
        {
            IMongoCollection<Player> colTemp = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            return await colTemp.AsQueryable().Where(predicate).ToListAsync();
        }

        public async Task<Player?> GetPlayerByIdAsync(Guid id)
        {
            IMongoCollection<Player> colTemp = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            return await colTemp.Find(item => item.Id == id).FirstOrDefaultAsync();
        }

        public async Task<Player?> GetPlayerByUserNameAsync(string username)
        {
            IMongoCollection<Player> colTemp = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            return await colTemp.Find(item => item.UserName == username).FirstOrDefaultAsync();
        }

        public async Task RemoveAsync(Player player)
        {
            await this.mongoDatabase.GetCollection<Player>(nameof(Player)).DeleteOneAsync(item => item.Id == player.Id);
        }

        public async Task UpdateAsync(Player player)
        {
            IMongoCollection<Player> colTemp = this.mongoDatabase.GetCollection<Player>(nameof(Player));
            await colTemp.ReplaceOneAsync(item => item.Id == player.Id, player);
        }
    }
}