Laden...

Forenbeiträge von NoOneKnows Ingesamt 333 Beiträge

16.02.2005 - 13:16 Uhr

Nein, gibt es nicht. Jede Instanz der Property zugehörigen Klasse verfügt über diese Eigenschaft. .NET kann nicht wissen, welche Instanz gemeint seine soll. Du kannst die Property ja auf jede Instanz dieser Klasse anwenden. Falls du dynamisch eine Eigenschaft eines Objekts auslesen oder schreiben möchtest muß du zusätzlich die Instanz ablegen.

16.02.2005 - 13:02 Uhr

Original von Ingo Boller
struct und class sind beide nicht objectorientiert, wenn man die Definitionen dazu mal durchgeht.

Ne, du hast ein komplett falsches Verständniss von Objektorientierung. Java und C# stellen in der Hinsicht das Maß aller Dinge. Und es gibt zigtausende Programmierer die das so akzeptieren. Und jetzt kommst du und behauptest es sei nicht objektorientiert, nur weil du es einfach nicht erwartest oder einfach anders gewohnt bist? Wenn Referenzen nach deinem Verständnis nun die Objekte selbst repräsentieren, dann fängst du wieder mit Pointer-Wirtschaft an und das ist der erste Schritt in die Verderbnis 🙂 Du kommst in der Objektorientierten-Programmierung nämlich nicht ohne Referenzen aus, also müßtest du in diesem Fall auf Pointer zurückgreifen. Und damit wird nur alles verkompliziert. Falls dus kompliziert magst empfehle ich C++. Falls du schnell an dein Ziel kommen möchtest empfehle ich C# 😉 Vielleicht solltest du dich einfach näher mit der Objektorientierung vertraut machen. Du wirst sehen das alles seinen Sinn hat.

09.02.2005 - 20:56 Uhr

Öhm, okay, scheint so zu sein 🙂 Was ich aber meinte ist $69b des Urhebergetztes. Demnach muß es sogar nicht einmal explizit im Arbeitsvertrag erwähnt sein:

(1) Wird ein Computerprogramm von einem Arbeitnehmer in Wahrnehmung seiner Aufgaben oder nach den Anweisungen seines Arbeitgebers geschaffen, so ist ausschließlich der Arbeitgeber zur Ausübung aller vermögensrechtlichen Befugnisse an dem Computerprogramm berechtigt, sofern nichts anderes vereinbart ist.

Sprich du bist dann zwar noch Urheber hast aber keine großartigen Rechte mehr.

09.02.2005 - 19:10 Uhr

Dies kannst du mit einem anderen Attribut machen. Du mußt es jedoch vor die Property schreiben. Dadurch legt der Designer die Werte des Objekts einzeln ab und macht nichts mit Serialisierung:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
09.02.2005 - 13:28 Uhr

Versuchs mal mit diesem Attribute:

[TypeConverter(typeof(ExpandableObjectConverter))]

//edit:
Dieses Attribut muß vor die Klasse die du im Designer aufklappen möchtest, nicht vor die Property.

09.02.2005 - 13:15 Uhr

Soweit ich weiß spielt das Copyright hier in Deutschland eh keine Rolle. Ob du da irgendwas hinschreibst oder nicht, du bist und bleibst Urheber der Software, auch ohne es erkenntlich zu machen. Natürlich macht man es trotzdem, allein schon um anderen zu zeigen: "Hey, ich hab die Software entwickelt". Aber es besteht keine notwendigkeit, von daher kannst du reinschreiben was du willst 🙂 Wenn du bei einer Firma arbeitest und Software entwickelst dann steht meist im Arbeitsvertrag das die Firma Urheber jeglicher Entwicklungen ist usw. Und mit Gewerbe hat das nichts zu tun. Ein Unternehmen kann genauso Urheber sein wie eine Privatperson.

Wiki
Hier steht auch nochmal unter Kennzeichnung das das Copyright rein freiwillig ist.

08.02.2005 - 20:17 Uhr

Ein schönes und gleichzeitig erschreckendes Beispiel ist System.Collections.Specialized.NameObjectCollectionBase. Man werfe einen kurzen Blick auf die gechützten Methoden die so aussehen:
BaseAdd(...)
BaseClear(...)
BaseGet(...)
...
BaseRemoveAt(...)
BaseSet(...)
Ich glaub da muß man nix mehr hinzufügen. Falls doch, reicht ein Blick auf die CollectionBase 🙂

05.02.2005 - 16:55 Uhr

Hallo,

nur ne Kleinigkeit. Folgender Link kann nicht verwendetfunktioniert nicht, obwohl er an sich korrekt ist:
Wikipedia

Gemeint ist die Seite:
Wikipedia

NoOneKnows

05.02.2005 - 16:53 Uhr

Wiki

Früher oder später kommst du nicht um Schnittstellen herum. Das ist fundamental Wichtig in objektorietierten Sprachen. Man kann es in den unterschieldichsten Zusammenhänghen einsetzen. Im normal Fall definiert eine Schnittstelle einfach eine gewisse Funktionalität, die die Klasse besitzt. Beispiel aus dem FX ist ICloneable. Jede Klasse die diese Interface einbindet hate eine Methode Clone(). Die Methode stellt sicher das eine Kopie des Objekts angefertigt wird. Es kann in den Klassen unterschieldichst implementiert werden, nach außen weißt du aber, wenn eine Klasse ICloneable implementiert, kannst du dir sichergehen eine Kopie anfertigen zu können. Anderes Beispiel wäre IEnumerable. Jede Klasse die diese Schnittstelle einbindet stellt sicher das ein foreach für ein Objekt dieser Klasse verwenden kann, usw.

Du kannst auch noch hier im Forum suchen, das Themen hatten wir auch schon einige Male.

05.02.2005 - 16:35 Uhr

Original von michaelschuler
Theoretisch könnte ich die VB funktion verwenden, was ich jedoch ziemlich unschön fände... Habe mir jetzt auch eine gebastelt, und zwar eine, die beim aufruf .Show() den String zurückgibt 😄

Genau und null wen man auf Abbrechen klickt. Naja, immerhin kann man das dann unterscheiden. In VB6 wußte man ja nie ob der Benutzer nun Abbrechen geklickt oder einfach nichts eingegeben hat. Man hat es eben nicht so genau genommen 🙂

04.02.2005 - 19:03 Uhr

Das hab ich auch schon vermisst. Ausgerechnet so etwas einfaches fehlt 🙂

04.02.2005 - 19:02 Uhr

Original von FZelle
@NoOneKnows:
Wo hast Du das Zitat her, könnte ich auch manchmal in anderen Foren zu dieser Frage gebrauchen.

Ich hab das in einer Newsgroup über Google Groups gefunden 🙂 Also nix offizielles, aber es beschreibt das eben.

04.02.2005 - 12:18 Uhr

Einfach casten:

((MdiChildForm) myMdiParrent.ActiveMdiChild).MyProperty = xyz;
03.02.2005 - 17:14 Uhr

Schau mal hier

03.02.2005 - 17:12 Uhr

Full Disagreement! Das der Resharper einige Bugs hat ist bekannt, aber finde mal etwas was ansatzweise so ein gutes Refactoring ermöglicht und den Entwicklungsprozess dermaßen beschleunigt wie der Resharper. Ich glaub da wirst du lange suchen können. Du kannst ja gern mal ein Blick auf Visual Assist werfen, aber das Ding ist vom Handling und überhaupt Meilen vom Resharper entfernt. Wie hier bei uns haben einige Lizenzen vom Resharper und wir arbeiten nun schon seit 3 bis 4 Monaten damit auch in Solutions die 20 Projekte beinhalten. Das Refactoring, die Suchfunktionen, usw. funktionieren. Ab und an, aber eher selten taucht der Exception-Dialog auf und wenn er auftaucht heißt das noch lange nicht das jetzt schluß ist. Ignore, nächster versuch und dann gehts meist. Auch das Error-Highlighting funktioniert nicht immer 100%, aber die speziellen Sonderfälle kennt man nach einer gewissen Zeit. Wenn du überlegst wieviel Zeit du damit sparrst im Verlgeich zu dem bisschen Ärger, das du mit dem Werkezug hast, dann fällt die Entscheidung klar für den Resharper aus. Und ich sag mal so, du hast keinen blaßen Schimmer was der Resharper im Hintergrund alles bewerkstelligt. Wir Entwickler hier sind immer wieder überrascht was der Resharper alles in der Struktur und in der Logik des Quellcodes erkennt. Aber das erkennt man nicht, wenn man sich das Tool eine halbe Stunde anschaut...

03.02.2005 - 14:38 Uhr

Ja, guck mal hier.

03.02.2005 - 14:23 Uhr

> Can someone explain to me the memory usage patterns I see when observing an
> Forms application in Taskmanager?
>
> what I see:
> Start the program and the TaskManager says it is 11 MBs or so.
> Minimize the program and the task manager says it is about 300KB or so.
> Maximize the program and the task manager says it is about 3.5MB give or
> take a few.
>
> So why the great differences in size?

This behavior is not specific to .NET applications only.

It is a feature of the Windows/Explorer shell.

If an application is minimized, Windows removes the working set memory from
the application by calling the Win32 function 'SetProcessWorkingSetSize':

<
>
>

Windows supposes that minimized applications will not be used for some time
and this memory will be made available to other processes.

When restoring the window the application gets the memory back:

<
>
>

This behavior is by design and it doesn't make sense to worry about

03.02.2005 - 14:20 Uhr

Original von Guggsdu
Aber selbst wenn ich solche Objekte finde, müßte doch der GC seinen Beitrag leisten und die Objekte wieder wegräumen!!

Das ist nicht immer so einfach. Ich hatte schon den Fall das ich alle Referenzen auf meine DataTable kleinlichst vernichtet hab und trotzdem wurde der Speicher immer weiter zugemüllt. Resultat war dann am Ende das ein DataGrid freudig alle Referenzen auf die DataTables gehortet hat und ich damit kein Stück Speicher mehr freibekommen hab.

Und ansonsten weißt ich nur, das man NICHTS darauf geben sollte was der Taskmanager speichertechnisch anzeigt. Die Anzeige stimmt einfach nicht. Ich weiß net wie es sich mit dem Taskmanager von Sysinternals verhält.

03.02.2005 - 13:01 Uhr

Dann wohl so:


bool isValid = Regex.Match(input, @"[1-9]\\d{0,2}").Success;

  1. Stelle muß eine 1-9 sein, dahinter können maximal 2 weitere Zahlen auftauchen oder garkeine.
02.02.2005 - 17:15 Uhr

Das schreit nach Regex 😉


bool isValid = Regex.Match(input, @"[1-9]\\d{3}").Success;

Das spart ein Try-Catch und irgendwelches rumgefrickel.

31.01.2005 - 19:52 Uhr

Nur so: Resharper ist eines der besten, wenn nicht sogar das beste Refactoring-Tool für Visual Studio. Damit kann man alles mit einem Fingerschnipp umbennen. Gibt eine 30-Tage Trial Version und wer mag kann sich nach den 30 Tagen wieder ein Trial-Key besorgen 😉

29.01.2005 - 14:05 Uhr

@cdr:
Sehe ich nicht so. Sicherlich kann man es so machen wie in dem Beispiel, aber der Copy-Constructor ist nicht notwendig um sowas nachzubilden. Der macht den Sachverhalt nur komplizierter als er wirklich ist. Hier ein simples Gegenbeispiel:

class Program
{
	static void Main(string[] args)
	{

		Z zet = new Z(15, 20, 25);
		X ex = zet;
		Z zetClone = zet.Clone(); // Punkt 1
		Z otherZet = (Z) ex.Clone(); // Punkt 2 und 3

		Console.WriteLine("{0} {1} {2}", otherZet.ValueOfX, otherZet.ValueOfY, otherZet.ValueOfZ);
		Console.ReadLine();
	}
}

public class X : ICloneable
{
	private int x;
	
	public X(int x)
	{
		this.x = x;
	}

	protected virtual void AdjustClone(object clone)
	{
		
	}

	object ICloneable.Clone()
	{
		X clone = (X) this.MemberwiseClone();
		AdjustClone(clone);
		return clone;
	}

	public X Clone()
	{
		return (X) ((ICloneable) this).Clone();
	}

	public int ValueOfX
	{
		get { return x; }
	}
}

public class Y : X
{
	private int y;

	public Y(int x, int y) : base(x)
	{
		this.y = y;
	}

	protected override void AdjustClone(object clone)
	{
		base.AdjustClone(clone);
		// Anpassung
	}

	public new Y Clone()
	{
		return (Y) ((ICloneable) this).Clone();
	}

	public int ValueOfY
	{
		get { return y; }
	}
}

public class Z : Y
{
	private int z;

	public Z(int x, int y, int z) : base(x, y)
	{
		this.z = z;
	}

	protected override void AdjustClone(object clone)
	{
		base.AdjustClone(clone);
		// Anpassung
	}

	public new Z Clone()
	{
		return (Z) ((ICloneable) this).Clone();
	}

	public int ValueOfZ
	{
		get { return z; }
	}
}

AdjustClone() dient dazu um Anpassungen am Clone zu machen, was ansonsten nicht gewährleistet werden kann. In deinem Beispiel ist es fatal wenn eine Klasse in der Vererbungshierarchie nicht mehr über den Copy-Constructor verfügt was in dem moment gegen ICloneable entspricht. Implementierst du ICloneable muß die Klasse klonbar sein und nicht nur unter der Bedingung das irgendwelche Konstruktoren vorhanden sind. Von daher ist das Beispiel von Hern Rüegg schlichtweg unsinn.

29.01.2005 - 11:54 Uhr

Der Nutzen der ApplicationException liegt ja nicht darin, das irgendeine brauchbare Funktionalität zur normalen Exception hinzugefügt wird. Du kannst dann einfach gezielt Exceptions abfangen die direkt im Zusammenhang mit der Applikation stehen. Sicherlich verwendet die Applikation auch System-Exceptions wie ArgumentNull usw. Aber man muß sich dann eben bewußt machen, das nur die "benutzerdefinierten" Exceptions abgefangen werden und das soll eben der Sinn der Sache sein. Wenn man von Exception ableitet geht das nicht. Das Microsoft im Reflection-Namepsace anscheinend Mist gemacht hat sieht man deutlich. Es gibt dort eben 4 Exceptions, die von ApplicationException erben, was unklar bleibt. Aber die Idee hinter ApplicationException ist schon sinnvoll, eben benutzerdefinierte Exception abfangen zu können.

28.01.2005 - 13:03 Uhr

Ich würd aufhören immer im Framework nachzuschauen, wie es da gemacht wird. Wir alle wissen doch das im Framwork nicht immer alles konsequent umgesetzt ist, was Microsoft selbst empfiehlt. Trotzdem sollte man sich weitesgehendst an das halten was von denen gesagt wird, weil es einen gewissen Sinn hat.

28.01.2005 - 00:28 Uhr

Versuchs mit etwas wie:

Type controlType = Type.GetType("System.Windows.Forms.ComboBox");
Control control = Activator.CreateInstance(controlType);

// oder so
control = Activator.CreateInstance("System.Windows.Forms", "ComboBox");
27.01.2005 - 19:34 Uhr

Spare nicht am falschen Ende 🙂 Leg am besten für jede Klasse eine eigene Datei an, egal wie klein die Klassen ausfallen mögen. Geschachtelte Klasse zu verwenden is ne philosophie Frage, aber Exceptions fallen da nicht drunter.

25.01.2005 - 20:17 Uhr

Des is goanz einfach:

MyMdiChild myChild = new MyMdiChild();
myChild.MdiParent = myMdiParent;
myChild.Show();
25.01.2005 - 20:09 Uhr

Wo liegt die Klasse XmlData? Wenn du irgendwas mit Casts machst muß die Klasse auch für die Steuerelement-Bilbilthek bekannt sein. Entweder in dem du die Klasse mit in die Bibliothek nimmst oder von der Steuerelement-Bibliothek und der Executable auf eine weitere Bibliothek referezierst, in der die XmlData-Klasse lagert.

25.01.2005 - 19:57 Uhr

Original von KRambo
Wenn du die Codezeile noch einfügst, dann schreibt er die Assemblydaten nicht mit:

  
BinaryFormatter formatter = new BinaryFormatter();  
formatter.AssemblyFormat = FormatterAssemblyStyle.Simple;  
  

Hoffe ich konnte dir helfen

Der Simple-Style verdeckt lediglich die Versionsnummer, nicht aber den Assemblynamen. Das kann verwenden um die zu serialisierende Klasse auch unabhängig von der Assemblyversion wieder deserialisieren zu können.

Und wenn man übrigens eine Klasse direkt in 2 verschiedenen Assemblies verwendet ohne diese jedoch über eine Bibliothek zu referenzieren, geht es nur noch über ISerializable.

25.01.2005 - 19:38 Uhr

Original von Chief Brodie
der copy-contructor soll grundsätzlich eine flache kopie liefern - für tiefe kopien ist das interface "IClonable" vorgesehen.

Wo steht das? 🙂 Guckst du hier. Man soll überhauptkeine Art von Copy-Constructor mehr verwenden, sondern nur noch ICloneable. Mit dem Copy-Constructor umgehst du nämlich diesen Mechanismus, der der an anderer Stelle sehr nützlich sein kann.

Edit:

Nur lustig, dass sich nichtmal das .NET Framework dran hält. Finds etwas ermüdend jedesmal
nachlesen zu müssen, ob ne flache oder tiefe Kopie erzeugt wird, darum verwend ich ICloneable
am besten gar nicht ..

Das is ja das Argument schlechthin, nur weils sonstwo im Framework nirgends benutzt wird. Das manchmal tiefe Kopien nicht gewünscht sind hat seine Gründe. Und benutzt man ICloneable kannst du einfach mit

if (myObject is ICloneable)
{
myClone = ((ICloneable) myObject).Clone();
}

eine Kopie erstellen ohne irgendwelche Details kennen zu müssen. Das is doch der Vorteil von Interfaces. Man man man... 🙂

25.01.2005 - 18:44 Uhr

Die sind ja beide total unzentral 😉 Eigentlich müsste man sowas wie Kassel nehmen.

19.01.2005 - 20:28 Uhr

Okay, danke. Also kommt es nicht in Frage so etwas über reguläre Ausrücke zu machen. Hab mal einen kleinen Blick auf ANTLR geworfen und war erstmal etwas überfordert, weil mir die Funktnionsweise noch nicht ganz klar, also was das Ding macht 😉 Ich hab mir Beispiel Grammatik-Dateien angeschaut, womit man ja scheinbar solche syntaktischen Gegebenheiten definieren kann. Das sieht schonmal nicht schlecht aus. Was ich brauch ist dann so ein fefrtiger Parser für SQL, den ich direkt über .NET/C# ansprechen kann und der mir meine eingegebene SQL Statements überprüft und zurückgibt, wo die Syntax inkorrekt ist und weshalb dies der Fall ist.

19.01.2005 - 12:16 Uhr

Eclipse ist ein bisschen Lahm. Da zieh ich mir VS .NET vor. Aber von den Features her ist Eclipse natürlich auch 1a.

19.01.2005 - 00:33 Uhr

Ich meinte ja auch, das es kein vorgefertigten Mechanismus dafür gibt. Programmieren kann man sicherlich fast alles 😉

18.01.2005 - 21:49 Uhr

Wie Pulpapex schreibt gibts da wohl wirklich tolle Lösung. Du wirst nirgends mehr erfahren, welches Control zuletzt den Fokus hatte. Aber ich würde statt mit dem Click-Event lieber mit den Enter oder GotFocus-Event arbeiten, das ist saubere. Es reicht ja wenn du eine Ereignis-Behandlung für alle Textboxen schreibst.

18.01.2005 - 21:37 Uhr

@ Verllas und cdr:
Danke für die Antworten. Das man relativ leicht über regüläre Ausdruck zum Beispiele eine Art Syntax-Highlighting realisieren kann ist schon klar. Worum es mir geht ist eben die Korrektheit einer Syntax zu überprüfen. Sowas konnte man ja mit Spart machen, denk ich. Dort bassierte also ein ein Typ "Operator" zum Beispiel auf Arithmetischen, Logisch, Relationalen Operatoren, die Typen für sich waren. Und die "Arithmetischen Operatoren" sind dann wieder Typen, eben in diesem Fall + - / * usw. So konnte man zum Beispiel wieder definieren wie sich ein "Ausdruck" zusammensetzt, nämlich z.B. über Operand Operator Operand. Und sowas würd ich halt gern rein basierend auf reguläre Ausdrücke mache. Im endeffekt sowas was auch der Resharper macht, nämlich OnTheFly die Syntax auf ihre korrektheit prüfen, nur das ganze wollte ich nicht für C#, sondern für SQL-Anweisungen und da stecken ja auch sehr viel syntaktische Muster drin. Nur ich hab irgendwie keinen Ansatz wie man an sowas über Regex rangeht!? Oder sollte man da eh einen anderen Weg gehen?

17.01.2005 - 21:58 Uhr

Wie funktioniert denn so ein Parser der rein auf Regex basiert? Ich mein, ich kenne Spart, was ja so ein Ansatz ist, aber wie funktioniert sowas wenn man direkt über Regex arbeitet? Kennt da jemand Beispiele?

BTW: Schönes Tool zum testen und experimentieren mir .NET-Regex ist übrigens Expresso.

17.01.2005 - 19:10 Uhr

Also die Verbindung kannst du die ganze Zeit offen halten, du mußt lediglich die Verbindung zu anfang erstellen und öffnen. Und diese bleibt solange geöffnet bis du sie wieder manuell schließt. Da gibts kein Timeout, wär mir zumindest ganz neu 🙂

Aber ich kenn eh nur die umgekehrte Variante, das man Verbindungen wieder spätestens nach einer bestimmten Zeit wieder schließen möchte. Das hat dann zum Beispiel lizenstechnische Gründe.

17.01.2005 - 19:04 Uhr

Original von Vellas
Genau, nichts gegen VB, wir sind Minderheiten ja tollerant gegenüber. 😄

Ich sach nur VB6 - You don't know the power of the dark side! 😉

16.01.2005 - 23:33 Uhr

Original von Pulpapex
"b" or not to "b"?

("[bb]" ist aber Unsinn. Und warum "{2}"?)

"To be or not to be" eben. Jups, das mit dem "[bb]" is net ganz korrekt und "{2}" heißt eben in dem Fall auch nur two/to. Habs so ausm original, wahrscheinlich isses so ums ein bissel schwieriger zu machen 😉

Edit: Jo 🙂

16.01.2005 - 23:03 Uhr

Regex g
|
|
|
v

16.01.2005 - 13:14 Uhr

@hauptmann:
Mit Kürzen mein ich jetzt einfach nur schlicht, statt "a = a ^ b" eben "a ^= b" zu verwenden, also nichts großartiges. War in deiner ursprünglichen C/C++ Anweisung ja genauso 🙂

@cdr:
Jo, ich glaub auch nicht, das man ernsthaft sowas im Code verwendet 🙂 Das is ne reine Spielerei. Aber es verdeutlicht auch so ein bissel die Funktionsweise des XOR-Operators.

15.01.2005 - 14:22 Uhr

Was mir grad noch aufgefallen ist. Schaut man sich folgendes an, funktioniert es wie es eigentlich sollte:

int c = 5;
int d = (c = 10) + c;

Der Compiler mach daraus:

d = 10 + 10;

Das liegt einfach daran das der Compiler einfach strikt alles von links nach rechts abarbeitet. Hier weiß er, daß das rechte "c" mittlerweile einen anderen Wert hat als ursprünglich angenommen. Daraus ergibt sich, das man den Dreieckstausch etwas verdrehen kann und es funktioniert, jedoch muß man dan auf ein "^=" verzichten:

a = (b ^= a ^= b) ^ a;
15.01.2005 - 14:16 Uhr

Hat mich auch gewundert das es net funzt, also hab ichs mal ausprobiert. An folgendem Beispiel sieht man genau warum es nicht geht:

int c = 5;
int d = c + (c = 10);

Der Compiler setzt folgende Zahlen ein

d = 5 + 10;

Zum Zeitpunkt, wo er definiert welchen Wert das erste c hat, weiß der Compiler noch nicht das die Variable gleich einen neuen Wert bekommt, deswegen funktioniert es auch in dem einzeiligen Dreieckstausch nicht:

int a = 13;
int b = 24;
// 1. Variante (Falsch)
a = a ^ (b = b ^ (a = a ^ b));
// 2. Variante (Richtig)
a = a ^ b ^ (b = b ^ a ^ b);

Bei der 1 Varinate hat das "a" rechts neben dem ersten gleichheitszeichen den ursprünglichen Wert, nicht den später zugewiesenen. Bei der 2. Variante wird dort der korrekte Wert für "a" erneut ermittelt. Und gekürzt sieht die richtige Variante dann so aus:

a ^= b ^ (b ^= a ^ b);
15.01.2005 - 13:33 Uhr

So könnte das aussehen, wenn man mit einem MemoryStream arbeitet. Um mit lesbaren Strings arbeiten zu können hab ich zusätzlich noch Base64 verwendet:


/// <summary>
/// Verschlüsselt einen Begriff, ahnhand des anegegebenen Schlüßels.
/// </summary>
/// <param name="input">Zu verschlüßelnde Zeichenfolge</param>
/// <param name="key">Schlüßel der zur Verschlüßlung verwendet wurde.</param>
/// <param name="initialVector">Initalisierungs Vektor.</param>
/// <returns>Verschlüsselter String</returns>
private static string EncryptTripleDes(string input, byte[] key, byte[] initialVector)
{
	TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();

	// muß, denk ich sein
	if (input == null)
		input = "";

	byte[] inData	= Encoding.UTF8.GetBytes(input);

	MemoryStream memory = new MemoryStream();

	ICryptoTransform transform = des.CreateEncryptor(key, initialVector);
	CryptoStream crypt = new CryptoStream(memory, transform, CryptoStreamMode.Write);

	crypt.Write(inData, 0, input.Length);
	crypt.FlushFinalBlock();

	return Convert.ToBase64String(memory.ToArray());
}

/// <summary>
/// Entschlüsselt einen mit EncryptTripleDes verschlüsselten Begriff,
/// ahnhand des anegegbenen Schlüßels.
/// </summary>
/// <param name="input">Verschlüsselte Zeichenfolge</param>
/// <param name="key">Schlüßel der zur Verschlüßlung verwendet wurde.</param>
/// <param name="initialVector">Initalisierungs Vektor.</param>
/// <returns>Entschlüsselter String oder Null, wenn Entschlüßlung nicht möglich</returns>
private static string DecryptTripleDes(string input, byte[] key, byte[] initialVector)
{
	TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();

	try
	{
		byte[] inData = Convert.FromBase64String(input);
		byte[] outData = new byte[input.Length];

		MemoryStream memory = new MemoryStream(inData);

		ICryptoTransform transform = des.CreateDecryptor(key, initialVector);
		CryptoStream crypt = new CryptoStream(memory, transform, CryptoStreamMode.Read);

		crypt.Read(outData, 0, input.Length);

		return Encoding.UTF8.GetString(outData).Trim(new char[] { '\0' } );
	}
	catch
	{
		return null;
	}
}

Der initialVector is ein Byte-Array der Länge 8 und der key ein Byte-Array der Länge 24.

14.01.2005 - 09:18 Uhr

Original von maxE
Etwas eleganter ist es natürlich, nur die Stellen auszubessern, die es wirklich nötig haben. Dazu eignen sich speziellle Diff-Algorithmen:

>

Jo, bei Computerspielen werden teilweise solche Patchsysteme eingesetzt um den Patch möglichst klein zu halten.

11.01.2005 - 09:00 Uhr

Original von turndevil
jetzt hab ich folgendes problem. die playlist gibt mir nur objects zurück. auf die kann ich natürlich nicht die fileinfo methoden anwenden. wie löse ich das am besten?

Entweder castest du das Ergebnis nach FileInfo oder besser, du leitest die PlayList von CollectionBase ab und implementierst sämtliche Methoden typsicher.

10.01.2005 - 18:56 Uhr

Besser siehts aber so aus 😉


ContextMenu cm = new ContextMenu();
MenuItem item = null;

cm.MenuItems.Add("Item 1");
item = cm.MenuItems.Add("Item 2");
item.MenuItems.Add("UnterItem 1 von MenuItem 2");
cm.MenuItems.Add("Item 3");

10.01.2005 - 15:46 Uhr

Das wiederspricht vollkommen den Prinzipien der Objektorientierung, was du da machen möchtest, Toddi. Du versucht einen String, also einen elementaren Datentyp referenziel zu verändern. Zu diesem Zweck solltest du eine eigene Klasse verwenden.