This page describes how to use the Microsoft.CodeAnalysis.Metrics package to perform source code analysis of .NET assemblies from a console application. Visual Studio users can perform source code analysis by clicking the "Analyze" dropdown menu and selecting "Calculate Code Metrics", but I sought to automate this process so I can generate custom code analysis reports from console applications as part of my CI pipeline.
db.Entry(message).State = EntityState.Added; db.SaveChanges();
try
{
// Your code...
// Could also be before try if you know the exception occurs in SaveChanges
context.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
} The main change in this release is a security fix, and it’s possible you
will need to change your own code to adapt. Here’s why: jQuery used a
regex in its jQuery.htmlPrefilter
method to ensure that all closing tags were XHTML-compliant when passed
to methods. For example, this prefilter ensured that a call like jQuery("<div class='hot' />") is actually converted to jQuery("<div class='hot'></div>"). Recently, an issue was reported that demonstrated the regex could introduce a cross-site scripting (XSS) vulnerability.
public class Service
{
public int ServiceId { get; set; }
public string ServiceName { get; set; }
} public interface ICoreService
{
Service LoadDefaultService();
} An unhandled exception occurred while processing the request InvalidOperationException: Unable to resolve service for type 'WebApplication1.Models.ICoreService' while attempting to activate 'WebApplication1.Controllers.HomeController' Microsoft.Extensions.Internal.ActivatorUtilities.GetService(IServiceProvider sp, Type type, Type requiredBy, Boolean isDefaultParameterRequired)
namespace Microsoft.Extensions.DependencyInjection
{
//
// Summary:
// Specifies the lifetime of a service in an Microsoft.Extensions.DependencyInjection.IServiceCollection.
public enum ServiceLifetime
{
//
// Summary:
// Specifies that a single instance of the service will be created.
Singleton = 0,
//
// Summary:
// Specifies that a new instance of the service will be created for each scope.
//
// Remarks:
// In ASP.NET Core applications a scope is created around each server request.
Scoped = 1,
//
// Summary:
// Specifies that a new instance of the service will be created every time it is
// requested.
Transient = 2
}
} public void ConfigureServices(IServiceCollection services)
{
ServiceDescriptor descriptor = new ServiceDescriptor(typeof(ICoreService),typeof(CoreServise),ServiceLifetime.Transient);
services.Add(descriptor);
services.AddMvc();
} 
ساخت یک Service Descriptor و اضافه کردن آن به سرویسها، فلسفه وجودی میان افزارها را زیر سوال می‌برد. پس بجای ایجاد یک Service Descriptor، از متدهای الحاقی تدارک دیده شده استفاده میکنیم. مثلا بجای دو خط کد بالا می‌توان از کد زیر استفاده نمود:
services.AddTransient<ICoreService,CoreServise>();
حال که یک دید کلی از نحوه کار مکانیزم تزریق وابستگی بدست آوردیم، میخواهیم این مکانیزم را با StructureMap جایگزین کنیم. بدین منظور ابتدا پکیج StructureMap را نصب میکنم.
در مرحله اول باید کلاسهایی را تدارک ببینیم که اینترفیس‌های بالا را پیاده سازی نمایند. یعنی کلاسهای ما باید بتوانند همان کاری را انجام دهند که مکانیزم پیش فرض MVC انجام می‌دهد.
اولین مورد، کلاس StructureMapServiceProvider می‌باشد.
internal class StructureMapServiceProvider : IServiceProvider
{
private readonly IContainer _container;
public StructureMapServiceProvider(IContainer container, bool scoped = false)
{
_container = container;
}
public object GetService(Type type)
{
try
{
return _container.GetInstance(type);
}
catch
{
return null;
}
}
} مورد دوم کلاس StructureMapServiceScope می‌باشد:
internal class StructureMapServiceScope : IServiceScope
{
private readonly IContainer _container;
private readonly IContainer _childContainer;
private IServiceProvider _provider;
public StructureMapServiceScope(IContainer container)
{
_container = container;
_childContainer = _container.GetNestedContainer();
_provider = new StructureMapServiceProvider(_childContainer, true);
}
public IServiceProvider ServiceProvider => _provider;
public void Dispose()
{
_provider = null;
if (_childContainer != null)
_childContainer.Dispose();
}
} مورد سوم StructureMapServiceScopeFactory می‌باشد:
internal class StructureMapServiceScopeFactory : IServiceScopeFactory
{
private IContainer _container;
public StructureMapServiceScopeFactory(IContainer container)
{
_container = container;
}
public IServiceScope CreateScope()
{
return new StructureMapServiceScope(_container);
}
} مورد بعدی کلاس StructureMapPopulator می‌باشد. وظیفه این کلاس جمع آوری اطلاعات مربوط به سرویسها می‌باشد.
internal class StructureMapPopulator
{
private IContainer _container;
public StructureMapPopulator(IContainer container)
{
_container = container;
}
public void Populate(IEnumerable<ServiceDescriptor> descriptors)
{
_container.Configure(c =>
{
c.For<IServiceProvider>().Use(new StructureMapServiceProvider(_container));
c.For<IServiceScopeFactory>().Use<StructureMapServiceScopeFactory>();
foreach (var descriptor in descriptors)
{
switch (descriptor.Lifetime)
{
case ServiceLifetime.Singleton:
Use(c.For(descriptor.ServiceType).Singleton(), descriptor);
break;
case ServiceLifetime.Transient:
Use(c.For(descriptor.ServiceType), descriptor);
break;
case ServiceLifetime.Scoped:
Use(c.For(descriptor.ServiceType), descriptor);
break;
}
}
});
}
private static void Use(GenericFamilyExpression expression, ServiceDescriptor descriptor)
{
if (descriptor.ImplementationFactory != null)
{
expression.Use(Guid.NewGuid().ToString(), context => { return descriptor.ImplementationFactory(context.GetInstance<IServiceProvider>()); });
}
else if (descriptor.ImplementationInstance != null)
{
expression.Use(descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationType != null)
{
expression.Use(descriptor.ImplementationType);
}
else
{
throw new InvalidOperationException("IServiceDescriptor is invalid");
}
}
} و در آخر کلاس StructureMapRegistration می‌باشد:
public static class StructureMapRegistration
{
public static void Populate(this IContainer container, IEnumerable<ServiceDescriptor> descriptors)
{
var populator = new StructureMapPopulator(container);
populator.Populate(descriptors);
}
} نهایتاً باید متد ConfigurationServices در کلاس StartUp را اندکی تغییر دهیم.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
services.AddMvc();
var container = new Container();
container.Configure(configure =>
{
configure.For<ICoreService>().Use<CoreServise>();
});
container.Populate(services);
return container.GetInstance<IServiceProvider>();
} در کد بالا، متد ConfigurationServices به جای آنکه Void برگرداند، نمونه‌ای از اینترفیس IServiceProvider را برمی‌گرداند. حال اگر برنامه را اجرا کنیم، وابستگی‌ها توسط StructureMap تزریق شده و برنامه بدون هیچ مشکلی اجرا میشود.
Today, we’re releasing .NET 5.0 Preview 2. It contains a set of smaller features and performance improvements. We’re continuing to work on the bigger features that will define the 5.0 release, some of which are starting to show up as initial designs at dotnet/designs.
In this article, we are going to learn about Vertical Slice Architecture in ASP.NET Core and the benefits it provides to make our code more maintainable. We’re also going to learn how it differs from traditional architecture and its advantages over the traditional approach.
<Window x:Class="TwoViews.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
Title="MVVM Light View Switching"
d:DesignHeight="300"
d:DesignWidth="300"
DataContext="{Binding Main,
Source={StaticResource Locator}}"
ResizeMode="NoResize"
SizeToContent="WidthAndHeight"
mc:Ignorable="d">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<ContentControl Content="{Binding CurrentViewModel}" />
<DockPanel Grid.Row="1" Margin="5">
<Button Width="75"
Height="23"
Command="{Binding SecondViewCommand}"
Content="Second View"
DockPanel.Dock="Right" />
<Button Width="75"
Height="23"
Command="{Binding FirstViewCommand}"
Content="First View"
DockPanel.Dock="Left" />
</DockPanel>
</Grid>
</Window>
/// This is our MainViewModel that is tied to the MainWindow via the
/// ViewModelLocator class.
/// </summary>
public class MainViewModel : ViewModelBase
{
/// <summary>
/// Static instance of one of the ViewModels.
/// </summary>
private static readonly SecondViewModel SecondViewModel = new SecondViewModel();
/// <summary>
/// Static instance of one of the ViewModels.
/// </summary>
private static readonly FirstViewModel FirstViewModel = new FirstViewModel();
/// <summary>
/// The current view.
/// </summary>
private ViewModelBase _currentViewModel;
/// <summary>
/// Default constructor. We set the initial view-model to 'FirstViewModel'.
/// We also associate the commands with their execution actions.
/// </summary>
public MainViewModel()
{
CurrentViewModel = FirstViewModel;
FirstViewCommand = new RelayCommand(ExecuteFirstViewCommand);
SecondViewCommand = new RelayCommand(ExecuteSecondViewCommand);
}
/// <summary>
/// The CurrentView property. The setter is private since only this
/// class can change the view via a command. If the View is changed,
/// we need to raise a property changed event (via INPC).
/// </summary>
public ViewModelBase CurrentViewModel
{
get { return _currentViewModel; }
set
{
if (_currentViewModel == value)
return;
_currentViewModel = value;
RaisePropertyChanged("CurrentViewModel");
}
}
/// <summary>
/// Simple property to hold the 'FirstViewCommand' - when executed
/// it will change the current view to the 'FirstView'
/// </summary>
public ICommand FirstViewCommand { get; private set; }
/// <summary>
/// Simple property to hold the 'SecondViewCommand' - when executed
/// it will change the current view to the 'SecondView'
/// </summary>
public ICommand SecondViewCommand { get; private set; }
/// <summary>
/// Set the CurrentViewModel to 'FirstViewModel'
/// </summary>
private void ExecuteFirstViewCommand()
{
CurrentViewModel = FirstViewModel;
}
/// <summary>
/// Set the CurrentViewModel to 'SecondViewModel'
/// </summary>
private void ExecuteSecondViewCommand()
{
CurrentViewModel = SecondViewModel;
}
}
<Application.Resources>
<vm:ViewModelLocator x:Key="Locator" d:IsDataSource="True" />
<!--
We define the data templates here so we can apply them across the
entire application.
The data template just says that if our data type is of a particular
view-model type, then render the appropriate view. The framework
takes care of this dynamically. Note that the DataContext for
the underlying view is already set at this point, so the
view (UserControl), doesn't need to have it's DataContext set
directly.
-->
<DataTemplate DataType="{x:Type vm:SecondViewModel}">
<views:SecondView />
</DataTemplate>
<DataTemplate DataType="{x:Type vm:FirstViewModel}">
<views:FirstView />
</DataTemplate>
</Application.Resources>
his is the last preview for .NET 7 and the next version will be our first release candidate (RC).
