Dieser Artikel wurde maschinell übersetzt.
Cloud-Speicher
Die Anwendung Engine mit Windows fueling Azure Speicher
Kevin Hoffman
Entwickler sind in der Regel um Ihre physischen, konkrete Infrastruktur wie einer Rahmenbestellung Sicherheit cling. Sie wissen, wie es verwendet und Sie wissen, wie es verwendet werden, wenn etwas schief geht, Sie wissen, wo sich diese. Dadurch kann oft eine Barriere, die Entwickler Übernahme neuer Technologien, wie z. B. computing cloud verlangsamt.
Eine der größten Fragen skeptisch Entwickler aufgefordert wird, wie Sie Hintergrund lauffähig können Prozesse in der Wolke – wie werden Ihre Modul-von weiterhin funktionieren. Dieser Artikel zielt darauf ab, zu durchschauen Mythen über mangelnde Hintergrundverarbeitung in der Wolke von zeigt, wie Sie können ein Modul Anwendung zu erstellen sowie Implementieren von asynchronen messaging und Verarbeiten von Windows Azure Speicher verwenden.
Um zu beweisen, dass Entwickler den Rahmenauftrag Sicherheit Ihrer physischen Infrastruktur shed und in Ihrer Anwendung Module in der Wolke, werden wir die Implementierung einer kleinen Teilmenge einer e-Commerce-Anwendung Hollywood Hacker durchlaufen, wobei Sie alle magischen Technologie, das Hollywood verwendet kaufen können, um die Gesetzen der Physik und altmodische Menschenverstand komplett zu ignorieren.
Die beiden wichtigsten Szenarien besprochen werden werden:
- Senden von asynchronen Textnachrichten (“ Toasts ”) an Benutzer der Anwendung zu benachrichtigen wichtige Ereignisse wie Ihre Einkaufswagen, übermittelt werden oder zum Senden von Nachrichten zwischen Mitarbeitern. In diesem Szenario wird Windows Azure Queue, Windows Azure Tabelle und einer Windows Azure Worker-Funktion verwendet.
- Senden von einen Warenkorb ein Fulfillment-Engine mit Windows Azure Warteschlangen und eine Windows Azure Worker-Rolle.
Intra-Application mit Queue Storage Messaging
Bevor wir den bestimmten Szenarien erhalten, müssen wir einige Grundlagen zu Windows Azure Queue abdecken. Warteschlangen in der Wolke funktionieren nicht wie Warteschlangen in einer .NET-Anwendung unformatierten Vanille Recht. Bei der Arbeit mit Daten in einer Anwendungsdomäne wissen Sie nur eine Kopie dieser Daten vorhanden ist und es sitzt bequem in einem einzelnen verwalteten Prozess.
In der Wolke eine Dateneinheit möglicherweise in Kalifornien leben und möglicherweise einen anderen in New York, und Sie müssen möglicherweise eine Worker-Rolle auf diese Weise die Verarbeitung dieser Daten in Texas und eine andere Worker-Rolle auf diese Weise Verarbeitung in North Dakota.
Anpassen, um diese Art der verteilten Datenverarbeitung und verteilte Daten, bringt viele Entwickler mit, wie z. B. die Codierung für potenzielle Fehler nicht vertraut sind, erstellen in das Konzept der Startversuch für Daten Commits und schließlich das Konzept der Idempotence Probleme.
Die Arbeitsweise von Windows Azure Warteschlangen ist recht einfach, solange Sie Sie wie in-Process regulären CLR Warteschlangen behandeln nicht. Zunächst die Anwendung fragt die Warteschlange für bestimmte Anzahl von Nachrichten (behalten Sie jedoch nie mehr als 20 zu einem Zeitpunkt; Beachten Sie, dass) und ein Zeitlimit angeben. Dieses Timeout steuert, wie lange diese Nachrichten von anderen Clients Warteschlangenverarbeitung ausgeblendet werden. Wenn Ihre Anwendung erfolgreich den gewünschten Verarbeitung in der Warteschlange Nachricht durchgeführt werden muss abgeschlossen wurde, sollten Sie die Nachricht löschen.
Wenn die Anwendung löst eine Ausnahme aus, oder andernfalls zum Verarbeiten der Warteschlange Nachricht fehlschlägt, wird die Nachricht nach der Zeitspanne erneut an andere Clients sichtbar werden. Auf diese Weise können zusätzliche Worker-Funktionen weiterhin verarbeiten, wenn eine ausfällt. Senden einer Nachricht an eine Warteschlange ist sehr einfach: Die Anwendung bildet die entsprechende HTTP-POST-Nachricht (entweder direkt oder mit Hilfe von einem Client-Bibliothek) und Zeichenfolge oder ein Array von Bytes sendet. Warteschlangen sind speziell für messaging-intra-application und nicht dauerhaft entwickelt, so dass die Nachrichten recht klein gehalten werden müssen.
Wie bereits erwähnt könnte Weise mehrere Worker-Rollen Ihnen alle versuchen, dieselben Nachrichten verarbeiten. Das Invisibility-Timeout, das Nachrichten werden ausgeblendet, die zurzeit verarbeitet werden ist hilfreich, aber dies nicht der Fall ist eine Garantie. Um einen Konflikt vollständig zu vermeiden, sollten Sie entwerfen Ihre Datenbankmodul verarbeitet, sodass Idempotent . Mit anderen Worten, sollte dieselbe Warteschlange Nachricht mehrere Male von mindestens einem Worker-Rollen verarbeitet werden, ohne die Anwendung in einem inkonsistenten Zustand versetzen können.
Idealerweise sollten Sie die Worker-Rolle in der Lage zu erkennen, wenn die Arbeit auf eine bestimmte Nachricht bereits abgeschlossen wurde. Beim Schreiben die Worker-Rollen zum Verarbeiten von Nachrichten in Warteschlange, beachten Sie, dass die besteht die Möglichkeit, Code zum Verarbeiten einer Nachricht, die bereits verarbeitet wurde versucht werden konnte, dass die Wahrscheinlichkeit, dass möglicherweise jedoch slim.
Der Codeausschnitt in Abbildung 1 veranschaulicht erstellen und Senden einer Nachricht an die Warteschlange eine Windows-Azure Azure Windows SDK mit die StorageClient-Assembly, die bereitgestellt wird. StorageClient-Bibliothek ist eigentlich nur ein Wrapper um die Windows Azure Storage HTTP-Schnittstelle.
Abbildung 1 Warteschlange erstellen und Senden von Nachricht an eine Windows-Azure
string accountName;
string accountSharedKey;
string queueBaseUri;
string StorageCredentialsAccountAndKey credentials;
if (RoleEnvironment.IsAvailable)
{
// We are running in a cloud - INCLUDING LOCAL!
accountName =
RoleEnvironment.GetConfigurationSettingValue("AccountName");
accountSharedKey =
RoleEnvironment.GetConfigurationSettingValue("AccountSharedKey");
queueBaseUri = RoleEnvironment.GetConfigurationSettingValue
("QueueStorageEndpoint");
}
else
{
accountName = ConfigurationManager.AppSettings["AccountName"];
accountSharedKey =
ConfigurationManager.AppSettings["AccountSharedKey"];
queueBaseUri =
ConfigurationManager.AppSettings["QueueStorageEndpoint"];
}
credentials =
new StorageCredentialsAccountAndKey(accountName, accountSharedKey);
CloudQueueClient client =
new CloudQueueClient(queueBaseUri, credentials);
CloudQueue queue = client.GetQueueReference(queueName);
CloudQueueMessage m = new CloudQueueMessage(
/* string or byte[] representing message to enqueue */);
Queue.AddMessage(m);
Andere Beispiele in diesem Artikel haben wir einige Wrapper-Klassen verwendet (auf der CodePlex-Website für Hacker Hollywood verfügbar: hollywoodhackers.codeplex.com/SourceControl/ListDownloadableCommits.aspx) die dieser Prozess vereinfacht.
Asynchrones Messaging (Toasts)
Interaktive Websites werden nicht nur die Rage heutzutage, Sie sind eine Voraussetzung. Benutzer also daran gewöhnt sind, um vollständig interaktive Websites geworden, die Ihrer Meinung nach etwas nicht in Ordnung ist, wenn Sie eine statische, nicht interaktive Seite auftreten. Mit, denken Sie daran möchten wir zum Senden von Benachrichtigungen an unsere Benutzer, wie Sie die Website verwenden können.
Dazu müssen Windows Azure Warteschlangen und die Tabelle Speichermechanismen zum Erstellen einer Nachricht Übermittlung Framework genutzt werden. Die Clientseite wird jQuery, die zusammen mit der jQuery Gritter-Plug-In verwenden, um Benachrichtigungen in den Browser des Benutzers als ein Toast, ähnlich wie die Nachrichten anzuzeigen, die über die Windows-Taskleiste einblenden Wenn Sie eine neue Outlook-e-Mails, Sofortnachricht oder Tweet erhalten.
Wenn ein Benutzer eine Benachrichtigung gesendet werden muss, wird es in die Warteschlange eingefügt werden. Die Worker-Rolle jedes Element in der Warteschlange verarbeitet, wird jede einzelne Behandlung dynamisch ermittelt. In unserem Fall ist es nur eine Sache für das Datenbankmodul dazu jedoch in einem komplexen CRM-Website oder ein Helpdesk-Website, die Möglichkeiten sind endlos.
Wenn die Worker-Rolle über eine Benutzerbenachrichtigung in der Warteschlange eingeht, wird die Benachrichtigung im Speicher für die Tabelle zu speichern und aus der Warteschlange zu löschen. Dies ermöglicht langfristig beibehalten werden, und warten Sie, bis der Benutzer zum Anmelden von Nachrichten. Nachrichten in Warteschlangenspeicher haben eine kurze maximale Lebensdauer und letzten werden nie mehr als ein paar Tage. Wenn der Benutzer die Website zugreift, unser Skript jQuery asynchron alle Nachrichten aus der Tabelle abrufen und Sie im Browser anzeigen, durch den Aufruf einer Methode auf einem Domänencontroller, der in einem bekannten Shape JavaScript Object Notation (JSON) zurückgibt.
Obwohl die Warteschlange nur Zeichenfolgen oder Bytearrays behandelt wird, können wir jede Art von strukturierten Daten in der Warteschlange speichern, indem Sie es in eine binäre Serialisierung und konvertieren es wieder, wenn es benötigt wird. Dies ist eine leistungsstarke Technik für stark typisierte Objekte an die Warteschlange übergeben. Wir werden dies in die Basisklasse für unsere Meldungen der Warteschlange zu erstellen. Anschließend kann unser System Nachrichtenklasse unsere Daten enthalten und das gesamte Objekt in die Warteschlange gesendet und bei Bedarf (siehe Abbildung 2 ) genutzt werden kann.
Abbildung 2 Speichern von strukturierte Daten in der Warteschlange
namespace HollywoodHackers.Storage.Queue
{
[Serializable]
public class QueueMessageBase
{
public byte[] ToBinary()
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
ms.Position = 0;
bf.Serialize(ms, this);
byte[] output = ms.GetBuffer();
ms.Close();
return output;
}
public static T FromMessage<T>(CloudQueueMessage m)
{
byte[] buffer = m.AsBytes();
MemoryStream ms = new MemoryStream(buffer);
ms.Position = 0;
BinaryFormatter bf = new BinaryFormatter();
return (T)bf.Deserialize(ms);
}
}
[Serializable]
public class ToastQueueMessage : QueueMessageBase
{
public ToastQueueMessage()
: base()
{
}
public string TargetUserName { get; set; }
public string MessageText { get; set; }
public string Title { get; set; }
public DateTime CreatedOn { get; set; }
}
Beachten Sie, dass für die BinaryFormatter-Klasse verwenden, Ihre Windows-Azure Worker-Rolle muss im vollständig vertrauenswürdigen Modus ausgeführt werden (Sie können dies über die Dienstkonfigurationsdatei aktivieren), beibehalten.
Jetzt müssen wir einen einfachen Wrapper für die Interaktion mit unserer Warteschlange. Im Kern benötigen wir die Möglichkeit, eine Nachricht in der Warteschlange einfügen, erhalten alle ausstehenden Nachrichten und leeren der Warteschlange (siehe Abbildung 3 ).
Abbildung 3-Wrapper für die Interaktion mit Warteschlangen
namespace HollywoodHackers.Storage.Queue
{
public class StdQueue<T> :
StorageBase where T : QueueMessageBase, new()
{
protected CloudQueue queue;
protected CloudQueueClient client;
public StdQueue(string queueName)
{
client = new CloudQueueClient
(StorageBase.QueueBaseUri, StorageBase.Credentials);
queue = client.GetQueueReference(queueName);
queue.CreateIfNotExist();
}
public void AddMessage(T message)
{
CloudQueueMessage msg =
new CloudQueueMessage(message.ToBinary());
queue.AddMessage(msg);
}
public void DeleteMessage(CloudQueueMessage msg)
{
queue.DeleteMessage(msg);
}
public CloudQueueMessage GetMessage()
{
return queue.GetMessage(TimeSpan.FromSeconds(60));
}
}
public class ToastQueue : StdQueue<ToastQueueMessage>
{
public ToastQueue()
: base("toasts")
{
}
}
}
Wir müssen auch einen Wrapper für unsere Tabelle Speicher einrichten, damit Benutzerbenachrichtigungen gespeichert werden können, bis Sie auf der Website anmelden. Tabellendaten werden organisiert ein PartitionKey, der den Bezeichner für ein Auflistung von Zeilen ist, und ein RowKey, der jede einzelne Zeile in einer bestimmten Partition eindeutig identifiziert. Die Auswahl der Daten, die Sie für eine PartitionKey verwenden und eine RowKey konnte einen der wichtigsten Entwurfsentscheidungen, die Sie, beim Speichern der Tabelle verwenden vornehmen.
Diese Features ermöglichen Lastenausgleich über Speicher (Knoten) und integrierte Skalierbarkeitsoptionen in Ihrer Anwendung bereitstellen. Unabhängig von Ihrer Daten Data Center-Affinität werden die Zeilen in Tabelle Speicher mit der gleichen Partition Schlüssel innerhalb des gleichen physischen Datenspeichers beibehalten. Da Nachrichten für jeden Benutzer gespeichert werden, ist der Partition Schlüssel werden der Benutzername und das RowKey eine GUID zur Identifizierung, die jede Zeile (siehe Abbildung 4 ).
Abbildung 4 Wrapper für die Tabelle Speicherung
namespace HollywoodHackers.Storage.Repositories
{
public class UserTextNotificationRepository : StorageBase
{
public const string EntitySetName =
"UserTextNotifications";
CloudTableClient tableClient;
UserTextNotificationContext notificationContext;
public UserTextNotificationRepository()
: base()
{
tableClient = new CloudTableClient
(StorageBase.TableBaseUri, StorageBase.Credentials);
notificationContext = new UserTextNotificationContext
(StorageBase.TableBaseUri,StorageBase.Credentials);
tableClient.CreateTableIfNotExist(EntitySetName);
}
public UserTextNotification[]
GetNotificationsForUser(string userName)
{
var q = from notification in
notificationContext.UserNotifications
where notification.TargetUserName ==
userName select notification;
return q.ToArray();
}
public void AddNotification
(UserTextNotification notification)
{
notification.RowKey = Guid.NewGuid().ToString();
notificationContext.AddObject
(EntitySetName, notification);
notificationContext.SaveChanges();
}
}
}
Nun, da unsere Speichermechanismen vorhanden sind, benötigen wir ein Worker-Rolle, die als unsere Modul fungiert, Verarbeiten von Nachrichten im Hintergrund von unserem e-Commerce-Site. Zu diesem Zweck definieren wir eine Klasse, die Sie mit der Rolle Mitarbeiter in unserem Dienst Wolke für Projekte (siehe Abbildung 5 ) zuordnen und Microsoft.ServiceHosting.ServiceRuntime.RoleEntryPoint-Klasse erbt.
Abbildung 5 Worker Rolle fungiert als Engine
public class WorkerRole : RoleEntryPoint
{
ShoppingCartQueue cartQueue;
ToastQueue toastQueue;
UserTextNotificationRepository toastRepository;
public override void Run()
{
// This is a sample worker implementation.
//Replace with your logic.
Trace.WriteLine("WorkerRole1 entry point called",
"Information");
toastRepository = new UserTextNotificationRepository();
InitQueue();
while (true)
{
Thread.Sleep(10000);
Trace.WriteLine("Working", "Information");
ProcessNewTextNotifications();
ProcessShoppingCarts();
}
}
private void InitQueue()
{
cartQueue = new ShoppingCartQueue();
toastQueue = new ToastQueue();
}
private void ProcessNewTextNotifications()
{
CloudQueueMessage cqm = toastQueue.GetMessage();
while (cqm != null)
{
ToastQueueMessage message =
QueueMessageBase.FromMessage<ToastQueueMessage>(cqm);
toastRepository.AddNotification(new
UserTextNotification()
{
MessageText = message.MessageText,
MessageDate = DateTime.Now,
TargetUserName = message.TargetUserName,
Title = message.Title
});
toastQueue.DeleteMessage(cqm);
cqm = toastQueue.GetMessage();
}
}
private void ProcessShoppingCarts()
{
// We will add this later in the article!
}
public override bool OnStart()
{
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
DiagnosticMonitor.Start("DiagnosticsConnectionString");
// For information on handling configuration changes
// see the MSDN topic at
//https://go.microsoft.com/fwlink/?LinkId=166357.
RoleEnvironment.Changing += RoleEnvironmentChanging;
return base.OnStart();
}
private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
{
// If a configuration setting is changing
if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
{
// Set e.Cancel to true to restart this role instance
e.Cancel = true;
}
}
}
Durchlaufen Sie Let’s der Arbeitscode Rolle. Nach dem Initialisieren und Einrichten der erforderlichen Warteschlange und die Tabelle speichern, wird der Code eine Schleife eingeben. Alle 10 Sekunden, wird es in der Warteschlange verarbeitet. Jedes Mal, wenn wir durch die Schleife Verarbeitung übergeben wir erhalten Meldungen aus der Warteschlange bis wir schließlich Null ist, zurückzugeben, der angibt, dass wir die Warteschlange geleert haben.
Es lohnt sich, dass Sie nie mehr als 20 Nachrichten aus der Warteschlange betrachten können reiterating. Alle Elemente, die Verarbeitung in einer Warteschlange wird eine begrenzte Zeitspanne etwas sinnvolle mit jeder Warteschlange-Nachricht, bevor die Warteschlangenmeldung als das Zeitlimit gilt überschritten und wird wieder in die Warteschlange hat – selbst für die Verarbeitung durch andere Benutzer verfügbar machen. Jede Nachricht wird als eine Benutzerbenachrichtigung in Tabelle Speicher hinzugefügt. Ein wichtiger Punkt bleibt festzuhalten über Worker-Funktionen ist, dass nach dem die Einstiegspunktmethode abgeschlossen ist, das Worker-Funktion erfolgt. Dies ist der Grund, warum Ihre Logik in einer Schleife ausführen müssen.
Auf der Clientseite müssen wir in der Lage sein, die Nachrichten als JSON zurückzugeben, damit jQuery asynchron abrufen und Anzeigen von Benachrichtigungen über neue Benutzer kann. Zu diesem Zweck wir fügen Code zum Controller Nachricht damit wir die Benachrichtigungen zugreifen können (siehe Abbildung 6 ).
Abbildung 6 Nachrichten als JSON zurückgeben
public JsonResult GetMessages()
{
if (User.Identity.IsAuthenticated)
{
UserTextNotification[] userToasts =
toastRepository.GetNotifications(User.Identity.Name);
object[] data =
(from UserTextNotification toast in userToasts
select new { title = toast.Title ?? "Notification",
text = toast.MessageText }).ToArray();
return Json(data, JsonRequestBehavior.AllowGet);
}
else
return Json(null);
}
In ASP.NET MVC 2 unter Visual Studio 2010 Beta 2 (der Umgebung zum Schreiben dieses Artikels verwendet wurde), kann nicht JSON-Daten jQuery oder einen anderen Client ohne die Option JsonRequestBehavior.AllowGet zurückgegeben werden. In ASP.NET MVC-1 ist diese Option nicht erforderlich. Wir können nun das JavaScript schreiben, die von die Abbildung 7 ).
Abbildung 7 Benachrichtigungen als Toast-ähnlichen Meldungen
$(document).ready(function() {
setInterval(function() {
$.ajax({
contentType: "application/json; charset=utf-8",
dataType: "json",
url: "/SystemMessage/GetMessages",
success: function(data) {
for (msg in data) {
$.gritter.add({
title: data[msg].title,
text: data[msg].text,
sticky: false
});
}
}
})
}, 15000)
});
Senden und Aufbereiten von einem Einkaufswagen
Für unsere Beispielanwendung wurde eine andere wichtige Szenario, das wir mit Warteschlangenspeicher aktivieren möchten Einkaufswagen übermitteln. Hollywood Hacker besitzt eine Drittanbieter-Erfüllungssystem (kann nicht alle Minianwendungen in Ihre wenig Lager behalten) so, dass das Datenbankmodul einige Verarbeitung auf dem Einkaufskorb erfolgen muss. Nach Abschluss des Moduls auf diese Weise verarbeitet, wird es eine Nachricht an die Benutzer Benachrichtigungswarteschlange, damit die Benutzer wissen, dass der Warenkorb verarbeitet wurde (oder, dass Probleme auftraten) senden. Wenn der Benutzer online, ist wenn der Einkaufswagen verarbeitet wird, erhält er eine Popupmenü Toast-Nachricht aus dem System. Falls er nicht online ist, erhalten er diesem Popup-Meldung beim nächsten er auf der Website anmeldet, wie in Abbildung acht .
Abbildung 8 Beispiel Benutzer Notification
.png)
Was müssen wir zunächst werden einige Wrapperklassen, die uns ermöglicht, die Interaktion mit der Warenkorb Einkaufswagen-Warteschlange. Diese Wrapper sind relativ einfach, und wenn den Quellcode für diese angezeigt werden sollen, Sie können checken Sie auf der CodePlex-Website.
Im Gegensatz zu einer standardmäßigen CRUD (erstellen, lesen, aktualisieren und löschen) Repository, Operationen für eine Warteschlange zu lesen sind einfache Lesevorgänge nicht. Denken Sie daran, dass wenn Sie aus einer Warteschlange eine Meldung erhalten, Sie haben eine begrenzte Zeitspanne, die während dem verarbeiten, die Nachricht und entweder den Vorgang fehl, oder der Nachricht löschen an abgeschlossener Verarbeitung. Dieses Muster übersetzen nicht gut in das Repository-Musters, damit wir diese Abstraktion deaktiviert die Wrapperklasse gelassen haben.
Nun, da wir den Code für die Interaktion mit dem Warenkorb Einkaufswagen Warteschlange haben, können wir Code platzieren, in den Einkaufswagen-Controller der Einkaufswagen Inhalt an die Warteschlange gesendet (siehe Abbildung 9 ).
Abbildung 9- absendenden Warenkorb zu Warteschlange
public ActionResult Submit()
{
ShoppingCartMessage cart = new ShoppingCartMessage();
cart.UserName = User.Identity.Name;
cart.Discounts = 12.50f;
cart.CartID = Guid.NewGuid().ToString();
List<ShoppingCartItem> items = new List<ShoppingCartItem>();
items.Add(new ShoppingCartItem()
{ Quantity = 12, SKU = "10000101010",
UnitPrice = 15.75f });
items.Add(new ShoppingCartItem()
{ Quantity = 27, SKU = "12390123j213",
UnitPrice = 99.92f });
cart.CartItems = items.ToArray();
cartQueue.AddMessage(cart);
return View();
}
In einem realen Szenario würde Sie erhalten den Warenkorb von einige Out-of-Process-Status wie eine Sitzung einen Cache zu speichern oder aus einem Formular bereitzustellen. Um den Artikel Code einfach wie möglich zu halten, sind wir nur den Inhalt von einem Einkaufswagen erstellen.
Mit dem Warenkorb Einkaufswagen-Inhalt in der Warteschlange sitzen, können wir schließlich unsere Worker-Rolle ändern, sodass die Warteschlange für ausstehende Carts in regelmäßigen Abständen überprüft. Jede Einkaufswagen aus der Warteschlange eine zu einem Zeitpunkt abrufen wird, selbst eine volle Minute für die Verarbeitung zu ermöglichen, und senden Sie eine Nachricht an die Benutzer Benachrichtigungswarteschlange informiert der Benutzer, den der Warenkorb wurde verarbeitet (siehe Abbildung 10 ).
Abbildung 10 Überprüfen der Warteschlange für ausstehende Einkaufswagen
private void ProcessShoppingCarts()
{
CloudQueueMessage cqm = cartQueue.GetMessage();
while (cqm != null)
{
ShoppingCartMessage cart =
QueueMessageBase.FromMessage<ShoppingCartMessage>(cqm);
toastRepository.AddNotification(new UserTextNotification()
{
MessageText = String.Format
("Your shopping cart containing {0} items has been processed.",
cart.CartItems.Length),
MessageDate = DateTime.Now,
TargetUserName = cart.UserName
});
cartQueue.DeleteMessage(cqm);
cqm = cartQueue.GetMessage();
}
}
Mit der Warteschlange-Nachricht wird abgerufen, deaktivieren und Einfügen in die Benachrichtigungstabelle Benutzer, der jQuery Gritter Code sitzen in der Masterseite wird dann die neue Nachricht auf die nächsten 15-Sekunden-Poll Zyklus zu erkennen und die Warenkorb Einkaufswagen Toast-Benachrichtigung an den Benutzer angezeigt.
Zusammenfassung und weitere Schritte
Das Ziel dieses Artikels besteht darin, erhalten Entwickler shed den Rahmenauftrag Sicherheit für Ihre physischen Datencenter und klar, dass Sie mehr Möglichkeiten mit Windows Azure als einfache “ Hello World ”-Websites erstellen.Mit der Leistungsfähigkeit von Windows Azure Warteschlangen und Windows Azure Tabelle speichern, und dieser Stromversorgung für asynchrones messaging zwischen der Anwendung und der Worker-Rollen können Sie Ihre Anwendung Datenbankmodul mit Windows Azure wirklich fuel.
Um den Artikel, klare und leicht lesbar zu halten, überlassen wir ziemlich Bit des Codes unverändert, ohne die Umgestaltung.Als Übung Ihren neuen Windows Azure Muskeln Gleitzeit, versuchen Sie, um einen Teil des Codes in diesem Artikel, um die Verwendung von Warteschlangen, die weitere umzugestalten Erstellen generischer und sogar eine eigenständige Assembly, die Code notwendig asynchrones messaging und Benachrichtigungen für alle ASP.NET MVC-Website enthält.
Das wichtigste besteht darin, Ihre Ärmeln Rollup, einige Websites erstellen und anzuzeigen, was Sie tun können.Der Code für diesen Artikel kann auf der CodePlex-Website für Hacker Hollywood gefunden werden: hollywoodhackers.codeplex.com.
exclaimcomputing.com Kevin HoffmanundNate Dudek die Co-founders des exclaim Datenverarbeitung, ein Unternehmen, die Entwicklung von Lösungen für spezialisiert werden die Wolke.