Einfache FTP Klasse für C#

Vor kurzem hab ich einen FTP-Datentransfer innerhalb eines C# Programmes benötigt, nach etwas Gehirnschmalzvernichtung ist dieses nichtssagende, undokumentierte Stück Code rausgekommen. Nichts besonderes, keine ausgefuchste Fehlerbehandlung, keine Spezialfunktionen, keine ausführlichen Tests durchlaufen – wozu auch, es läuft ja. 😉

Zur meiner Entschuldigung muss ich auch vorbringen, dass das ja nur der erste Schuss ist – zumindest bevor es produktiv geht, sollten zumindest noch ein paar Fehlerbehandlungsroutinen da reinwachsen.

using System;
using System.Net;
using System.IO;

class FTP {

    private string ftpServerIP;
    private string ftpUserName;
    private string ftpPassWord;

    public FTP(string serverIP, string userName, string passWord) {
        this.ftpServerIP = serverIP;
        this.ftpUserName = userName;
        this.ftpPassWord = passWord;
    }

    public bool Upload(string fileName) {
        FileInfo fi = new FileInfo(fileName);
        string uri = "ftp://" + ftpServerIP + "/" + fi.Name;

        FtpWebRequest ftpRequest = CreateRequest(uri, WebRequestMethods.Ftp.UploadFile);
        ftpRequest.ContentLength = fi.Length;

        int buffLength = 2048;
        byte[] buff = new byte[buffLength];
        int count;
            
        bool result = false;
            
        using (FileStream fileStream = fi.OpenRead()) {
            Stream ftpStream = ftpRequest.GetRequestStream();

            count = fileStream.Read(buff, 0, buffLength);

            while (count > 0) {
                ftpStream.Write(buff, 0, count);
                count = fileStream.Read(buff, 0, buffLength);
            }

            ftpStream.Close();
            fileStream.Close();

            result = true;
        }

        return result;

    }

    public bool Download(string filePath, string fileName) {

        string uri = "ftp://" + ftpServerIP + "/" + fileName;
        FtpWebRequest ftpRequest = CreateRequest(uri, WebRequestMethods.Ftp.DownloadFile);

        int buffLength = 2048;
        int count;
        byte[] buff = new byte[buffLength];

        bool result = false;

        using (FileStream outputStream = new FileStream(filePath + "\\" + fileName, FileMode.Create)) {

            FtpWebResponse response = (FtpWebResponse) ftpRequest.GetResponse();
            Stream ftpStream = response.GetResponseStream();

            count = ftpStream.Read(buff, 0, buffLength);
            while (count > 0) {
                outputStream.Write(buff, 0, count);
                count = ftpStream.Read(buff, 0, buffLength);
            }

                
            ftpStream.Close();
            response.Close();
            outputStream.Close();

            result = true;
        }

        return result;
    }

    private FtpWebRequest CreateRequest(string uri, string requestMethod) {
        FtpWebRequest ftpRequest;
        ftpRequest = FtpWebRequest.Create(new Uri(uri)) as FtpWebRequest;
        ftpRequest.Credentials = new NetworkCredential(this.ftpUserName, this.ftpPassWord);
        ftpRequest.KeepAlive = false;
        ftpRequest.Method = requestMethod;
        ftpRequest.UseBinary = true;
        return ftpRequest;
    }
}

 

C# Farbenmanagement #2

Ein paar kleine Optimierungen / Refactorings haben sich in meiner Farbenkonvertierungsklasse breitgemacht.

Zum einen habe ich den Code vereinfacht, indem ich sich wiederholenden Code entfernt habe, zum anderen brauchte ich noch eine weitere Konvertierungsart, und zwar vom XYZ Farbraum zurück in den L*ab Farbraum.

Farbmessgeräte werden üblicherweise einmal am Tag kalibriert, dazu haben sie einen Weiß-Standard der gemessen wird und an dem sich das Gerät orienterien kann. Somit werden die Alterungserscheinungen des Blitzlichtes wieder kompensiert und man bekommt gleichmässige Messergebnisse.

Die Werte dieses Standards liegen aber nur als XYZ Werte vor, das Messgerät liefert aber in der gebrauchten Einstellung nur L*ab Werte zurück, daher die kleine zusätzliche Konvertierungsmethode.

Bei den Refactorings hat sich gezeigt wie unendlich praktisch Unit-Tests sind. Man kann seine Methoden optimieren, kürzen, verändern. Ist man fertig lässt man die Unit-Tests drüberlaufen und kann sich dann sicher sein, dass die Überarbeitungen nichts an den Ergebnissen geändert hat.

Und hier nun der gesamte neue Code:

Read moreC# Farbenmanagement #2

C# Farbenmanagement #1

Für eine Auftragsarbeit musst ich mich Farbräumen und deren Konvertierungen herumschlagen. Herausgefallen ist dabei so eine Art kleine „Farbverwaltungs“-Klassenbibliothek, mal sehen vielleicht wird ja in Zukunft noch mehr draus, es gibt ja noch viele Farbräume zu begutachten.

Anfangen tut das mit den verschiedenen Farbmodellen die es gibt, konkret brauchte ich nur einige wenige:

  • L*ab – ein gängiger (uralter) Standard in der „Farbenindustrie“
  • L*CH – eine andere Darstellung der Farbwerte
  • XYZ – eine Beschreibung des CIE Farbraumes
  • sRGB – wird u.a. von Windows verwendet um Farben auf dem Bildschirm darzustellen

Falls ihr mehr zu diesem Thema wissen wollt findet ihr ganz viele Ressourcen unter: Easy RGB

Um kurz auf die Programmiertechnik einzugehen: ich habe mich dazu entschieden die Klassen so in der Art immutable zu machen, das heisst eine einmal erzeugte Instanz kann nicht mehr geändert werden. Man kann die Werte einer Instanz nur über den Konstruktor ändern. So richtig immutable ist es aber wiederum doch nicht programmier, weil instanzen der gleichen Klasse bzw. die von einer dieser Modelklassen erben könnten ja theoretisch Werte ändern. Aber ich hatte jetzt keine Lust mich da im Moment weiter einzulesen und das wirklich 100%ig zu machen.

Und nun zu den Listings, die Namespaces hab ich rausgenommen, könnt ihr ja euch ganz einfach dazudenken 😉

Read moreC# Farbenmanagement #1

Quick Sort

Und weiter mit den Sortierübungen, jetzt der Quicksort in C

 
#include 

void quick_sort(int *liste, int links, int rechts);
void output(int *liste, int start, int ende);

int main(int argc, char* argv[])
{
	
	int a[] = {15, 9, 12, 1, 6, 13, 3, 4, 7, 10, 8, 11, 2, 5, 14, 16};

	printf("+Start:n");
	quick_sort(a,0,15);
	printf("+Ende:n");
	output(a,0,15);


	return 0;
}
void output(int *liste, int start, int ende)
{
	int i=0;

	for(i=start; i<=ende; i++)
	{
		printf("[%2d] ",liste[i]);
	}
	printf("n");
}


void quick_sort(int *liste, int in_links, int in_rechts)
{
	int links=in_links;
	int rechts=in_rechts;
	int mitte=liste[(links+rechts)/2];
	int temp=0;
	printf("+QSort: Von %d bis %d - Teile bei [%2d]:n  ",links,rechts, mitte);
	output(liste,links,rechts);
	do
	{
		while (liste[links] < mitte) links++;
		while (liste[rechts] > mitte) rechts--;
		if (links <= rechts)
		{
			printf("  Tausche [%2d] <--> [%2d]n  ", liste[links], liste[rechts]);
			temp = liste[links];
			liste[links] = liste[rechts];
			liste[rechts] = temp;
			output(liste,in_links,in_rechts);
			links++;
			rechts--;
		}
	} while (links <= rechts);
	if (rechts > in_links) quick_sort(liste, in_links, rechts);
	if (links < in_rechts) quick_sort(liste, links, in_rechts);
}

Bubble Sort

Eine einfache Implementierung des Bubble Sort Algorithmus in C

#include 
#define MAX 8

void bubble_sort(int *liste);
void output(int *liste);

int main(int argc, char* argv[])
{
	
	int a[] = {15, 9, 12, 1, 6, 13, 3, 4};

	output(a);
	bubble_sort(a);

	return 0;
}
void output(int *liste)
{
	int i=0;

	for(i=0; i=i; j--)
		{
			if (liste[j-1] > liste[j])
			{
				printf(" Tausche: [%2d] > [%2d] \n",liste[j-1],liste[j]); 
				x = liste[j-1];
				liste[j-1] = liste[j];
				liste[j] = x;
				printf(" "); 
				output(liste);
			}
			else
			{
				//printf(" Vergleich: [%2d] < [%2d] \n",liste[j-1],liste[j]);
			}
		}

	}

}