Caching can help improve the performance of an ASP.NET Core application. Distributed caching is helpful when working with an ASP.NET application that’s deployed to a server farm or scalable cloud environment. Microsoft documentation contains examples of doing this with SQL Server or Redis, but in this post,I’ll show you an alternative.
You may wish to detect idle users and respond, for example, to log them out so their sensitive data is protected, or taunt them, or whatever. I don't care.
This module will include a variety of services and directives to help you in this task.
How to Repair MDF Files in SQL Server Database
Here are some of the reasons why nullable reference types are less than ideal:
/// Example: "00001.00042.00005".
/// Example: "00001.00042.00006".
public class OrganizationalUnit : TrackableEntity<User>, IHasRowVersion, IPassivable
{
#region Constants
/// <summary>
/// Maximum depth of an UO hierarchy.
/// </summary>
public const int MaxDepth = 16;
/// <summary>
/// Length of a code unit between dots.
/// </summary>
public const int PathUnitLength = 5;
/// <summary>
/// Maximum length of the <see cref="Path"/> property.
/// </summary>
public const int MaxPathLength = MaxDepth * (PathUnitLength + 1) - 1;
public const char HierarchicalDisplayNameSeperator = '»';
#endregion
#region Properties
public string Name { get; set; }
public string NormalizedName { get; set; }
public string HierarchicalDisplayName { get; set; }
/// <summary>
/// Hierarchical Path of this organization unit.
/// Example: "00001.00042.00005".
/// It's changeable if OU hierarch is changed.
/// </summary>
public string Path { get; set; }
public bool IsActive { get; set; } = true;
public byte[] RowVersion { get; set; }
#endregion
#region Navigation Properties
public OrganizationalUnit Parent { get; set; }
public long? ParentId { get; set; }
public ICollection<OrganizationalUnit> Children { get; set; } = new HashSet<OrganizationalUnit>();
public ICollection<UserOrganizationalUnit> UserOrganizationalUnits { get; set; } =
new HashSet<UserOrganizationalUnit>();
#endregion
#region Public Methods
/// <summary>
/// Creates path for given numbers.
/// Example: if numbers are 4,2 then returns "00004.00002";
/// </summary>
/// <param name="numbers">Numbers</param>
public static string CreatePath(params int[] numbers)
{
if (numbers.IsNullOrEmpty())
{
return null;
}
return numbers.Select(number => number.ToString(new string('0', PathUnitLength))).JoinAsString(".");
}
/// <summary>
/// Appends a child path to a parent path.
/// Example: if parentPath = "00001", childPath = "00042" then returns "00001.00042".
/// </summary>
/// <param name="parentPath">Parent path. Can be null or empty if parent is a root.</param>
/// <param name="childPath">Child path.</param>
public static string AppendPath(string parentPath, string childPath)
{
if (childPath.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(childPath), "childPath can not be null or empty.");
}
if (parentPath.IsNullOrEmpty())
{
return childPath;
}
return parentPath + "." + childPath;
}
/// <summary>
/// Gets relative path to the parent.
/// Example: if path = "00019.00055.00001" and parentPath = "00019" then returns "00055.00001".
/// </summary>
/// <param name="path">The path.</param>
/// <param name="parentPath">The parent path.</param>
public static string GetRelativePath(string path, string parentPath)
{
if (path.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(path), "Path can not be null or empty.");
}
if (parentPath.IsNullOrEmpty())
{
return path;
}
if (path.Length == parentPath.Length)
{
return null;
}
return path.Substring(parentPath.Length + 1);
}
/// <summary>
/// Calculates next path for given path.
/// Example: if code = "00019.00055.00001" returns "00019.00055.00002".
/// </summary>
/// <param name="path">The path.</param>
public static string CalculateNextPath(string path)
{
if (path.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(path), "Path can not be null or empty.");
}
var parentPath = GetParentPath(path);
var lastUnitPath = GetLastUnitPath(path);
return AppendPath(parentPath, CreatePath(Convert.ToInt32(lastUnitPath) + 1));
}
/// <summary>
/// Gets the last unit path.
/// Example: if path = "00019.00055.00001" returns "00001".
/// </summary>
/// <param name="path">The path.</param>
public static string GetLastUnitPath(string path)
{
if (path.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(path), "Path can not be null or empty.");
}
var splittedPath = path.Split('.');
return splittedPath[splittedPath.Length - 1];
}
/// <summary>
/// Gets parent path.
/// Example: if path = "00019.00055.00001" returns "00019.00055".
/// </summary>
/// <param name="path">The path.</param>
public static string GetParentPath(string path)
{
if (path.IsNullOrEmpty())
{
throw new ArgumentNullException(nameof(path), "Path can not be null or empty.");
}
var splittedPath = path.Split('.');
if (splittedPath.Length == 1)
{
return null;
}
return splittedPath.Take(splittedPath.Length - 1).JoinAsString(".");
}
#endregion
} 
البته یک ویو نمایشی برای حالت درختی هم بهتر است داشته باشید.
یکسری متد DomainService
public virtual async Task<string> GetNextChildPathAsync(long? parentId)
{
var lastChild = await GetLastChildOrNullAsync(parentId).ConfigureAwait(false);
if (lastChild == null)
{
var parentPath = parentId != null ? await GetPathAsync(parentId.Value).ConfigureAwait(false) : null;
return OrganizationalUnit.AppendPath(parentPath, OrganizationalUnit.CreatePath(1));
}
return OrganizationalUnit.CalculateNextPath(lastChild.Path);
}
public async Task<string> GetNextChildHierarchicalDisplayNameAsync(string name, long? parentId)
{
var parent = parentId != null
? await _organizationalUnits.SingleOrDefaultAsync(a => a.Id == parentId.Value).ConfigureAwait(false)
: null;
return parent == null
? name
: $"{parent.HierarchicalDisplayName} {OrganizationalUnit.HierarchicalDisplayNameSeperator} {name}";
}
public virtual async Task<OrganizationalUnit> GetLastChildOrNullAsync(long? parentId)
{
return await _organizationalUnits.OrderByDescending(c => c.Path)
.FirstOrDefaultAsync(ou => ou.ParentId == parentId).ConfigureAwait(false);
}
public virtual async Task<string> GetPathAsync(long id)
{
Guard.ArgumentNotZero(id, nameof(id));
var organizationalUnit = await _organizationalUnits.SingleOrDefaultAsync(ou => ou.Id == id).ConfigureAwait(false);
if (organizationalUnit == null)
{
throw new KeyNotFoundException();
}
return organizationalUnit.Path;
}
public async Task<List<OrganizationalUnit>> FindChildrenAsync(long? parentId, bool recursive = false)
{
if (!recursive)
{
return await _organizationalUnits.Where(ou => ou.ParentId == parentId).ToListAsync().ConfigureAwait(false);
}
if (!parentId.HasValue)
{
return await _organizationalUnits.ToListAsync().ConfigureAwait(false);
}
var path = await GetPathAsync(parentId.Value).ConfigureAwait(false);
return await _organizationalUnits.Where(
ou => ou.Path.StartsWith(path) && ou.Id != parentId.Value).ToListAsync().ConfigureAwait(false);
}
public virtual async Task MoveAsync(long id, long? parentId)
{
Guard.ArgumentNotZero(id, nameof(id));
var organizationalUnit = await _organizationalUnits.SingleOrDefaultAsync(ou => ou.Id == id).ConfigureAwait(false);
if (organizationalUnit == null || organizationalUnit.ParentId == parentId)
{
return;
}
//Should find children before Path change
var children = await FindChildrenAsync(id, true).ConfigureAwait(false);
//Store old Path of OU
var oldPath = organizationalUnit.Path;
//Move OU
organizationalUnit.Path = await GetNextChildPathAsync(parentId).ConfigureAwait(false);
organizationalUnit.ParentId = parentId;
//Update Children Paths
foreach (var child in children)
{
child.Path = OrganizationalUnit.AppendPath(organizationalUnit.Path, OrganizationalUnit.GetRelativePath(child.Path, oldPath));
}
}
Welcome to the Edument CQRS and Intentful Testing Starter Kit project page. On this page, you will find links to our open sourced CQRS Starter Kit on GitHub as well as tutorials to get you started.
This is the first release of a 64-bit Visual Studio and we’d love for you to download it, try it out, and join us in shaping the next major release of Visual Studio with your feedback.
Full Modern React Tutorial
32 videos
In this full React tutorial series, I'll take you from novice to ninja. We'll cover all the basics - what React is, setting up, components & routing - before diving into state management, async code, built-in hooks & custom hooks too.
ILogger: is responsible to write a log message of a given Log Level.
ILoggerProvider: is responsible to create an instance of ILogger (you are not supposed to use ILoggerProvider directly to create a logger)
ILoggerFactory: you can register one or more ILoggerProviders with the factory, which in turn uses all of them to create an instance of ILogger. ILoggerFactory holds a collection of ILoggerProviders.
Strategy pattern is one of the most useful design patterns in OOP. It lets you select an algoritm’s implementation at runtime. However most of the examples you will find online won’t make sense if you are using dependency injection
