KeenTech » C#

Authentifizierung an Netzwerkfreigaben via C#

FireFox — Fri, 03 Apr 2009 12:00:47 +0000

Eine Mail erreichte mich heute, in der ich gefragt wurde, wie man zB. mein Programm easyLiveSync, oder eigene Implementierungen dazu bewegen könnte, auf Netzlaufwerke bzw. Freigaben zuzugreifen, bei denen sich explizit angemeldet werden muss. Ursache aus der Mail war, dass die Synchronisierung von bzw. auf Netzlaufwerke geschehen sollte, diese aber des Öfteren im Explorer als “Getrennt” angezeigt werden, obwohl ein Doppelklick darauf die Verbindung aufbaut. Ebenso, wenn das Laufwerk getrennt ist, wird aus anderen Programmen heraus der Zugriff verweigert.

Ich bin ein Freund von Boardmitteln, wo sie denn sinnvoll und zeiteinsparend sind. Und unter C# und Co. kann man auch die Boardmittel nutzen, um zumindest vorerst eine Verbindung unter Nutzung von Nutzer und Passwort auf eine Freigabe zu erreichen.

Der Befehl unter Windows lautet: net use SERVERNAME\IPC$ /user:USERNAME PASSWORD. Alternativ kann man auch die Freigabe vorher auf ein Laufwerksbuchstaben mappen mittels: net use FreierLaufWerksbuchstabe: \\SERVERNAME\FREIGABE /user:USERNAME PASSWORD. Danach kann man über den neu belegten Laufwerksbuchstaben auf die entfernten Daten zugreifen.

Will man dies nun via C# realisieren, existieren zwar einige Boardmittel, aber mittels eines Sechszeilers geht das Ganze recht einfach von der Hand. Folgender Quellcode-Ausschnitt zeigt dies auf:

ProcessStartInfo psi = new ProcessStartInfo(“net”,”use “ + SERVERNAME + @”\IPC$ /user:” + USERNAME + ” ” + PASSWORD);
Process proc = new Process();
proc.StartInfo = psi; proc.Start();
proc.WaitForExit();
proc.Close();

SERVERNAME, USERNAME und PASSWORD sind in diesem Fall Variablen des Typs string. Danach kann man problemlos den Zugriff via UNC auf die Freigabe des Server realisieren und seine “Dummheiten” mit anstellen. Ebenso ist durch Abänderung der ersten Quellcode-Zeile die Anbindung auf ein Laufwerksbuchstaben möglich:

ProcessStartInfo psi = new ProcessStartInfo(“net“,“use Laufwerk: \\\\“ + SERVERNAME + @“\Freigabe /user:” + USERNAME + ” “ + PASSWORD);

Der Rest sollte dann nach Schema F ablaufen.

Update – Programm: easyLiveSync

FireFox — Fri, 27 Feb 2009 21:05:52 +0000

Ich habe mal etwas in meinen Projekten gekramt und ein Programm, welches ich mal für unterschiedliche Bekannte geschrieben habe, herausgepickt. Ursache war erneut eine Anfrage eines weiteren Bekannten, ob es nicht möglich ist, Dateien und Verzeichnisse in “Echtzeit” auf ein Ziel der Wahl zu synchronisieren, damit im Ernstfall eine Wiederherstellung dieser Dateien möglich ist. Ich bitte hier an dieser Stelle das Wort “Ernstfall” nicht zu ernst zu nehmen, denn 100%ige Sicherheit gibt es nicht – auch nicht bei meinen Anwendungen

Es passiert viel zu oft, dass Dateien zB. von Netzlaufwerken irrtümlich gelöscht werden. Da Windows keinerlei Netzlaufwerk-Papierkörbe kennt, ebenso wenig Mac OS X bei Zugriff auf SMB-Shares, ist dieses Programm vor 2 Jahren entstanden. Es synchronisiert die Quelle zum Ziel (zB. ein eigener “Papierkorb” oder Backup-Ordner auf dem Netzwerk) und verweilt zur Laufzeit im Hintergrund, überprüft die Zugriffe auf die jeweiligen Dateien und Ordner und synchronisiert das Ganze dementsprechend. Wird eine Datei erzeugt, wird diese auch am Ziel umgehend erzeugt. Wird eine Datei geändert, geschieht dies auch am Ziel. Beim Löschen und Umbenennen passiert ebenso das Gleiche am Ziel. (Löschen kann in dieser Version abgeschaltet werden).

Sicherlich gibt es genügend Backup-Programme – kostenfrei und käuflich – aber diese halfen nicht bei oben genanntem Problem, wenn eine Datei erzeugt, aber Minuten oder Stunden später irrtümlich, durch DAU-Verhalten oder Layer-8 Problem, gelöscht wurden. Normale Backup- oder Syncprogramme laufen entweder immer nach einer Zeit X in Minuten oder gar nur einmal täglich.

Ich habe das Programm noch einmal auf die Schnelle etwas bearbeitet (Menüs, Dialoge) und diese ebenso einem Test unter Windows XP und Windows Vista unterzogen. Voraussetzung ist .Net Framework 3.5, aber bei Bedarf kann ich auch das Ganze für 2.0 anbieten.

Technischer Hintergrund: Das Ganze basiert auf der FileSystemWatcher-Klasse des .Net Frameworks, welches Created, Changed, Renamed und Deleted-Ereignisse verarbeitet und diese Information an das Ziel weitergibt. Es ist einstellbar, ob Deleted-Ereignisse verarbeitet werden sollen, oder nicht. Ebenso sind mehrere Sync-Jobs parallel möglich, um mehrere Ordner zu überwachen und zu sichern.

Es wird dringend davon abgeraten, eine komplette Festplatte (zB. Laufwerk C:) überwachen zu lassen. Die Auslagerungsdatei, der Windows-, wie auch weitere systemrelevante Ordner, schreiben gern und viel in ihre Dateien und Ordner herum. Das würde das Programm und somit den Rechner nur unnötig ausbremsen und für eventuell daraus resultierende “Schäden” übernehme ich definitiv keine Haftung. Apropos Haftung: Die Nutzung, der hier kostenfrei zur Verfügung gestellten Anwendung, unterliegt eigener Verantwortung. Das Programm, wie angeboten, ist “as is”, beinhaltet mit Sicherheit den einen oder anderen Fehler und eine 100%ige Funktion kann nicht gewährleistet werden. Das Programm liegt ebenso in den Original-Quellen vor, damit der geneigte Nutzer oder Programmierer sich der Basis annehmen und dann seine eigene Anwendung daraus stricken kann.

Update: Bug bereinigt – in bestimmten Konstellationen wurde das Ziel nicht korrekt geschrieben. Vornehmlich, wenn die Quelle im Vergleich zum bestehenden Ziel kleiner war. Programm + Quellcode in den Links wurden aktualisiert.

Das Programm startet derzeitig immer im Fenster-Modus. Optionen, um dies zu ändern, existieren noch nicht. Ein Doppelklick auf das Symbol in der Tray (das Teil neben der Uhr) blendet das Fenster aus bzw. wieder ein. Die Anwendung kann nur über das Tray-Symbol (rechte Maustaste – Beenden) beendet werden – oder aber, indem es mit dem Task-Manager abgeschossen wird – je nachdem, wie man es gern hat. Über Menüpunkt “Job -> Anlegen” kann ein Sync-Job angelegt werden. Um einen Job zu bearbeiten, einfach rechte Maustaste auf den gewünschten Job in der Liste und dann auf “Job ändern” klicken. Ebenso verhält es sich, wenn ein Job gelöscht werden soll.

Nachdem ein Job angelegt bzw. geändert wurde (oder aber mit definierten Jobs nach Start von easyLiveSync) wird pro Job jeweils abgefragt, wie weiter vorzugehen ist (Dies wird in einer späteren Version mit hinterlegbaren Job-Optionen geändert werden). Es stehen 3 Möglichkeiten zur Wahl:

Zielordner (alles, aber auch wirklich alles darin) löschen, Quelle in Ziel kopieren und danach das Ganze live überwachen,
Zielordner nicht löschen (wenn zB. schon einmal gesynced wurde), Quelle (neue oder geänderte Dateien und Ordner) werden auf das Ziel kopiert und danach das Ganze live überwacht, oder
nichts kopieren, sondern die Änderungen von Quelle auf Ziel übertragen (hier kann es bei Situationen, wo noch niemals vorher das Ziel gefüllt wurde, zu Problemem kommen – sprich Error).

Mehr gibt es eigentlich nicht zu wissen.

Für Verbesserungsvorschläge, dumme, negative, wie auch positive Kommentare, bin ich offen – und mit Sicherheit gibt es etwas zu verbessern (zB. Dateifilter, Überprüfung wann eine Datei an Quelle und Ziel gleich ist usw.)

Die Digital-Uhr in Brandenburg / Havel

FireFox — Wed, 23 May 2007 21:24:29 +0000

Seit geraumer Zeit steht sie in Brandenburg an der Havel und verrichtet fleißig ihren Dienst. Sie vermittelt jedem Nicht-Uhren Besitzer, wie schnell doch die Zeit vergeht und in letzter Zeit vermehren sich die Touristen, die es in die Stadt zieht, vor ihr, um davor abgelichtet zu werden. Die Rede ist von der Digital-Uhr auf dem Neustadt-Markt, deren elektronisches und technisches Innenleben von Industrieelektronik Brandenburg GmbH (IEB) (meinem Arbeitgeber) gefertigt wurde. Ich selbst durfte an diesem “Kleinod” mitwirken: speziell mit der alleinigen Entwicklung einer Windows-Anwendung für die Verwaltung und den Fernzugriff auf das Herzstück – die Steuerelektronik – der Uhr.
Wozu, wird der geneigte Interessierte fragen, brauch man einen Fernzugriff. Relativ einfach: Es ist mit Hilfe der Software möglich zeitgesteuert Skripte (Grafiken und Texte) über die 4(!) Laufbandanzeigen unter den 4(!) großen Hauptanzeigen (jede zeigt in eine der Haupthimmelsrichtung) ablaufen zu lassen. Das Ganze wird anwendungsseitig durch eine SQL-Datenbank gestützt. Die Texte, Grafiken und zeitlichen Abfolgen und Laufzeiten werden in der Datenbank abgelegt, um die Menge der übertragenen Daten bei späteren Aktualisierungen so gering wie möglich zu halten und um nicht ausversehen bestimmte Skripte auf der Uhr zu löschen.

Wozu das Ganze? Der Gedanke liegt darin, daß über diesem Wege die Einwohner und auch Besucher der Stadt über Ereignisse informiert werden können, die derzeitig oder in naher Zukunft in Brandenburg aufkommen.

Sollte jemand das Interesse verspühren andere über die Uhr grüßen, Glückwünsche für Hochzeiten, Geburtstage und andere Feierlichkeiten aussprechen, oder Werbung für sein Unternehmen anzeigen lassen zu wollen, kontaktiert einfach IEB.

Anbei noch 3 Bildchen (die Farbgebung und das Design stammt nicht von uns – wohlbemerkt)

[singlepic id="455" w="200" h="200" mode="" float="left" ]

AntMe! – die Ameisensimulation

FireFox — Mon, 16 Apr 2007 16:55:57 +0000

Im MSDN Bereich von Microsoft ist vor einigen Tagen ein interessantes Projekt vorgestellt worden. Es geht um AntMe! – eine Ameisensimulation. Ich habe die letzten Tage hier und da einen Blick darauf geworfen und finde, daß es für Einsteiger sehr gut geeignet ist, C# oder VB .Net zu lernen. Das Projekt selbst wird in 2 Paketen angeboten – für Einsteiger und Professionelle Entwickler. In der Professional Version ist der komplette Quellcode des Projekts enthalten – nebst GDI+ und Direct3D Darstellung. Der Quellcode selbst ist ist gut dokumentiert und die Hilfe sollte allen ein guter Einstieg sein.
Es macht sichtlich Spaß seinen Ameisen Leben einzuhauchen und diese mit wohlüberlegten Programmcode auszustatten.

Ich stelle einfach mal meinen derzeitigen Stand meiner Ameisen (nach effektiven 2 Stunden Überlegen und Ausprobieren) zur Verfügung. Vielleicht hat ja der eine oder andere Interesse daran sich daran zu versuchen.

Der Quelltext selbst ist noch nicht (bis auf den Inhalt aus der Vorlage) dokumentiert.

[source:csharp]
using System;
using System.Collections.Generic;
using System.Text;
using AntMe;

namespace AntMe.Spieler
{

[Spieler(
Name = "FireFox",
Vorname = "Michael",
Nachname = "Hensel"
)]

// Das Typ-Attribut hier erlaubt das Ändern der Ameisen-Eigenschaften. Um hier Änderungen vorzunehmen muss
// dem neuen Ameisentyp unbedingt ein Name zugewiesen und bei “BestimmeTyp” auch angegeben werden.
// Eine genauere Beschreibung gibts in Lektion 6 des Ameisen-Tutorials
[Typ(
Name = "Sammler",
GeschwindigkeitModifikator = 0,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = 1,
ReichweiteModifikator = 1,
SichtweiteModifikator = 1,
EnergieModifikator = -1,
AngriffModifikator = -1
)]

[Typ(
Name = "Kämpfer",
GeschwindigkeitModifikator = 0,
DrehgeschwindigkeitModifikator = -1,
LastModifikator = -1,
ReichweiteModifikator = 1,
SichtweiteModifikator = 0,
EnergieModifikator = 1,
AngriffModifikator = 0
)]

public class Sammler : Ameise
{
int LetzteNahrung = 0;
Zucker LetzterZucker=null;
///

/// Gibt dem Spieler die Möglichkeit, eigene Variablen zu initialisieren.
/// Wird vor jedem Spiel aufgerufen. Statische Variablen müssen hier
/// initialisiert werden!
///

Animation-Klasse

FireFox — Sun, 15 Apr 2007 20:40:52 +0000

Die Animation-Klasse von beta.unclassified.de zeigt ein Anwendungsszenario für die in einem früheren Eintrag angesprochene DelayedCall Klasse. Mit ihr können Controls als auch Forms animiert werden, ohne das ständige Neuzeichnen bei Resize-Operationen im Hintergrund hervorzurufen.

Beispiel:
Ein Form wird in seiner Größe geändert. Im ResizeEnd-Event wird die gewünschte Animation der beinhaltenden Controls aufgerufen.
Die Controls werden über die Animation-Klasse und der DelayedCall auf die jeweils übergebenen Größenänderungen angepasst, so daß eine sanfte Animation erfolgt.

Ein Beispiel sei hier kurz vermerkt, wie die Animation-Klasse angewendet werden kann. ucT ist in diesem Fall ein Control (in meiner Testapplikation ein UserControl mit einigen eingebetteten Controls, wie Buttons, Textbox usw). Für die vertikale Animation wird der Animation-Klasse den Parametern ResizeVert, dem Control (welches animiert werden soll), die letztendliche zu erreichende Höhe, eine Methode die nach Abschluß aufgerufen werden soll und die Dauer der Animation, aufgerufen.

[source:csharp]
private void TestForm_ResizeEnd(object sender, EventArgs e)
{
new KeenTech.UI.Animation(KeenTech.UI.AnimationTypes.ResizeVert, this.ucT,
this.ClientSize.Height – ucT.Height, new KeenTech.UI.AnimationFinishedHandler(Test), 350);
new KeenTech.UI.Animation(KeenTech.UI.AnimationTypes.ResizeHoriz, this.ucT,
this.ClientSize.Width – ucT.Width, new KeenTech.UI.AnimationFinishedHandler(Test), 350);
}
[/source]

Die Animation-Klasse sieht wie folgt aus (Namespace wurde an eigene Begebenheiten angepasst):

[source:csharp]
using System;
using System.Windows.Forms;
using System.Drawing;

// Benötigt die Klasse DelayedCall
//
// Anwendung:
//
// Ausblenden und anschließendes Schließen des Fensters:
// (Close ist Methode des Fensters this)
//
// new Animation(AnimationTypes.FadeOut, this, 0, Close);
//
// Sanftes Ändern der Höhe des Fensters auf 500 Pixel:
// (SomeTaskWhenResized ist die aufzurufende Funktion nach Abschluss der Größenänderung)
//
// new Animation(AnimationTypes.ResizeVert, this, 500 – Height, SomeTaskWhenResized);
//
// .NET-Kompatibilität: 2.0
//
// Hinweise für .NET 1.1: Als EventHandler muss ein ‘new delegate…’ übergeben werden,
// der Funktionsname allein ist eine Abkürzung, die seit .NET 2.0 möglich ist.

namespace KeenTech.UI
{
public enum AnimationTypes
{
None,
ResizeHoriz,
ResizeVert,
FadeIn,
FadeOut
}

public delegate void AnimationFinishedHandler();

public class Animation
{
AnimationTypes type;
object target;
int offset;
AnimationFinishedHandler handler;
int start;
int end;
int interval;
int duration;
int timePassed;
bool cancellationPending = false;

public Animation(AnimationTypes type, object target, int offset, AnimationFinishedHandler handler)
: this(type, target, offset, handler, 0)
{
}

public Animation(AnimationTypes type, object target, int offset, AnimationFinishedHandler handler, int duration)
{
this.type = type;
this.target = target;
this.offset = offset;
this.handler = handler;
this.duration = duration;

// timings in ms
interval = 10;
timePassed = 0;

Control c;
Form f;
switch (type)
{
case AnimationTypes.ResizeHoriz:
c = target as Control;
if (c == null)
return;
start = c.Width;
end = start + offset;
if (this.duration == 0)
this.duration = 150;
break;
case AnimationTypes.ResizeVert:
c = target as Control;
if (c == null)
return;
start = c.Height;
end = start + offset;
if (this.duration == 0)
this.duration = 150;
break;
case AnimationTypes.FadeIn:
f = target as Form;
if (f == null)
return;
start = (int)(f.Opacity * 100);
end = start + offset;
if (this.duration == 0)
this.duration = 250;
break;
case AnimationTypes.FadeOut:
f = target as Form;
if (f == null)
return;
start = (int)(f.Opacity * 100);
end = start + offset;
if (this.duration == 0)
this.duration = 2000;
break;
default:
return;
}

Next();
}

public void Cancel()
{
cancellationPending = true;
}

private double MakeCurve()
{
double timePercent = (double)timePassed / (double)duration;

// we use the sine function from 3pi/2 to 5pi/2
// scale down linear time percentage from 0…1 to 3pi/2 to 5pi/2
double curve = Math.Sin(1.5 * Math.PI + timePercent * Math.PI);
// translate sine output from -1…1 to 0…1
curve = (curve + 1) / 2;
// DEBUG: don’t use curve but linear progress instead
//curve = timePercent;

return curve;
}

public void Next()
{
if (cancellationPending)
return; // and don’t come back

timePassed += interval;
if (timePassed > duration)
{
if (handler != null)
handler();
return;
}

Control c;
Form f;
Rectangle wa;
switch (type)
{
case AnimationTypes.ResizeVert:
c = target as Control;
c.Height = start + (int)((end – start) * MakeCurve());
wa = Screen.FromControl(c).WorkingArea;
if (c is Form && c.Bottom > wa.Bottom)
{
c.Top -= c.Bottom – wa.Bottom;
if (c.Top < wa.Top)
{
c.Top = wa.Top;
}
}
break;
case AnimationTypes.ResizeHoriz:
c = target as Control;
c.Width = start + (int)((end – start) * MakeCurve());
wa = Screen.FromControl(c).WorkingArea;
if (c is Form && c.Right > wa.Right)
{
c.Left -= c.Right – wa.Right;
if (c.Left < wa.Left)
{
c.Left = wa.Left;
}
}
break;
case AnimationTypes.FadeIn:
f = target as Form;
f.Opacity = (double)(start + ((end – start) * MakeCurve())) / 100;
break;
case AnimationTypes.FadeOut:
f = target as Form;
f.Opacity = (double)(start + ((end – start) * MakeCurve())) / 100;
break;
}

new DelayedCall(new DelayedCall.Function(this.Next), interval);
}
}
}

[/source]