In meinem letzten Windows 8 Training, entwickelte sich das Thema Web Services zum beherrschenden Thema. WCF oder Rest? Welche REST Stack (Web API, Dataservices oder gar RIA Services)? Wie Benutzer anmelden? Wir haben uns dann letztendlich für Basic Authentifizierung entschieden, gesichtet über eine HTTPS Verbindung. Das geht relativ einfach und problemlos und ist sicher.
Wenn man sich dem HTTPClient hingibt, den es jetzt ja auf allen .NET Plattformen gibt, ist das seltsamerweise sehr komplex. Zunächst muss man dem Webserver mitteilen welche Authentifizierungsverfahren er unterstützen soll. Dabei gibt es drei Stellen in die man eingreifen kann. Die zentralen Config Dateien, die Web.Config der Web Anwendung und die Settings in Visual Studio.
Im folgende Beispiel ist Basic Authentifizierung generell erlaubt. In IISExpress SSL und Windows aktiviert
In der Web Config <authentication mode="Windows"></authentication>
Eine ASP.NET Web Api Service Methode wird mit dem Authorize Attribut abgesichert.
1: <Queryable()>
2: <Authorize()>
3: Function GetDriveMappings() As IQueryable(Of DriveMappings)
Der erste check ist nun der Aufruf des Services im Browser.
Dummerweise klappt das auf anhieb. Warum? Es sollte doch eigentlich nur ein angemeldeter Benutzer möglich sein? Ist er auch. Ein Breakpoint in der Web Api Routine und eine Abfrage von User.Identity.Name offenbart den aktuellen Windows Benutzer. Wie funktioniert das nun?
Der Browser fordert die URL an und der Server antwortet einer 401 Statusmeldung und den möglichen Authentifzierungsverfahren.
Hier Basic, NTLM und Negotiate für Kerberos. Der Browser verwendet die für ihn sicherste Methode, braucht aber noch einen zusätzlichen Request um eine verschlüsselte Sicherheitstoken Kommunikation sicher zustellen.
Also am Ende drei Requests.
Für einen Windows 8 (Modern UI/Metro) Client wird in der Regel nicht automatisch der angemeldet Windows Benutzer verwendet.
Die Hilfsklasse Netzwork Credentials enthält auch eine Eigenschaft UseDefaultCeredentials mit der auf den angemeldete User zurückgegriffen wird.
Im folgenden VB.NET Sample Code Snippet kommt ein Demo User zum Einsatz.
1: Dim h As HttpClientHandler = New HttpClientHandler()
2: Dim c = New Net.NetworkCredential("demo", "demo") 3: h.Credentials = c
4: Dim http As New HttpClient(h)
5: 'http.BaseAddress = New Uri("https://localhost:44301") 6: http.BaseAddress = New Uri("http://localhost:27536/") Auch hier ist es so, das die Verschlüsselung ausgehandelt wird. Man kann also nicht BASIC erzwingen, außer man schaltet am Webserver “Windows” wieder aus. Nicht zu verwechseln mit dem Eintrag in der Web.Config, der nur darauf hinweist, Windows als Benutzerdatenbank zu verwenden.
Der zweite request sendet dann schließlich Username und Passwort mit
Nie vergessen, Username: Passwort ist nur Base64 codiert und lässt sich decodieren. Also immer die Kombi Basic und HTTPS verwenden.
Vom 24.-27. Juni 2013 findet die diesjährige Developer Week in Nürnberg statt. Neben vielen spannenden Themen rund um die Softwareentwicklung in den Bereichen Web, Mobile sowie im Microsoft .NET Umfeld und vielversprechenden Keynotes verteilt über drei Konferenztage gibt es natürlich auch jede Menge Möglichkeiten zum Socializing.
Wir sind mit einem Vortrag von Nico Orschel über Test Management mit Visual Studio 2012 sowie einem eigenen Stand als Aussteller mit an Board. Nähere Infos zu finden im Blog der Developer Week.
Besuchen Sie uns – es lohnt sich!
AIT in Nürnberg auf der Developer Week 2013 is a post from: AIT Blog
Microsoft stellt seit kurzem einen frei verfügbaren Service zum Darstellen von Office Dokumenten im Browser bereit. Diese Dokumente müssen lediglich im Web öffentlich erreichbar und somit nicht mehr unter SkyDrive, docs.com oder Office 365 abgelegt sein.
Bei dem Service handelt es sich um einen Office Web App Server und kann unter folgender URL aufgerufen werden:
Die Unterstützten Browser können aus der Fußzeile in der oberen Abbildung entnommen werden 
Samples
Doch nun ein paar Beispiele zur praktischen Anwendung. Im folgenden finden Sie einen Link zu einer PowerPoint Präsentation (Beim Klick auf den Link wird die Datei heruntergeladen) :
Und nun ein generierter Link vom Office Web App Server zu dem selben Dokument:
Desweiteren noch eine kleine Demonstration, wie Excel aber auch Word Dokumente über diesen Weg im Browser dargestellt werden:
Fazit
Sollen öffentliche Office Dokumente im Internet als HTML dargestellt werden, so eignet sich dieser Service hervorragend. Denn es muss auf keine der oben gelisteten Cloud Storages zurückgegriffen werden, die genau solch eine Darstellung von Dokumenten bisher ermöglicht haben. Nein die Dokumente können nun auf einem eigenen Server gehostet und über diesen Service im Browser dargestellt werden. Aus meiner Sicht sehr praktisch 
Für Intranets oder Portale, für die eine Anmeldung erforderlich ist, kann dieser Service natürlich nicht angewandt werden.
Die Windows Azure Mobile Services haben ein wichtiges Update erhalten. Diese vereinfachen signifikant die Entwicklung für mobile Applikationen, welche die Cloud benutzen. Scott Guthrie erläutert die einzelnen, neuen Features auf seinem Blog. Dazu gehören:
· Unterstützung für eigene APIs
· Unterstützung für Git Source Control
· Unterstützung für Node.js NPM Module
· Kostenlose 20MB SQL Datenbank für Mobile Services und Web Sites
· Unterstützung für Android Broadcast Push Notification
Zusätzlich wird im Interoperability-Blog gezeigt, wie Push-Benachrichtigungen für Android-Geräte jetzt auch über die Google Cloud Messaging-Plattform versandt werden können.
Übrigens, für vertiefte und praxisorientierte Infos zum Thema ist das englischsprachige Windows Azure Developer Center eine gute Anlaufstelle.
Websites bestehen heutzutage häufig aus zahlreichen größeren CSS- und JavaScript-Dateien. Gerade beim Laden über langsame Netzwerkverbindungen (z.B. in Mobilfunknetzwerken) wird dies zum Problem. ASP.NET 4.5 bietet zwei Instrumente zur Beschleunigung:
CSS- und JavaScript-Dateien können vor der Übertragung zum Client verkleinert werden, indem Leerräume und Kommentare aus dem Quellcode entfernt werden.
Mehrere CSS- und JavaScript-Dateien können vor der Übertragung zu einer Datei zusammengefasst werden. Durch die Reduzierung der Anzahl der HTTP-Anfragen wird die Übertragung einer Webseite beschleunigt.
Zum Konfigurieren dieser Möglichkeiten, die sich Minification und Bundling nennen, sehen die Projektvorlagen eine Klasse BundleConfig im Ordner App_Start vor. Sie weist eine statische Methode RegisterBundles auf. Diese wird beim Start der Webanwendung zur Ausführung gebracht, indem sie von der Methode Application_Start in der Datei global.asax aufgerufen wird. Bei diesem Aufruf übergibt sie die statsiche Auflistung BundleTable.Bundles, welche per Definition sämtliche registrierte Bundles beinhaltet.
Das nachfolgende Listing zeigt einen Teil der Methode RegisterBundles, welche von der Projektvorlage Internet-Application eingerichtet wurde. An den Konstruktor von ScriptBundle übergibt sie den Namen des Bundes. Mit Include werden die einzelnen Dateien angegeben, die zum Bundle hinzuzufügen sind. Bei der Angabe dieser Dateinamen kann der Entwickler Platzhalter verwenden. Ein Stern (*) steht zum Beispiel für eine beliebige Zeichenkette; der Platzhalter {version} für eine Versionsnummer. Die vordefinierte Liste an Bundles kann der Entwickler nach Belieben erweitern.
public static void RegisterBundles(BundleCollection bundles)
{
bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
"~/Scripts/jquery-{version}.js"));
bundles.Add(new ScriptBundle("~/bundles/jqueryui").Include(
"~/Scripts/jquery-ui-{version}.js"));
bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
"~/Scripts/jquery.unobtrusive*",
"~/Scripts/jquery.validate*",
"~/Scripts/methods_de.js"));
[...]
}
Wird in einer View über ein Script-Tag auf den Namen eines Bundles mit JavaScript-Dateien oder über einen Link-Tag auf den Namen eines Bundles mit CSS-Dateien verwiesen, erhält der Browser diese Dateien mit einer einzigen Anfrage in einer "minificated" Form. Dabei ist auch darauf zu achten, dass Bundles mit HTTP-Kopfzielen ausgeliefert werden, die den Browser ermutigen, sie zu cachen.
Darauf muss man zuerst kommen: Die Toolbar des Antiviren Programms "Free AVG" verpfuscht die Internet Explorer Einstellungen.
Das wirkt sich so aus, dass nach jedem Neustart und obwohl schön neu eingestellt, beim öffnen eines neuen Tabs nur eine leere Seite kommt.
Und nicht wie gewünscht die erste Startseite als neues Tab.
Der Übeltäter kann entweder auf die angenehme oder auf die harte Tour entfernt werden.
Nachdem entfernen einmal das gewünschte einstellen und es bleibt auch.
Quelle: http://answers.microsoft.com/en-us/ie/forum/ie9-windows_vista/new-tab-page-on-internet-explorer-keeps-changing/6dd63d7a-1181-4ffb-a256-225ba5a528e1
Da ich nächste Woche als Sprecher auf der Developer Week unterwegs bin, möchte ich an dieser Stelle auch ein wenig die Werbetrommel rühren. Denn die Veranstalter bieten dieses Jahr etwas Besonderes an. Für alle die nicht dabei sein können, gibt es 15 Sessions kostenlos als Live Stream! Einer davon ist mein eigener. Wer also Lust [...]
In einen meiner vorangegangenen Artikeln wurde gezeigt, wie die Navigate Up Breadcrumb in SharePoint 2013 wieder eingebunden werden kann. Diesmal soll die Title Breadcrumb in die oft so leere SuiteBar integriert werden. Eine kurze bildhafte Veranschaulichung des Ziels:
Im folgenden werden nun die einzelnen Schritte genauer beschrieben. Viel Spaß
Customize Master Page
Zu Beginn laden wir uns eine Kopie der gewünschten Master Page aus der Master Page Gallery herunter. Ich werde in diesem Beispiel die Seattle.master verwenden.
Anschließend suchen wir in der Master Page folgende Stelle:
<div class="ms-tableCell ms-verticalAlignMiddle">
<SharePoint:DelegateControl id="ID_SuiteBarBrandingDelegate" ControlId="SuiteBarBrandingDelegate" runat="server" />
</div>
Diese Stelle erweitern wir mit der Logik der Title Breadcrumb und positionieren diese Hinter dem SuiteBar Text. Die daraus resultierende Änderung schaut wie folgt aus:
<div>
<SharePoint:DelegateControl id="ID_SuiteBarBrandingDelegate" ControlId="SuiteBarBrandingDelegate" runat="server" />
</div>
<div class="suitebar-TitleBreadcrumb">
<SharePoint:SPTitleBreadcrumb
runat="server"
RenderCurrentNodeAsLink="true"
SiteMapProvider="SPContentMapProvider"
CentralAdminSiteMapProvider="SPXmlAdminContentMapProvider"
DefaultParentLevelsDisplayed="5"
WelcomePageUsesWebTitle="true">
<PATHSEPARATORTEMPLATE>
<SharePoint:ClusteredDirectionalSeparatorArrow runat="server" />
</PATHSEPARATORTEMPLATE>
</SharePoint:SPTitleBreadcrumb>
</div>
Schließlich muss nur noch mittels CSS die gewünschte Formatierung der Title Breadcrumb gesetzt und die Master Page im SharePoint bereitgestellt werden.
Fazit
Einer von vielen Ansätzen, die Title Breadcrumb in SharePoint 2013 zu integrieren und zu positionieren. Der hier beschriebene Ansatz füllt die oft so leere SuiteBar und da kein Code verwendet wurde, kann diese Lösung auch unter Office 365 angewandt werden. Ich hoffe euch hiermit einen kleinen Anreiz gegeben zu haben und euer Feedback ist wie immer erwünscht.
Mit einem Methoden Attribut, lässt sich ein kompletter REST ASP.NET Web Api Controller oder explizit eine CRUD Methode vor unerlaubten Zugriff schützen.
1: <Authorize(Roles:="Benutzer")>
2: Function GetDriveMappings() As IQueryable(Of DriveMappings)
Dabei wird nur geprüft ob die Rechte des angemeldeten (authenticated) Users ausreichen.
Um die Benutzer Anmeldung abzuhandeln kann man sich der eingebauten Methoden (Modules) des IIS bedienen. Per web.config wird eingestellt, das die Windows Benutzerdatenbank verwendet wird, um die Konten zu verwalten.
1: <authentication mode="Windows"></authentication>
In einem anderen Blog Artikel habe ich gezeigt, wie man den Membership Provider statt dessen als Benutzer Datenbank verwendet.
Wenn ein Browser einen geschützte Seite anfordert, antwortet der Server mit einer 401 Statusmeldung und liefert im Header das gewünschte Authentifizierungsverfahren mit. Es braucht also intern zwei Requests und eine Benutzereingabe von User und Passwort um die gewünschte Seite zu bekommen.
Für einen Service Aufruf ist das ungeeignet. Man muss die Credentials schon beim Initialen Request mitgeben. Wie das auszusehen hat, kann man gut erkennen, wenn man per Fiddler den zweiten, erfolgreich authentifizierten Request, betrachtet.
Benutzer und Passwort werden im HTTP Header Base 64 codiert mitgeliefert, getrennt durch einen Doppelpunkt. Hier wurde einfach der Header aus dem Web Request kopiert. Es gibt auch Online Base64 En-Decoder. In der Praxis wird man dafür ein wenig .net code verwenden.
1: Dim encodedText = Convert.ToBase64String(Encoding.UTF8.GetBytes("demo" + ":" + "demo"))Um diesen Basic authentication String aus einer WinRT Anwendung per HTTP Request mitzugeben, greift man direkt in den HTTP Header des HTTPClients ein.
1: Dim http As New HttpClient()
2: http.DefaultRequestHeaders.Authorization =
3: New Headers.AuthenticationHeaderValue("Basic", "ZGVtbzpkZW1v") 4: Dim jsondata =
5: Await http.GetStringAsync(New Uri("http://localhost.fiddler:27536/api/DriveMappings/"))Wenn alles gut geht, sollte Fiddler dann einen 200 Code anzeigen. Hinweis: immer https anschalten. Basic Clear Text heißt nicht umsonst so.
Murphy
Es gibt allerdings eine Menge Dinge die dabei schief laufen können. Wenn man IISExpress verwendet, muss Basic Authentifizierung erst aktiviert werden. In den Einstellungen in Visual Studio sucht man das vergeblich.
Im IIS 7 wird die Authentifizierung über ein User Interface eingestellt. Beim Express muss man direkt in die applicationhost.config Datei. Diese findet man unter C:\Users\USER\Documents\IISExpress. Dort im Bereich authorization
1: <authentication>
2: <anonymousAuthentication enabled="true" userName="" />
3: <basicAuthentication enabled="true" />
Fiddlertipp
Um den Traffic bei Win8 RT (Modern UI, METRO) Apps mitzubekommen muss man in den Fiddler WIn8 Settings die APP erlauben und nicht localhost verwenden.( Zeile 5 HTTPClient Sample)
Vom 05.-07. Juni 2013 fand der Karlsruher Entwicklertag statt. Mittlerweile sind die Folien der Vorträge online verfügbar. Das Material zu den Sessions von AIT können direkt nachfolgend heruntergeladen warden:
Vielen Dank für die vielen guten Gespräche sowie das tolle Feedback zu den Vorträgen!
Folien des Karlsruher Entwicklertags online is a post from: AIT Blog
In Visual Studio 2010 gab es eine Funktion um durch Rechtsklick auf eine Methode einen
Unit-Test-Stub für diese Methode zu generieren. Diese Funktion fehlt leider in VS
2012 nachdem Microsoft dort das Unit-Test Framework komplett umgebaut hat. Eine kleine
Extension von der VSGallery, erstellt von den ALM
Rangers fügt diese Funktion VS 2012 nun wieder hinzu.
Ein Visual Studio 2012 ist auf meinem Rechner drauf für Windows 8 und das neue "Schnickschnack",... ein 2010 aus historischen Gründen, ein 2008 aber... aus richtig produktiv wichtigen Gründen.
Smart Device Projects auf Basis von .NET Compact Framework schreibe ich heute noch irre gern, und das funktioniert leider momentan nur unter 2008.
Mit dem .Net Compact Framework 3.9 kommt endlich der Sprung auf Visual Studio 2012 (obwohl Ende des Jahres 2013 in den Startlöchern steht...).
Seit Anfang des Jahres habe ich also auch 2008 drauf, und heute meinte mein tolles Visual Studio leider, dass es ausgelaufen ist obwohl ich mir 100% sicher bin, dass ich keine Trial-Version installiert habe. Google angeworfen, und kam drauf, dass ein einfaches "Upgrade" möglich wäre per Systemsteuerung - Software - Add/Remove Feature.
Leider fehlte hierbei aber der Upgrade-Pfad in der Installationsroutine, wieder mit google gesprochen - aha! It´s not a bug - It´s a feature.
Festhalten - Seit Windows 7 ist der Eintrag "verschwunden", über Umwege bin ich dann auf Microsoft Connect gelandet und dort wird ein "Hot"fix bereitgestellt:
https://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=27638
Damit konnte das Problem wieder gelöst werden - Key eingeben und fertig.
Almost everytime when I’m doing SQL Server consulting engagements, DBAs are showing me queries and their Execution Plans, where SQL Server is just ignoring a good defined Non-Clustered Index. Imagine for example the following table and index definition:
CREATE TABLE Customers
(
CustomerID INT NOT NULL,
CustomerName CHAR(100) NOT NULL,
CustomerAddress CHAR(100) NOT NULL,
Comments CHAR(185) NOT NULL,
Value INT NOT NULL
)
GO
CREATE UNIQUE CLUSTERED INDEX idx_Customers ON Customers(CustomerID)
GO
CREATE UNIQUE NONCLUSTERED INDEX idx_Test ON Customers(Value)
GO
When you are populating the table with 80.000 records and running the following query, SQL Server just ignores your Non-Clustered Index and scans the whole table:
SELECT * FROM Customers
WHERE Value < 1063
GO
Mostly people are now proud, because they think they have found a bug in SQL Server, and sometimes they are trying to hint the Query Optimizer with an index hint, which then produces the following (expected) Execution Plan:
As you can see from the picture, SQL Server has to do a Bookmark Lookup, because you don’t have a Covering Non-Clustered Index defined for that specific query. SQL Server is doing you here a big favor, when your whole Clustered Index is scanned: making the Bookmark Lookup for every retrieved record is too expensive, so SQL Server scans the whole table, which produces less I/Os for your query and reduces the CPU consumption, because the Bookmark Lookup is always done through a Nested Loop operator.
This behavior or “safety net” is called the Tipping Point in SQL Server. Let’s have now a more detailed look on that concept. In a short, the Tipping Point just defines if SQL Server is doing a Bookmark Lookup, or a whole Table/Clustered Index Scan. This also implies that the Tipping Point is only relevant for Non-Covering Non-Clustered Indexes. An index which acts as a Covering Non-Clustered Index for a specific query doesn’t have a Tipping Point, so the problems described in this blog posting are not relevant to it.
When you have a specific query in front of you, which produces a Bookmark Lookup, it depends on the number of retrieved pages if SQL Server is doing a full scan or using the Bookmark Lookup. Yes, you have read correct: the number of retrieved pages dictates if it’s good or not good to do a Bookmark Lookup! Therefore it is completely *irrelevant* how many records a specific query returns, the only thing that matters is the number of pages. The Tipping Point is somewhere between 24% – 33% of the pages the query has to read for a specific query.
Before that range, the Query Optimizer chooses a Bookmark Lookup, after the query tipped over, the Query Optimizer produces an Execution Plan with a full scan of the table (with a Predicate inside the Scan operator). This also means that the size of your records defines where the Tipping Point lives. With very small records you can only retrieve a smaller set of records from your table, with larger records you can retrieve a huger set of records, before the query is over the Tipping Point and is doing a full scan. The following picture illustrates this behavior in more detail:
Let’s have a look on some concrete examples of that concept. Let’s just populate the table definition from earlier with 80.000 records:
DECLARE @i INT = 1
WHILE (@i <= 80000)
BEGIN
INSERT INTO Customers VALUES
(
@i,
'CustomerName' + CAST(@i AS CHAR),
'CustomerAddress' + CAST(@i AS CHAR),
'Comments' + CAST(@i AS CHAR),
@i
)
SET @i += 1
END
GO
In our case every record is 400 bytes long, therefore 20 records can be stored on 1 page of 8kb. When we are doing a full scan (SELECT * FROM Customers) of the table, SQL Server produces 4.016 logical reads (can be seen from the session option SET STATISTICS IO ON):
In our case the table consists of 4.000 data pages in the leaf level of the Clustered Index, which means the Tipping Point is somewhere between 1.000 and 1.333 pages that we are reading for that specific table. This means you can read about 1,25% – 1,67% (1000/80000, 1333/80000) of the records from the table, before the Query Optimizer decides to do a full scan of the table. Imagine the following query:
SELECT * FROM Customers
WHERE Value < 1062
GO
In that case SQL Server decides to do a Bookmark Lookup, because the query itself produces 3.262 logical reads. Imagine that: you are retrieving 1.061 records out of 80.000 records, and the query already needs 3.262 logical reads – a complete scan of the table just costs you constantly 4.016 logical reads (regardless of the number of records that the query returns).
As you can see from these numbers, Bookmark Lookups are getting really expensive (regarding I/O costs, and also regarding CPU costs!), when you retrieve a huge amount of records through a Bookmark Lookup. Your logical reads would just explode, and therefore SQL Server implements the Tipping Point, which just discards that inefficient Execution Plan and scans the whole table. Imagine the following almost same query:
SELECT * FROM Customers
WHERE Value < 1063
GO
In that case SQL Server discards the Execution Plan with the Bookmark Lookup and is doing a full scan of the table which produces constantly 4.016 logical reads. Almost 2 identical queries, but 2 different Execution Plans! A huge problem for performance tuning, because you have no Plan Stability anymore.
Based on your input parameters you are getting 2 different plans! That’s also one of the biggest drawbacks of Bookmark Lookups. With Bookmark Lookups you can’t achieve Plan Stability! When such a cached plan get’s reused with a huger amount of records (or your statistics are out-of-date), you will really have performance problems, because the inefficient plan with the Bookmark Lookup get’s blindly reused by SQL Server! I have seen examples of that problem where queries were running minutes instead of a few seconds.
As we have already said, the Tipping Point depends on the number of pages you read for your specific query. Imagine we are changing our table definition a little bit, and each record is now only 40 bytes long. In that case 200 records can be stored on one page of 8kb.
CREATE TABLE Customers3
(
CustomerID INT NOT NULL,
CustomerName CHAR(10) NOT NULL,
CustomerAddress CHAR(10) NOT NULL,
Comments CHAR(5) NOT NULL,
Value INT NOT NULL
)
GO
When we are populating the table again with 80.000 records, we need only 400 pages in the leaf level of the Clustered Index. In this case the Tipping Point is somewhere between 100 and 133 read pages, means you can only retrieve around 0,125% – 0,167% of the records through the Non-Clustered Index. This is almost NOTHING! Your Non-Covering Non-Clustered Index is now just useless!!!
The following query produces a Bookmark Lookup, and the second one a Clustered Index Scan:
-- Bookmark Lookup with 332 logical reads,
SELECT * FROM Customers3
WHERE Value < 157
GO
-- The following query does a clustered index scan.
-- The query produces 419 I/Os.
SELECT * FROM Customers3
WHERE Value < 158
GO
As you can see from the second query, you only retrieve 157 records out of 80.000 records, which means your query is very, very, very selective, but SQL Server just ignores your perfect (?) Non-Clustered Index. For that query your Non-Clustered Index isn’t really perfect, because it’s not a Covering Non-Clustered Index. Imagine what happens when you hint SQL Server for the Non-Clustered Index, and you just retrieve every record from the table through the ineffient Bookmark Lookup:
SELECT * FROM Customers3 WITH(INDEX(idx_Test))
WHERE Value < 80001
GO
That query produces 165.151 logical reads – really far away from the logical reads that the Clustered Index Scan produces. As you can see from this example, the Tipping Point is just a safety net in SQL Server, and prevents that queries with a Bookmark Lookup get really expensive. But it doesn’t depend on the number of records. In both examples we dealed with the same amount of records in the table – 80.000. The only thing that we have changed is the size of the records, and therefore we have changed the size of the table, and finally the Tipping Point changed, and SQL Server just ignored our almost perfect Non-Clustered Index.
Moral of the story: a Non-Clustered Index, which isn’t a Covering Non-Clustered Index has a very, very, very, very, very selective Use Case in SQL Server! Think about that the next time when you are working on your indexing strategy.
Call to action: do you have also encountered in your workloads scenarios where SQL Server just ignored your almost perfect Non-Clustered Index, and you thought about what is going on with that specific query? Please feel free to leave a comment with your stories…
Thanks for reading
-Klaus
... und setz den Application Name im ConnectionString.
Wer schon einmal in die Verlegenheit kam, und prüfen musste, warum es auf einer Datenbank zu Fehlern kommt und welche Anwendung diese erzeugt, der wird froh sein, wenn der Application Name gesetzt war.
Worum geht es?
Beim Verbindungsaufbau zum SQL Server wird nicht nur Benutzername und Kennwort, sondern auch ein Anwendungsname ausgetauscht. Dieser Anwendungsname wird in Tracing-Tools (wie z.B. dem Profiler) auch angezeigt.
Nun ist es für die Fehlersuche sehr sinnvoll, wenn dieser Anwendungsname eindeutig ist.
Leider wird in der Praxis häufig vergessen, diesen zu setzen, was dazu führt, dass hier nur der Standardwert .NET SQLClient Data Provider steht. Das ist für die Problemsuche nicht sehr hilfreich. Mit den neueren Projekt-Templates von Visual Studio, in denen Entity Framework verwendet wird, hat sich dieses Problem nur etwas verlagert. Hier ist der Parameter zwar schon im ConnectionString enthalten, wird aber auf den neuen Standardwert EntityFramework gesetzt - auch nicht sehr hilfreich.
Wie setzt man den ApplicationName?
Im ConnectionString gibt es den Parameter Application Name oder die gleichbedeutende Abkürzung App. Dieser muss gesetzt werden.
Beispiele:
<connectionStrings>
<add name="MyEntities" connectionString="metadata=res://*/Models.MyModel.csdl|res://*/Models.MyModel.ssdl|res://*/Models.MyModel.msl;provider=System.Data.SqlClient;provider connection string="data source=.;initial catalog=MyDb;integrated security=True;MultipleActiveResultSets=True;App=Meine Anwendung"" providerName="System.Data.EntityClient" />
</connectionStrings>
<connectionStrings>
<add name="DefaultConnection" connectionString="Server=.;Database=MyDb;Integrated Security=SSPI;Application Name=Meine Anwendung;" providerName="System.Data.SqlClient" />
</connectionStrings>
Das geht sowohl in klassischen ConnectionStrings als auch in Connectionstrings für das Entity Framework.
Am 29. Juli haben Timo, Vitali und ich interessantes Angebot von Microsoft in Anspruch genommen. Im Rahmen der BizSpark on Tour Aktion haben wir uns einen kostenloses Coworking Space im Startplatz in Köln gebucht.
Während so eines Coworking Termins kann man mit der Unterstützung von Microsoft Mitarbeitern an Windows Store Apps oder Windows Phone Apps arbeiten. Wir haben uns dazu entschieden unsere gmail calender Windows 8 App, mit der wir Termine des Google Kalenders anzeigen, auf nächste Level zu bringen.
Die erste Version der App hatten wir Ende März “über Nacht” entwickelt und nach und nach Features nachgeliefert. Meist geschah dies jedoch nach Feierabend. Die App hatte immer noch einige Macken bzw. eine fehlende Features. Daher kam uns Microsofts Coworking Angebot gerade recht. Mit der Unterstützung der beiden Microsoft Kollegen Daniel Meixner und Malte Lantin konnten wir an diesem Tag einige Fehler ausmerzen und lang gewünschte Features einbauen.
Der Tag stand für uns unter dem Motto:
Dies ist eines der fünf Microsoft Design Style Prinzipien. Der Kern dieses Prinzips sagt aus, dass man seine Anwendung sicher und zuverlässig machen sollte (make it safe and reliable) und sich wirklich um die Details kümmern sollte (Sweat the details).
Und genau das haben wir an diesem Tag gemacht:
Timo und ich haben uns darum gekümmert, die Zuverlässigkeit der Synchronisation zu Google zu verbessern. Außerdem haben wir das Live Tile und die Integration in den Lock Screen verbessert. Vitali hat den Tag dazu genutzt das meist gewünschte Feature, nämlich die Bearbeitung von Terminen zu implementieren.
Alles in allem war es ein wirklich toller Tag. Die beiden Microsoft Kollegen waren wirklich sehr hilfsbereit und uns bei der Analyse einiger Probleme unterstützt. Außerdem konnten wir die Gelegenheit auch nutzen um in lockerer Atmosphäre mit Startup Flair über diverse andere Windows 8 und Windows Phone 8 Themen zu diskutieren. Aus unserer Sicht war der Tag daher ein voller Erfolg!
Hast du auch Lust auf einen Coworking Termin bekommen?
Die Aktion läuft übrigens noch einige Tage in Köln und Berlin. Wenn du also auch Lust darauf hast eine Windows 8 oder Windows Phone 8 App zu entwickeln, oder weiter zu entwickeln, kannst du dich auf der BizSpark Seite für einen kostenlosen Termin registrieren. Im Moment sind noch einige Plätze frei!
Nachdem kürzlich für Windows Server 2012 ein R2 angekündigt wurde, gibt es nun auch einige Details zu den Änderungen in Hyper-V. Diese möchte ich hier kurz zusammentragen:
Generation-2-VMs
Es wird eine neue Generation für VMs geben, die verschiedene neue Szenarien unterstützen soll, so z.B. das Booten von iSCSI. Dies wird erreicht, indem hier nahezu vollständig auf Emulation von Hardware verzichtet werden soll. Dies funktioniert allerdings nur mit 64-Bit Client-Systemen und nur mit Windows 8 und dem Server 2012 als Gast.
VM Direct-Connect
Bisher ist für einen direkteren Zugriff auf die VM (inkl. Durchreichen von Laufwerken und Zwischenablage) eine RDP-Verbindung nötig, für die wiederum eine Netzwerkverbindung zwischen Gast und Host nötig ist, mit allen damit verbundenen Sicherheitsrisiken und Konfigurationsaufwänden. Mit Direct-Connect werden diese Möglichkeiten künftig auch mit der klassischen VM-Verbindung möglich sein.
Erweiterte Replikation einer VM
Es soll möglich sein, dass ein Host für eine VM nicht mehr nur Quelle ODER Ziel für die Replikation ist, sondern beides. Damit wird es möglich sein, ein Replikat innerhalb des Unternehmens, ein zweites außerhalb aufzubewahren. Vermutlich wird es auch möglich sein, eine VM direkt an 2 Ziele zu replizieren.
Die Replikation unter Server 2012 lässt lediglich ein Intervall von 5 Minuten zu. Im R2 wird es möglich sein, alternativ auch 30 Sekunden oder 15 Minuten zu wählen - je nach Notwendigkeit und Kapazität. Da nach 12 fehlerhaften Versuchen die Replikation unterbrochen wird, hätte man damit die Möglichkeit, 3 Stunden Downtime zu tolerieren.
Kompression & SMB Direct
Bei der Migration von VMs wird es 2 neue Optionen geben: Kompression der zu übertragenden Daten oder Übertragung via SMB Direct (setzt Netzwerkadapter auf beiden Seiten voraus, die RDMA unterstützen). Microsoft empfiehlt bei 10GBps-Links die Nutzung von RDMA, andernfalls die Kompression. Hierbei muss man natürlich den Einfluss der höheren CPU-Last auf die restlichen VMs beachten.
Online Export & Klonen
In Windows Server 2012 muss eine VM erst heruntergefahren/ausgeschaltet werden, bevor sie exportiert oder mittels SCVMM geklont werden kann. In R2 wird dies nun auch bei laufenden VMs möglich sein, wodurch es auch für Produktivumgebungen interessant wird.
Online-Größenänderung von VHDX
Es soll in Windows Server 2012 R2 möglich sein, eine VHDX während deren Nutzung durch eine laufende VM sowohl zu vergrößern, als auch sie zu verkleinern!
Storage-QoS
Der Windows Server 2012 R2 wird eine Möglichkeit bieten, die IOPS einer VM zu beschränken. Damit kann man eine IO-lastige VM begrenzen, um anderen VMs weiterhin eine akzeptable Datenrate auf dem Storage zu ermöglichen.
Dynamic Memory für Linux-VM
Für supportete Linux-Systeme wird es möglich sein, deren RAM-Zuweisung (wie bisher auch bereits bei Windows-Gast-Systemen möglich) dynamisch zu gestalten. Damit werden z.B. größere Ansammlungen von Linux-(Web-)Servern dynamischer.
Shared VHDX
Für Cluster-Szenarien wird es möglich sein, dass 2 VMs eine gemeinsame VHDX nutzen. Damit entfällt die Notwendigkeit, ein CSV auf iSCSI- oder FibreChannel-Basis einzusetzen.
Am 20.06.2013 um 18:00 Uhr findet das nächste Treffen der .NET Usergroup Karlsruhe (XING-Gruppe der .NET Usergroup Karlsruhe) statt.
Thema
StreamInsight: Complex Event Processing by Microsoft von Constantin Klein.
Details zum Thema
Eine ständig wachsende Anzahl an Sensoren, bringt uns dem "Internet der Dinge" kontinuierlich näher. Anwendungen, die eine große Menge an Daten aus Ereignisströmen verarbeiten müssen, sind eine logische Konsequenz. Vielen Entwicklern ist daher die Reactive Extensions (Rx) Bibliothek ein Begriff. Microsoft stellt mit StreamInsight aber eine weitere mächtige Plattform für Applikationen zur Verfügung, die sich mit der umfangreichen Verarbeitung von real-time Event Strömen befassen.
Dieser User Group Abend stellt StreamInsight als eine großartige Erweiterung Ihrer Toolbox für die Entwicklung von Anwendungen
vor, die mit der Verarbeitung komplexer Ereignisse (CEP- Complex Event Processing) betraut sind. Sie sehen außerdem, wie der Einstieg in diese Technologie gelingt und wie einfach er für .NET Entwickler ist.
Über den Sprecher
Constantin arbeitet als Anwendungsarchitekt und Entwickler bei der Freudenberg Forschungsdienste SE & Co. KG. Dort beschäftigt er sich hauptsächlich mit dem Design und der Entwicklung von Web-Informationssystemen und Datenbanken. Seit seinem Studium der Wirtschaftsinformatik gilt sein besonderes Interesse darüber hinaus allen aktuellen Themen im Microsoft .NET Umfeld, insbesondere aber dem Thema Softwarearchitektur.
Er ist MCSD, MCITP Database Developer und MCPD Web + Enterprise Application Developer. Seit 2010 wurde er jährlich von Microsoft zum Most Valuable Professional (MVP) für SQL Server ernannt.
Er engagiert sich zusätzlich im Vorstand des Just Community e.V. (http://www.justcommunity.de) und als Leiter der .NET User Group Frankfurt (http://www.dotnet-ug-frankfurt.de).
Sein Blog finden Sie unter: http://kostjaklein.wordpress.com
Teilnahme
Bitte meldet Euch wieder via XING an, die Location ist wieder DJK-Ost:
DJK-Ost
Friedrichstaler Allee 52
76131 Karlsruhe
Anfahrt: http://www.djk-ost.de/html/vereinsheim.html
Mit öffentlichen Verkehrsmitteln eher schwierig aber
mit Bus 30 ab Durlacher Tor bis Büchiger Allee und 1km Kanalweg zu Fuß möglich.
Bloggen jetzt auch von Mac OSX aus? Das muss ich ausprobieren. Ich habe keine Lust, immer wieder für bequemes Bloggen Windows mit dem Windows Live Writer anzuwerfen. Der macht das Schreiben und Publizieren zwar sehr einfach - doch Windows ist eine Last in dem Zusammenhang.
Aber jetzt bin ich irgendwie auf Byword gestoßen. Eigentlich benutze ich Mou für Markdown und bin damit zufrieden. Doch
Wer Visual Studio für die Entwicklung von Websites und Websystemen verwendet, kennt den eingebauten IIS Express Webserver. Dieser versteckt sich im System Tray und kann über das Kontextmenü aufgerufen werden.
Zu bequemeren Verwaltung des IIS Express gibt es seit kurzem auf der codeplex-Plattform das Projekt IIS Express GUI. Das codeplex-Projekt besteht aus einer grafischen Oberfläche um IIS Express-Websites zu starten, zu stoppen oder neue Websites anzulegen.
https://iisexpressgui.codeplex.com/
IISExpressGUI Version 1.0 beta wurde von Matteo Tontini in C# mit WPF Oberfläche geschrieben und steht lauffähig kompiliert und mit Quellcode zum Download bereit.
An dieser Stelle passt auch noch rasch mein Praxis-Tipp für IIS Express-Anwender zum Thema IISExpress und SSL–configuring web https failed.
Danke an Christoph Wille für den Tipp!
Der Wunsch ist schnell und klar formuliert: Nutzer möchten sich nicht durch ellenlange Registrierungsformulare quälen, sondern so schnell wie möglich "rein". Und da sowieso alle entweder bei Facebook (fast alle), Google (sehr viele) oder Twitter (einige) sind, liegt es nahe, diese Dienste auch für die Registrierung und den Login für die eigene Website oder App anzubieten. Schließlich hat man kein Interesse daran, dass jemand das eigene Angebot gar nicht erst ausprobiert, weil er schon vor der Registrierung kapituliert.
Der ideale Registrierungsprozess, wie alles Nachfolgende am Beispiel Facebooks, sieht also wie folgt aus:
- Der Nutzer loggt sich bei Facebook unter Angabe seiner E-Mail-Adresse und seines Passworts ein.
- Facebook fragt ihn, ob er der eigenen Anwendung vertraut und bestimmte Daten anvertrauen möchte. Er bejaht es.
- Anschließend leitet Facebook den Nutzer zur eigenen Anwendung weiter und der Nutzer ist eingeloggt und kann loslegen.
Das ist durchaus möglich, abhängig davon, wie viele Daten man vom Authentifizierungsanbieter erhält oder selbst benötigt. Twitter beispielsweise gibt grundsätzlich keine E-Mail-Adressen heraus, auch Angaben zum Geschlecht des Nutzers sind mangels von Twitter selbst erhobener Daten nicht möglich.
Davon abgesehen birgt dieser ideale Weg jedoch ein echtes Problem in sich: die vollkommene Abhängigkeit von (am Beispiel) Facebook. Ein Seiteneffekt, der für kleinere Projekte vielleicht einkalkuliert werden kann, weil die Wahrscheinlichkeit eines Problems gering ist. Welche Probleme können auftreten?
- Der Nutzer kündigt seinen Facebook-Account. Das ist, als ob ein Hausmeister seinen Generalschlüssel wegwirft - er kommt anschließend nirgendwo mehr rein.
- Facebook ändert seine Lizenzbestimmungen oder kündigt gar die Zusammenarbeit mit "unserer Anwendung" auf. Kam alles schon vor.
Was ist also das Ziel des Anbieters, und letztlich auch des Nutzers?
- Nutzer können sich weiterhin einloggen, wenn sie ihren Account bei Facebook gelöscht haben.
- Nutzer können sich weiterhin einloggen, wenn der Facebook-Login, aus welchen Gründen auch immer, nicht mehr funktioniert.
Wie lässt sich das erreichen? Nur, in dem parallel eine weitere Login-Möglichkeit geschaffen wird. Hierfür benötigt man die E-Mail-Adresse und ein Passwort. In der Praxis sähe der Registrierungsvorgang dann so aus:
- Der Nutzer loggt sich bei Facebook unter Angabe seiner E-Mail-Adresse und seines Passworts ein.
- Facebook fragt ihn, ob er der eigenen Anwendung vertraut und bestimmte Daten anvertrauen möchte. Er bejaht es.
- Anschließend leitet Facebook den Nutzer zur eigenen Anwendung weiter, wo ihm ein Registrierungsformular angezeigt wird.
- Hier sind dann je nach Anbieter mehr oder weniger Daten ausgefüllt (FB: Vorname, Nachname, E-Mail, Profilbild; Twitter: Profilbild).
- Der Nutzer gibt noch sein eigenes Passwort ein und schließt die Registrierung ab.
Das ist Mist. Denn der Nutzer wird sich fragen, "Warum muss ich nun noch mal mein Kennwort eingeben? Das habe ich doch gerade bei Facebook schon getan? Was machen die damit?". Und selbst wenn er hier noch nicht stutzig wird, kommt das dicke Ende dann zum Schluss. Nämlich dann, wenn der Worstcase eintritt und der Login via Facebook nicht mehr funktioniert. Dann fragt er sich, vielleicht zwei oder drei Jahre nach der Registrierung "Wie war noch mal meine E-Mail-Adresse, die ich vor 5 Jahren bei euch eingegeben habe? Und wie war mein Passwort?".
Ergo: Das eigentliche Ziel, die Registrierung zu verkürzen und damit deutlich bequemer zu machen lässt sich so nicht erreichen. Hier gibt es zwei widerstrebende Interessen vom Nutzer, der es gerne bequem hat, und uns, die gerne unabhängig sind.
Ergebnis: den eigenen Registrierungsprozess so kurz und angenehm wie möglich gestalten und auf Drittanbieter verzichten.
| Kommentieren | © 2013 Thomas Bandt
Diesmal ein kurzer Blog-Eintrag von mir, mit nur einem Wort: WAU!
Halo to hit Windows 8 and Windows Phone 8 in July!
Endlich beginnt der Sommer :-) ….
In der MSDN Mediathek steht eine sechsteilige Videoreihe zur Verfügung, die sich ganz dem Thema Moderne Softwareentwicklung mit Visual Studio 2012 widmet. Die einzelnen Teile drehen sich dabei um
When the TFS Services preview went live, I started moving my on premise projects to the hosted tfs services. At some point I wanted to delete a team project created in the hosted services. For now, the web interface does not provide an option for that...(read more)
Dank des Windows Azure SDKs ist es nicht nur möglich, virtuelle Maschinen mittels PowerShell zu erstellen, sondern auch eigene Images hochzuladen, einzubinden und die Maschine zu starten. In diesem Tutorial soll gezeigt werden, wie durch PowerShell die Vorteile des Cloud Computing effektiv genutzt werden können, um zu jeder Zeit die notwendigen Ressourcen anzulegen und wieder zu löschen.
Voraussetzung: Ein Azure-Account (entweder die kostenlose Testversion oder der klassische Account) sowie einen Rechner mit Windows 7 oder höher bzw. Windows Server 2008 oder höher.
Schritt 1: Installation und Konfiguration
In Windows 7 und 8 sowie in den Server-Versionen 2012 und 2008 ist PowerShell bereits vorinstalliert. Wir laden hier die Windows Azure PowerShell herunter, in der die notwendigen cmdlets für Azure erhalten sind. Dazu navigieren wir auf diese Seite, scrollen ein Stück nach unten, klicken auf "Windows Azure PowerShell" und im aufpoppenden Fenster auf “Ausführen” (bzw. “Run”). Es öffnet sich nun der Installationsprozess, der mehr oder weniger selbsterklärend ist.
Ist das SDK installiert, öffnen wir die Windows Azure PowerShell (Suchfunktion) und nicht die klassische PowerShell. Nun laden wir zunächst unsere Accountdaten herunter, indem wir folgendes cmdlet eingeben:
> Get-AzurePublishSettingsFile
Es öffnet sich ein Browserfenster und wir können uns mit unseren Azure-Accountdaten einloggen. Danach werden uns die publishsettings zum Download angeboten, die wir lokal speichern.
Abschließend navigieren wir zu jenem Ordner, in dem wir unsere publihssettings abgelegt haben und geben folgendes cmdlet ein (je nach filename natürlich abgewandelt):
> Import-AzurePublishSettingsFile <filename>.publishsettings
Achtung: Sollte der Azure-Account deaktiviert oder sonst nicht erreichbar sein, wird hier eine “Object reference not set”-Exception ausgelöst.
Schritt 2: Storage anlegen, VHD hochladen und VM erstellen
Windows Azure unterstützt das gängige VHD-Format für virtuelle Festplatten. Wir können also ein System, das wir lokal in einer VM-Umgebung installiert haben, mit nur einigen wenigen Zeilen Code hochladen. Zuvor drei kurze Begriffserklärungen:
Storage: Ein Storage-Account ist de facto nichts anders als ein Ordner, in dem Dateien (meistens BLOB – Binary Large Objects wie zB Videos oder eben VHDs) gespeichert werden können.
Image: Images sind vorgefertigte Abbilder von Betriebssystemen aus denen Disks erstellt werden können.
Disk: Eine Disk ist schlussendlich ein Teil einer virtuellen Maschine, der als "Festplatte” des Systems fungiert. Aus Images können beliebig viele Disks erstellt werden.
Wir benötigen als erstes ein Speicherkonto um unsere VHD auf Azure lagern zu können. Dazu geben wir folgenden Befehl in der Azure PowerShell ein:
> New-AzureStorageAccount -StorageAccountName "ubuntustorage111" -Label "UbuntuStorage"
-Location "West Europe"
Der Parameter “-StorageAccountName” muss weltweit einzigartig sein, kann aber ebenso wie Label und Location frei gewählt werden.
Im nächsten Schritt laden wir die VHD in den soeben erstellten Storage-Account. Verschiedene Programme wie zB VirtualBox erlauben die einfache Erstellung von VHDs, wichtig in diesem Zusammenhang ist stets, dass wir unsere virtuelle Maschine bereits lokal so konfigurieren müssen, dass wir später darauf zB via SSH zugreifen können. In diesem Tutorial werde ich später via SSH auf unsere Maschine zugreifen, daher ist auf der hochzuladenden Maschine bereits ein SSH-Server installiert.
Sind wir sicher, dass wir alles passend konfiguriert haben und bereit für die Cloud sind, laden wir die VHD mit folgendem Befehl in unseren Storage-Account:
Dabei ändern wir den Parameter “-Destination” – je nachdem welchen StorageAccountName wir gewählt haben – ebenso ab wie den “LocalFilePath” der angibt, wo auf unserer lokalen Festplatte die hochzuladende VHD liegt. Wichtig zu erwähnen ist in diesem Zusammenhang, dass die Upload-Geschwindigkeit des verwendeten Internet-Zugangs über 2 Mbps liegen sollte, andernfalls dauert der Upload extrem lange, was besonders bei instabilen Internetverbindungen leicht zu Abbrüchen führen kann.
Ist der Upload erfolgreich, erstellen wir aus der VHD eine bootbare Disk mit folgendem Befehl:
> Add-AzureDisk -DiskName 'UbuntuServerDisk1' –MediaLocation
'https://ubuntustorage111.blob.core.windows.net/vhds/UbuntuServer.vhd' -OS "Linux"
Wenn wir ein Windows-System hochgeladen haben, ändern wir hier den Parameter “-OS” von “Linux” auf “Windows”.
Es wäre auch möglich, aus der hochgeladenen VHD zuerst ein Image zu erstellen (Befehl: Add-AzureVMImage) und aus diesem Image die Disk. Da aber ohnehin ein Befehl existiert um direkt aus der VHD die Disk zu erstellen brauchen wir diesen Umweg nicht gehen.
Nun folgt ein wichtiger Schritt: Wir müssen Azure noch bekannt geben, welche Subscription wir für das Deployment der virtuellen Maschine verwenden wollen, andernfalls beschwert sich Azure bei Eingabe des New-AzureVm-cmdlet mit der Meldung “Must specify MediaLocation or set a current storage account using Set-AzureSubscription”. Zusätzlich dazu müssen wir den aktuell verwendeten Storage-Account mittels des Parameters “-CurrentStorageAccount” angeben. Um die notwendigen Daten zu erhalten geben wir zunächst
ein. Wir erhalten folgende Ausgabe:
In diesem Bild ist der <SUBSCRIPTION-NAME> als oranges Rechteck hinterlegt, die <SUBSCRIPTION-ID> als grünes Rechteck und der <THUMBPRINT> als roter Kreis. Diese Werte fügen wir in das folgende config-script ein, das es auch hier zum Download gibt:
# Die folgenden Parameter anpassen:
$subscriptionName = '<SUBSCRIPTION-NAME>'
$subscriptionId = '<SUBSCRIPTION-ID>'
$thumbprint = '<THUMBPRINT>'
$storageAccount = '<STORAGE-ACCOUNT>'
# Ab hier nichts mehr aendern
$mgmtCert = Get-Item cert:\\CurrentUser\My\$thumbprint
Set-AzureSubscription -SubscriptionName $subscriptionName -SubscriptionId $subscriptionId
-Certificate $mgmtCert
Set-AzureSubscription -DefaultSubscription $subscriptionName
Set-AzureSubscription -SubscriptionName $subscriptionName –CurrentStorageAccount $storageAccount
Nachdem wir das ps1-script angepasst und ausgeführt haben, wählen wir noch die aktuelle Konfiguration aus:
> Select-AzureSubscription -SubscriptionName "<SUBSCRIPTION-NAME>"
Schlussendlich können wir die bereits konfigurierte Disk in eine VM einbinden, die wir mit folgendem Befehl erstellen:
> New-AzureVMConfig -DiskName 'UbuntuServerDisk1' -InstanceSize Small -Name 'UbuntuServer' |
Add-AzureEndpoint -Name "ssh" -Protocol tcp -LocalPort 22 -PublicPort 22 |
Add-AzureEndpoint -Name "http" -Protocol tcp -LocalPort 80 -PublicPort 80 |
New-AzureVM -ServiceName 'UbuntuServer62722' -Location 'West Europe'
Zu beachten ist, dass der Parameter “-ServiceName” wieder weltweit einzigartig ist und noch nicht vergeben sein darf, andernfalls erhalten wir die Meldung:
New-AzureVM : "An exception occurred when calling the ServiceManagement API. HTTP Status Code: 409. Service Management Error Code: ConflictError. Message: The specified DNS name is already taken.
Außerdem wichtig ist bei dieser pipe, dass Endpoints mittels “Add-AzureEndpoint” gesetzt werden, damit die Maschine von außen über Port 22 und Port 80 erreichbar ist. Tun wir das nicht, befindet sich die Maschine in einer BlackBox und kann von außen nicht angesprochen werden. In anderen Worten: Löschen und erneut konfigurieren.
Wenn die Maschine nicht von selbst startet, können wir dies auch manuell tun. Dazu ersetzen wir in nachfolgendem Script nur den “-ServiceName” und den “-Name” Parameter:
> Start-AzureVM -ServiceName "UbuntuServer62722" -Name "UbuntuServer"
Damit sollte unsere VM fertig konfiguriert sein – sie wird nun auch mit Status “Running” in unserem Management-Portal in Azure angezeigt:
Um uns nun zu unserer Maschine zu verbinden, geben wir in einem SSH-Programm unserer Wahl den ServiceName gefolgt von “cloudapp.net” ein. Wir sehen unsere DNS auch im Dashboard, wenn wir auf die VM klicken, unten rechts im “quick glance”-Block:
Hinweis: Sollte man übrigens unabsichtlich durch Experimentieren die Konfiguration der Azure PowerShell “zerschießen”, hilft es eventuell, den Ordnerinhalt in “C:\Users\<username>\AppData\Roaming\Windows Azure Powershell” zu löschen. In diesem Ordner werden Default-Konfigurationen von Azure PowerShell gespeichert.
Schritt 3: Download der VHD und Aufräumen
Eventuell möchten wir unsere VM aus dem Netz nehmen, downloaden und unsere VM- und Storage-Accounts löschen. Hier gehen wir mehr oder weniger den umgekehrten Weg aus Schritt 2. Zuerst stoppen wir die VM:
> Stop-AzureVM -ServiceName "UbuntuServer62722" -Name "UbuntuServer"
Danach können wir die VHD downloaden:
> Save-AzureVhd -Source 'https://ubuntustorage111.blob.core.windows.net/vhds/UbuntuServer.vhd'
-LocalFilePath "C:\Users\t-chvor\Desktop\DownloadedVM.vhd"
Dann entfernen wir die VM:
> Remove-AzureVM -ServiceName "UbuntuServer62722" -Name "UbuntuServer"
Nun können wir die Disk und die zugehörige VHD entfernen. Es kann aber einige Minuten dauern bis die VM tatsächlich gelöscht ist, das bedeutet zwischen dem vorherigen und dem nächsten cmdlet sollte eine kurze Wartezeit liegen, andernfalls erhalten wir die Exception: “A disk with name UbuntuServerDisk1 is currently in use by virtual machine”
> Remove-AzureDisk -DiskName "UbuntuServerDisk1" –DeleteVHD
Jetzt entfernen wir noch das Cloud-Service:
> Remove-AzureService -ServiceName "UbuntuServer62722"
Abschließend entfernen wir den Storage-Account:
> Remove-AzureStorageAccount -StorageAccountName "ubuntustorage111"
Damit sind alle Daten gelöscht, es fallen hierfür keine Kosten mehr an.
Dadurch, dass der Up- und Download-Prozess vollständig scriptbar ist, können VHDs zu jeder Zeit hochgeladen, daraus VM erstellt und wieder gelöscht werden – je nachdem wann die Maschine benötigt wird. Das bedeutet in der Realität: Lässt sich ungefähr voraussagen, wann ich für meine Services mehr Rechenleistung brauche, kann ich temporär zeitgesteuert über ein PowerShell-Script einen eigenen Server via Azure zuschalten. Durch diesen “on demand”-Ansatz ergibt sich der große Vorteil, dass nicht extra Hardware gekauft werden muss, wenn diese nicht permanent benötigt wird.
Es ist hier Microsoft außerdem hoch anzurechnen, dass sie auch die Distribution von Linux-basierten Systemen vollständig unterstützen, außerdem ist die Gefahr eines “Vendor lock-in” durch den jederzeit möglichen Download der virtuellen Festplatten in gängigen Formaten praktisch gänzlich ausgeschlossen.
Das komplette PS-Script für den automatisierten Upload gibt es hier zum Download (ohne error-handling), es müssen lediglich die entsprechenden Variablen angepasst werden.
Es wird nicht oft gebraucht, aber wenn, dann müssen wohl die meisten nachschlagen wie es geht. Hier eine kurze Zusammenfassung. In den untenstehenden Passagen wird eine Datenbank namens test verwendet. Dies ist an die eigenen Bedürfnisse anzupassen.
exec sp_dboption 'test', 'single user', 'FALSE'
Sollte eine aktive Verbindung bestehen, erfolgt nun diese Meldung:
Msg 5064, Level 16, State 1, Line 1
Changes to the state or options of database 'test' cannot be made at this time. The database is in single-user mode, and a user is currently connected to it.
Msg 5069, Level 16, State 1, Line 1
ALTER DATABASE statement failed.
sp_dboption command failed.
Um die SPID heraus zu finden, ist folgendes Statement zu verwenden:
select d.name, d.dbid, spid, login_time, nt_domain, nt_username, loginame
from sysprocesses p inner join sysdatabases d on p.dbid = d.dbid
where d.name = 'test'
Nun, die SPID wählen und den Prozess ins Nirvana schicken:
kill 57
Nun nochmals das erste Statement ausführen:
exec sp_dboption 'test', 'single user', 'FALSE'
Command(s) completed successfully.
Fertisch.
Noch vor seinem Sabbatical hat Chris zusammen mit Neno Loje und Thomas Schissler eine Videoserie zum Thema Moderne Softwareentwicklung aufgenommen. In Vertretung von Chris freue ich mich, euch heute diese Videoserie präsentieren zu können. Das Format unterscheidet sich von den sonst klassischen Webcasts. Chris diskutiert in den Videos jeweils mit ausgewählten Gästen über aktuelle Trends und Themen in der Softwareentwicklung. Für uns ist besonders euer Feedback wichtig und wir freuen uns über eure Kommentare.
Moderne Softwareentwicklung:
Moderne Softwareentwicklung 1 - Trends in der modernen Softwareentwicklung
Die Software-Entwicklung ist ein Gebiet das sich schnell verändert und weiterentwickelt. Dabei findet diese Veränderung in den letzten Jahren nicht nur auf technologischer Ebene, sondern zunehmend auch auf der Prozess-Ebene statt. In diesem Video geben drei Experten einen Überblick über die wichtigsten Trends und Entwicklungen für moderne Software-Entwicklung und bieten Ihnen damit eine einfache Möglichkeit, sich schnell darüber zu informieren, welche Themen für Ihre Teams in Zukunft wichtig sein werden und welche Aspekte dabei besonders zu beachten sind.
Moderne Softwareentwicklung 1 - Trends in der modernen Softwareentwicklung | Microsoft from Visual Studio [Microsoft]
Moderne Softwareentwicklung 2 - Modernes Anforderungsmanagement und Planung
Das Bild ist meistens ähnlich: Es gibt eine große Liste an Wünschen an eine Software und nur begrenzte Mittel, mit denen man nicht alles umsetzen kann. Gerade deshalb ist es wichtig, sich auf die richtigen Dinge zu fokussieren und die "Wunschliste" sichtbar zu machen, sodass jeder weiß was und in welcher Reihenfolge es abgearbeitet wird, um letztlich möglichst viel Mehrwert (aus Sicht des Kunden) zu produzieren.
Moderne Softwareentwicklung 2 - Modernes Anforderungsmanagement und Planung | Microsoft from Visual Studio [Microsoft]
Moderne Softwareentwicklung 3 - Stakeholder effizient einbinden
Einer der wichtigsten Trends in der modernen Softwareentwicklung ist eine Veränderung in der Zusammenarbeit mit den sog. Stakeholdern, also Kunden, Vertrieb, Support, Management etc. Diese werden stärker in den Entstehungsprozess von Software eingebunden. Warum das wichtig ist und wie man dies effizient organisieren kann, erfahren sie in diesem Video.
Moderne Softwareentwicklung 3 - Stakeholder effizient einbinden | Microsoft from Visual Studio [Microsoft]
Moderne Softwareentwicklung 4 - Continuous Delivery als zentraler Motor für erfolgreiche Projekte
Kurze Zyklen bieten für die Softwareentwicklung einige interessante Vorteile, aber auch Herausforderungen. Um kurze Zyklen und häufige Releases zu ermöglichen ist auch ein höherer Automatisierungsgrad in den Test- und Release-Prozessen von Nöten. Ist dies erstmals vollbracht, erhält man auf verschiedenen Ebenen eine frühzeitige Rückmeldung. Ist die Implementierung eines Features geplant, geht weniger Zeit verloren bis es seine Produktionsreife erreicht und dann idealerweise schon bald von den Benutzern der Software genutzt werden kann.
Moderne Softwareentwicklung 4 - Continuous Delivery als zentraler Motor für erfolgreiche Projekte | Microsoft from Visual Studio [Microsoft]
Moderne Softwareentwicklung 5 - Optimierte Qualitätssicherung für moderne Prozesse
Moderne Entwicklungsprozesse versuchen neue Software-Inkremente in immer kürzeren Zyklen bereitzustellen um kontinuierlich zu prüfen, ob die umgesetzte Funktionalität die Anwenderanforderungen erfüllt oder ob entsprechend korrigiert werden muss. Bereitstellung neuer (Test-)Versionen im Rhythmus von wenigen Wochen erfordert aber neue Test-Strategien, da die bisherigen Vorgehensweisen in diesem Szenario meist versagen. Informieren sie sich, wie sie ihre Test-Prozesse fit machen für Continuous Delivery.
Moderne Softwareentwicklung 5 - Optimierte Qualitätssicherung für moderne Prozesse | Microsoft from Visual Studio [Microsoft]
Moderne Softwareentwicklung 6 - Erweiterbare und wartbare Architekturen im Team entwickeln
Eine wichtige Anforderung an Architektur ist die einfache Erweiterbarkeit und eine robuste Struktur, die Änderungen möglichst auf wenig Code-Bereiche begrenzt, um das Risiko von Änderungen zu minimieren. Nur so kann die Idee von gewachsener Architektur tatsächlich auch umgesetzt werden. Welche Aspekte dabei wichtig sind und wie dieses Vorhaben gelingen kann, wird in diesem Video erläutert.
Moderne Softwareentwicklung 6 - Erweiterbare und wartbare Architekturen im Team entwickeln | Microsoft from Visual Studio [Microsoft]
Viel Spaß mit den Videos!
Dennis
Microsoft hat im Rahmen der Keynote der TechEd North America zahlreiche Verbesserungen der Windows Azure Plattform veröffentlicht, die ich kurz zusammenfassen möchte:
Neues Abrechnungsmodell “pro Minute”
Bisher wurde bei der Messung des Verbrauchs an Rechenleistung eine angefangene Stunde jeweils aufgerundet und bei der Berechnung der Kosten jeweils die zugehörigen Kosten pro Stunde zugrunde gelegt. Ab sofort ist die Abrechnung auf eine “pro Minute”-Berechnung umgestellt, d.h. es wird nicht mehr aufgerundet, und die Kosten orientieren sich noch stärker am tatsächlichen Verbrauch.
Unterstützung von ACLs für öffentliche Endpunkte in Virtual Machines
Für Inbound Traffic können pro für Empfang geöffneten Endpunkt in Virtuellen Maschinen Access Control Lists (ACLs) definiert werden. Damit kann auf Netzwerkebene festgelegt werden, wer Zugriff auf Virtual Machines erhält und wer nicht.
Weitere Geräteoptionen für den Aufbau gesicherter Site-to-Site-Verbindungen
Neben Cisco und Juniper werden jetzt auch Netzwerk-Geräte von WatchGuard, F5 und Citrix für den Aufbau gesicherter VPN-Site-to-Site Verbindungen mittels Virtual Network unterstützt.
Unterstützung von SSL für Windows Azure Websites (Preview)
Für Reserved Instances in Windows Azure Websites können jetzt eigene Domainnamen konfiguriert werden, die über SSL-Zertifikate abgesichert werden können. Hierzu können im Windows Azure Management Portal eigene SSL-Zertifikate hochgeladen und hinterlegt werden.
BizTalk Services (Preview)
Bereits gestern habe ich ja über die neuen BizTalk Services gebloggt. Diese Dienste erlauben die Integration von Azure Services, SaaS- oder On-premises-Anwendungen durch konfigurationsbasierten Einsatz des BizTalk Service. Dieser stellt EDI-Funktionen zur Verfügung. Die Verbindung zu On-premises Line-of-Business-Anwendungen erfolgt dabei über Cloud Endpoints, hinter denen Adapter zu SAP-, Oracle-, SQL-Server- oder PeopleSoft-Adapter hängen können.
Umstelllung der MSDN Benefits
Bisher waren in MSDN Subscriptions feste Verbrauchseinheiten für Windows Azure enthalten (z.B. konkret “750 Rechenstunden”). Die Benefits werden nun in ein Modell umgestellt, bei der eine geldwerte Leistung definiert ist, d.h. Nutzer erhalten einen “Gutschein im Wert von X Euro”, und es bleibt ihnen überlassen, wie sie diesen Geldbetrag auf die Nutzung von Azure Ressourcen verwenden. Dabei gelten folgende Geldwerte:
- Visual Studio Professional mit MSDN: 50$
- Visual Studio Premium mit MSDN: 100$
- Visual Studio Ultimate mit MSDN: 150$
Darüber hinaus erhalten MSDN Abonnenten Rabatte auf die Kosten (z.B. 33% Rabatt auf Windows Azure Virtual Machines).
Ab sofort dürfen die meisten in einer MSDN Subscription enthaltenen Softwareprodukte auch für Entwicklungs- und Test-Installationen auf Windows Azure verwendet werden.
Weitere Informationen
Bereits zum 4. Mal findet der .NET Open Space Süd in Karlsruhe statt und die Anmeldung ist seit Samstag möglich. Einige Plätze sind noch frei.
Wer noch nicht weiß, was ihn beim .NET Open Space erwartet, hier die obligatorische Beschreibung:
Die besten Gespräche hat man fernab von einer festgelegten Agenda, bei einem Kaffee und beim "du". Dort gibt es keine Rollenaufteilung in Sprecher / Zuhörer, Entwickler / Administrator usw. und die Themen finden sich vor Ort ganz von selbst. Das ist die Idee vom .NET Open Space, die sich bereits seit 2008 in Leipzig, Ulm und Karlsruhe bewährt hat. Hier sind alle gleich. Auch die Organisatoren halten sich im Hintergrund und moderieren nur ab und an etwas.
Der .NET Open Space Süd 2011 läuft vom 16.07.2011 bis 17.07.2011. Welche Inhalte in dieser Zeit bearbeitet werden, wird vor Ort bestimmt, denn die Veranstaltung ist Open Space.
Die Teilnahme ist kostenlos. Wenn du möchtest, kannst du den Organisatoren einen Geldbetrag zukommen lassen, welcher für die Gestaltung (Abendveranstaltung, Getränke etc.) verwendet wird. Trage den Betrag hier mit in die Teilnehmerliste ein. Über die Höhe des Betrages, ob z.B. 25 EUR, 50 EUR, 100 EUR oder mehr, entscheidest du vollkommen frei und selbst. Bedenke, dass die Veranstaltung gerade vom Sponsoring der Teilnehmer lebt.
Die Teilnehmer gestalten das Programm selbst. Erfahrungsaustausch ist das A und O und steht im Vordergrund.
Mehr Informationen und Anmeldung unter: http://karlsruhe.netopenspace.de
Twitter-Nutzer erhalten aktuelle News von @nossued.
Der offizielle Twitter-Hash-Tag ist #nossued.
Die Anmeldung zu den Parties am Freitag und Samstag werden wir dieses Mal nicht stringent vornehmen, d.h. wer da ist, ist da und der Rest hat Pech gehabt 
Die geplanten Locations sind am Freitag Enchilada und am Samstag Alte Bank (sofern nichts mehr dazwischen kommt – Bestätigung folgt über Twitter).
An dieser Stelle auch wieder ein herzliches Dankeschön an Alexander Groß und Torsten Weber für die Unterstützung bei der Einrichtung der Website für den .NET Open Space Süd 2013.
Yesterday during the opening keynote of TechEd North America Microsoft released the first official details about the next version of SQL Server: SQL Server 2014. There are huge improvements in the area of High Availability, Performance, and Scalability, on which I want to concentrate in this weblog posting.
Disclamer: This blog posting is based on the first official information that Microsoft released yesterday (June 3, 2013) about SQL Server 2014. This posting is not a complete feature reference for SQL Server 2014, nor it could be 100% accurate, because there is not really too much information currently available.
SQL Server AlwaysOn
With SQL Server 2012 Microsoft released the first implementation of AlwaysOn, mainly a completely new High Availability technology based on the principles of Database Mirroring. With the SQL Server 2014 release Microsoft now supports up to 8 different Secondaries, which provides you a huge scaleout in comparison of the 4 Secondaries that are possible currently with SQL Server 2012. The question for me is, who will really pay for it. I’m working with a lot of different customers, which are currently not able to migrate to AlwaysOn, because of the additional licensing costs (AlwaysOn is only part of the Enterprise Edition of SQL Server). Scaling out Read-Only workload to Secondaries is a perfect concept, but almost no one of my customers will actually pay for that nice feature (as soon as you use a Secondary, you have to fully license it).
Online Database Operations
Online Database Operations are for some SQL Server based shops just a foundation. Unfortunately Microsoft made here our life in the past not really easy. SQL Server 2012 has already made a huge step forward in this area. With SQL Server 2014 Microsoft is doing an additional step and provides Online Index Operations on the Partition Level, which will be a very nice feature for VLDBs (Very Large Databases).
Backups to Azure
The 1st time when I read about Backups to Azure, I thought Microsoft is kidding us. No, they really made it: you can now store your backup files directly in Azure. In my opinion this is just a crazy idea. It introduces a lot of overhead regarding the involved latency times, and you have no direct access to your backup files anymore. Just imagine your ISP (Internet Service Provider) goes offline, your connection to the cloud is cut-off, and in the mean time your database crashes, and you have to restore it from backup files that are currently not accessible. Just a horror story – nothing more. Not recommended from my side because you have no direct control over the RTO (Recovery Time Objective) anymore.
Smart Backups
With Smart Backups Microsoft takes regularily backups to Windows Azure of your databases or your whole SQL Server instance, whenever it is necessary. Yes, you read correctly: whenever necessary. Normally when I’m doing consulting and training, I’m saying your backup strategy is only as good as your recovery strategy. This means you should define how long it should take until your database is online after a crash/desaster recovery, and from that period of time you should derive your backup strategy. But with Smart Backup you are just doing it the opposite way. Also not really recommended.
SQL Server with Windows Azure Storage
This is a really funny feature which makes sure that I can also do a lot of consulting engagements over the next years which indirectly drives the improvements of the realism of my Boeing 737-800 flight simulator 
. With SQL Server 2014 you are now finally able to store your data and transaction log files directly in Windows Azure Storage. Very cool regarding performance because you just introduce a huge overhead regarding latency times for your files in your SQL Server installation. Mainly all my customers currently have problems with huge latency times to their local based SANs, imagine what happens when you go over the wire through the internet to the Cloud to access your data files, or write out transaction log records for committing your inflight transactions. I hope sys.dm_io_virtual_file_stats has BIGINT data types for the stall time columns – I have to check that afterwards
Hekaton
With Hekaton SQL Server 2014 provides us a true Multi Version Concurrency Control system (MVCC) integrated directly within the good old traditional relational engine of SQL Server. The main goal about MVCC is to avoid traditional locking and latching in the main memory of the SQL Server process. With Hekaton you can completely avoid locking when accessing and changing data. Yes, also the Exclusive Locks are completely gone when changing data – really awesome work!
In addition to that Hekaton also avoids completely the traditional latching architecture that relational databases must use for synchronizing concurrent resource access in main memory. Because of that big shift parts of the relational and storage engine of SQL Server are completely rewritten to take advantage of these new approaches for dealing with large scale OLTP workloads. Hekaton can be interesting, but in the 1st step you have to hit the limits of SQL Server, so that Hekaton can be interesting for you. In my opinion customers in the 1st step hit limits in SQL Server because of their bad indexing strategy, or because the transaction log can’t cope with the current amount of transaction log records (just think about Page Splits). I have just seen over the time a few customers which have really hit the limits of SQL Server because of Latch Contention. If you are hitting these limits, Hekaton can be interesting for you. But on the other hand, there is also a long list of restrictions that you have to keep in mind:
- Row Sizes can’t be larger than 8060 bytes (incl. Variable Length Columns!)
- LOB Data Types are not supported
- No Foreign Key Constraints.
- …
When I’m currently looking into database designs, they are mainly not qualified for Hekaton because of the above listed restrictions. Just imagine you have a table with 2 VARCHAR(4500) fields: in sum you are over the 8060 bytes limits, and you can’t use Hekaton for that specific table, without doing any reengineering of that table…
ColumnStore Indexes
Yes, they did it in SQL Server 2014: Updateable Clustered ColumnStore Indexes! Nothing more to say- just WELL DONE! J
Statistics Improvements
Statistics are now maintained on the partition level, but they are still created on the table level. Maintaining on the partition level means, that 20% of changes of the specific column on the partition level triggers the update of the underlying statistics objects. Also very nice, but I would have preferred Partition Level Statistics…
Resource Governor
Till SQL Server 2012 we were able to throttle CPU and Memory (Query Memory). With SQL Server 2014 they finally added IO Throtteling. You can now specify the maximum IOPS for a specific Resource Pool. Also a very nice addition J.
Conclusion
As you can see there are a lot of new enhancements in the area of peformance, scalability, and high availability in SQL Server 2014. But for some enhancements you really have to think if they really make sense for your environment, and if you can live with the introduced side effects – like higher latency times. All in all I’m really looking forward to the first public CTP version to try out all that nice stuff.
Call to action: What do you think about the various enhancements in SQL Server 2014, and do you think you will migrate after the RTM version to it? Please feel free to leave a comment with your feelings/concerns about it…
Thanks for reading
-Klaus
Die oftmals sehr prägnanten Commandlets der Windows PowerShell kann man sich auch in .NET-Anwendungen zu nutze machen.
Christian Folie und Jörg Egretzberger stellen am 6. Juni 2013 beim .NET Community Austria Treffen ein Projekt vor, bei dem Event Sourcing sehr erfolgreich eingesetzt wird. Anstatt den aktuellen Zustand von Objekten in der Datenbank zu speichern, wird die Änderung (= Domain Event) auf einem Stapel (=Event Store) gespeichert. So kann zu jedem Zeitpunkt eine neue Ansicht, ein neuer Report, oder eine neue Auswertung erstellt werden und auf ALLE Daten bzw. Änderungen seit Stunde 0 zurück gegriffen werden. Plus kostenlos: komplettes Audit Log.
Wir zeigen euch das Projekt, in dem zur Zeit 1,5 Millionen Events gespeichert sind und im Endausbau 86.000 neue Events pro Tag hinzukommen. Außerdem: wie Perfomance Tuning gemacht wurde, wie einfach es war und warum wir Entity Framework durch Simple.Data ersetzt haben.
Weiters wollen wir euch weitergeben, welche enormen Vorteile sich beim täglichen Entwickeln ergeben und warum die Entwickler schneller neue Features schreiben und auch deployen, sowie das Feedback vom Kunden weitergeben. Zum Beispiel Deployment und Datenbankmigration: es werden die Datenbanktabellen gelöscht (!?) und neu erstellt. Downtime: < 1 Sekunde
(und das bei einem virtualisierten Server mit 1 Core und 2 GB RAM)
Wir wollen auch über die Pläne mit NoSQL Datenbanken und Greg Youngs Event Store mit euch diskutieren.
Kurzum: ein MUSS für jeden Entwickler der ein Projekt sehen möchte, bei dem man leichtgewichtig, schnell und wendig entwickeln kann, ohne die Laster von SQL & Co. mitschleppen zu müssen. Wer erfahren möchte, was agiles entwickeln in der Praxis bedeutet und warum in diesem Projekt extrem rasch auf Kundenwünsche und Änderungen reagiert werden kann, sollte diesen Termin nicht verpassen.
Wann: 6. Juni 2013 um 18 Uhr
Wo: ÖBB-IKT GmbH
Elisabethstraße 9
1010 Wien
Treffpunkt im Hof bzw. beim Portier
Bitte meldet euch hier an: http://dotnetopenspace.ning.com/forum/topics/6-6-2013-eventsourcing-in-der-praxis
Microsoft hat Windows Azure heute um einen neuen Plattform-Dienst ergänzt: BizTalk Service. Dabei handelt es sich um einen PaaS-Dienst, mit dessen Hilfe viele Integrationsszenarien zur Vernetzung von Cloud- und Enterprise-Line-of-Business-Systemen umgesetzt werden können. BizTalk Services stellen dabei zentrale Funktionen der BizTalk-Plattform in der Cloud zur Verfügung ohne dass zu deren Betrieb Installations- oder Administrationskenntnisse erforderlich sind.
In der aktuellen Ausgabe der Cloud Cover Show stellen Nick Harris und Nathan Totten zusammen mit Kent Brown und Guru Venkataraman BizTalk Services vor und beschreiben verschiedene Einsatzszenarien dieses neuen Dienstes.
Windows Azure BizTalk Services erlauben die Integration von Azure Services, SaaS- oder On-premises-Anwendungen durch konfigurationsbasierten Einsatz des BizTalk Service. Dieser stellt EDI-Funktionen zur Verfügung. Die Verbindung zu On-premises Line-of-Business-Anwendungen erfolgt dabei über Cloud Endpoints, hinter denen Adapter zu SAP-, Oracle-, SQL-Server- oder PeopleSoft-Adapter hängen können.
Über ein Drag-and-Drop-Interface können Nachrichtenflüsse ausgehend von Quellen wie HTTP, FTP, SFTP und REST, validiert und transformiert in beliebige Ausgabeformate hin zu Endpoints konfiguriert werden.
Erste Schritte
- Wählen Sie im Windows Azure Management Portal den Menüpunkt NEW (unten links).
- Wählen Sie unter APP SERVICES den Punkt BIZTALK SERVICE.
- Wählen Sie den Punkt CUSTOM CREATE und folgen Sie den vorgegebenen Schritten.
Sollten der Menüpunkt BIZTALK SERVICE deaktiviert sein, müssen Sie diesen erst aktivieren. Führen Sie hierzu folgende Schritte aus:
- Klappen Sie das Hauptmenü oben auf. Klicken Sie hierzu rechts oben im Management Portal auf den Pfeil neben dem Windows Azure Logo.
- Wählen Sie den Menüpunkt SUPPORT.
- Wählen Sie oben den Menüpunkt ACCOUNT.
- Wählen Sie den Menüpunkt PREVIEW FEATURES.
- Klicken Sie unter dem Eintrag BizTalk Services auf die Schaltfläche TRY NOW.
Innerhalb weniger Minuten sollten die BizTalk Services freigeschaltet werden.
Weitere Informationen
Das Microsoft .NET Framework ist nun seit rund zehn Jahren ein fester Bestandteil in der Applikationsentwicklung. Die Version 4.5 enthält wesentliche Neuerungen und bietet eine solide Grundlage für moderne Applikationen und Benutzeroberflächen (UI). Der MVP Jose Luis Latorre (Mitbegründer der Zurich Developers .NET User Group) hat nun ein praxisorientiertes Buch zum Thema mit dem Titel Microsoft .NET Framework 4.5 Quickstart Cookbook veröffentlicht. Sein "Kochbuch" bietet Rezepte zu allen spannenden Features der neusten Version des .NET Frameworks und zeigt, wie mit den besten Zutaten die Applikationsentwicklung sicher gelingt. Der Autor erläutert nicht nur die umfangreichen Neuerungen des .NET Frameworks 4.5, sondern bietet zahlreiche Techniken um diese Features gleich selber korrekt zu verwenden.
Bis zum 3. Juli 2013 gibt es bei Packt Publishing 20% Rabatt auf den regulären Preis, gleichzeitig ist es auch auf Amazon erhältlich.
![46fe0e70-a06b-433b-870a-66cb53e0db8e[1]](http://blogs.msdn.com/cfs-file.ashx/__key/communityserver-blogs-components-weblogfiles/00-00-00-86-80-metablogapi/6177.46fe0e70_2D00_a06b_2D00_433b_2D00_870a_2D00_66cb53e0db8e1_5F00_thumb_5F00_221A6D48.png "46fe0e70-a06b-433b-870a-66cb53e0db8e[1]")
Gestern, an der TechEd North America, gab es neue Ankündigungen zu Visual Studio 2013:
Die nächste Version, Visual Studio 2013, wird noch dieses Jahr verfügbar. Einer erster Preview Build wird auf der Build 2013 in San Francisco Ende dieses Monats bereitgestellt. In Visual Studio gibt es viele neue Funktionen welchen den Applikations Lebenszyklus unterstützen, inklusive neuer Funktionen zur Agilität, Qualitätsmanagement und DevOps:
- Agiles Portfolio Management – Team- und Organisationsweites Verwalten von grossen agilen Projekten durch die Darstellung hierarchischer Beziehungen der Arbeitselemente.
- Cloud basierende Last Tests – Die neue Funktion des Team Foundation Service nutzt die Skalierbarkeit von Windows Azure um Weblast zu generieren und tausende von simultanen virtuellen Benutzern zu simulieren. Damit lässt sich gut beurteilen wie sich Webapplikationen und Dienste unter hoher Last verhalten.
- Code Informationsanzeigen die zusätzliche Informationen direkt im Codeeditor von Visual Studio über Unit-Tests, Work Items, Code Verweise und vieles mehr bereitstellen. Erhöhte Produktivität durch Projekt- und kontextbezogenen Informationen, welche direkt im Codeeditor von Visual Studio konsumiert werden können ohne den Editor verlassen zu müssen.
- Verbesserte Zusammenarbeit mit dem “Team Room”
- Identity Integration in Visual Studio – Verknüpfung der IDE mit Backend Diensten, beispielsweise Roaming Unterstützung für Entwicklereinstellungen wenn Entwickler den Arbeitsplatz wechseln.
- Unterstützung im TFS für integrierte Codekommentare, welche Code Reviews mit erhöhter Transparenz und Nachverfolgbarkeit ermöglichen.
- Neuer .NET Memory Dump Analyzer – Einfache Navigation, Lokalisierung und Darstellung von .NET Objekten, Vergleich von zwei Memory Dumps um Speicherlecks schneller aufzufinden und zu beheben.
- Integrierte Git Unterstützung in Visual Studio 2013 am Client und am Server, inklusive in der on-Premise Variante des Team Foundation Server 2013.
Weitere Informationen zu Visual Studio 2013 finden Sie auf dem Blog von Somesegar und dem Blog von Brian Harry.
Die Keynote der TechEd finden Sie auf Channel 9. Hier werden auch nach und nach die weiteren Sessions publiziert.
Wie auf
Somesegar Blog’s beschrieben wurden heute einige Neuerungen auf der TechEd in Amerika zu Visual Studio und MSDN bekannt gegeben. Einige dieser Neuerungen stehen bereits ab heute im Team Foundation Service zur Verfügung. Im Verlauf der kommenden Wochen und auf der Build erfahren Sie mehr über die vielen Neuerungen. Zusätzlich hat Scott noch einige zusätzliche Änderungen zu Windows Azure publiziert. Dazu gehören unter anderen:
- Minutengenaue Abrechnung und keine Verrechnung für angehaltene VM’s
- SSL Support für Web Seiten
- Active Directory – Aktualisiertes Directory sync utility, Möglichkeit Office 365 Verzeichnis Mandanten aus dem Windows Azure Management Portal zu verwalten
- Free Trial: Flexiblere Trial-Angebote
Hier ein kleiner übersetzter Überblick über die wichtigsten Neuerungen
- Visual Studio 2013 und Team Foundation Service
- InRelease
- MSDN and Dev/Test on Windows Azure
Visual Studio 2013
Die nächste Version, Visual Studio 2013 wird noch dieses Jahr verfügbar. Einer erster Preview Build wird auf der Build 2013 in San Francisco Ende dieses Monats bereitgestellt. In Visual Studio gibt es viele neue Funktionen welchen den Applikations Lebenszyklus unterstützen, inklusive neuer Funktionen zur Agilität, Qualitätsmanagement und DevOps.
- Agiles Portfolio Management – Team- und Organisationsweites Verwalten von großen agilen Projekten durch die Darstellung hierarchischer Beziehungen der Arbeitselemente.
- Cloud basierende Last Tests – Die neue Funktion des Team Foundation Service nutzt die Skalierbarkeit von Windows Azure um Weblast zu generieren und tausende von simultanen virtuellen Benutzern zu simulieren. Damit lässt sich gut beurteilen wie sich Webapplikationen und Dienste unter hoher Last verhalten.
- Code Informationsanzeigen die zusätzliche Informationen direkt im Codeeditor von Visual Studio über Unit-Tests, Work Items, Code Verweise und vieles mehr bereitstellen. Erhöhte Produktivität durch Projekt- und kontextbezogenen Informationen, welche direkt im Codeeditor von Visual Studio konsumiert werden können ohne den Editor verlassen zu müssen.
- Verbesserte Zusammenarbeit mit dem “Team Room” mit dem Team Mitgliedern mit real time und persistenten Chat kommunizieren nahtlose verknüpft mit Daten und Interaktionen im gesamten TFS
- Identity Integration in Visual Studio – Verknüpfung der IDE mit Backend Diensten, beispielsweise Roaming Unterstützung für Entwicklereinstellungen wenn Entwickler den Arbeitsplatz wechseln.
- Unterstützung im TFS für integrierte Codekommentare, welche Code Reviews mit erhöhter Transparenz und Nachverfolgbarkeit ermöglichen.
- Neuer .NET Memory Dump Analyzer – Einfache Navigation, Lokalisierung und Darstellung von .NET Objekten, Vergleich von zwei Memory Dumps um Speicherlecks schneller aufzufinden und zu beheben.
- Integrierte Git Unterstützung in Visual Studio 2013 am Client und am Server, inklusive in der on-Premise Variante des Team Foundation Server 2013.
InRelease
DevOps wird für Unternehmen als Teil des Applikations Lebenszyklus immer wichtiger. Es ist heute notwendig immer schneller qualitativ hochwertige Anwendungen zu entwickeln und bereitzustellen. Einer unser Fokuspunkte in der Weiterentwicklung ist daher DevOps.
Als Teil dieses erhöhten Fokus gab Microsoft heute die Vereinbarung bekannt, in der InCycle’s InRelease Geschäftsbereich von Microsoft akquiriert wird. InRelease ist eine führende Lösung für Release Management für .NET und Windows Server Anwendungen. InCycle’s InRelease Produkt ist eine Lösung zur kontinuierlichen Bereitstellung welche einen einheitlichen integrierten Bereitstellungsprozess durch alle ihre Umgebungen von TFS bis zur Produktion anbietet.
Diese Akquise wird Microsofts Angebot im Bereich von ALM und DevOps erweitern. Wir freuen uns unseren Kunden kontinuierlich neue Werkzeuge und Möglichkeiten bereitzustellen, um Ihnen zu helfen hoch qualitative Anwendungen und Dienste mit erhöhter notweniger Agilität zu entwickeln und zu betreiben.
MSDN and Dev/Test on Windows Azure
Die technischen Verbesserungen in Visual Studio zeigen nur eine Facette unserer Arbeit um die Produktivität und den Erfolg von Entwicklungsteams zu verbessern die auf der Microsoft Plattform entwickeln.
Wir haben die Windows Azure Vorteile welche berechtigten MSDN Abonnenten zu Verfügung stehen verbessert; Sie können nun selbst auswählen, wie Sie Ihre Windows Azure-Gutschriften für die Entwicklung und das Testen nutzen möchten, beispielsweise für virtuelle Maschinen (VMs), Websites, Cloud-Dienste, Dienste auf Mobilgeräten, Speicher, SQL-Datenbanken, Content Delivery Network, HDInsight, Mediendienste und mehr. Mit Ihrem Windows Azure MSDN-Vorteil erhalten Sie außerdem mit MSDN-Abonnement-Software wie beispielsweise SQL Server und BizTalk Server Zugang zu vorkonfigurierten Images virtueller Maschinen. Alternativ hierzu können Sie mit Ihrer MSDN-Software selbst virtuelle Maschinen hochladen.
Eines unserer Ziele ist es für jedes Mitglied eines Entwicklungsteam die Möglichkeit zu schaffen jegliche benötigte Umgebungen für Entwicklung oder Test ohne Hindernisse aufzusetzen zu können. En wichtiger Schritt in diese Richtung ist der neue Windows Azure MSDN Vorteil. Ab dem 1. Juni 2013 erhalten aktive MSDN Subscriber das Nutzungsrecht ausgewählte Software aus der MSDN (mehr Details finden Sie im Visual Studio and MSDN Lizenzierungsdokument ) in Windows Azure VM’s für Entwicklung und Test einzusetzen.
Durch die Bereitstellung eines einfachen und skalierbaren Zugangs zu cloud basierten Entwicklung- und Testressourcen verbessern wir die Agilität ihrer Entwicklungsteams.
Andreas Pollak
Product Marketing Manager Visual Studio 2012 (Entwicklungs- und Testwerkzeuge)
Leader im Magic Quadrant von Gartner für ALM
Heute wurden an der TechEd North America Änderungen für MSDN Abonnementen bekannt geben:
Erweiterte Windows Azure-Vorteile! MSDN Abonnementen können ab 1. Juni selbst auswählen, wie Sie Ihre Windows Azure-Gutschriften für die Entwicklung und das Testen nutzen möchten, beispielsweise für virtuelle Maschinen (VMs), Websites, Cloud-Dienste, Dienste auf Mobilgeräten, Speicher, SQL-Datenbanken, Content Delivery Network, HDInsight, Mediendienste und mehr. Als MSDN-Abonnement erhalten Kunden je nach Produktversion im ersten Monat der Nutzung Ihres Windows Azure-Vorteils eine Gutschrift von bis zu 150USD und danach einen Freibetrag im jeweiligen Monat ihres aktiven MSDN Abonnements.
Mit dem Windows Azure MSDN-Vorteil erhalten alle Abonnementen ausserdem durch MSDN-Abonnement-Software wie beispielsweise SQL Server und BizTalk Server Zugang zu vorkonfigurierten Images virtueller Maschinen. Alternativ hierzu können Abonnementen mit der MSDN-Software auch selbst virtuelle Maschinen hochladen.
Ab 1. Juni 2013 können Abonnementen MSDN-Software auf Windows Azure-VMs ausführen. Dieses Cloud-Nutzungsrecht gilt für sämtliche durch das MSDN-Abonnement abgedeckte Software ausser Windows-Clients und Windows Server.Darüber hinaus können Nutzer MSDN-Software mit qualifizierten MSDN-Cloud-Partnern nutzen. Weitere Informationen über Cloud-Nutzungsrechte finden Sie im Whitepaper über Lizenzierung von Visual Studio und MSDN.
MSDN Vorteil Team Foundation Service, die ALM-Lösung in der Cloud. Bei Team Foundation Service handelt es sich um eine durchgängige Lösung für den Umgang mit kritischen Elementen des Lifecycle Management. Sie wird ständig mit den neuesten Werkzeugen (beispielsweise mit herkömmlicher und verteilter Versionskontrolle (TFS/Git), flexiblem Portfolio-Management auf Unternehmensebene und Team Room-Zusammenarbeit) aktualisiert. Erfahren Sie mehr über die neuesten Funktionen.
Die Windows Azure MSDN Benefit sind ausschliesslich für Entwicklungs – und Testzwecken einzusetzten.
Zusammen mit Neno Loje und Christian Binder habe ich ein paar kurze Videos aufgezeichnet
in denen wir gemeinsam darstellen, welche Aspekte in der modernen Software-Entwicklung
wichtig sind. Unsere Teams hier bei artiso arbeiten im wesentlichen (wenn es der Kunde
erlaubt) nach diesen prinzipien und wir haben dadurch die Aspekte Kundenzufriedenheit,
Qualität und Performance merklich verbessern können. Auch wenn diese Dinge sich nicht
alle über Nacht einführen lassen, kann ich nur jedem Team empfehlen, sich auf die
Reise zu machen und den Umstellungsprozess zu beginnen. Die Videos sind kurz gehalten
und sollten einen guten Überblick über die Themen geben, die sie nicht verpassen sollten,
wenn sie sich und ihre Software-Teams fit für die Zukunft machen wollen.
Moderne Softwareentwicklung 1 - Trends in der modernen Software Entwicklung
http://www.youtube.com/watch?v=jcCSa7boTgA
Moderne Softwareentwicklung 2 - Modernes Anforderungsmanagement und Planung
http://www.youtube.com/watch?v=GdLgjgiRHvs
Moderne Softwareentwicklung 3 - Stakeholder effizient einbinden
http://www.youtube.com/watch?v=iYp_T3BkuPM
Moderne Softwareentwicklung 4 - Continuous Delivery für erfolgreiche Projekte
http://www.youtube.com/watch?v=SZj7h53nOfo
Moderne Softwareentwicklung 5 - Optimierte Qualitätssicherung für moderne Prozesse
http://www.youtube.com/watch?v=ie56ESWXg1Q
Moderne Softwareentwicklung 6 - Erweiterbare und wartbare Architekturen entwickeln
http://www.youtube.com/watch?v=jEGU4c8IKHo
Moderne Softwareentwicklung:
Moderne Softwareentwicklung 1 - Trends in der modernen Softwareentwicklung
Die Software-Entwicklung ist ein Gebiet das sich schnell verändert und weiterentwickelt.
Dabei findet diese Veränderung in den letzten Jahren nicht nur auf technologischer
Ebene, sondern zunehmend auch auf der Prozess-Ebene statt. In diesem Video geben drei
Experten einen Überblick über die wichtigsten Trends und Entwicklungen für moderne
Software-Entwicklung und bieten Ihnen damit eine einfache Möglichkeit, sich schnell
darüber zu informieren, welche Themen für Ihre Teams in Zukunft wichtig sein werden
und welche Aspekte dabei besonders zu beachten sind.
Moderne Softwareentwicklung
1 - Trends in der modernen Softwareentwicklung | Microsoft from Visual
Studio [Microsoft]
Moderne Softwareentwicklung 2 - Modernes Anforderungsmanagement und Planung
Das Bild ist meistens ähnlich: Es gibt eine große Liste an Wünschen an eine Software
und nur begrenzte Mittel, mit denen man nicht alles umsetzen kann. Gerade deshalb
ist es wichtig, sich auf die richtigen Dinge zu fokussieren und die "Wunschliste"
sichtbar zu machen, sodass jeder weiß was und in welcher Reihenfolge es abgearbeitet
wird, um letztlich möglichst viel Mehrwert (aus Sicht des Kunden) zu produzieren.
Moderne Softwareentwicklung
2 - Modernes Anforderungsmanagement und Planung | Microsoft from Visual
Studio [Microsoft]
Moderne Softwareentwicklung 3 - Stakeholder effizient einbinden
Einer der wichtigsten Trends in der modernen Softwareentwicklung ist eine Veränderung
in der Zusammenarbeit mit den sog. Stakeholdern, also Kunden, Vertrieb, Support, Management
etc. Diese werden stärker in den Entstehungsprozess von Software eingebunden. Warum
das wichtig ist und wie man dies effizient organisieren kann, erfahren sie in diesem
Video.
Moderne Softwareentwicklung
3 - Stakeholder effizient einbinden | Microsoft from Visual
Studio [Microsoft]
Moderne Softwareentwicklung 4 - Continuous Delivery als zentraler Motor für
erfolgreiche Projekte
Kurze Zyklen bieten für die Softwareentwicklung einige interessante Vorteile, aber
auch Herausforderungen. Um kurze Zyklen und häufige Releases zu ermöglichen ist auch
ein höherer Automatisierungsgrad in den Test- und Release-Prozessen von Nöten. Ist
dies erstmals vollbracht, erhält man auf verschiedenen Ebenen eine frühzeitige Rückmeldung.
Ist die Implementierung eines Features geplant, geht weniger Zeit verloren bis es
seine Produktionsreife erreicht und dann idealerweise schon bald von den Benutzern
der Software genutzt werden kann.
Moderne Softwareentwicklung
4 - Continuous Delivery als zentraler Motor für erfolgreiche Projekte | Microsoft from Visual
Studio [Microsoft]
Moderne Softwareentwicklung 5 - Optimierte Qualitätssicherung für moderne
Prozesse
Moderne Entwicklungsprozesse versuchen neue Software-Inkremente in immer kürzeren
Zyklen bereitzustellen um kontinuierlich zu prüfen, ob die umgesetzte Funktionalität
die Anwenderanforderungen erfüllt oder ob entsprechend korrigiert werden muss. Bereitstellung
neuer (Test-)Versionen im Rhythmus von wenigen Wochen erfordert aber neue Test-Strategien,
da die bisherigen Vorgehensweisen in diesem Szenario meist versagen. Informieren sie
sich, wie sie ihre Test-Prozesse fit machen für Continuous Delivery.
Moderne Softwareentwicklung
5 - Optimierte Qualitätssicherung für moderne Prozesse | Microsoft from Visual
Studio [Microsoft]
Moderne Softwareentwicklung 6 - Erweiterbare und wartbare Architekturen im
Team entwickeln
Eine wichtige Anforderung an Architektur ist die einfache Erweiterbarkeit und eine
robuste Struktur, die Änderungen möglichst auf wenig Code-Bereiche begrenzt, um das
Risiko von Änderungen zu minimieren. Nur so kann die Idee von gewachsener Architektur
tatsächlich auch umgesetzt werden. Welche Aspekte dabei wichtig sind und wie dieses
Vorhaben gelingen kann, wird in diesem Video erläutert.
Moderne Softwareentwicklung
6 - Erweiterbare und wartbare Architekturen im Team entwickeln | Microsoft from Visual
Studio [Microsoft]
Die Gesten von Windows 8 und Jquery Mobile unterscheiden sich erheblich. In der Web App lässt sich nur eine Wischgeste von Rechts-Links oder umgekehrt realisieren (swipeleft, swiperight). Folgenden Code ans Ende einer Web Page.
1: $(function () { 2: $('#page1').on('swipeleft', swipeleftHandler); 3: function swipeleftHandler(event) { 4: $("#mypanel").panel("open"); 5: }
6: });
Allerdings funktioniert das bei mir nur mit Chrome, IE 10 feuert das Event nicht. Wenn wer eine Erklärung hat, bitte als Kommentar.
Für die Charme Icons habe ich Powerpoint beklaut. In der Storyboard Funktion gibt es bei mir eine Reihe von Modern UI Symbole.
Ich bin mir nicht sicher ob ich die irgendwann mal installiert habe. Wenn man nach “Misc Windows 8 storyboard.sbsx” sucht findet man diese auch im Web.
In JQuery Mobile gibt es das Panel Element. Darunter wird ganz normal eine DIV gestapelt.
1: <div data-role="page" data-theme="b" id="page1">
2: <div data-role="panel" id="mypanel" data-title="Home" data-position="right"
data-display="overlay">
3: <div>
4: <img src="Images/search.gif" />
5: <span>Search</span>
6:
7: </div>
8: <div>
9: <img src="Images/share.gif" />
10: <br />
11: Share
12: </div>
13: <div>
14: <img src="Images/win.gif" />
15: <br />
16: Start
17: </div>
18: <div>
19: <img src="Images/devices.gif" />
20: <br />
21: Devices
22: </div>
23: <div>
24: <img src="Images/settings.gif" />
25: <br />
26: Settings
27: </div>
28: </div>
29: <div data-role="header">
30: <h1>hannes</h1>
31: </div>
32: <div data-role="content">
33: blabkab
34: </div>
35: </div>
Für das Flyout wird eine Standard Breite von 17em genommen. Um das JQuery Mobile Panel Element zu stylen habe ich folgendes CSS verwendet.
1: <style>
2: .ui-panel
3: { 4: width: 6em;
5: }
6:
7: .ui-panel-inner
8: { 9: background-color: black;
10: }
11:
12: .ui-panel-inner > div
13: { 14: color: Silver;
15: font-family: Arial;
16: margin-top: 20px;
17: margin-bottom: 20px;
18: text-align: center;
19: }
20: </style>
Letztendlich wird noch die Referenz auf die Jquery Javascript Librarys gesetzt.
1: <link href="Content/jquery.mobile-1.3.0.css" rel="stylesheet" />
2: <script src="Scripts/jquery-1.8.2.js"></script>
3: <script src="Scripts/jquery.mobile-1.3.1.js"></script>
Das gif animierte Ergebnis in Chrome, sieht fast aus wie bei Windows 8 METRO.
Problem: Wenn man die neueste JQuery Version (hier 2.0.1) verwendet, ist Schluss mit Lustig. Man sieht nur den Ladebalken kreisen. Das zeigt auch wieder ganz gut die Problematik mit JavaScript Librarys. Da nutzt auch Quelloffen und Open Source nichts.
For many years now I'm a happy Linux user. Admittedly, I haven't been much into Linux in my first years as professional software developer. I always needed something which was more or less better or faster achievable with Linux than with Windows, which for many years was my primary OS both for development and personal usage. At that time, I used Linux mainly as a server OS, mostly as a VCS-, File- or Webserver.
Seven years ago I decided to bring Linux back to my desktop. I decided to give the compelling Ubuntu distribution a chance. At that times I started with Ubuntu Feisty in a dual-boot with Windows XP.
I was very satisfied with the "easy" experience of installation and configuration. I wasn't used to expect from a Linux OS to immediately have appropiate VGA drivers and display resolution. Prior to Ubuntu, I was mainly dealing with SuSE the years before (starting with the very first version 4.2). With SuSE, it was almost impossible for me to use it efficiently as a desktop OS. I was lucky to manage network connections, firewall, samba and ssh on SuSE - no more, no less.
Back to Ubuntu. With Feisty and Gutsy, I got Linux to experience as a valid desktop OS. Although I wasn't using it as my main OS, I kept my curiousity on a constant scale to trigger me frequently back to use Ubuntu.
After two years of infrequent sessions with Ubuntu on my desktop I decided to hop around a little and give Debian a spin. By that time I already was fairly familiar with the distribution layout and toolset within Ubuntu. Since I knew Ubuntu being a derivate of Debian, I found Debian to be a valid next step in improving my understanding of Linux.
My Debian experience was fairly good. For most things, I knew how to deal with them. I even was surprised to have a better support for my hardware than I had with Ubuntu. However, it turned out to be a rather uninspiring desktop experience, since I was missing new shiny software which happen to be standard on Ubuntu.
Granted, my time with Debian was more or less an "experimantal" phase. I tried KDE after being a Gnome user for many years. I experimented with IceWM, XFCE and even got myself to fully configure a FVWM environment. That was both fun and a great way to relearn things I forgot over the past years of the Windows regimen on my desktops.
Finally, three years ago I decided to completely switch to Linux. My decision was mainly reasoned by the fact that I was working on both a Python and ASP.NET project which no longer forced me need to frequently get back to Windows. Since I already was using Windows on a VM for a couple of months (within Debian on a dual-boot installation), I got used to have Linux as my main OS.
So, my first full-fledged Linux desktop experience was again with Ubuntu (Maverick aka. "Perfect 10"). I had a great start since this was to me the first real experience to effectively and efficiently work on Linux as a desktop OS. I managed to develop the ASP.NET project with Mono and Monodevelop, I got my first contact with the lovely Python programming language, I got rid of all the MS Office ratpack software by using LibreOffice and GMail, I started to relearn VIM.
However, as time flew by, I happen to realize that Ubuntu was overloaded and freakingly packed full with plenty of useless and unfinished stuff. With the arrival of PPA's and the incredibly fast growth of packages, my system got regressed more often than I wanted it to be. Even me as non-expert, novice-level Linux user could recognize the lousy filesystem management, the inconsistent configuration strategies and the lack of solid tested core packages.
Despite the inner life of Ubuntu being degenrated to a big mess, the main reason for quitting with Ubuntu is the sick politics and strategy of Canonical. It started off with the debut of Unity in Maverick, continued with the dumbest idea ever made in Linux distribution history in Quantal, and doesn't get any better with the drop of Wayland in favor of their own half-baked Mir.
My conclusion: Ubuntu is out! Ubuntu is nothing more than a freaking wrong capitalizing of free software, surrounded with bloaty adware features and an overall attitude of this "we wanna be cool and hipster like Apple but can't because we're too dumb" company called Canonical. Sorry to say it, but Ubuntu sucks!
Lucky me that I found a nice exit with Fedora's Lovelock. Just a few days after its release, I installed Lovelock on my laptop. Admittedly, I didn't got everything running at first sight and with the new Gnome Shell, systemd and SELinux I certainly needed a coumple of months to get comfy with it.
After this slight ramp-up, Fedora was a very pleasant and stable distribution. Packages have good quality and are being updated frequently, the overall system is clean and consistent - both at the surface as well as behind the doors. I even installed Fedora on my tablet and had a great pleasure using it at meetings and for my day to day tasks.
Fedora gave me the possibility to (re)discover things. My tablet installation certainly was a motivation as well, since I had to deal with limited resources, although I was running the full-blown Shell with it. I tried XFCE (again), Openbox, Xmonad, awesome, dwm and many other niceties. I continued to happily use Fedora on my tablet up to Beefy Miracle.
At that time, while I was constantly exploring the Linux ecosystem, I dived into the myriad of available Linux distros as well. I installed quite a fair amount of distros (on VMs), ranging from the obvious Debian, Mint and Mageia up to the lesser known CrunchBang, Sabayon and Arch. My primary motivation was to extend my knowledge of Linux as OS and ecosystem.
After a period of evaluation, I decided to move away from Fedora a few months ago. I could write a large blog only about this fairly complex and lengthy process of evalution and decision. To keep a long story short: I was quite satisfied with Fedora, yet I was missing simplicity and flexibility to a certain extent. I found myself compiling my own stuff to get things going as I wanted to. Hence, I concluded to move on and opt for Arch.
Today, I happily run Arch on two laptops for a couple of months. So far it's been a great experience. I wouldn't recommend Arch to people being new to Linux or people not willing to dive into details.
For me, Arch is a incredibly good match. Everything in Arch is clear, transparent, consistent. The community and the user repositories are great and not only put attention on detail, but on quality as well. Thanks to Arch, I'm learning more about Linux, from Kernel to X and back.
On the flip side, Arch requires attention and detail. If you're not willing to invest time, precision and accuracy in your system, Arch is not your proper companion. That being said, I'm very happy with Arch and find myself to be more efficient on my desktop than I ever was.
Systemrelevante Größen sind in der Softwareentwicklung wie auch sonst im Leben zu vermeiden. Dieser Meinung bin ich immer noch und sogar immer mehr.
Doch auch wenn wir sie vermeiden sollen, heißt das nicht, dass wir das immer können. Manches ist einfach systemrelevant, weil es die fundamentale Wahl für ein System repräsentiert. Es muss konstant bleiben - ansonsten handelt es sich um ein ganz
Viele Bücher zeigen wie man mittels TDD sauberen Code schreiben kann. Michael Feathers geht in “Working Effectively with Legacy Code” einen anderen Weg. Er zeigt wie man aus Legacy Code Schritt für Schritt und mit viel Arbeit eine saubere Codebasis schaffen kann.
Dieser Weg ist alles andere als leicht, startet dafür aber dort wo wohl die meisten Software-Projekte sind: Bei einer grossen Menge Code mit nur wenigen (oder gar keinen) Tests und der dennoch geschäftskritische Funktionen erfüllt. Wie erhält man dessen Funktionalität und schafft es gleichzeitig flexibel auf neue Anforderungen zu reagieren?
Schritt für Schritt
Wichtig ist das man nicht gleich zu Beginn alles hinwirft. Nur weil der Code noch über keinen einzigen Test verfügt bedeutet dies nicht dass dies so bleiben muss. Im Buch findet man für sehr viele Situationen Tipps und Tricks um mit dem Testen zu beginnen.
Allerdings kann man nicht von einem Extrem in andere springen. Wo noch keine Tests vorhanden sind gleich mit TDD alles machen zu wollen wird sehr schnell scheitern. Besser ist es mit wohlüberlegten und gezielten Tests zu beginnen. Vor der geplanten Änderung erst einmal den Code anschauen und mit Tests auf einer höheren Ebene (wie Integrations- oder Akzeptanztests) beginnen. Oft braucht es auch Mut erst einmal ein Loch aufzureissen um überhaupt einen Test scheiben zu können. Denn wenn man vor dem ändern von Code erst einen Test haben will und für diesen Test erst eine Anpassung am Code braucht steht man vor einem Henne-Ei Problem.
Soll sich die Situation verbessern muss man bereit seit für eine gewisse Zeit mit Code zu leben der nicht allen OO-Regeln folgt. Zusätzliche Konstruktoren nur um Abhängigkeiten zu übergeben sind oft nötig bis dies „korrekt“ gelöst werden kann. Bleibt man dran und geht konsequent den eingeschlagenen Weg kann man auch das grösste Gestrüpp entwirren – dies geschieht aber nicht über Nacht.
Einstellung ändern
Aber was ist eigentlich Legacy Code genau und warum ist dies etwas Schlechtes? Feathers hat in seinem Buch zwei Definitionen, von denen man in der Regel nur die weniger freundlich formulierte in Erinnerung behält:
Legacy Code is Code Without Tests
In dem Sinne liegt es bei jedem einzelnen Entwickler aufzuhören vorneweg Legacy Code zu schreiben und sich über die Qualität und Testbarkeit seines Codes Gedanken zu machen. Andernfalls sind all die im Buch aufgezeigten Ansätze für nichts und man ist in kurzer Zeit wieder da wo man begonnen hat.
Was Michael Feathers in seinem Buch leider nicht anspricht ist wie man sein Team von der Notwendigkeit von wartbarem Code überzeugen kann. Genau dies aber dürfte in vielen Projekten wohl das grösste Hindernis sein.
Characterization Tests
Von all den verschiedenen Ansätzen die in diesem Buch vorgestellt werden fand ich die Characterization Tests am hilfreichsten. Bei diesen Tests fängt man nicht wie bei TDD mit dem gewünschten Verhalten an und folgt dem Red-Green-Refactor Mantra. Stattdessen beginnt man den Test in dem man beim Assert-Aufruf das Resultat der Methode mit dem Default-Wert des entsprechenden Datentyps vergleicht. Der Test wird in den meisten Fällen fehlschlagen und die Fehlermeldung liefert einem den korrekten Wert. Dieser setzt man dann im Assert-Aufruf ein und hat so einen erfolgreich bestandenen Test.
Ohne den Code anzupassen kann man so recht schnell die einzelnen Eigenschaften einer Methode oder einer ganzen Klasse durch Tests fixieren. Dieses Korsett an Tests dient einem nach dem Refactoring zu verifizieren das die Verbesserungen das Verhalten des Codes nicht verändert haben.
Um Legacy Code mit Tests zu versehen macht man also genau das was bei TDD verpönt ist: Den Test so zu schreiben das der aktuelle Code diesen besteht ohne sich Gedanken über die wirklichen Anforderungen zu machen. Aber genau dies macht diese Art von Tests für mich so praxisrelevant. Hat man Legacy Code muss man auf diesen eingehen und eine Lösung finden die den aktuellen Code beschreibt. Hat man einmal so viele Tests dass man wirklich weiss was der Code macht gilt es wieder den Schalter umzulegen und zu prüfen ob dies auch wirklich korrekt ist. Bis es so weit ist muss man die liebgewordenen Regeln aber auch einmal zurückstellen können.
Weiterführende Bücher
Nach dem der Code mit Tests versehen ist geht es ans Aufräumen. Dazu verweist Feathers oft auf Martin Fowlers “Refactoring“. Das Standardwerk zu diesem Thema sollte man kennen, da man ansonsten den Ausführungen kaum folgen kann.
Wer mittels Refactoring grössere Ziele verfolgt sollte auch einen Blick auf “Refactoring to Patterns” von Joshua Kerievsky werfen. Dies baut ebenfalls auf Fowlers Buch auf und erklärt wie man mit einer Kombination von Refactorings grössere Strukturverbesserungen erreichen kann.
Fazit
Michael Feathers zeigt einem in diesem Buch wie man von einer durchschnittlichen Codebasis zu einer kommt die dank Tests auf geänderte Anforderungen reagieren kann. Der Weg dorthin ist aber nicht zu unterschätzen und man muss auch einmal bereit sein eine gewisse Unordnung zu akzeptieren. Will man sich darauf einlassen liefert einem dieses Buch viele wertvolle Tipps.
Zum Buch
“Working Effectively with Legacy Code” von Michael Feathers, 2004 Prentice Hall, ISBN: 978-0-1311-7705-5, 434 Seiten, Englisch
Einsortiert unter:Bücher, dnugBern, webDotNet, webJava, webLinux Tagged: .Net, Bücher, Clean Code 
Die meisten SharePoint 2013 Nutzer werden bereits aktiv mit dem Newsfeed WebPart auf der Teamsite arbeiten. Dabei kam bestimmt bei einigen die Frage auf, ob der Titel des WebParts angepasst werden kann. Leider ist dies standardmäßig nicht der Fall.
Was die Beweggründe bei Microsoft dafür waren, weiß ich zwar nicht. Aber umso mehr hat dieser Artikel seine Daseinsberechtigung, da er einen Lösungsansatz beschreibt, mit dem der Titel angepasst werden kann.
Customize Newsfeed Title
Zunächst zum anzupassenden Newsfeed WebPart und in dessen Properties navigieren und den Titel wie gewünscht anpassen. Außerdem muss der Chrome Type auf Standard gesetzt werden, da der Titel sonst nicht angezeigt wird.
Werden diese Änderungen gespeichert, so wird beim Laden des WebParts zwei verschiedene Titel angezeigt. Doch dieser kann relativ einfach mittels CSS ausgeblendet werden.
Sollte diese Änderung nur für einen Newsfeed WebPart durchgeführt werden, so kann auch ein Content Editor WebPart mit dem unten aufgeführten CSS auf der gewünschten Seite platziert und die restlichen Schritte übersprungen werden.
Dazu eine neue Datei newsfeed.css mit folgendem Inhalt erstellen:
.ms-microfeed-siteFeedTitleArea{
display:none;
}
Diese Datei legen wir im Root Web der Websitesammlung in der Style Library ab und veröffentlichen diese.
Nun muss zunächst sichergestellt sein, dass das Websitesammlungs-Feature SharePoint Server Publishing Infrastructure aktiv ist.
Anschließend wechseln wir in die Site Master Page Settings (/_layouts/15/changesitemasterpage.aspx) der Websitesammlung und verweisen hier auf unser newsfeed.css:
Wird diese Änderungen gespeichert und die Teamsite erneut aufgerufen, so wird der WebPart mit einem neuen Titel angezeigt:
Wurde das Websitesammlungs-Feature SharePoint Server Publishing Infrastructure vorhin nur aus diesem Grund aktiviert, so kann es jetzt wieder deaktiviert werden.
Fazit
Es ist zwar ärgerlich, dass Microsoft den Titel dieses praktischen WebParts nicht flexibel gestaltet hat, aber technisch gesehen vielelicht ein klein wenig verständlich. Denn klickt man auf den Titel Newsfeed so aktualisiert sich der Feed-Liste. Trotzdem hätte dafür auch der Titel aus den WebPart Properties verwendet werden können
Nichtsdestotrotz kann mittels CSS und ein wenig Konfiguration ein eigener Titel gesetzt werden, jedoch ohne Möglichkeit zur Aktualisierung für den Nutzer. Aber ich finde dies ist ein denkbarer Kompromiss, da es sich immerhin um eine supportete Lösung handelt.
Ich hoffe ich konnte euch damit weiterhelfen und wie immer freue ich mich über Feedback.
Hallo,
in meiner letzten Schulung war die Nachfrage gegeben, ob es möglich sei, C++ und C# zu mischen. Nachdem mir der Ansatz nicht unbekannt war, versuchte ich dies zu zeigen. Dabei stoß ich auf das ein oder andere Problem und dachte „für die Nachwelt“ wäre ein Blogeintrag doch sehr sinnvoll.
Prinzipiell ging ich von dem Problem aus, dass Funktionen im C++ Projekt vom C# Projekt aufgerufen werden müssen. Dafür erzeugte ich mir zuerst ein Einfaches „C++ Win32 Projekt“, wobei es sich um ein DLL Projekt handelt.
Dieses Projekt erhielt hierbei eine Funktion von mir:
extern "C" __declspec(dllexport) int __stdcall SayHelloWorld()
{
return 1234;
}
Diese Funktion wird also markiert als extern, und für den DLL-Export freigegeben.
Um in der .NET Welt diese Applikation nun auszuführen, habe ich eine kleine Klasse „CppWrapper“ geschrieben:
public static class CppWrapper
{
[DllImport("Win32Project1.dll")]
public static extern int SayHelloWorld();
}
Mit dem Attribut kann angegeben werden, welche DLL den nun verwendet werden sollte, hier könnte auch ein absoluter Pfad angegeben werden.
Anschließend konnte man nun mittels .NET und der CppWrapper Klasse die Methode ganz einfach aufrufen.
private void HelloWorld(object sender, RoutedEventArgs e)
{
var erg = CppWrapper.SayHelloWorld();
MessageBox.Show("Cpp: " + erg);
}
Ich empfehle noch in dem .NET Projekteinstellungen, unter Debug das Native Debugging zu aktivieren, dann kann man anschließend direkt vom .NET Code in den C++ Code debuggen und auch wieder zurückkehren.
Soweit so gut, die nächste Frage war, ob man von C++ auch wieder irgendwie in die .NET Welt wechseln kann, und ja auch dies funktioniert.
Dafür habe ich folgenden Funktionspointer per typedef definiert im C++ Teil:
typedef int (_stdcall* CSharpCallback)(int x, int y);
Damit wurde der Funktionspointer CSharpCallback definiert, der einen Integer zurückliefert und zwei als Parameter entgegennimmt. Wichtig ist hierbei die stdcall Konvention, da ansonsten die Anwendung Probleme mit dem ESP-Register erhält und abstürzen wird (Bin an diesem Punkt leider nicht genau durch Wikipedia schlau geworden was hier der genaue Unterschied in der C++ Welt ist – wäre für einen Hinweis dankbar).
Anschließend habe ich eine weitere Methode gebaut:
extern "C" __declspec(dllexport) void __stdcall SetAddDelegate(CSharpCallback cb)
{
int sum = cb(10,20);
}
Das bedeutet nun kann ein Funktionszeiger an diese Methode übergeben werden, und dieser kann jederzeit aufgerufen werden.
Zurück in der .NET Welt habe ich auch hier den Funktionszeiger (delegate) und die Methode definiert:
[DllImport("Win32Project1.dll")]
public static extern void SetAddDelegate(AddNumber number);
public delegate int AddNumber(int x, int y);
Die Verwendung war anschließend die folgende:
private void CallDelegate(object sender, RoutedEventArgs e)
{
CppWrapper.SetAddDelegate(AddMethod);
}
private int AddMethod(int x, int y)
{
return x + y;
}
Was ich an diesem Punkt aber erstaunlich fand war anschließend folgende „Verbesserung“ mit einer Lambdaexpression – selbst das funktionierte:
private void CallDelegate(object sender, RoutedEventArgs e)
{
CppWrapper.SetAddDelegate((x,y)=> x + y);
}
Ich musste erstaunt feststellen: Die Sprachen/Technologien, zu mischen war nicht so schwierig, und ich sehe auch Vorteile für typische Software die schon Jahrzehnte in C++ entwickelt wurde, so zumindest teilweise den „Sprung“ in die .NET Welt zu schaffen - auch wenn hier einige gefährliche Ecken auf einen warten. Somit – Happy Coding J
SharePoint Apps sind seit der Einführung von SharePoint 2013 in aller Munde. Versucht man jedoch mit einer SharePoint-Hosted App Funktionalitäten bereitzustellen, so stößt man oft an technische Grenzen. Ein Problem besteht zum Beispiel darin, eine Master Page, Page Layout oder ein WebPart im Root Web der Websitesammlung zu provisionieren.
Denn die Komponente wird immer im App Web bereitgestellt und es kann über keinen deklarativen Ansatz dieses für das Root Web geltend gemacht werden. Doch dank des neuen JSOM kann dieses Problem mit JavaScript gelöst werden. Dieser Artikel soll einen Lösungsansatz auf Basis von JavaScript darstellen, welcher für folgende Elemente angewendet werden könnte:
- Master Page
- Page Layout
- WebPart
- Search Template
- Theme
- Composed Look
- …
Doch wie nun genau diese Elemente im Root Web der Websitesammlung bereitgestellt werden, soll nun genauer betrachtet werden
Create a SharePoint 2013 App
Zu Beginn habe ich mittels Visual Studio 2012 ein neues SharePoint 2013 App Projekt vom Typ SharePoint-Hosted App erzeugt.
Anschließend wurde im Ordner Scripts eine weitere Datei mit dem Namen Msscorner.PublishFiles.js hinzugefügt und wie folgt angepasst:
Function.registerNamespace('Msscorner.PublishFiles');
//Array with Files to publish
Msscorner.PublishFiles = {
Files: new Array()
}
//enum of available FileTypes
Msscorner.PublishFiles.FileTypes = {
MasterPage: 0,
PageLayout: 1,
SearchTemplate: 2,
WebPart: 3,
Theme: 4,
ComposedLook: 5
}
//item object
Msscorner.PublishFiles.Item = function (Title, Url, Type) {
this.Title = Title;
this.Url = Url;
this.FileType = Type;
}
Msscorner.PublishFiles.Publish = function () {
var appCtx, hostCtx;
var appList, hostList;
var appItemColl, hostItemColl;
var currentItem;
var Publish = {
Init: function() {
appCtx = new SP.ClientContext.get_current();
hostCtx = new SP.AppContextSite(appCtx, Publish.GetParam("SPHostUrl"));
for (var i = 0; i < Msscorner.PublishFiles.Files.length; i++) {
currentItem = Msscorner.PublishFiles.Files[i];
var listTitle = Publish.GetListTitle();
appList = appCtx.get_web().get_lists().getByTitle(listTitle);
hostList = hostCtx.get_site().get_rootWeb().get_lists().getByTitle(listTitle);
appCtx.load(hostList);
appCtx.load(appList);
appCtx.executeQueryAsync(Publish.GetFile, Function.createDelegate(this, Publish.OnError));
}
},
GetFile: function () {
console.log("Try to get the current File: " + currentItem.Title)
var fileUrl = Publish.GetParam("SPAppWebUrl") + "/" + currentItem.Url;
console.log(fileUrl);
$.ajax({
url: fileUrl,
type: "GET"
}).done(Function.createDelegate(this, Publish.CopyFile)).error(Function.createDelegate(this, Publish.OnError));
},
CopyFile: function(sender, args){
console.log("Try to Copy Current File: " + currentItem.Title);
var fileCreationInfo = new SP.FileCreationInformation();
fileCreationInfo.set_url(currentItem.Title);
fileCreationInfo.set_content(new SP.Base64EncodedByteArray());
fileCreationInfo.set_overwrite(true);
var fileContent = sender;
for (var i = 0; i < fileContent.length; i++) {
fileCreationInfo.get_content().append(fileContent.charCodeAt(i));
}
var newFile = hostList.get_rootFolder().get_files().add(fileCreationInfo);
appCtx.load(newFile);
appCtx.executeQueryAsync(Publish.UpdateItem, Function.createDelegate(this, Publish.OnError));
},
UpdateItem: function(){
var query = "<View><Query><Where><Eq><FieldRef Name='FileLeafRef'/><Value Type='Text'>" + currentItem.Title + "</Value></Eq></Where></Query></View>";
var camlQuery = new SP.CamlQuery();
camlQuery.set_viewXml(query);
hostItemColl = hostList.getItems(camlQuery);
appItemColl = appList.getItems(camlQuery);
appCtx.load(hostItemColl);
appCtx.load(appItemColl, Publish.GetIncludedFields());
appCtx.executeQueryAsync(Publish.UpdateProperties, Function.createDelegate(this, Publish.OnError));
},
UpdateProperties: function () {
console.log("Try to update properties");
var listItemEnumerator = hostItemColl.getEnumerator();
var listItem, appListItem;
while (listItemEnumerator.moveNext()) {
listItem = listItemEnumerator.get_current();
break;
}
listItemEnumerator = appItemColl.getEnumerator();
while (listItemEnumerator.moveNext()) {
appListItem = listItemEnumerator.get_current();
break;
}
console.log("Properties received");
listItem.set_item('ContentType', appListItem.get_contentType().get_name());
if (currentItem.FileType == Msscorner.PublishFiles.FileTypes.MasterPage) {
listItem.set_item('UIVersion', appListItem.get_item('UIVersion'));
listItem.set_item('MasterPageDescription', appListItem.get_item('MasterPageDescription'));
}
listItem.update();
var file = listItem.get_file();
file.publish("Published by app");
appCtx.load(listItem);
appCtx.load(file);
appCtx.executeQueryAsync(Publish.OnSuccess, Function.createDelegate(this, Publish.OnError));
},
OnSuccess: function () {
console.log("Provisioning succeeded");
$('#message').text("Provisioning succeeded");
},
OnError: function(sender, args){
console.log('Request failed. ' + args.get_message() + '\n' + args.get_stackTrace());
$('#message').text("Request failed.");
},
GetParam: function(param){
var params = document.URL.split("?")[1].split("&");
for (var i = 0; i < params.length; i++) {
prop = decodeURIComponent(params[i]);
if (prop.indexOf(param) > -1)
return prop.split("=")[1];
}
},
GetListTitle: function(){
if (currentItem.FileType == Msscorner.PublishFiles.FileTypes.MasterPage)
return "Master Page Gallery";
else if (currentItem.FileType == Msscorner.PublishFiles.FileTypes.WebPart)
return "Web Part Gallery";
},
GetIncludedFields: function () {
if (currentItem.FileType == Msscorner.PublishFiles.FileTypes.MasterPage)
return "Include(ContentType, UIVersion, MasterPageDescription)";
else if (currentItem.FileType == Msscorner.PublishFiles.FileTypes.WebPart)
return "Include(Title, ContentType, Group, WebPartDescription)";
}
};
Publish.Init();
}
Im nächsten Schritt fügen wir dem Projekt eine Master Page hinzu. Dazu erstellen wir ein neues Modul und fügen diesem unsere Master Page hinzu. Es sollte sich damit ungefähr folgende Struktur ergeben:
Nun werfen wir noch einen kleinen Blick in die Elements.xml des Modules, damit die Master Page auch richtig im App Web bereitgestellt wird.
<?xml version="1.0" encoding="utf-8"?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
<Module Name="Files">
<File Path="Files\Sample.master" Url="_catalogs/masterpage/Sample.master" Type="GhostableInLibrary">
<Property Name="UIVersion" Value="15"></Property>
<Property Name="MasterPageDescription" Value="This is a sample Master Page"></Property>
</File>
</Module>
</Elements>
Die URL des Elements merken wir uns und navigieren in die App.js. Die darin enthaltene ready Funktion passen wir wie folgt an:
$(document).ready(function () {
Msscorner.PublishFiles.Files.push(new Msscorner.PublishFiles.Item("sample.master", "/_catalogs/masterpage/sample.master", Msscorner.PublishFiles.FileTypes.MasterPage));
Msscorner.PublishFiles.Publish();
});
Wir befüllen das Files Array mit einem neuen Eintrag und geben dabei den Namen, Url und Typ des Elements an. Beim Ausführen der App, wird diese Datei mit JavaScript vom App Web ins Root Web der Websitesammlung verschoben und veröffentlicht. Navigieren wir in das Root Web der Websitesammlung, so finden wir folgendes Resultat in der Master Page Gallery vor:
Fazit
Es wurde gezeigt, dass es mit JavaScript möglich ist, eine Master Page aus einer App heraus im SharePoint bereitzustellen. Damit muss auch bei dem Thema Layout nicht zwingendermaßen eine Farm Solution erstellt werden, da CSS über die gleiche Art und Weise bereitgestellt werden kann. Dieser Ansatz kann auch für die oben aufgeführten Elemente verwendet werden, jedoch müsste dafür das Script noch für gewisse Spezifikas angepasst werden.
Trotzdem sehe ich in dieser Lösung einen sehr großen Mehrwert und weitere technische Möglichkeiten für SharePoint Hosted Apps. Denn damit kann schon ein kleines Intranet mit eigener Master Page, Page Layouts, Composed Looks, Search Templates und konfigurierten Search Driven WebParts mittels SharePoint Hosted Apps realisiert werden. Und besonders für Office 365 Kunden sind das doch gute Nachrichten, denn die wenigsten wollen Ihre Daten an eine Provider App schicken
Wer RavenDB nicht auf seinem eigenen Server betreiben möchte oder einfach wissen möchte wieviel Speicherplatz die eigentlichen Daten benötigen gibt es zwei Möglichkeiten:
Falls es noch einen anderen Weg gibt: Immer her damit – aktuell hab ich nur die beiden Methoden gefunden und sie scheinen mehr oder weniger zu passen.
RavenDB Storage per JSON über die API:
Über die Server-Statistics (http://localhost:8080/admin/stats) bekommt man ein JSON mit dem Eintrag “TotalDatabaseHumaneSize”
RavenDB Speicher direkt auf Dateiebene:
Über das “Data” File innerhalb des Datenbank Ordners sieht man ebenfalls die Größe.
Speicherplatz ist lokal natürlich billig… aber wie sieht es gehosted aus?
Wer RavenDB selbst betreibt der sollte eigentlich keine Probleme mit Festplattenspeicher haben – wir reden hier von einem zweistelligen MB Betrag bei in meinem Beispiel 1500 Dokumenten mit einigen Daten daran – selbst Gigabytes sind heute billig.
Gehosted sieht es bei RavenHQ und CloudBird aktuell so aus (Stand Mai 2013). Diese beiden Hoster sind (glaub ich) aktuell auch die einzigen die RavenDB “in der Cloud” gemanaged anbieten. Der Speicher ist hier schon “teurer”, jedenfalls für Hobby-Entwickler.
RavenHQ
Genauere Informationen gibt es hier.
CloudBird
Genauere Informationen gibt es hier.
Damit sollte man nun in der Lage sein abzuschätzen wieviel “Speicher” man benötigt und kann den entsprechenden Plan auswählen.
Diese Aufgabenstellung schreit extremst nach einem Service Bus. Hier hat man allerdings die Qual der Wahl. Nach einer Recherche, die mittlerweile doch Monate zurück liegt, kamen lediglich Lösungen zum Vorschein, die zwar das eigentlich gewünschte Szenario (Message senden und vergessen, Hauptsache sie wird verarbeitet) abbilden, allerdings noch viel, viel mehr. Die Systeme (beispielsweise MassTransit) sind aufwändig zu konfigurieren, ziehen zahlreiche Abhängigkeiten an und liefern weit mehr als tatsächlich benötigt werden. Ein einfacher “Message Bus” der nach dem Prinzip “Fire and Forget” funktioniert war nicht zu finden. Also mal eben selbst geschrieben - und zur Verfügung gestellt.
Hintergrund
Business-Anwendungen bestehen nicht nur aus zeitkritischen Aktionen. In vielen Fällen müssen auch Aufgaben durchgeführt werden, die durchaus außerhalb des eigenen Prozesses laufen können. Ein Beispiel hierfür sind Benachrichtigungen auf Basis von neuen/geänderten/gelöschten Objekten. Diese müssen nicht sofort gesendet werden (idealerweise jedoch zeitnah), sollten jedoch auf gar keinen Fall die eigentliche Anwendung beeinträchtigen. Würden sie jedoch - ausgeführt innerhalb desselben Prozesses - sehr wohl, da gerade das Versenden von E-Mails durchaus Zeit in Anspruch nimmt. Die Lösung besteht in der Verwendung eines Service/Message Buses.
Und genau das ist die Crux an der Geschichte: Ich persönlich möchte etwas, das sofort einsetzbar ist. Die Konfigurationspflicht muss sich in Grenzen halten und ich möchte mir für diese Aufgabenstellung möglichst wenig in meine Preconditions ziehen. FireAndForget war geistig geboren.
Ziele
Die Ziele für dieses Projekt ergeben sich großteils aus dem bereits Geschriebenem:
- Einfache Konfiguration
- Behandlung von Nachrichten soll ebenfalls einfach zu implementieren sein
- Bestmögliche Performance
- Möglichst wenig Abhängigkeiten
- Simples Deployment über typischerweise verwendete Deployment-Prozesse
Eckdaten
Die aktuellste Umsetzung (zu diesem Zeitpunkt Version 0.2.0) ist auf GitHub zu finden, eine ausführliche Dokumentation auf der Projektseite. Die durch die Ziele beschriebenen Punkte wurde bestmöglich erfüllt.
Zur Verfügung stehe eine Core-Bibliothek, welche die gesamte Funktionalität abdeckt. Zusätzlich wurde eine Konsolen-Applikation dazugepackt. Diese zieht einen self-hosted Container hoch und ermöglicht den Zugriff via einer JSON REST API.
Erweiterungsmöglichkeiten sind an einigen (wichtigen) Stellen gegeben:
- Datenbank. Damit sichergestellt wird, dass alle Messages auch wirklich ausgeführt werden, müssen diese (inklusive des entsprechenden Status) in einer Datenbank abgelegt werden. Hierfür existiert das Interface IRepository, welches für eigene Bedürfnisse implementiert werden kann. Im Standard wird eine Implementierung für den SQL Server ausgeliefert. Dabei werden alle notwendigen Tabellen und Indizes automatisch angelegt (lediglich die gewünschte Datenbank muss vorhanden sein und konfiguriert werden).
- Executoren. Klingt nach einer bösen Sache, ist es aber nicht. Nachrichten für FireAndForget müssen einen bestimmten Nachrichtentyp bekannt geben. Für diesen Typ muss ein entsprechender Executor vorhanden sein. Durch das Implementieren der Schnittstelle ITaskExecutor und der Konfiguration desselben kann dies erreicht werden.
Um Nachrichtentypen aufzuteilen und asynchron ausführen zu können, besteht die Möglichkeit, sogenannte Worker zu konfigurieren. Dabei handelt es sich um - voneinander unabhängigen - Queues, in die Messages eines bestimmten Nachrichtentyps (per Konfiguration festgelegt) fließen und ausgeführt werden.
Wie funktioniert es?
Jeder konfigurierte Worker prüft alle 200 Millisekunden, ob Nachrichten zur Abarbeitung vorliegen. Ist dies der Fall, wird das Abfrageintervall aufgehoben und alle bekannten Nachrichten behandelt. Erst danach fällt der Worker wieder in seinen “Überpüfungsmodus” zurück. Abgearbeitete Nachrichten werden mit einem entsprechenden Status in die Datenbank geschrieben. Wird die Behandlung einer Message durch einen Fehler abgebrochen, erhält diese sowohl einen eigenen Status, als auch eine entsprechende Fehlermeldung, welche ebenfalls in der Datenbank nachgelesen werden kann.
Fehlerhafte Nachrichten können durch einen Retry-API-Aufruf erneut ausgeführt werden (wenn das Problem - beispielsweise ein ausgefallener Mailserver - behoben wurde). Auch bei Neustart von FireAndForget werden alle nicht abgeschlossenen Nachrichten erneut behandelt.
Zeitverzögerte Nachrichten
In der Praxis hat sich herausgestellt, dass es gewünscht ist, Nachrichten nicht sofort auszuführen. Deshalb besteht die Möglichkeit, ein Durchführungsdatum(-uhrzeit) zu setzen. Ein entsprechender Worker stellt diese Möglichkeit bereit und schickt die entsprechenden Nachrichten zu gegebener Zeit durch die dafür vorgesehene Pipeline. Gerade für zeitverzögerte Nachrichten bietet es sich auch an, diese als “Bulk-Operation” zu behandeln. Dies kann ebenfalls bei der entsprechenden Nachricht angegeben werden. Findet sich ein Executor, der Bulk-Nachrichten für diesen Typ behandeln kann, werden alle zeitverzögerten Nachrichten hierfür zusammengefasst und zu gegebener Zeit als eine Nachricht behandelt. In der Datenbank wird jede Nachricht dennoch separat behandelt.
Fazit
FireAndForget ist in einigen meiner Projekte im Einsatz. Die Lösung wird immer dann verwendet, wenn Aufgaben nicht innerhalb des eigentlichen Prozesses durchgeführt werden müssen und keine Antwort notwendig ist. Durch die einfache Konfiguration und den wenigen Abhängigkeiten lässt sich FireAndForget sehr einfach in die eigenen Infrastruktur integrieren. Mir schweben noch zahlreiche Erweiterungsmöglichkeiten vor, Hauptziel ist aber, dass sich der Verwender möglichst schnell mit seiner eigentlichen Aufgabe beschäftigen kann und keine 100 Seiten Dokumentation lesen muss.
Die Powershell ist ein prima Werkzeug und immer mehr System-Tools und Dienste stellen Powershell Module zur Verfügung. Da ich aber nur “am Rande” mit Powershell zutun habe bin ich auf ein nettes Detail gestossen, welches vermutlich bei den erfahreneren Powershell Usern maximal ein müdes Lächeln hervorruft:
Ps-Cmd | Format-List etc.
Um den Text-Output zu formatieren oder um alle Details des Ergebnisses zu sehen gibt es folgende Befehle:
Format-Wide
Format-List
Format-Table
Format-Custom
Insbesondere das “lange” Dateiennamen bzw. Objekt-Namen irgendwann abgeschnitten werden hatte mich dazu veranlasst nach diesen Methoden zu suchen.
Beispiel:
dir | Format-List Name,LastWriteTime
Ich nehm den einfachen “dir”-Command, wobei man den Output überall über diese Zusätze formatieren kann.
Format-Wide
Format-List
Format-Table
Bei Format-Custom hatte ich spontan kein gutes Beispiel gefunden, vermutlich kann man damit aber nette Sachen machen 
Powershell-Anfänger Kurs erstmal wieder beendet.
Da Requirements die Grundlage der Entwicklung und somit auch der Kommunikation mit dem Kunden und innerhalb des Teams sind, lohnt es sich in einigen Fällen diese in der Muttersprache des Kunden zu verfassen um Missverständnissen vorzubeugen. Gherkin bzw. Specflow unterstützen dies in dem die Feature Dateien in über 40 unterschiedlichen Sprachen erstellt werden können. Dazu gehört, [...]
Die aktuelle Nachlese (updated 13.06.2012) zur ALM Briefing Tour findest Du hier zum Download.
Bei der halbtägigen (nicht halbstündigen *ha ha*, danke Wolfgang) ALM Briefing Tour zeigen wir Dir, wie Du die verschiedenen Herausforderungen in der Anforderungsanalyse, Softwareentwicklung, Qualitätssicherung und Betrieb besser verwalten kannst und Dir und deinem Team Zeit ersparst. Anbei die Termine für Juni =>
Termine Juni (kostenlose ALM Briefing Tour)
06.06.2013 - Wien
11.06.2013 - Graz
19.06.2013 - Bregenz
20.06.2013 - Linz
Übrigens, bei Microsoft beginnt mit Juli das neue Fiskal Jahr und wir sind schon eifrig am Planen welche Veranstaltungen und Inhalte euch interessieren könnten und wir für euch bereitstellen dürfen. Themenwünsche sind gerne willkommen 
.
Andreas Pollak
Product Marketing Manager Visual Studio 2012 (Entwicklungs- und Testwerkzeuge)
Leader im Magic Quadrant von Gartner für ALM
JavaScript tut Not. Es hilft halt nichts. Lieber würde ich mich zwar mehr mit F# beschäftigen, doch dringender scheint mir JavaScript-Fingerfertigkeit. Denn mit JavaScript kann ich meine Reichweite vergrößern in Richtung Web und Mobile. Bisher bin ich ja eher der “Desktop GUI Guy” ;-) Und mit JavaScript kann ich coole Entwicklungen schneller mitmachen im Bereich Backend, z.B. node.js oder Cloud