In short, we’re making Xamarin’s cross-platform tools available in
Visual Studio, from Community up through Enterprise at no additional
cost and we’re open-sourcing the Xamarin SDK – the core of the Xamarin
toolchain. In addition, we’re making Xamarin’s services (for example,
Test Cloud and Xamarin University) available along with the existing
Microsoft mobile DevOps capabilities.
https://blog.xamarin.com/xamarin-for-all/?utm_medium=social&utm_campaign=blog&utm_source=twitter&utm_content=xamarin-for-all
Today, we are releasing the .NET March 2021 Updates. These updates contains reliability and security improvements. See the individual release notes for details on updated packages.
You can download 5.0.4 , 3.1.13, 2.1.26 versions for Windows, macOS, and Linux, for x86, x64, Arm32, and Arm64.
Ext.data.JsonP.request({
url: '@url',
params: {
apiKey: '1234'
},
callbackKey: 'myCallbackFn',
success: function(){
},
failure: function(){
},
scope: this
}); حال با همه این تفاسیر آیا این فریم ورک یک رویا برای هر توسعه دهنده وب خواهد بود؟
به طور قطع نه. با توجه به اصل واقع بینی! همواره به خاطر داشته باشید که
اگر این فریم ورک یک ابزار بی نقص و همه منظوره بود الآن مطمئنا صدها کتاب و
مستندات درباره آن نوشته شده بود و شاید شهرتی بس فراتر از این داشت.
کابوسی به نام ExtJs
Ext.Net چیست؟
Ext.Net یک پیاده سازی خاص از فریم ورک ExtJs است که برای توسعه پروژه‌های Asp.Net Web Forms و Asp.Net MVC طراحی شده است. تفاوت اصلی بین این دو محصول در نوع کدنویسی برای استفاده در پروژه‌های Asp.Net است. برای مثال در هنگام کار با Ext.Net و پروژه‌های MVC از آنجا که این محصول سازگاری کامل با موتور Razor دارد به راحتی می‌توانید به صورت سینتکس Razor صفحات خود را طراحی کنید.
مثال:
ExtJs
Ext.create('Ext.panel.Panel', {
title: 'Fit Layout',
width: 500,
height: 200,
items: {
title: 'Inner Panel',
html: 'Panel content',
bodyPadding: 10,
border: true
},
renderTo: Ext.getBody()
}); 
@(X.Panel()
.ID("ExpandablePanel")
.Title("Panel")
.Width(500)
.Height(300)
.Collapsible(true)
.Loader(X.ComponentLoader()
.Url(Url.Action("RenderChild"))
.Mode(LoadMode.Frame)
.DisableCaching(true)
.Params(new { containerId = "ExpandablePanel" })
.LoadMask(lm => lm.ShowMask = true)
)
.Listeners(l => {
l.Expand.Handler = "this.reload();";
l.Collapse.Handler = "this.clearContent();";
})
) 
using var dbContext = new MyDbContext(); var objectToDelete = await dbContext.Objects.FirstAsync(o => o.Id == id); dbContext.Objects.Remove(objectToDelete); await dbContext.SaveChangesAsync();
using var dbContext = new MyDbContext();
var objectToDelete = new MyObject { Id = id };
dbContext.Objects.Remove(objectToDelete);
await dbContext.SaveChangesAsync(); await dbContext.Objects.Where(x => x.Id == id).ExecuteDeleteAsync();
public class User
{
public int Id { get; set; }
public required string FirstName { get; set; }
public required string LastName { get; set; }
public virtual List<Book> Books { get; set; } = new();
public virtual Address? Address { get; set; }
}
public class Book
{
public int Id { get; set; }
public required string Type { get; set; }
public required string Name { get; set; }
public virtual User User { get; set; } = default!;
public int UserId { get; set; }
}
public class Address
{
public int Id { get; set; }
public required string Street { get; set; }
public virtual User User { get; set; } = default!;
public int UserId { get; set; }
} public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
{
}
public DbSet<User> Users { get; set; } = default!;
public DbSet<Book> Books { get; set; } = default!;
public DbSet<Address> Addresses { get; set; } = default!;
} context.Books.Where(book => book.Name.Contains("1")).ExecuteDelete(); DELETE FROM [b] FROM [Books] AS [b] WHERE [b].[Name] LIKE N'%1%'
context.Users.Where(user => user.Id <= 500).ExecuteDelete();
DELETE FROM [u] FROM [Users] AS [u] WHERE [u].[Id] <= 500 The DELETE statement conflicted with the REFERENCE constraint "FK_Books_Users_UserId". The conflict occurred in database "EF7BulkOperations", table "dbo.Books", column 'UserId'.
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
{
}
public DbSet<User> Users { get; set; } = default!;
public DbSet<Book> Books { get; set; } = default!;
public DbSet<Address> Addresses { get; set; } = default!;
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder
.Entity<User>()
.HasMany(user => user.Books)
.WithOne(book => book.User)
.OnDelete(DeleteBehavior.Cascade);
modelBuilder
.Entity<User>()
.HasOne(user => user.Address)
.WithOne(address => address.User)
.HasForeignKey<Address>(address => address.UserId)
.OnDelete(DeleteBehavior.Cascade);
}
} context.Users.Where(user => user.Id <= 400) .ExecuteUpdate(p => p.SetProperty(user => user.LastName, user => "Updated"));
UPDATE [u] SET [u].[LastName] = N'Updated' FROM [Users] AS [u] WHERE [u].[Id] <= 400
context.Users.Where(user => user.Id <= 300)
.ExecuteUpdate(p => p.SetProperty(user => user.LastName,
user => "Updated" + user.LastName)); UPDATE [u] SET [u].[LastName] = N'Updated' + [u].[LastName] FROM [Users] AS [u] WHERE [u].[Id] <= 300
context.Users.Where(user => user.Id <= 800)
.ExecuteUpdate(p => p.SetProperty(user => user.LastName,
user => "Updated" + user.LastName)
.SetProperty(user => user.FirstName,
user => "Updated" + user.FirstName)); UPDATE [u] SET [u].[FirstName] = N'Updated' + [u].[FirstName], [u].[LastName] = N'Updated' + [u].[LastName] FROM [Users] AS [u] WHERE [u].[Id] <= 800
Here’s what’s new in this preview release:
dotnet watch foreignObject elementsAction and RenderFragment component parameters
endpoints.MapGet("/api/authors", async (MinimalBlogDbContext ctx) =>
{
var authors = await ctx.Authors.ToListAsync();
return authors;
});
endpoints.MapPost("/api/authors", async (MinimalBlogDbContext ctx, AuthorDto authorDto) =>
{
var author = new Author();
author.FirstName = authorDto.FirstName;
author.LastName = authorDto.LastName;
author.Bio = authorDto.Bio;
author.DateOfBirth = authorDto.DateOfBirth;
ctx.Authors.Add(author);
await ctx.SaveChangesAsync();
return author;
}); 
using MediatR;
using MinimalBlog.Domain.Model;
namespace MinimalBlog.Api.Features.Authors;
public class CreateAuthorCommand : IRequest<Author>
{
public AuthorDto AuthorDto { get; set; } = default!;
} public interface IRequest<out TResponse> : IBaseRequest
namespace MinimalBlog.Api.Features.Authors;
public class CreateAuthorCommandHandler : IRequestHandler<CreateAuthorCommand, Author>
{
private readonly MinimalBlogDbContext _context;
private readonly IMapper _mapper;
public CreateAuthorCommandHandler(MinimalBlogDbContext context, IMapper mapper)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public async Task<Author> Handle(CreateAuthorCommand request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var toAdd = _mapper.Map<Author>(request.AuthorDto);
_context.Authors.Add(toAdd);
await _context.SaveChangesAsync(cancellationToken);
return toAdd;
}
} public interface IRequestHandler<in TRequest, TResponse> where TRequest : IRequest<TResponse>
endpoints.MapPost("/api/authors", async (IMediator mediator, AuthorDto authorDto) =>
{
var command = new CreateAuthorCommand { AuthorDto = authorDto };
var author = await mediator.Send(command);
return author;
}); 
endpoints.MapGet("/api/authors", async (IMediator mediator, CancellationToken ct) =>
{
var request = new GetAllAuthorsQuery();
var authors = await mediator.Send(request, ct);
return authors;
}); public class Handler : IRequestHandler<Command>
public interface IRequestHandler<in TRequest> : IRequestHandler<TRequest, Unit> where TRequest : IRequest<Unit>
public async Task<Unit> Handle(Command request, CancellationToken cancellationToken)
{
// ...
return Unit.Value;
} public class Command : IRequest
using MediatR;
using MinimalBlog.Domain.Model;
namespace MinimalBlog.Api.Features.Authors;
public class GetAllAuthorsQuery : IRequest<List<Author>>
{
} namespace MinimalBlog.Api.Features.Authors;
public class GetAllAuthorsHandler : IRequestHandler<GetAllAuthorsQuery, List<Author>>
{
private readonly MinimalBlogDbContext _context;
public GetAllAuthorsHandler(MinimalBlogDbContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
public Task<List<Author>> Handle(GetAllAuthorsQuery request, CancellationToken cancellationToken)
{
return _context.Authors.ToListAsync(cancellationToken);
}
} endpoints.MapGet("/api/authors", async (IMediator mediator) =>
{
var request = new GetAllAuthorsQuery();
var authors = await mediator.Send(request);
return authors;
}); 
public static class CreateAuthor
{
public class Command : IRequest<AuthorGetDto>
{
// ...
}
public class Handler : IRequestHandler<Command, AuthorGetDto>
{
// ...
}
} var command = new CreateAuthor.Command { AuthorDto = authorDto };
var author = await mediator.Send(command, ct); public static class GetAllAuthors
{
public class Query : IRequest<List<AuthorGetDto>>
{
//...
}
public class Handler : IRequestHandler<Query, List<AuthorGetDto>>
{
//...
}
}