SQL Practice Blog – SQL Server, BizTalk und .NET Erfahrungen

Git: Add .gitignore after commit

leave a comment »

I had created a new repository in GitHub and forgot to add the .gitignore file to ignore all my Visual Studio and debugging files. However, I did not realize it until after I created the first commit.

These are the steps to apply the gitignore file later:

  1. Create a .gitignore file in the root of your local repository.
  2. Run this command. This removes everything from the index:
    git rm -r --cached .
  3. Re-add all files. Now the files and folders from gitignore are ignored.
    git add .
  4. Then commit the changes again and push it to your GitHub repository
    git commit -m ".gitignore is now working" 
    git push
Advertisements

Written by Robert Meyer

Oktober 4, 2017 at 07:21

Veröffentlicht in Git

Tagged with , ,

Self Hosted ASP.NET Core: TagHelper doesn’t work

leave a comment »

I have implemented a simple TagHelper in a ASP.NET Core 2.0 Website, which replace the

My custom TimeTagHelper:

[HtmlTargetElement("time")]
public class TimeTagHelper : TagHelper
{
    public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
    {
        output.Content.SetHtmlContent($"<h1>{DateTime.Now.ToShortTimeString()}</h1>");
    }
}

If I start the website project directly, the TagHelper works without problems. Launched from the Console / Service, the

The solution: PreserveCompilationContext

These are the steps that helped me:

  1. Add the following ItemGroup definition to my Selhosted.Website.csproj
 <ItemGroup>
    <EmbeddedResource Include="wwwroot\**\*;Views\**\*;Areas\**\Views" />
  </ItemGroup>

 

  1. Add the PreserveCompilationContext property to the PropertyGroup in Selhosted.Website.csproj
 <PropertyGroup>
    <TargetFramework>netcoreapp2.0</TargetFramework>
    <AssemblyName>SelfHosted.Website</AssemblyName>
    <RootNamespace>SelfHosted.Website</RootNamespace>
    <TypeScriptToolsVersion>2.3</TypeScriptToolsVersion>
    <PreserveCompilationContext>true</PreserveCompilationContext>
  </PropertyGroup>

 

  1. Include the generated SelfHosted.Website.deps.json from the websites bin folder to the SelfHosted.Console project and set the Copy to Output Directory to Copy always.64fcb891c62c3a149c6ff350ebe0b1d3

You can find the sample project in my GitHub Repo: roeb/DotNetCoreSamples

Written by Robert Meyer

September 29, 2017 at 07:56

SelfHosted ASP.NET Core 2.0 Application

with 2 comments

Auf Grund einer Projektanforderung musste ich mich die Tage damit auseinandersetzen, wie man eine ASP.NET Core 2.0 Website und Web API in einem eigenen Prozess als Windows Service bereitstellt.
Hierbei gibt es einige Besonderheiten zu beachten, auf welche ich in diesem Post gern näher eingehen möchte.

Folgende Technologien kommen zum Einsatz:

  • Alle Projekte basieren auf .NET Core 2.0 oder .NET Standard 2.0
  • Autofac als IoC Container
  • NLog für das Logging
  • Peter Kottas WindowsService als ServerFabric (GitHub)

Grundlegende Architektur der Anwendung

Architecture

Zu finden ist dieses Beispiel auf GitHub.

Grundlegendes Vorgehen

Die Konsolenapplikation kann als WindowsService oder direkt ausgeführt werden und hostet die Website und die API. Die Website und die API sind beides .NETStandard 2.0 Projekte, während die Console eine .NET Core 2.0 Anwendung darstellt.

Aufbau der SelfHosted.Console

IApplication definiert ein Interface zum Starten und Stoppen der Applikationen. Eine Applikation kann eine Website oder eine WebApi sein.

IApplication

Diese Applikationen werden in Autofac registriert und einem gekapselten MicroService geladen und gestartet.

	public class SelfHostedWindowService : MicroService, IMicroService
    {
        private IServiceProvider _provider;

        public void Start()
        {
            this.StartBase();

            var builder = new ContainerBuilder();
            builder.RegisterType<WebApplication>().As<IApplication>();
            builder.RegisterType<WebApiApplication>().As<IApplication>();
            var applicationContainer = builder.Build();

            _provider = new AutofacServiceProvider(applicationContainer);

            foreach (var app in _provider.GetServices<IApplication>())
            {
                app.Start();
            }

            System.Console.WriteLine("Windows services started.");
        }

        public void Stop()
        {
            this.StopBase();

            foreach (var app in _provider.GetServices<IApplication>())
            {
                app.Stop();
            }

            System.Console.WriteLine("Windows services stopped.");
        }
    }

Beim Starten der Konsole oder des Services, wird der MicroService registriert und in einer ServiceFactory geladen. Dadurch starten alle Applikationen, welche in den jeweiligen MicroService definiert sind.

	ServiceRunner<SelfHostedWindowService>.Run(config =>
	{
		var serviceName = "SelfHosted.WindowsService";

		config.SetName(serviceName);
		config.Service(serviceConfig =>
		{
			serviceConfig.ServiceFactory((service, extraArguments) =>
			{
				return new SelfHostedWindowService();
			});

			serviceConfig.OnStart((service, extraArguments) =>
			{
				System.Console.WriteLine("Service {0} started", serviceName);
				service.Start();
			});

			serviceConfig.OnStop((service) =>
			{
				System.Console.WriteLine("Service {0} stopped", serviceName);
				service.Stop();
			});

			serviceConfig.OnError(e =>
			{
				System.Console.WriteLine($"Service '{serviceName}' errored with exception : {e.Message}");
			});
		});
	});

Besonderheiten in der ASP.NET Core 2.0 Website

Es gibt jedoch beim hosten seiner ASP.NET Core 2.0 Website in einer Console noch drei wichtige Dinge zu beachten.

      1. Alle Views müssen Embedded werden. Dafür habe ich folgende Extension Methode geschrieben, welche im Startup bei AddRazorOptions aufgerufen wird.
        	public static RazorViewEngineOptions AddViews(this RazorViewEngineOptions options)
        	{
        		options.FileProviders.Add(new EmbeddedFileProvider(typeof(ServiceCollectionExtensions).GetTypeInfo().Assembly, "SelfHosted.Website"));
        		return options;
        	}
        
      2.  Danach stellte sich heraus, dass noch einige Assemblies fehlten. Diese werden ebenfalls per Extension Methode im Startup geladen.
        	public static RazorViewEngineOptions AddCompilationAssemblies(this RazorViewEngineOptions options)
        	{
        		var myAssemblies = AppDomain
        		   .CurrentDomain
        		   .GetAssemblies()
        		   .Where(x => !x.IsDynamic)
        		   .Concat(new[] { // additional assemblies used in Razor pages:
        					typeof(HtmlString).Assembly, // Microsoft.AspNetCore.Html.Abstractions
        					typeof(IViewLocalizer).Assembly, // Microsoft.AspNetCore.Mvc.Localization
        					typeof(IRequestCultureFeature).Assembly // Microsoft.AspNetCore.Localization
        		   })
        		   .Select(x => MetadataReference.CreateFromFile(x.Location))
        		   .ToArray();
        
        		var previous = options.CompilationCallback;
        
        		options.CompilationCallback = context =>
        		{
        			previous?.Invoke(context);
        			context.Compilation = context.Compilation.AddReferences(myAssemblies);
        		};
        
        		return options;
        	}
        
      3. Jetzt müssen noch alle statischen Files, welche z.B. im wwwroot liegen embedded werden. Auch hier gibt es wieder eine passende Extension Methode.
        	public static IServiceCollection AddStaticFiles(this IServiceCollection collection)
        	{
        		// static files are embedded resources in the "wwwroot" folder
        		collection.Configure<StaticFileOptions>(options =>
        		{
        			options.FileProvider = new EmbeddedFileProvider(typeof(Startup).Assembly, typeof(Startup).Namespace + ".wwwroot");
        		});
        
        		return collection;
        	}
        

Aufgerufen werden die Extension Methods im Startup der Website, in der Funktion ConfigureServices wie folgt:

	public IServiceProvider ConfigureServices(IServiceCollection services)
	{
		services.AddSingleton<IConfiguration>(Configuration);
		services.AddMvc()
			.AddRazorOptions(options =>
			{
				options.AddViews();
				options.AddCompilationAssemblies();
			});
		services.AddStaticFiles();

		var builder = new ContainerBuilder();
		builder.Populate(services);
		this.ApplicationContainer = builder.Build();

		return new AutofacServiceProvider(this.ApplicationContainer);
	}

 

Zusammenfassung

Auf diesem Weg erreicht man eine sehr leichtgewichtige Anwendung, welche komplett in einem eigenen Prozess unabhängig von dem Betriebssystem und Webserver installiert werden kann. Somit erreicht man bei seiner Produktentwicklung, welchen bei Kunden vor Ort installiert werden muss, eine sehr hohe Flexibilität und ich unabhängig der Umgebung.

Written by Robert Meyer

September 22, 2017 at 10:40

SQL Server 2012: EOMONTH Funktion

leave a comment »

Mit dem SQL Server 2012 ist eine neue Datumsfunktion dazu gekommen. Mit EOMONTH ist es möglich sich den letzten Tag des Monats ausgeben zu lassen. Dies ist besonders interessant wenn man Wertebereiche innerhalb eines Monats oder über mehrere Monate Tag genau selektieren möchte.

So wendet man EOMONTH an, um sich den letzten Tag des Monats August im Jahr 2012 ausgegeben zu lassen:

image

Man kann jedoch auch Monat dazu addieren oder abziehen. Hierfür steht ein optionaler Operator zur Verfügung.

image

Es ist nur eine kleiner Erweiterung, aber sie erleichtert doch auf angenehme Art die Arbeit mit TSQL.

Written by Robert Meyer

August 7, 2012 at 13:18

Veröffentlicht in SQL Server

Tagged with , ,

“Add STS Reference” in Visual Studio 2012

leave a comment »

Ich habe heute ein Azure Projekt im neuen Visual Studio 2012 angefangen und wollte ACS einbinden. Bei Visual Studio 2010 ging dies sehr einfach über den Menupunkt “Add STS Reference …”.

image

Dieser ist jedoch leider bei Visual Studio 2012 nicht vorhanden. Hier führt es auch nicht zum gewünschten Erfolg, wenn man das aktuelle Azure SDK installiert. Jedoch ist es über einen Umweg möglich die vermisste Funktionalität in Visual Studio 2012 wieder herbei zu zaubern.

  1. Im Hauptmenu von Visual Studio 2012 im Eintrag “Tools” auf den Menupunkt “Extensions and Updates …” klicken.
    image
  2. In dem sich nun öffnenden Fenster im linken Menu die Kategorie “Online” auswählen und in das Suchfeld “Identity” eingeben. Danach die “Identity and Access Tools” herunterladen und installieren und Visual Studio 2012 neustarten.

    image

  3. Nach dem Neustart von Visual Studio 2012 gibt es einen neuen Menueintrag im Kontextmenu des Projektes mit der Bezeichnung “Identity and Access …”. Hier kann nun wie gewohnt eine ACS Referenz hinzugefügt werden.
    image

image

Written by Robert Meyer

Juli 30, 2012 at 11:57

Paging mit OFFSET und FETCH im SQL Server 2012

leave a comment »

Lange hat es gedauert, doch nun beherrscht der SQL Server mit Version 2012 endlich das Paging. Unter Paging versteht man die Festlegung davon wie viele Datensätze pro Seite ausgeben werden sollen. Dies wird besonders bei diversen Webapplikationen benötigt um die Anzahl der geladenen Daten zu verringern. Würde die Suche auf einer Website ein Trefferergebnis von 400 Datensätzen betragen, möchte der Nutzer sicherlich nicht alle 400 Datensätze mit einmal auf der Website sehen, sondern z.B. immer nur 20 Stück. Diese 20 Datensätze werden jetzt auf 20 Seiten aufgelistet. Damit der Traffic möglichst gering bleibt, werden auch immer nur die Datensätze der aktuellen Seite geladen. Das nennt man Paging.

Möglichkeiten mit dem SQL Server 2012

Mit dem SQL Server 2012 kommen unter anderen zwei neue Befehle welche in der ORDER BY Klausel genutzt werden können:

  • OFFSET
    Legt fest wie viele Datensätze übersprungen werden, bevor Datensätze zurückgegeben werden.
  • FETCH
    Gibt an wie viele Datensätze nach der OFFSET Klausel angezeigt werden sollen

Beispiel

In dem Beispiel werden Kundendaten selektiert, welche mit dem Nachnamen Meyer beginnen. Allerdings werden die ersten 40 Zeilen übersprungen und von da an 20 Zeilen selektiert.

image

Varianten von OFFSET und FETCH

Anstelle von NEXT kann man auch FIRST genutzt werden, es handelt sich hierbei nur um ein Synonym. Das gleich gilt für das Wort ROWS, hier kann auch ROW genutzt werden. Anstelle der direkten Anzahl der Datensätze bei OFFSET oder FETCH kann hier auch eine Variable zum Einsatz kommen. Dies könnte zum Beispiel so aussehen und wäre im zusammenhangen mit dynamisches Stored Procedures recht interessant.

image

Expressions in OFFSET und FETCH

Es ist ebenfalls möglich Expressions im Zusammenhang von OFFSET und FETCH zu nutzen. Hier ein Beispiel:

image

Zur Verfügung stehen die Erweiterungen OFFSET und FETCH bereits ab dem SQL Server 2012 Express.

Written by Robert Meyer

Juli 19, 2012 at 07:25

Veröffentlicht in SQL Server

Tagged with , , , , ,

Neuerungen mit SharePoint 2013

with 5 comments

Diese Nacht war es endlich soweit und die Microsoft SharePoint 2013 Preview stand, neben Office 2013, zum Download bereit. Natürlich bringt SharePoint 2013 viele neue Features mit. Mit einigen hat man gerechnet, andere kamen ziemlich überraschend. Ich möchte euch hier eine kurze Auflistung der neuen Features zur Verfügung stellen.

  • .NET 4.0 mit SharePoint 2013
  • Workflow Foundation 4.0
  • SharePoint Marketplace for Apps
    Mit SharePoint 2013 führt Microsoft den Marketplace für SharePoint Apps ein. Eine SharePoint App ist eine Webapplikation, welche in SharePoint eingebunden werden kann. Hier ist man in der Wahl der Technologie relativ frei und kann z.B. HTML 5, CSS und JavaScript nutzen. Hierzu gibt es im Object Modell auf der Ebene von SPWeb eine Erweiterung mit dem Namen SPApp.
  • Stärkere Integration der Office Produkte in SharePoint 2013
  • Verbesserung in Client Object Model
    Das Client Object Model wurde mit der Möglichkeit der Suche erweitert. Somit ist es nun auch Möglich über das Client Object Model die in SharePoint integrierte Suche zu nutzen.
  • Verbesserung der Workflows über den SharePoint Designer
    Es ist nun Möglich dass bei Workflows, welche über den SharePoint Designer erstellt werden, Schleifen eingesetzt werden können. Dies ging bisher bei SharePoint 2010 nur bei Workflows die mit Visual Studio erstellt wurden.
  • Anstelle von AJAX kommt nun HTML5 mit JQuery zum Einsatz
  • MinimaDownload Strategy (MDS)
    MDS ist eine Erweiterung die Microsoft dem SharePoint Server 2013 spendiert hat, mit der es Möglich ist nur den veränderten Bereich von Webseiten zu übertragen. Das Ziel ist den Traffic möglichst gering zu halten und die Geschwindigkeit bei Nutzern mit geringer Bandbreite zu erhöhen.
  • OAuth 2.0 Authentication
    Unterstützung von WIndows Live ID, Twitter oder Facebook.
  • Unterstützung von Visual Studio 2012

Herunterladen kann man sich SharePoint 2013 Foundation kostenlos auf der Seite von Microsoft. Wer eine MSDN Subscription besitzt, kann sich die größeren Versionen dort herunterladen.

Viel Spaß beim Ausprobieren!

Written by Robert Meyer

Juli 17, 2012 at 08:59

Veröffentlicht in SharePoint

Tagged with , , ,