Wie man mit .NET und C# eine Echtzeit-Wahlanwendung erstellt
Published: 2024-03-05 04:02:56

Mit C# und .NET können Sie ganz einfach eine Echtzeit-Wahlanwendung im Browser erstellen, die es den Benutzern ermöglicht, in Echtzeit zu wählen und die Ergebnisse zu sehen. Es handelt sich um eine Webanwendung, die die Funktionalität eines Echtzeit-Wahlsystems bietet. In Anbetracht der rasanten technologischen Entwicklung ist es unerlässlich, Schritt zu halten, und deshalb möchte ich erwähnen, dass wir in diesem Tutorial C# 9, ASP.NET 5.0 und PubNub C# SDK Version 4.4.0 verwenden.

In diesem Tutorial zeigen wir, wie man eine webbasierte Echtzeit-Wahlanwendung mit der [C# PubNub API](https://github.com/pubnub/c-sharp) und ASP.NET MCV4, einem Teil der Microsoft ASP.NET Core Web API, erstellt. Damit können Benutzer abstimmen, und die Ergebnisse werden dank des PubNub C# SDK automatisch ausgewertet und in Echtzeit angezeigt. Wir werden insbesondere die Methoden \`publish()\`, \`Subscribe()\` und \`DetailedHistory\` nutzen, um unsere Echtzeit-Wahl-App zu betreiben. Sie können den Quellcode auf GitHub finden.

In jeder Echtzeit-Anwendung sollen die Frage und die Auswahl der Antworten aus einem Backend wie einer SQL-Server-Datenbank mit einem Entity-Framework stammen. Um unseren Fokus in diesem Tutorial einzugrenzen, werde ich die Fragen und Antwortoptionen in der Methode \`GetActivePollQuestion()\` der Klasse \`SampleData\` hart kodieren und diese als xml-Strings wiedergeben. In einem realen Szenario würden Sie dynamische Daten als Xml-String zurückgeben wollen.

### Schemas für eine Echtzeit-Abstimmungs-App

In diesem Zusammenhang ebnen Schemas den Weg für eine organisierte und strukturierte Datenspeicherung, die eine effiziente Datenverarbeitung ermöglicht. Um unsere Ziele zu erreichen, wurden zwei [Schemata](https://gist.github.com/stephenlb/a3fce3a43e1fba4564b6#schemas) erstellt, PollQuestion.xsd und PollUserAnswer.xsd. Diese stellen einen Entwurf für unsere Daten dar, der die Struktur und die Art der gespeicherten Informationen umreißt.

Die entsprechenden Klassendateien, PollQuestion.cs und PollUserAnswer.cs, wurden mit den folgenden Befehlen im Visual Studio-Terminal über das Tool xsd.exe erzeugt:

```js
XSD.EXE PollQuestion.xsd /c /l:cs /n:ePoll.Types

XSD.EXE PollUserAnswer.xsd /c /l:cs /n:ePoll.Types
```

Schauen Sie sich die Formate dieser Schemata an:

```js
<xs:schema id="PollQuestion"
    targetNamespace="pubnub-csharp-demo-epoll-1.0"
    elementFormDefault="qualified"
    xmlns="pubnub-csharp-demo-epoll-1.0"
    xmlns:mstns="pubnub-csharp-demo-epoll-1.0"
    xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="PollQuestion">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="ID" type="xs:string"></xs:element>
        <xs:element name="Question" type="xs:string"></xs:element>
        <xs:element name="Active" type="xs:boolean"></xs:element>
        <xs:element name="AnswerGroup">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="Answer" type="xs:string" maxOccurs="unbounded" minOccurs="2"></xs:element>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>
```

```js
<xs:schema id="PollUserAnswer"
    targetNamespace="pubnub-csharp-demo-epoll-1.0"
    elementFormDefault="qualified"
    xmlns="pubnub-csharp-demo-epoll-1.0"
    xmlns:mstns="pubnub-csharp-demo-epoll-1.0"
    xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="PollUserAnswer">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="QuestionID" type="xs:string"></xs:element>
        <xs:element name="Question" type="xs:string"></xs:element>
        <xs:element name="UserAnswer" type="xs:string"></xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>
```

### Veröffentlichung von Nachrichten über WebSockets für Echtzeit-Abstimmungen

Die Methode \`Publish()\` spielt in unserer Echtzeit-Abstimmungsanwendung eine entscheidende Rolle, da sie verwendet wird, um die Umfrageantworten an einen bestimmten PubNub-Kanal zu senden. Diese Nachricht wird dann von allen Instanzen, die diesen Kanal abonniert haben, in Echtzeit empfangen, was ein interaktives Abstimmungserlebnis ermöglicht. Sie können diesen Vorgang mit dem folgenden C#-Code-Segment leicht konfigurieren.

```js
public bool SaveAnswer(PollUserAnswer answer)
{
    bool ret = false;

    string pubnubChannel = answer.QuestionID;
    mrePublish.AddOrUpdate(pubnubChannel, new ManualResetEvent(false), (key, oldState) => new ManualResetEvent(false));
    messagePublished[pubnubChannel] = false;

    pubnub.Publish().Channel(pubnubChannel).Message(answer.UserAnswer)
        .Execute(new PNPublishResultExt(
            (result, status) => {
                if (!status.Error && result != null)
                {
                    messagePublished[pubnubChannel] = true;
                    mrePublish[pubnubChannel].Set();
                }
            }));

    mrePublish[pubnubChannel].WaitOne(TimeSpan.FromSeconds(10));

    return messagePublished[pubnubChannel];
}
```

### Abonnieren von Echtzeit-Abstimmungs-Benutzerbeiträgen über WebSockets

Auf der anderen Seite der Gleichung wird die Methode \`Subscribe()\` für den Empfang von Umfrageantworten in Echtzeit verwendet. Dies ermöglicht unserer Anwendung, Echtzeit-Updates zu liefern. Das PubNub SDK kann automatisch jede Nachricht/jeden Link wiederherstellen, die/der unter Verwendung von Long Polling und anderen Protokollen verloren gegangen ist. Um diese Funktionalität in Ihrem C#-Code zu erhalten, können Sie das folgende Code-Snippet hinzufügen.

```js
pubnub.Subscribe<string>()
    .Channels(new List<string> { pubnubChannel })
    .WithPresence() // If you need presence feature
    .Execute();

// Handling messages, presence, and status within the subscription listener
pubnub.AddListener(new SubscribeCallbackExt(
    (pubnubObj, message) => {
        if (message != null)
        {
            Console.WriteLine("VOTE RECEIVED!");
            Console.WriteLine(message.Message);
            Console.WriteLine();
        }
    },
    (pubnubObj, presence) => {
        // Handle presence event if needed
    },
    (pubnubObj, status) => {
        if (status != null)
        {
            if (status.Category == PNStatusCategory.PNConnectedCategory)
            {
                Console.WriteLine("SUBSCRIBE CONNECT CALLBACK:");
                Console.WriteLine(status.Category.ToString());
                Console.WriteLine();
            }
            else if (status.Error)
            {
                Console.WriteLine();
                Console.WriteLine(status.ErrorData.Information);
                Console.WriteLine();
            }
        }
    }
));
```

### Laden der Historie von Nachrichten über WebSockets für das Echtzeit-Abstimmungs-Dashboard

Die Methode \`DetailedHistory\` holt historische Nachrichten aus einem Kanal. Diese Methode holt diese Nachrichten asynchron und ermöglicht es uns, den Verlauf der Abstimmungsdaten von einem bestimmten PubNub-Kanal zu sehen. Hier ist das Codesegment, das dies demonstriert:

```js
public async Task<List<string>> GetPollResultsAsync(string questionID)
{
    List<string> ret = new List<string>();

    string pubnubChannel = questionID;
    long startTimetoken = 0; // For fetching all messages. Adjust as needed.

    try
    {
        PNHistoryResult result = await pubnub.History()
            .Channel(pubnubChannel)
            .Start(startTimetoken)
            .Count(100) // Adjust based on how many messages you expect to fetch. Max usually 100.
            .IncludeTimetoken(true)
            .ExecuteAsync();

        if (result != null && result.Messages != null)
        {
            foreach (var message in result.Messages)
            {
                // Assuming the messages are strings. Adjust as necessary for your data format.
                ret.Add(message.Entry.ToString());
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"An error occurred: {ex.Message}");
        // Handle errors or exceptions as necessary.
    }

    return ret;
}
```

Zusammenfassung
---------------

Inzwischen sollten Sie gut verstanden haben, wie man eine Echtzeit-Abstimmungsanwendung mit C#, .NET und dem PubNub C# SDK erstellt. Wenn Sie das Tutorial gründlich verfolgt haben, werden Sie festgestellt haben, wie einfach es ist, mit PubNub Echtzeitfunktionen in Ihre Anwendungen zu integrieren.

Im nächsten Blog-Beitrag gehen wir noch einen Schritt weiter, indem wir zusätzliche Funktionen wie Angular auf dem Frontend einbinden, Benutzerauthentifizierung hinzufügen, Datenverschlüsselung konfigurieren und vieles mehr. Bleiben Sie dran an unserer Playlist mit Webentwicklungs-Tutorials!

Erste Schritte
--------------

Unsere Plattform unterstützt Entwickler bei der Erstellung, Bereitstellung und Verwaltung von Echtzeit-Interaktivität für Webanwendungen, mobile Anwendungen und IoT-Geräte. Sie ist besonders nützlich für die Erstellung einer Echtzeit-Abstimmungsanwendung, wie die, die wir in diesem Tutorial besprechen werden.

Die Grundlage unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Sie können sich auf uns verlassen, wenn es um robuste und leistungsstarke Lösungen geht.

### PubNub erleben

[Live-Rundgang](https://www.pubnub.com/tour/introduction/)

### Einrichten

Um mit der Erstellung Ihrer eigenen Echtzeitanwendungen zu beginnen, melden Sie sich für ein [PubNub-Konto](https://admin.pubnub.com/#/login) an.

### Starten Sie

Die [PubNub-Dokumente](https://www.pubnub.com/docs) helfen Ihnen, ganz gleich, was Sie erstellen. Wir bieten umfangreiche Anleitungen für verschiedene Anwendungsfälle und SDKs, einschließlich [C#](https://www.pubnub.com/docs/sdks/c-sharp), das wir in diesem Tutorial verwendet haben.

#### Inhalt

[Schemas für eine Echtzeit-Abstimmungs-AppVeröffentlichen von](#h-0)[Nachrichten über WebSockets für Echtzeit-AbstimmungenAbonnieren von](#h-1)[Echtzeit-Abstimmungs-Benutzereingaben über WebSocketsLaden](#h-2) der[Historie von Nachrichten über WebSockets für das](#h-3)[Echtzeit-Abstimmungs-DashboardEinpackenErfahren](#h-5) Sie[PubNubErstmalig](#h-6)[einrichtenErstmalig](#h-7)[anfangen](#h-8)

Wie kann PubNub Ihnen helfen?
=============================

Dieser Artikel wurde ursprünglich auf [PubNub.com](https://www.pubnub.com/blog/how-to-build-a-realtime-voting-app-with-net-and-c/) veröffentlicht.

Unsere Plattform hilft Entwicklern bei der Erstellung, Bereitstellung und Verwaltung von Echtzeit-Interaktivität für Webanwendungen, mobile Anwendungen und IoT-Geräte.

Die Grundlage unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Mit über 15 Points-of-Presence weltweit, die 800 Millionen monatlich aktive Nutzer unterstützen, und einer Zuverlässigkeit von 99,999 % müssen Sie sich keine Sorgen über Ausfälle, Gleichzeitigkeitsgrenzen oder Latenzprobleme aufgrund von Verkehrsspitzen machen.

PubNub erleben
--------------

Sehen Sie sich die [Live Tour](https://www.pubnub.com/tour/introduction/) an, um in weniger als 5 Minuten die grundlegenden Konzepte hinter jeder PubNub-gestützten App zu verstehen

Einrichten
----------

Melden Sie sich für einen [PubNub-Account](https://admin.pubnub.com/signup/) an und erhalten Sie sofort kostenlosen Zugang zu den PubNub-Schlüsseln

Beginnen Sie
------------

Mit den [PubNub-Dokumenten](https://www.pubnub.com/docs) können Sie sofort loslegen, unabhängig von Ihrem Anwendungsfall oder [SDK](https://www.pubnub.com/docs)