Q: What's the near-term roadmap for .NET tooling?
A: While tentative, here are some short term plans:
The first preview of Entity Framework Core (EF Core) 8 is available on NuGet today!
EF Core 8, or just EF8, is the successor to EF Core 7, and is scheduled for release in November 2023, at the same time as .NET 8.
EF8 currently targets .NET 6. This will likely be updated to .NET 8 as we near release.
EF8 will align with .NET 8 as a long-term support (LTS) release. See the .NET support policy for more information.
public class PostDto : BaseDto<PostDto, Post, long>
{
public string Title { get; set; }
public string Text { get; set; }
public int CategoryId { get; set; }
public string CategoryName { get; set; } //=> Category.Name
} public abstract class BaseDto<TDto, TEntity, TKey>
where TDto : class, new()
where TEntity : BaseEntity<TKey>, new()
{
[Display(Name = "ردیف")]
public TKey Id { get; set; }
public TEntity ToEntity()
{
return Mapper.Map<TEntity>(CastToDerivedClass(this));
}
public TEntity ToEntity(TEntity entity)
{
return Mapper.Map(CastToDerivedClass(this), entity);
}
public static TDto FromEntity(TEntity model)
{
return Mapper.Map<TDto>(model);
}
protected TDto CastToDerivedClass(BaseDto<TDto, TEntity, TKey> baseInstance)
{
return Mapper.Map<TDto>(baseInstance);
}
} public abstract class BaseEntity<TKey>
{
public TKey Id { get; set; }
}
public class Post : BaseEntity<long>
{
public string Title { get; set; }
public string Text { get; set; }
public int CatgeoryId { get; set; }
public Category Category { get; set; }
} var postDto = new PostDto(); var post = postDto.ToEntity();
var post = // finded by id var updatePost = postDto.ToEntity(post);
var postDto = PostDto.FromEntity(post);
public static class AutoMapperConfiguration
{
public static void InitializeAutoMapper()
{
Mapper.Initialize(configuration =>
{
configuration.ConfigureAutoMapperForDto();
});
//Compile mapping after configuration to boost map speed
Mapper.Configuration.CompileMappings();
}
public static void ConfigureAutoMapperForDto(this IMapperConfigurationExpression config)
{
config.ConfigureAutoMapperForDto(Assembly.GetEntryAssembly());
}
public static void ConfigureAutoMapperForDto(this IMapperConfigurationExpression config, params Assembly[] assemblies)
{
var dtoTypes = GetDtoTypes(assemblies);
var mappingTypes = dtoTypes
.Select(type =>
{
var arguments = type.BaseType.GetGenericArguments();
return new
{
DtoType = arguments[0],
EntityType = arguments[1]
};
}).ToList();
foreach (var mappingType in mappingTypes)
config.CreateMappingAndIgnoreUnmappedProperties(mappingType.EntityType, mappingType.DtoType);
}
public static void CreateMappingAndIgnoreUnmappedProperties(this IMapperConfigurationExpression config, Type entityType, Type dtoType)
{
var mappingExpression = config.CreateMap(entityType, dtoType).ReverseMap();
//Ignore mapping to any property of source (like Post.Categroy) that dose not contains in destination (like PostDto)
//To prevent from wrong mapping. for example in mapping of "PostDto -> Post", automapper create a new instance for Category (with null catgeoryName) because we have CategoryName property that has null value
foreach (var property in entityType.GetProperties())
{
if (dtoType.GetProperty(property.Name) == null)
mappingExpression.ForMember(property.Name, opt => opt.Ignore());
}
}
public static IEnumerable<Type> GetDtoTypes(params Assembly[] assemblies)
{
var allTypes = assemblies.SelectMany(a => a.ExportedTypes);
var dtoTypes = allTypes.Where(type =>
type.IsClass && !type.IsAbstract && type.BaseType != null && type.BaseType.IsGenericType &&
(type.BaseType.GetGenericTypeDefinition() == typeof(BaseDto<,>) ||
type.BaseType.GetGenericTypeDefinition() == typeof(BaseDto<,,>)));
return dtoTypes;
}
} public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
AutoMapperConfiguration.InitializeAutoMapper();
} public static IEnumerable<Type> GetDtoTypes(params Assembly[] assemblies)
{
var allTypes = assemblies.SelectMany(a => a.ExportedTypes);
var dtoTypes = allTypes.Where(type =>
type.IsClass && !type.IsAbstract && type.BaseType != null && type.BaseType.IsGenericType &&
(type.BaseType.GetGenericTypeDefinition() == typeof(BaseDto<,>) ||
type.BaseType.GetGenericTypeDefinition() == typeof(BaseDto<,,>)));
return dtoTypes;
} public static void ConfigureAutoMapperForDto(this IMapperConfigurationExpression config, params Assembly[] assemblies)
{
var dtoTypes = GetDtoTypes(assemblies);
var mappingTypes = dtoTypes
.Select(type =>
{
var arguments = type.BaseType.GetGenericArguments();
return new
{
DtoType = arguments[0],
EntityType = arguments[1]
};
}).ToList();
foreach (var mappingType in mappingTypes)
config.CreateMappingAndIgnoreUnmappedProperties(mappingType.EntityType, mappingType.DtoType);
} public static void CreateMappingAndIgnoreUnmappedProperties(this IMapperConfigurationExpression config, Type entityType, Type dtoType)
{
var mappingExpression = config.CreateMap(entityType, dtoType).ReverseMap();
//Ignore mapping to any property of entity (like Post.Categroy) that dose not contains in dto (like PostDto.CategoryName)
//To prevent from wrong mapping. for example in mapping of "PostDto -> Post", automapper create a new instance for Category (with null catgeoryName) because we have CategoryName property that has null value
foreach (var property in entityType.GetProperties())
{
if (dtoType.GetProperty(property.Name) == null)
mappingExpression.ForMember(property.Name, opt => opt.Ignore());
}
} 
ASP.NET Core Ditching .NET Framework, Will Be 'Part of .NET Core' Going Forward
برای پیاده سازی distributed tracing، می‌توانیم از ابزار متن باز و محبوب Jaeger (با تلفظ یِگِر) که ابتدا توسط شرکت Uber منتشر شد، استفاده کنیم. نحوه کارکرد Jaeger بصورت زیر می‌باشد:
ساده‌ترین روش برای راه‌اندازی Jager، استفاده از داکر ایمیج All in one که شامل ماژول های agent ، collector، query و ui است. پورت 6831 مربوط به agent و پورت 16686 مربوط به ui می‌باشد. برای جزئیات مربوط به ماژول‌های مختلف از این لینک استفاده کنید.
docker run -d -p 6831:6831/udp -p 6832:6832/udp -p 14268:14268 -p 14250:14250 -p 16686:16686 -p 5778:5778 --name jaeger jaegertracing/all-in-one:latest
بعد از اجرای دستور بالا، اطلاعات مربوط به سرویس‌ها و trace ها در ماژول Jager UI با آدرس http://localhost:16686 قابل مشاهده است.
جهت استفاده از Jaeger از پروژه تستی که شامل دو سرویس User و Gateway می‌باشد، استفاده میکنیم. در سرویس User، متد AddUser در صورت عدم وجود کاربر در دیتابیس، اطلاعات کاربر از گیت‌هاب را دریافت و در دیتابیس ذخیره میکند. سرویس Gateway از Ocelot برای مسیردهی درخواست‌ها استفاده میکند. برای آشنایی با ocelot این پست را مطالعه نمایید.
public async Task<ApiResult<Models.User>> AddUserAsync(string username)
{
var result = new ApiResult<Models.User>();
var user = await _applicationDbContext.Users.FirstOrDefaultAsync(x => x.Login == username);
if (user is null)
{
try
{
var url = string.Format(_appConfig.Github.ProfileUrl, username);
var apiResult = await _httpClient.GetStringAsync(url);
var userDto = JsonSerializer.Deserialize<UserDto>(apiResult);
user = _mapper.Map<Models.User>(userDto);
await _applicationDbContext.Users.AddAsync(user);
await _applicationDbContext.SaveChangesAsync();
result.Result = user;
result.Message = "User successfully Created";
return result;
}
catch (Exception e)
{
result.Message = "User not found";
return result;
}
}
result.Message = "User already exist";
result.Result = user;
return result;
}
برای ثبت Trace مربوط به درخواست‌ها در Jaeger ، بعد از نصب پکیج‌های Jaeger و OpenTracing.Contrib.NetCore در هر دو سرویس، در کانفیگ هریک از سرویس‌ها مورد زیر را اضافه میکنیم:
"JaegerConfig": {
"Host": "localhost",
"Port": 6831,
"IsEnabled": true,
"SamplingRate": 0.5
}
و برای اضافه شدن tracer به برنامه از متد الحاقی زیر استفاده میکنیم:
public static class Extensions
{
public static void AddJaeger(this IServiceCollection services, IConfiguration configuration)
{
var config = configuration.GetSection("JaegerConfig").Get<JaegerConfig>();
if (!(config?.IsEnabled ?? false))
return;
if (string.IsNullOrEmpty(config?.Host))
throw new Exception("invalid JaegerConfig");
services.AddSingleton<ITracer>(serviceProvider =>
{
string serviceName = Assembly.GetEntryAssembly()?.GetName().Name;
ILoggerFactory loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
var sampler = new ProbabilisticSampler(config.SamplingRate);
var reporter = new RemoteReporter.Builder()
.WithLoggerFactory(loggerFactory)
.WithSender(new UdpSender(config.Host, config.Port, 0))
.WithFlushInterval(TimeSpan.FromSeconds(15))
.WithMaxQueueSize(300)
.Build();
ITracer tracer = new Tracer.Builder(serviceName)
.WithLoggerFactory(loggerFactory)
.WithSampler(sampler)
.WithReporter(reporter)
.Build();
GlobalTracer.Register(tracer);
return tracer;
});
services.AddOpenTracing();
}
}
برای ثبت traceها استراتژی‌های متفاوتی وجود دارد. در اینجا از ProbabilisticSampler استفاده شده‌است که در سازنده‌ی آن می‌توان درصد ثبت Traceها را مقدار دهی کرد. در نهایت این متد الحاقی را در Startup اضافه میکنیم:
builder.Services.AddJaeger(builder.Configuration);
بعد از اجرای پروژه و فراخوانی https://localhost:6000/gateway/Users/Add ، سرویس Gateway، درخواست را به سرویس User ارسال میکند و این سرویس‌ها در Jaeger UI قابل مشاهده هستند.
جهت مشاهده trace ها ، سرویس مورد نظر را انتخاب و روی Find Traces کلیک کنید. با کلیک روی Trace مورد نظر، جزئیات فعالیت هایی مثل فراخوانی سرویس و مراجعه به دیتابیس قابل مشاهده است.
برای اضافه کردن لاگ سفارشی به یک span، می‌توان از اینترفیس ITracer استفاده کرد:
private readonly IUserService _userService;
private readonly ITracer _tracer;
public UsersController(IUserService userService, ITracer tracer)
{
_userService = userService;
_tracer = tracer;
} [HttpPost]
public async Task<ActionResult> AddUser(AddUserDto model)
{
var actionName = ControllerContext.ActionDescriptor.DisplayName;
using var scope = _tracer.BuildSpan(actionName).StartActive(true);
scope.Span.Log($"Add user log username: {model.Username}");
return Ok(await _userService.AddUserAsync(model.Username));
}
کدهای مربوط به این مطلب در اینجا قابل دسترسی است.
QueryableExtensions: AllAsync AnyAsync AverageAsync ContainsAsync CountAsync FirstAsync FirstOrDefaultAsync ForEachAsync LoadAsync LongCountAsync MaxAsync MinAsync SingleAsync SingleOrDefaultAsync SumAsync ToArrayAsync ToDictionaryAsync ToListAsync DbSet: FindAsync DbContext: SaveChangesAsync Database: ExecuteSqlCommandAsync
public class User
{
public int Id { get; set; }
public string Name { get; set; }
public virtual ICollection<BlogPost> BlogPosts { get; set; }
}
public class BlogPost
{
public int Id { get; set; }
public string Title { get; set; }
public string Content { get; set; }
[ForeignKey("UserId")]
public virtual User User { get; set; }
public int UserId { get; set; }
} public class MyContext : DbContext
{
public DbSet<User> Users { get; set; }
public DbSet<BlogPost> BlogPosts { get; set; }
public MyContext()
: base("Connection1")
{
this.Database.Log = sql => Console.Write(sql);
}
} private async Task<User> addUserAsync(CancellationToken cancellationToken = default(CancellationToken))
{
using (var context = new MyContext())
{
var user = context.Users.Add(new User
{
Name = "Vahid"
});
context.BlogPosts.Add(new BlogPost
{
Content = "Test",
Title = "Test",
User = user
});
await context.SaveChangesAsync(cancellationToken);
return user;
}
} [AsyncTimeout(8000)] public async Task<ActionResult> Index(CancellationToken cancellationToken)
var user = await addUserAsync();
Console.WriteLine("user id: {0}", user.Id);
private async Task<User> updateAsync(CancellationToken cancellationToken = default(CancellationToken))
{
using (var context = new MyContext())
{
var user1 = await context.Users.FindAsync(cancellationToken, 1);
if (user1 != null)
user1.Name = "Vahid N.";
await context.SaveChangesAsync(cancellationToken);
return user1;
}
}
private async Task<int> deleteAsync(CancellationToken cancellationToken = default(CancellationToken))
{
using (var context = new MyContext())
{
var user1 = await context.Users.FindAsync(cancellationToken, 1);
if (user1 != null)
context.Users.Remove(user1);
return await context.SaveChangesAsync(cancellationToken);
}
} public async Task<List<TEntity>> GetAllAsync()
{
return await Task.Run(() => _tEntities.ToList());
} private async Task<List<User>> getUsersAsync(CancellationToken cancellationToken = default(CancellationToken))
{
using (var context = new MyContext())
{
return await context.Users.ToListAsync(cancellationToken);
}
} internal override async Task<long> ExecuteAsync( //... rowsAffected = await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); //...
var connectionString = "........";
var sql = @"......"";
var users = new List<User>();
using (var cnx = new SqlConnection(connectionString))
{
using (var cmd = new SqlCommand(sql, cnx))
{
await cnx.OpenAsync();
using (var reader = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection))
{
while (await reader.ReadAsync())
{
var user = new User
{
Id = reader.GetInt32(0),
Name = reader.GetString(1),
};
users.Add(user);
}
}
}
} // multiple operations
private static async Task loadAllAsync(CancellationToken cancellationToken = default(CancellationToken))
{
using (var context = new MyContext())
{
var task1 = context.Users.ToListAsync(cancellationToken);
var task2 = context.BlogPosts.ToListAsync(cancellationToken);
await Task.WhenAll(task1, task2);
// use task1.Result
}
} An unhandled exception of type 'System.NotSupportedException' occurred in mscorlib.dll Additional information: A second operation started on this context before a previous asynchronous operation completed. Use 'await' to ensure that any asynchronous operations have completed before calling another method on this context. Any instance members are not guaranteed to be thread safe.