1. usa.gif Project Description
    1. General
    2. Examples
      1. Using the RemotingInterface
      2. Using the EventLogManager

  1. germany.gif Projektbeschreibung
    1. Allgemein
    2. Beispiele
      1. Verwendung des RemotingInterface
      2. Verwendung des EventLogManagers

usa.gif Project Description

General
PS.Framework is an Application Framework to simplify the developement of .NET Applications.

It's containing many helpfull classes and functions e.g. an RemotingInterface to simplify the use of .NET Remoting and an EventLogManager for easily log application output (errors, warnings...) into an xml file or into the Windows EventViewer.

The PS.Framework runs on Microsoft .NET Framework 3.5. The following passages will give a quick overview about the PS.Framework. For detailed informations see the Documentation.


Examples

1. Using the RemotingInterface
With the RemotingInterface from the PS.Framework its very easy to create distributed applications. In this step it's shown the creation of the remoting Server.

// create an instance of the remoting server class        
RemotingServer<HelloWorldInterface> server = new RemotingServer<HelloWorldInterface>();
// set the remoting configuration file
server.ConfigFile = "ConfigFile_Remoting.xml";
// open the server
server.Open();

console.ReadLine();

Thats all whats needed to publish server side objects to remoting Clients. At this time only one server side class can be directly published.

The server side class HelloWorldInterface doesn't have to derive from MarshalByRefObj class while the RemotingServer will automatically map it to an instance of RemotingInterface<T> which is derived by MarshalByRefObj.

After creation of the RemotingServer a RemotingClient has to be created. In this step it's shown how to access the server side object.

// create an instance of remoting client
RemotingClient<ServerBusinessClass> client = new RemotingClient<ServerBusinessClass>();
// set the connection settings
client.HostName = "localhost"; // HostName can be the name or IPAddress of the host
client.Port = 12345; 
client.RemoteInterface = "HelloWorldInterface.rem"; // sets the name of the published interface
client.ProtocolRef = "tcp"; // sets the used .NET Remoting connection protocol

// connect to the remoting server
client.Connect();

// check the connection 
client.CheckConnection();

// if the connection successfully established get the interface
if (client.ConnectionState == InterfaceConnectionState.Connected)
{
	HelloWorldInterface helloWorldInterface = client.Interface as HelloWorldInterface;

	helloWorldInterface.SayHello("Hello World!");
}


2. Using the EventLogManager
With the EventLogManager its very easy to log errors or informations into the Windows EventLog or into a specified XML-File.
In this step its shown how easy it is to write log entries with the EventLogManager.

Setting up the configuration file
At first it's importand to configure the path to the configuration file of the EventLogManager. If no configuration file is configured the default location will be used.
In that case the location will be the application folder and the configuration file must be ConfigFile_Event.xml.
Otherwise the location of the config file must be added to the application configuration.

Example:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="ConfigFile_Event" value="Configurations\ConfigFile_Event.xml"/>
  </appSettings>
</configuration>

Defining the configuration for a xml-file log:
<?xml version="1.0" encoding="utf-8" ?>
<LoggerConfiguration>
  <!-- The file where the log entries should be written to. - Free editable -->
  <LogFile>ps_log.xml</LogFile>
  <!-- The Log Type - We have only two, XmlLog and EventLog in this case its the XmlLog-->
  <LogType>XmlLog</LogType>
</LoggerConfiguration>

Defining the configuration for the Windows EventLog:
<?xml version="1.0" encoding="utf-8" ?>
<LoggerConfiguration>
  <!-- The Log Type - We have only two, XmlLog and EventLog in this case its the EventLog-->
  <LogType>EventLog</LogType>
  <!-- The event source -->
  <EventSource>PS_TestSource</EventSource>
  <!-- The event log - needed to specify where to log inside the windows event log -->
  <EventLog>PS TestLog</EventLog>
</LoggerConfiguration>

Now there's all prepared for using the EventLogManager. Before the first use the EventLogManager must be initialized as shown below:
PSEV.Initialize();

After initialization it's possible to write log entries from wherever you want in your application as shown below:
PSEV.WriteEvent("Application started successfull.", null, LogEntryType.SuccessAudit);

If you are using the LogType EventLog it's importand to uninitialize the EventLogManager as shown below:
PSEV.Uninitialize();


germany.gif Projektbeschreibung

Allgemein
Das PS.Framework ist ein Framework, zur Vereinfachung der Erstellung von .NET Anwendungen.

Es enthält viele hilfreiche Klassen und Funktionen, z.B. das RemotingInterface, welches die Entwicklung von verteilten Anwendungen vereinfachen soll und einen EventLogManager um Anwendungsausgaben (Fehler, Warnungen...) in eine Xml-Datei oder das Windows Ereignisprotokoll zu schreiben.

Das PS.Framework läuft unter dem Microsoft .NET Framework 3.5. Die folgenden Absätze geben einen kurzen Einblick in das PS.Framework. Detaillierte Informationen sind der Documentation zu entnehmen.


Beispiele

1. Verwendung des RemotingInterface
Mit dem RemotingInterface ist es sehr einfach verteilte Anwendungen zu entwickeln. Im ersten Schritt wird gezeigt, wie einfach ein RemotingServer erstellt werden kann.

 // Instanz des RemotingServers erstellen      
RemotingServer<HelloWorldInterface> server = new RemotingServer<HelloWorldInterface>();
// Pfad zur Konfigurationsdatei zuweisen
server.ConfigFile = "ConfigFile_Remoting.xml";
// Server starten
server.Open();

console.ReadLine();

Das reicht schon, um ein serverseitiges Objekt zu veröffentlichen. Bisher kann auf diese Weise nur eine serverseitige Klasse bereit gestellt werden.

Die Klasse HelloWorldInterface muss nicht von MarshalByRefObject abgeleitet werden, da sie durch den RemotingServer automatisch in eine Instanz von RemotingInterface<T> gemapped wird, welche von MarshalByRefObject erbt.

Nachdem der Server erstellt wurde, muss eine Client-Applikation erstellt werden. Deshalb wird im 2. Schritt gezeigt, wie einfach auf ein serverseitig veröffentlichtes Objekt zugegriffen werden kann.

// Remoting Client erzeugen und diesem als T Parameter HelloWorldInterface übergeben
// damit wird es automatisch auf RemotingInterface<T> gemapped.
RemotingClient<HelloWorldInterface> client = new RemotingClient<HelloWorldInterface>();
// Verbindungseinstellungen setzen
client.HostName = "localhost"; // HostName kann der Hostname oder die IP des Hostrechners sein.
client.Port = 12345; 
client.RemoteInterface = "HelloWorldInterface.rem"; //RemoteInterface ist der Name des bereitgestellten Objektes
client.ProtocolRef = "tcp"; // ProtocolRef ist das .NET Remoting Protokoll, über das 

// Verbindung zum Server aufbauen
client.Connect();

// Verbindung überprüfen 
client.CheckConnection();
 // Wurde die Verbindung erfolgreich hergestellt, können wir uns die Instanz des HelloWorldInterface holen
 if (client.ConnectionState == InterfaceConnectionState.Connected)
 {
	HelloWorldInterface helloWorldInterface = client.Interface as HelloWorldInterface;

	helloWorldInterface.SayHello("Hello World!");
 } 


2. Verwendung des EventLogManagers
Mit dem EventLogManager aus dem Framework ist es sehr einfach, Fehler oder Informationen in das Windows Ereignisprotokoll oder eine Xml-Datei zu protokollieren.
In diesem Abschnitt wird gezeigt, wie einfach es ist Logeinträge mit dem EventLogManager zu schreiben.

Vorbereitung der Konfiguration
Zu aller erst ist es wichtig, den Pfad zur Konfigurationsdatei für den EventLogManager bekannt zu machen. Wurde dies nicht gemacht, wird der Standardpfad verwendet.
In diesem Fall ist es der Anwendungspfad und die Konfigurationsdatei muss den Namen ConfigFile_Event.xml tragen.
Ansonsten ist der Pfad zur Konfigurationsdatei in der Anwendungskonfiguration einzufügen.

Beispiel:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="ConfigFile_Event" value="Configurations\ConfigFile_Event.xml"/>
  </appSettings>
</configuration>

Konfiguration für die Protokollierung in eine Xml-Datei:
<?xml version="1.0" encoding="utf-8" ?>
<LoggerConfiguration>
  <!-- Der Pfad zu der Datei, in die Logeinträge geschrieben werden sollen. -->
  <LogFile>ps_log.xml</LogFile>
  <!-- Der Typ der LogEngine, in diesem Fall XmlLog. -->
  <LogType>XmlLog</LogType>
</LoggerConfiguration>

Konfiguration für die Protokollierung in das Windows Ereignisprotokoll:
<?xml version="1.0" encoding="utf-8" ?>
<LoggerConfiguration>
  <!-- Der Typ der LogEngine, in diesem Fall EventLog. -->
  <LogType>EventLog</LogType>
  <!-- Die Quelle für Einträge in das Ereignisprotokoll. -->
  <EventSource>PS_TestSource</EventSource>
  <!-- Das EventLog, die Angabe ist wichtig, um Logeinträge in den korrekten Pfad zu speichern. -->
  <EventLog>PS TestLog</EventLog>
</LoggerConfiguration>

Nun ist alles für die Verwendung des EventLogManagers vorbereitet. Vor der ersten Verwendung des EventLogManagers muss dieser wie im Folgenden gezeigt initialisiert werden:
PSEV.Initialize();

Nach der Initialisierung ist es von überall in der Anwendung möglich, Logeinträge zu protokollieren. Im Folgenden wird gezeigt, wie ein Logeintrag geschrieben werden kann:
PSEV.WriteEvent("Application started successfull.", null, LogEntryType.SuccessAudit);

Wenn Sie den Log-Typen EventLog verwenden ist es wichtig, den EventLogManager zu entladen:
PSEV.Uninitialize();

Last edited Apr 11, 2012 at 8:07 PM by inflames2k, version 31