Asp.Net MVC Solution Architecture project with Async Repository pattern by Service having Dependency Injection by Unity - Page 2
The entire Solution structure is shown in the snapshots below
Infrastructure
Domain
**
**
Presentation
Using the 'Entity Framework Power Tools Beta 4 (Visual Studios Extension)' we auto-generate the entity classes, mapper classes and the database context class, namely 'StarDesc.cs', 'StarDescMap.cs' and 'StarSystemContext.cs'.
StarDesc.cs
namespace CG.StarSystem.Data.Models
{
public partial class StarDesc
{
public int Id { get; set; }
public string StarName { get; set; }
public string StarSize { get; set; }
public string StarDistanceFromSun { get; set; }
public string StarGalaxyName { get; set; }
public string StarBrightness { get; set; }
public string SpectralType { get; set; }
}
}
StarDescMap.cs
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;
namespace CG.StarSystem.Data.Models.Mapping
{
public class StarDescMap : EntityTypeConfiguration<StarDesc>
{
public StarDescMap()
{
// Primary Key
this.HasKey(t => t.Id);
// Properties
this.Property(t => t.Id)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
this.Property(t => t.StarName)
.HasMaxLength(150);
this.Property(t => t.StarSize)
.HasMaxLength(50);
this.Property(t => t.StarDistanceFromSun)
.HasMaxLength(50);
this.Property(t => t.StarGalaxyName)
.HasMaxLength(50);
this.Property(t => t.StarBrightness)
.HasMaxLength(50);
this.Property(t => t.SpectralType)
.HasMaxLength(50);
// Table & Column Mappings
this.ToTable("StarDesc");
this.Property(t => t.Id).HasColumnName("Id");
this.Property(t => t.StarName).HasColumnName("StarName");
this.Property(t => t.StarSize).HasColumnName("StarSize");
this.Property(t => t.StarDistanceFromSun).HasColumnName("StarDistanceFromSun");
this.Property(t => t.StarGalaxyName).HasColumnName("StarGalaxyName");
this.Property(t => t.StarBrightness).HasColumnName("StarBrightness");
this.Property(t => t.SpectralType).HasColumnName("SpectralType");
}
}
}
StarSystemContext.cs
using System.Data.Entity;
using CG.StarSystem.Data.Models.Mapping;
namespace CG.StarSystem.Data.Models
{
public partial class StarSystemContext : DbContext
{
static StarSystemContext()
{
Database.SetInitializer<StarSystemContext>(null);
}
public StarSystemContext()
: base("Name=StarSystemContext")
{
// the terrible hack
var ensureDLLIsCopied =
System.Data.Entity.SqlServer.SqlProviderServices.Instance;
}
public DbSet<SpectralClassesSubType> SpectralClassesSubTypes { get; set; }
public DbSet<StarDesc> StarDescs { get; set; }
public DbSet<StarTypeByLuminosityClass> StarTypeByLuminosityClasses { get; set; }
public DbSet<StarTypeBySpectralClass> StarTypeBySpectralClasses { get; set; }
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Configurations.Add(new SpectralClassesSubTypeMap());
modelBuilder.Configurations.Add(new StarDescMap());
modelBuilder.Configurations.Add(new StarTypeByLuminosityClassMap());
modelBuilder.Configurations.Add(new StarTypeBySpectralClassMap());
}
}
}
IStarDescRepository.cs
using CG.StarSystem.Data.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace CG.StarSystem.Repository.StarDescs
{
public interface IStarDescRepository: IDisposable
{
Task<List<StarDesc>> GetStarDescsAsync();
Task<StarDesc> GetStarDescByIdAsync(int? id);
Task CreateStarAsync(StarDesc stardesc);
Task DeleteStarAsync(int? id);
Task EditStarDescAsync(StarDesc stardesc);
}
}
StarDescRepository.cs
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using CG.StarSystem.Data.Models;
using System.Data.Entity;
namespace CG.StarSystem.Repository.StarDescs
{
public class StarDescRepository : IStarDescRepository, IDisposable
{
private StarSystemContext _context;
/// <summary>
/// Create a new instance of <see cref="StarDescRepository" />.
/// </summary>
/// <param name="transaction">Active transaction</param>
/// <exception cref="ArgumentNullException">transaction</exception>
public StarDescRepository()
{
_context = new StarSystemContext();
}
public async Task<List<StarDesc>> GetStarDescsAsync()
{
return await _context.StarDescs.ToListAsync();
}
public async Task<StarDesc> GetStarDescByIdAsync(int? id)
{
return await _context.StarDescs.FindAsync(id);
}
public async Task CreateStarAsync(StarDesc stardesc)
{
_context.StarDescs.Add(stardesc);
await _context.SaveChangesAsync();
}
public async Task EditStarDescAsync(StarDesc stardesc)
{
_context.Entry(stardesc).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public async Task DeleteStarAsync(int? id)
{
StarDesc stardesc = await _context.StarDescs.FindAsync(id);
_context.StarDescs.Remove(stardesc);
await _context.SaveChangesAsync();
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_context.Dispose();
}
disposedValue = true;
}
}
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
}
}
IStarDescService.cs
using CG.StarSystem.Data.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace CG.StarSystem.ApplicationServices
{
public interface IStarDescService : IDisposable
{
Task<List<StarDesc>> GetAllStarsAsync();
Task<StarDesc> GetStarDescriptionByIdAsync(int? id);
Task AddStarAsync(StarDesc stardesc);
Task DeleteStarAsync(int? id);
Task EditStarDescAsync(StarDesc stardesc);
}
}
StarDescService.cs
using CG.StarSystem.Data.Models;
using CG.StarSystem.Repository.StarDescs;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace CG.StarSystem.ApplicationServices
{
public class StarDescService : IStarDescService, IDisposable
{
private readonly IStarDescRepository _StarDescRepository;
//public StarDescService(IStarDescRepository IStarDescRepository) {
// _IStarDescRepository = IStarDescRepository;
//}
public StarDescService()
{
_StarDescRepository = new StarDescRepository();
}
public async Task<List<StarDesc>> GetAllStarsAsync()
{
return await _StarDescRepository.GetStarDescsAsync();
}
public async Task<StarDesc> GetStarDescriptionByIdAsync(int? id)
{
return await _StarDescRepository.GetStarDescByIdAsync(id);
}
public async Task AddStarAsync(StarDesc stardesc)
{
await _StarDescRepository.CreateStarAsync(stardesc);
}
public async Task DeleteStarAsync(int? id)
{
await _StarDescRepository.DeleteStarAsync(id);
}
public async Task EditStarDescAsync(StarDesc stardesc)
{
await _StarDescRepository.EditStarDescAsync(stardesc);
}
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_StarDescRepository.Dispose();
}
disposedValue = true;
}
}
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
#endregion
}
}