This is a practical guide for implementing Domain Driven Design (DDD). While the implementation details are based on the ABP Framework infrastructure, the basic concepts, principles and models can be applied to any solution, even if it is not a .NET solution.
Introducing QOI — the Quite OK Image format. It losslessly compresses RGB and RGBA images to a similar size of PNG, while offering a 20x-50x speedup in compression and 3x-4x speedup in decompression. All single-threaded, no SIMD. It's also stupidly simple.
Compared to stb_image and stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and 20% better compression. It's also stupidly simple and fits in about 300 lines of C.
benchmark results here
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:system="clr-namespace:System;assembly=mscorlib">
<system:String x:Key="button1">Hello!</system:String>
<system:String x:Key="button2">How Are You?</system:String>
<system:String x:Key="button3">Are You OK?</system:String>
</ResourceDictionary>
<Application x:Class="BeRMOoDA.WPF.LocalizationSample.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
StartupUri="MainWindow.xaml">
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Culture_en-US.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
</Application>
<Button Content="{DynamicResource ResourceKey=button1}" />
<Button Content="{DynamicResource ResourceKey=button2}" />
<Button Content="{DynamicResource ResourceKey=button3}" />
<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:system="clr-namespace:System;assembly=mscorlib">
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="Culture_fa-IR_Farsi.xaml"/>
</ResourceDictionary.MergedDictionaries>
<system:String x:Key="button1">سلام!</system:String>
<system:String x:Key="button2">حالت چطوره؟</system:String>
<system:String x:Key="button3">خوبی؟</system:String>
</ResourceDictionary>
public class CultureAssemblyModel
{
//the text will be displayed to user as language name (like Farsi)
public string DisplayText { get; set; }
//name of .dll file (like Culture_fa-IR_Farsi.dll)
public string Name { get; set; }
//standar notation of this culture (like fa-IR)
public string Culture { get; set; }
//name of resource dictionary file inside the loaded .dll (like Culture_fa-IR.xaml)
public string XamlFileName { get; set; }
}
//will keep information about loaded assemblies
public List<CultureAssemblyModel> CultureAssemblies { get; set; }
//loads assmeblies in languages folder and adds their info to list
void LoadCultureAssemblies()
{
//we should be sure that list is empty before adding info (do u want to add some cultures more than one? of course u dont!)
CultureAssemblies.Clear();
//creating a directory represents applications directory\languages
DirectoryInfo dir = new DirectoryInfo(System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\languages");
//getting all .dll files in the language folder and its sub dirs. (who knows? maybe someone keeps each culture file in a seperate folder!)
var assemblies = dir.GetFiles("*.dll", SearchOption.AllDirectories);
//for each found .dll we will create a model and set its properties and then add to list for (int i = 0; i < assemblies.Count(); i++)
{
string name = assemblies[i].Name;
CultureAssemblyModel model = new CultureAssemblyModel() { DisplayText = name.Split('.', '_')[2], Culture = name.Split('.', '_')[1], Name = name , XamlFileName =name.Substring(0, name.LastIndexOf(".")) + ".xaml" };
CultureAssemblies.Add(model);
}
}
comboboxLanguages.ItemsSource = CultureAssemblies;
<ComboBox HorizontalAlignment="Left" Margin="10" VerticalAlignment="Top" MinWidth="100" Name="comboboxLanguages">
<ComboBox.ItemTemplate>
<DataTemplate>
<Label Content="{Binding DisplayText}"/>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
//loads selected culture
public void LoadCulture(CultureAssemblyModel culture)
{
//creating a FileInfo object represents .dll file of selected cultur
FileInfo assemblyFile = new FileInfo("languages\\" + culture.Name);
//loading .dll into memory as a .net assembly
var assembly = Assembly.LoadFile(assemblyFile.FullName);
//getting .dll file name
var assemblyName = assemblyFile.Name.Substring(0, assemblyFile.Name.LastIndexOf("."));
//creating string represents structure of a pack uri (something like this: /{myassemblyname;component/myresourcefile.xaml}
string packUri = string.Format(@"/{0};component/{1}", assemblyName, culture.XamlFileName);
//creating a pack uri
Uri uri = new Uri(packUri, UriKind.Relative);
//now we have created a pack uri that represents a resource object in loaded assembly
//and its time to load that as a resource dictionary (do u remember that we had resource dictionary in culture assemblies? don't u?)
var dic = Application.LoadComponent(uri) as ResourceDictionary;
dic.Source = uri;
//here we will remove current merged dictionaries in our resource dictionary and add recently-loaded resource dictionary as e merged dictionary
var mergedDics = this.Resources.MergedDictionaries;
if (mergedDics.Count > 0)
mergedDics.Clear();
mergedDics.Add(dic);
}
void comboboxLanguages_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
var selectedCulture = (CultureAssemblyModel)comboboxLanguages.SelectedItem;
App app = Application.Current as App;
app.LoadCulture(selectedCulture);
}
de4dot is an open source (GPLv3) .NET deobfuscator and unpacker written in C#. It will try its best to restore a packed and obfuscated assembly to almost the original assembly. Most of the obfuscation can be completely restored (eg. string encryption), but symbol renaming is impossible to restore since the original names aren't (usually) part of the obfuscated assembly.
Supported obfuscators/packers
Structured data in earlier versions of ASP.NET meant creating and registering custom types and configuration sections for our applications. In ASP.NET Core and in Core MVC, structured configuration is a breeze with support for JSON documents as the storage mechanism and the ability to flatten hierarchies into highly portable keys.
.NET Framework is the implementation of .NET that’s installed on over one billion machines and thus needs to remain as compatible as possible. Because of this, it moves at a slower pace than .NET Core.
Develop and deploy databases in Visual Studio with migration scripts.
Want to work on databases in Visual Studio alongside your application? Feeling the pain of managing and deploying database changes manually? Then ReadyRoll's the tool for you.
It generates numerically ordered SQL migration scripts that sit inside your project and take your schema from one version to the next.
You can add them to version control, use them to build and release, and automate database and application deployments, all in one process.
In Visual Studio 2015 Succinctly, author Alessandro Del Sole explains how to take advantage of the highly anticipated features in Microsoft Visual Studio 2015. Topics include sharing code between different types of projects, new options for debugging and diagnostics, and improving productivity with other services in the Visual Studio ecosystem, such as NuGet and Azure.
