Ich glaube in Visual Studio 2005 gibt es dazu Möglichkeiten.
Ich werde das mal ausprobieren.

Grüße, Christoph

Ich wollte gerade ein Thema mit genau dieser Frage erstellen.

Die Frage habe ich nämlich auch.
Ich muss aus einem Programm, was sehr modular aufgebaut ist, eine geteilte Anwendung machen, die über einen Webservice kommuniziert.

Da habe ich mir gedacht, dass das kein Problem wäre.
Ich instanziere eine Klasse und rufe eine Methode daraus auf(mit anderen Klassen als Parametern). Diese Schnittstelle wollte ich jetzt durch einen Webservice kapseln.
Für die Parameterübergabe wollte ich bei beiden Programmteilen(Client und Webservice) die bisherigen Assemblys mit den Klassen einbinden.

Wenn ich jetzt allerdings den Webverweis einfüge, dann erstellt er die Klassendefinitionen aus der WSDL-Datei. Wie kann ich ihm beibringen, dass es sich bei den durch WSDL bereitgestellten Klassen um meine Klassen handelt?

Muss ich manuell die .cs-Datei verändern, die durch den Webverweis erstellt wird und dann den Webverweis löschen, damit die Datei nicht überschrieben wird?

Oder gibt es da eine eingebaute Lösung. Eine verteilte Unternehmensanwendung mit gemeinsamen Klassen ist doch recht üblich, oder?

Grüße, Christoph

Und PHP läuft dann auf dem Client Rechner als .EXE kompiliert oder wie sehe ich das?

Wenn dem nicht so ist und man erst nen Apache oder IIS mit Modul für PHP installieren muss, finde ich das um Längen schlimmer als nen Framework zu saugen(von Java kennt man das ja auch).

Und außerdem ist PHP keine wirkliche Konkurrenz zu C#, weil es auf ganz andere Dinge abzielt.

Grüße, Christoph

@Red_Wraith: Dann brauchst du trotzdem noch Mono oder .NET, ist nur ein anderer Compiler

@x-sharp: Aber nicht das 2.0 Framework, oder?

Mach einen Link auf die Redistributable!
Oder erzähl den Kunden, dass sie ein Windows Update brauchen und wie das geht!
Oder kann man das noch nicht über Windows Update empfangen?

einMember.Name="heinz";
AlleMember.Add(einMember);

einMember.Name="peter";
AlleMember.Add(einMember);

Du packst zweimal den gleichen Member in die Liste!
Zwischendurch änderst du seinen Namen!

Grüße, Christoph

//EDIT: Kommando zurück, siehe nachfolgendem Kommando von Herbivore!
Ich dachte, dass es eine Klasse wäre, muss die Uhrzeit gewesen sein.
Ein Struct wird natürlich via boxing in die arraylist gepackt.

_Original von Bini_Noch bin ich nicht arbeitslos. Allerdings, so wie sich die Lage hier in der Firma darstellt, kann das schlagartig eintreten 😦

War auch nur ein schäbiger Witz! Nicht ernst nehmen! Wünsche dir viel Glück!

Ich wünsche auch viel Glück!

Falls du länger arbeitlos sein willst: MS Office "12" soll PDFs erzeugen können <--- nicht ernst nehmen

Um nochmal auf das Thema Komprimierung zu kommen: Ich habe im IIS 6.0 die HTTP-Komprimierung aktiviert und auf alle Dateitypen angewendet.
Leider ist "BytesSent" in den Logs gleich geblieben(Neustart schon diverse Male getestet), nachdem ich den Webservice erneut aufgerufen habe.
Muss ich Clientseitig etwas einstellen? Wenn ja, was?
Es handelt sich um einen Webservice, der eine XML-Datei ausliest und als String zurückgibt.

Edit: Wenn ich die Methode GetWebRequest überlade und folgendes hinzufüge:

		protected override System.Net.WebRequest GetWebRequest(Uri uri)
		{
			System.Net.WebRequest request = base.GetWebRequest(uri);
			//request.Headers.Add("Accept-Encoding", "gzip, deflate");
			return request;
		}

dann kommen die Daten komprimiert an.
Das entpacken muss ich dann selber per SharpZipLib machen.
Geht das auch einfacher? Wie sieht es in .Net 2.0 bzw Delphi aus?

Das Thema Verschlüsselung sollte erledigt sein, wenn man SSL mit Zertifikaten benutzt, oder?

Sorry, versucht mal die FileVersionInfo Klasse!

Grüße, Christoph

Die FileInfo Klasse(so heißt sie glaube ich) sollte da etwas bieten.

Grüße, Christoph

OK, danke!

Ich wusste nicht, dass Zeilenumbrüche als Whitespaces gewertet werden!

Vielen Dank für jegliche Hilfe im Voraus!

Ich probier jetzt schon wieder einige Zeit an einem RegEx-Ausdruck rum.

Folgender Text:

"
belibieger Text..
tables=(TabellenName1,
TabellenName2,
TabellenNameXY)
belibieger Text..
"

Ich hätte jetzt gerne ein Array aus TabellenNamen da heraus.
Ist das ohne weiteres möglich?

Ich bin bei "tables=(([^,)]*[)])*" hängen geblieben!
Leider sind da noch die Zeilenumbrüche und die , drin!

Grüße Christoph

Ich habe eine Projektmappe mit einem Webservice A und einer Formsanwendung B(und ein paar gemeinsam benutzen Bibliotheken).
Die Forms-Anwendung starte ich im Debugmodus und debugge sie, sie ruft den lokal laufenden Webservice auf. In diesem Moment soll das Debuggen des Webservice gestartet werden(Breakpoint sind natürlich gesetzt). Wie kann ich das einstellen? Es klappt im Moment nur, wenn ich das Webserviceprojekt in einer neuen Instanz des VisualStudio öffne und dort eine Debug-Session starte.

Vielen Dank für Eure Antworten!

Grüße, Christoph

Hier meine momentane Lösung(die sicherlich noch einige Haken hat, Exception Handling zum Beispiel und ich weiß nicht, ob das auch mit überladenen Funktionen klappt):

MethodExecutor.cs:

using System;
using System.Reflection;

namespace Helper
{
	/// <summary>
	/// Zusammenfassung für Class1.
	/// </summary>
	public class MethodExecutor
	{
		public MethodExecutor(Type newType, string MethodName, object MethodObject, object[] Params)
		{
			this.ClassType = newType;
			this.MethodInfo = this.ClassType.GetMethod(MethodName,BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
			this.MethodObject = MethodObject;
			this.Params = Params;
		}

		private Type ClassType;

		private MethodInfo MethodInfo;

		private object MethodObject;

		private object[] Params;


		public object Invoke()
		{
			return this.MethodInfo.Invoke(this.MethodObject,this.Params);
		}
	}
}

MethodExecutorList.cs:

using System;
using System.Collections;

namespace Helper
{
	/// <summary>
	///   A collection that stores <see cref='MethodExecutor'/> objects.
	/// </summary>
	[Serializable()]
	public class MethodExecutorList : CollectionBase 
	{
		
		/// <summary>
		///   Initializes a new instance of <see cref='MethodExecutorList'/>.
		/// </summary>
		public MethodExecutorList()
		{
		}
		
		/// <summary>
		///   Initializes a new instance of <see cref='MethodExecutorList'/> based on another <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <param name='val'>
		///   A <see cref='MethodExecutorList'/> from which the contents are copied
		/// </param>
		public MethodExecutorList(MethodExecutorList val)
		{
			this.AddRange(val);
		}
		
		/// <summary>
		///   Initializes a new instance of <see cref='MethodExecutorList'/> containing any array of <see cref='MethodExecutor'/> objects.
		/// </summary>
		/// <param name='val'>
		///       A array of <see cref='MethodExecutor'/> objects with which to intialize the collection
		/// </param>
		public MethodExecutorList(MethodExecutor[] val)
		{
			this.AddRange(val);
		}
		
		/// <summary>
		///   Represents the entry at the specified index of the <see cref='MethodExecutor'/>.
		/// </summary>
		/// <param name='index'>The zero-based index of the entry to locate in the collection.</param>
		/// <value>The entry at the specified index of the collection.</value>
		/// <exception cref='ArgumentOutOfRangeException'><paramref name='index'/> is outside the valid range of indexes for the collection.</exception>
		public MethodExecutor this[int index] 
		{
			get 
			{
				return ((MethodExecutor)(List[index]));
			}
			set 
			{
				List[index] = value;
			}
		}
		
		/// <summary>
		///   Adds a <see cref='MethodExecutor'/> with the specified value to the 
		///   <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <param name='val'>The <see cref='MethodExecutor'/> to add.</param>
		/// <returns>The index at which the new element was inserted.</returns>
		/// <seealso cref='MethodExecutorList.AddRange'/>
		public int Add(MethodExecutor val)
		{
			return List.Add(val);
		}
		
		/// <summary>
		///   Copies the elements of an array to the end of the <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <param name='val'>
		///    An array of type <see cref='MethodExecutor'/> containing the objects to add to the collection.
		/// </param>
		/// <seealso cref='MethodExecutorList.Add'/>
		public void AddRange(MethodExecutor[] val)
		{
			for (int i = 0; i < val.Length; i++) 
			{
				this.Add(val[i]);
			}
		}
		
		/// <summary>
		///   Adds the contents of another <see cref='MethodExecutorList'/> to the end of the collection.
		/// </summary>
		/// <param name='val'>
		///    A <see cref='MethodExecutorList'/> containing the objects to add to the collection.
		/// </param>
		/// <seealso cref='MethodExecutorList.Add'/>
		public void AddRange(MethodExecutorList val)
		{
			for (int i = 0; i < val.Count; i++)
			{
				this.Add(val[i]);
			}
		}
		
		/// <summary>
		///   Gets a value indicating whether the 
		///    <see cref='MethodExecutorList'/> contains the specified <see cref='MethodExecutor'/>.
		/// </summary>
		/// <param name='val'>The <see cref='MethodExecutor'/> to locate.</param>
		/// <returns>
		/// <see langword='true'/> if the <see cref='MethodExecutor'/> is contained in the collection; 
		///   otherwise, <see langword='false'/>.
		/// </returns>
		/// <seealso cref='MethodExecutorList.IndexOf'/>
		public bool Contains(MethodExecutor val)
		{
			return List.Contains(val);
		}
		
		/// <summary>
		///   Copies the <see cref='MethodExecutorList'/> values to a one-dimensional <see cref='Array'/> instance at the 
		///    specified index.
		/// </summary>
		/// <param name='array'>The one-dimensional <see cref='Array'/> that is the destination of the values copied from <see cref='MethodExecutorList'/>.</param>
		/// <param name='index'>The index in <paramref name='array'/> where copying begins.</param>
		/// <exception cref='ArgumentException'>
		///   <para><paramref name='array'/> is multidimensional.</para>
		///   <para>-or-</para>
		///   <para>The number of elements in the <see cref='MethodExecutorList'/> is greater than
		///         the available space between <paramref name='arrayIndex'/> and the end of
		///         <paramref name='array'/>.</para>
		/// </exception>
		/// <exception cref='ArgumentNullException'><paramref name='array'/> is <see langword='null'/>. </exception>
		/// <exception cref='ArgumentOutOfRangeException'><paramref name='arrayIndex'/> is less than <paramref name='array'/>'s lowbound. </exception>
		/// <seealso cref='Array'/>
		public void CopyTo(MethodExecutor[] array, int index)
		{
			List.CopyTo(array, index);
		}
		
		/// <summary>
		///    Returns the index of a <see cref='MethodExecutor'/> in 
		///       the <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <param name='val'>The <see cref='MethodExecutor'/> to locate.</param>
		/// <returns>
		///   The index of the <see cref='MethodExecutor'/> of <paramref name='val'/> in the 
		///   <see cref='MethodExecutorList'/>, if found; otherwise, -1.
		/// </returns>
		/// <seealso cref='MethodExecutorList.Contains'/>
		public int IndexOf(MethodExecutor val)
		{
			return List.IndexOf(val);
		}
		
		/// <summary>
		///   Inserts a <see cref='MethodExecutor'/> into the <see cref='MethodExecutorList'/> at the specified index.
		/// </summary>
		/// <param name='index'>The zero-based index where <paramref name='val'/> should be inserted.</param>
		/// <param name='val'>The <see cref='MethodExecutor'/> to insert.</param>
		/// <seealso cref='MethodExecutorList.Add'/>
		public void Insert(int index, MethodExecutor val)
		{
			List.Insert(index, val);
		}
		
		/// <summary>
		///  Returns an enumerator that can iterate through the <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <seealso cref='IEnumerator'/>
		public new MethodExecutorEnumerator GetEnumerator()
		{
			return new MethodExecutorEnumerator(this);
		}
		
		/// <summary>
		///   Removes a specific <see cref='MethodExecutor'/> from the <see cref='MethodExecutorList'/>.
		/// </summary>
		/// <param name='val'>The <see cref='MethodExecutor'/> to remove from the <see cref='MethodExecutorList'/>.</param>
		/// <exception cref='ArgumentException'><paramref name='val'/> is not found in the Collection.</exception>
		public void Remove(MethodExecutor val)
		{
			List.Remove(val);
		}

		public object[] InvokeAll()
		{
			ArrayList AL = new ArrayList();

			foreach(MethodExecutor MI in this)
			{
				try
				{
					AL.Add(MI.Invoke());
				}
				catch(Exception ex)
				{
					AL.Add(ex);
				}
			}

			return AL.ToArray();
		}

		
		/// <summary>
		///   Enumerator that can iterate through a MethodExecutorList.
		/// </summary>
		/// <seealso cref='IEnumerator'/>
		/// <seealso cref='MethodExecutorList'/>
		/// <seealso cref='MethodExecutor'/>
		public class MethodExecutorEnumerator : IEnumerator
		{
			IEnumerator baseEnumerator;
			IEnumerable temp;
			
			/// <summary>
			///   Initializes a new instance of <see cref='MethodExecutorEnumerator'/>.
			/// </summary>
			public MethodExecutorEnumerator(MethodExecutorList mappings)
			{
				this.temp = ((IEnumerable)(mappings));
				this.baseEnumerator = temp.GetEnumerator();
			}
			
			/// <summary>
			///   Gets the current <see cref='MethodExecutor'/> in the <seealso cref='MethodExecutorList'/>.
			/// </summary>
			public MethodExecutor Current 
			{
				get 
				{
					return ((MethodExecutor)(baseEnumerator.Current));
				}
			}
			
			object IEnumerator.Current 
			{
				get 
				{
					return baseEnumerator.Current;
				}
			}
			
			/// <summary>
			///   Advances the enumerator to the next <see cref='MethodExecutor'/> of the <see cref='MethodExecutorList'/>.
			/// </summary>
			public bool MoveNext()
			{
				return baseEnumerator.MoveNext();
			}
			
			/// <summary>
			///   Sets the enumerator to its initial position, which is before the first element in the <see cref='MethodExecutorList'/>.
			/// </summary>
			public void Reset()
			{
				baseEnumerator.Reset();
			}
		}
	}
}

Benutzung:

...
private MethodExecutorList MIL = new MethodExecutorList();
...

string FileName = @"C:\zulöschen.txt";
string FileName2 = @"C:\Quelle.txt";
string FileName3 = @"C:\Ziel.txt";


this.MIL.Add(new MethodExecutor(typeof(System.IO.File),"Delete",null,new object[] {FileName}));

this.MIL.Add(new MethodExecutor(typeof(System.IO.File),"Move",null,new object[] {FileName2,FileName3}));

..

foreach(object obj in this.MIL.InvokeAll())
{
   Console.WriteLine(obj);
}

//oder
this.MIL.InvokeAll()

Kommentare sind natürlich gern gesehen.

Grüße, Christoph

Danke, dass sieht schon spitze aus. Ist nur Schade, dass man dafür noch für jeden "Typ" Funktion ein extra delegate braucht.
Ich arbeite gerade an einer Methode via Reflection auf der Arbeit. Das poste ich mal morgen, wenn ich wieder auf der Arbeit bin.

Grüße, Christoph

Also irgendwie komme ich auch mit "new delegate (eigene_Funktion), new Object [] { Parameter1, Parameter2 }" nicht weiter.

Gibt es denn keine Möglichkeit, sich den Aufruf einer Methode inklusive Parameter zu merken um sie später aufzurufen.

Im Sinne von Aufrufmerker = new Aufruf("File", "Delete", @"C:\Test.txt");

und bei Aufrufmerker.tudas(); löscht er dann die Datei?

Grüße, Christoph

Original von herbivore
Hallo Quallo,

Deswegen ja: new Funktionszeiger(eigene_Funktion(Parameter1, Parameter2)));
da Ausdrücke aber von innen nach außen ausgewertet werden, würde hier aber - wie ich schrieb - erst die Funktion aufgerufen und dann deren Rückgabewert an den Konstruktor von Funktionszeiger übergeben werden - mal abgesehen davon, dass es sich deshalb schon nicht komplilieren lassen würde.

Da hast du natürlich recht, aber so ist es nicht gemeint.
Ich meine mit new Funktionszeiger(eigene_Funktion(Parameter1, Parameter2))); , dass ein Zeiger auf die Funktion eigene_Funktion mit den Parametern Parameter1(z.B. "Biene") und Parameter2(z.B. "Maja") erstellt wird. eigene_Funktion steht somit nur für den Namen der Funktion, soll aber keinen Aufruf darstellen.

Ah, jetzt verstehe ich, du willst die Do-Funktion innerhalb von new Funktionszeiger aufrufen. Aber das Problem bleibt. Das einzige was der Funktionszeiger-Konstruktor zu sehen bekommen würde, wäre der Rückgabewert. Und daran kann man weder die Funktion noch deren Parameter ermitteln, die zu dem Rückgabewert geführt haben.

Du musst also die Undo-Funktion und die Parameter schon so verarbeiten, wie ich geschrieben habe.

Wenn du nicht davon abgehst, dir Aktionen zu merken und dir stattdessen den Zustand merkst. Immerhin gibt es ja eine masse Funktionen, die keine Umkehrfunktion haben.
herbivore

Ich denke, dass dieses hier
new delegate (eigene_Funktion), new Object [] { Parameter1, Parameter2 }
schon der richtige Ansatz ist.

Eine Funktion, die beliebige andere Funktionen rückgängig macht, wäre glaube ich sauschwer zu implementieren(und als Komponente wahrscheinlich ein Goldesel!).

Grüße und vielen Dank, Christoph

Original von herbivore
Hallo Quallo,

Kann man nicht irgendwie herausbekommen, ob jemand gerade Schreibzugriff auf die Datei hat?
Du meinst sicher, ob man nicht herausfinden kann, ob gerade jemand schreibend zugreift. 🙂 Das ist ein großer Unterschied.

Man kann die Datei mit dem entsprechenden ShareMode versuchen zu öffnen und wenn das geht, gereift keiner schreibend zu.

herbivore

Genau das meine ich! Warst mal wieder erfolgreich beim Gedanken lesen g.
Man sollte das mal testen, wenn das zuverlässig klappt, dann ist es sicherlich besser als das prüfen der Größe!

Grüße, Christoph

@herbivore: Deswegen ja: new Funktionszeiger(eigene_Funktion(Parameter1, Parameter2)));

@Fzelle: Ich werde mir das mal anschauen.

@Alle: Vielen Dank für die Hilfe, wenn es eine Lösung gibt, werde ich die natürlich posten!

Okay, da hast du recht!

Folgender Code klappt auch:

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace InnerExceptionTest
{
	/// <summary>
	/// Zusammenfassung für Form1.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		private System.Windows.Forms.TextBox textBox1;
		/// <summary>
		/// Erforderliche Designervariable.
		/// </summary>
		private System.ComponentModel.Container components = null;

		public Form1()
		{
			//
			// Erforderlich für die Windows Form-Designerunterstützung
			//
			InitializeComponent();

			//
			// TODO: Fügen Sie den Konstruktorcode nach dem Aufruf von InitializeComponent hinzu
			//

			try
			{
				try
				{
					throw new Exception("Test1");
				}
				catch(Exception ex)
				{  
					try
					{
						throw new Exception("Test2",ex);
					}
					catch(Exception ex2)
					{
						throw new Exception("Test3",ex2);
					}
				}
			}
			catch(Exception ex)
			{
				//ex = Test3
				//ex.InnerException = Test2
				//ex.InnerException.InnerException = Test1 <--- leider null

				Console.WriteLine(ex.InnerException.Message); //ok
				Console.WriteLine(ex.InnerException.InnerException.Message); //nicht ok, da Inner Exception == null

				this.textBox1.Text = Logging.FormatException(ex);

			}

		}

		/// <summary>
		/// Die verwendeten Ressourcen bereinigen.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null) 
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Vom Windows Form-Designer generierter Code
		/// <summary>
		/// Erforderliche Methode für die Designerunterstützung. 
		/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
		/// </summary>
		private void InitializeComponent()
		{
			this.textBox1 = new System.Windows.Forms.TextBox();
			this.SuspendLayout();
			// 
			// textBox1
			// 
			this.textBox1.Location = new System.Drawing.Point(8, 8);
			this.textBox1.Multiline = true;
			this.textBox1.Name = "textBox1";
			this.textBox1.Size = new System.Drawing.Size(736, 552);
			this.textBox1.TabIndex = 0;
			this.textBox1.Text = "textBox1";
			// 
			// Form1
			// 
			this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
			this.ClientSize = new System.Drawing.Size(752, 570);
			this.Controls.Add(this.textBox1);
			this.Name = "Form1";
			this.Text = "Form1";
			this.ResumeLayout(false);

		}
		#endregion

		/// <summary>
		/// Der Haupteinstiegspunkt für die Anwendung.
		/// </summary>
		[STAThread]
		static void Main() 
		{
			Application.Run(new Form1());
		}
	}
}

Dann muss der Fehler irgendwo in meinem Code liegen.
Frage ist nur wo.

Sorry für die Panikmache, vielleicht interessiert jemanden noch das hier:

		/// <summary>
		/// Formatiert eine Fehlermeldung und gibt sie als string zurück
		/// </summary>
		/// <param name="ex">Fehler</param>
		/// <returns>Formatierte Fehlerbeschreibung</returns>
		public static string FormatException(Exception ex)
		{
			StringBuilder NewText = new StringBuilder();
			Exception AktError;
			int TabAnzahl = 0;

			AktError = ex;

			while(true)
			{
				NewText.Append(Environment.NewLine);

				for(int Run = 0; Run < TabAnzahl; Run++)
				{
					NewText.Append("   ");
				}
				TabAnzahl++;


				NewText.Append(AktError.Message);

						
				if (AktError.InnerException != null)
				{
					AktError = AktError.InnerException;
				}
				else
				{
					break;
				}
			}

			NewText.Append(Environment.NewLine);
			NewText.Append(AktError.StackTrace);

			return NewText.ToString();
		}

Ja, entschuldige, ich habe die exception 3 vergessen.

Werde das nochmal korrigieren.

Das Problem besteht allerdings weiterhin.

Meine Idee sieht in etwa so aus:

RedoList = new ArrayList;

//mache etwas
RedoList.Add(new Funktionszeiger(File.Delete(Dateiname)));

//mache etwas
RedoList.Add(new Funktionszeiger(eigene_Funktion(Parameter1, Parameter2)));

Wenn fehler folgendes:

foreach(Funktionszeiger FZ in RedoList)
{
FZ.starteFunktion //oder starteFunktion(FZ);
}

Grüße, Christoph

Ich habe bei Exceptions, wenn ich sie verarbeite, immer das Problem, dass ich nur eine InnerException habe.

Also folgendes:

try
{
  try
  {
    throw new Exception("Test1");
  }
  catch(Exception ex)
  {  
    try
    {
      throw new Exception("Test2",ex);
    }
    catch(Exception ex2)
    {
      throw new Exception("Test3",ex2);
    }
  }
}
catch(exception ex)
{
//ex = Test3
//ex.InnerException = Test2
//ex.InnerException.InnerException = Test1 <--- leider null

Console.WriteLine(ex.InnerException.Message); //ok
Console.WriteLine(ex.InnerException.InnerException.Message); //nicht ok, da Inner Exception == null

}

Folgendes: Ich brauche eine Liste von Funktionsaufrufen, die ich abarbeiten lassen kann.

Ich muss ein Rollback-Mechanismus implementieren. Da habe ich mir gedacht, dass ich immer, wenn ich eine Aktion durchführe, in eine Liste einen Funktionsaufruf packe(inkl. Paramater), der gestartet werden soll, wenn die Operation schief geht.

Bei einem Commit lösche ich die Liste, bei einem Rollback starte ich alle Funktionen nacheinandern.

Ist soetwas möglich, wenn ja, wie?

Grüße, Christoph

P.S. .NET 1.1

Kann man nicht irgendwie herausbekommen, ob jemand gerade Schreibzugriff auf die Datei hat?

Ist das nicht ein NTFS-Feature, das ganz unten im Kernel von Windows irgendwo werkelt?

Wenn man schaut was übrig bleibt ist 20% natürlich weniger als 33%.
Mit Winzip maximale Kompression bleiben etwa 5-10% übrig.
Kein Base 64 enthalten.

Das das ganze recht ausgereift ist denke ich auch, das würde sonst ja zu massiven Problemen auf vielen Rechnern führen.

Danke!
Das bringt eine Reduktion auf ca. 1/3 der Datenmenge.

Habt ihr Erfahrungen damit gemacht?
Kann man die Reduktion steigern?
Gibt es vielleicht Probleme?

Grüße, Christoph

Gibt es unter Windows Server 2003 eine einfache Möglichkeit, ein komprimiertes Verzeichnis zu machen?

Ich muss massiv XML-Dateien archivieren, da ist es kein Problem mit einem Zip-Algorithmus die Dateigröße auf unter 10 % einzudämpfen.

Meine Idee ist nun, dass ich ein komprimiertes Verzeichnis nehme und das Betriebssystem für mich die Dateien komprimiert wenn ich sie schreibe und dekomprimiert wenn ich sie lese.

Das Ganze wäre für die Anwendung völlig gekapselt und ich könnte die Dateien wie gewohnt ansprechen.

Grüße, Christoph

Original von norman_timo
Hallo zusammen,

habt Ihr mal auf der Webseite von
> das "Feature" mit den unterschiedlichen Flaggen/Sprachen ausprobiert?

Ich meine die wohl unnötigsten Features mit der Hex- oder Oktaldarstellung der Site?

Gott es gibt so viel unnützes im Web, aber lustig LOL.

Ciao
Norman-Timo

In der Tat sehr lustig!!!

Es gibt doch eine Api-Funktion um die Windows-Sounds, die der Benutzer mit Ereignissen verknüpft hat(oder die Standardeinstellungen), abzuspielen, wenn ich mich nicht irre.
Das wäre sicherlich der beste Weg.

Eigentlich sollte man soetwas durch Kapselung umgehen.
Aber eigentlich habe ich das Feature auch schon oft vermisst g.

Kann man auch ein Polo-Shirt bestellen?

Grüße, Christoph

Ich weiß nicht, ob es schon erwähnt wurde, aber die Seite gehört zu Microsoft, falls jemand denkt, dass das nicht seriös ist.

Hat jemand auf der Seite die genaueren Veresionen bzw. Lizenzen gesehen, die man da bekommt?

Dann werde ich mal auf der Arbeit nachfragen, die werden mir wohl die 25 Euro stellen, kann das ja auch sehr gut für die Schule gebrauchen und was ich privat lerne ist ja dann sofort auch auf der Arbeit als Wissen vorhanden!

Grüße, Christoph

Okay, in deinen weiteren Ausführungen gebe ich dir natürlich recht.
Nur wenn ich mal schaue, dass ich problemlos Daten mit ping im 1 ms bereich versenden kann, muss es meines Erachtens möglich sein, dass das Ansprechen eines seriellen Ports fast(!!!) immer in einer geringen Zeit klappt, nur halt nicht zu 100 % zuverlässig.

Aber ohne Programme im Hintergrund sollte das klappen.

Weiß jemand, wie das mit Mono unter Linux oder mac aussieht?

Grüße, Christoph

10/1000 Sekunden Genauigkeit sollte auch für win kein Problem sein.
Für MicroSekunden(nicht Millisekunden) und feste Interrupt und Antwortzeiten sollte man ein Echtzeitbetriebssystem nehmen. Verlässlichkeit(im Timing) ist dort oft wichtiger!

Ich suche eine Bibliothek um Fingerabdrücke von einem Scanner zu überprüfen.
Muss (leider) kostenlos bis günstig sein. Es tun auch dlls, die bei Lesegeräten dabei sind, die kann ich ja kapseln.

Habt ihr da Ansätze?

Folgender Vorgang: Wenn ein User den Finger auf den Scanner drückt und in Datenbank gefunden wird, wird seine ID in einem Event zurückgeliefert.

Einen Test gibt es hier:
http://www.heise.de/security/dienste/browsercheck/demos/ie/wmf.shtml

Gibt es noch genauere Infos zu der Exception?

Mach mal ein Breakpoint auf den Konstruktor der Form und steppe durch.
Das hilft bestimmt!

Wahrscheinlich ist der Fehler nämlich in dem new XYXForm() angesiedelt.

Ich hoffe, dass das hilft.

Grüße, Christoph

@Herbivore: Das ist sicherlich sehr sehr unglücklich, dass die Serialisierung nur mit den von dir beschriebenen Maßnahmen geht, aber das sie deswegen völliger Schrott ist kann ich nicht sagen.
Es ist schon sehr sehr nett aus einem Schema eine Klasse zu machen und dann per Deserialisierung eine Instanz einzulesen.
Das benutze ich in diversen Projekten, in denen es ich Xml-Dateien verarbeiten muss.
Hätte das aber auch lieber so wie bei der binären oder soap-serialisierung, aber dazu ist es sicherlich nötig einige Meta-Daten abzulegen und das will man nun mal nicht in einer weiterzuverarbeitenden, offenen xml-datei.

Bei 1.1 auf jeden Fall:

Start --> Systemsteuerung --> Verwaltung --> Microsoft .NET Framework 1.1-Konfiguration --> TreeView --> Arbeitsplatz --> Laufzeitsicherheitsrichtlinie --> Ein Weitergabepaket erstellen

Kann man nicht mehr wie bei 1.1 seine Einstellungen als WMI-Packet exportieren?

Ist doch viel einfacher auf jedem Client im Unternehmen ein WMI-Packet zu installieren. Das kann der Admin oftmals auch vollautomatisch auf allen Systemen installieren lassen.

Grüße, Christoph

Microsoft hat vorzeitig einen Patch zur WMF-Lücke veröffentlicht.

Wer Informationen zu der Lücke oder dem Patch sucht: http://www.heise.de/newsticker/meldung/68033

Der Patch kommt über Windows-Update automatisch, wenn dies eingestellt ist.

Grüße, Christoph

Lade dir doch mal Demo- oder Sharewareversionen runter und teste es mal.

Ich würde die Webcastmaker je nach Funktionsweise in Gruppen einteilen und für jede Gruppe ein Programm exemplarisch darstellen(im Referat).

Ich kann mir nicht vorstellen, dass es bei Google keine Informationen und Produkte zu finden gibt, mit deren Hilfe man einen Webcast erstellen kann.

Einige Webcasts werden mit Flash gemacht(Camtasi als ein Beispiel), andere nehmen Videos und Ton vom Desktop auf...

Manche sind auch erstellt wie eine Präsentation.

Es gibt sicherlich auf einigen Seiten Webcasts, wie man mit den Produkten Webcasts erstellt.

Grüße, Christoph

Doppelpost, bitte schließen!

Original von svenson
Da fragt man sich doch, warum das Ding nicht gleich als LGPL läuft, die besagt nämlich genau das.

Genau das war auch mein Gedanke, einen Satz weiter hattest du dann geschrieben.

Ich habe es jetzt mit einem BinaryStream und Read<hier bitte Datentyp einsetzen>() gemacht.
Also mit ReadChars und mit ReadInt32 usw.

Das geht besser.
Ein weiterer Vorteil ist, dass ich in dem Struct aus den Daten(als Mehrzahl von Datum) als String ein DateTime machen konnte, dadurch, dass ich den Text nach dem ReadChars parsen konnte.

Vielen Dank für Eure Hilfe, wäre aber für die Nachwelt sicherlich trotzdem schön, wenn eine Lösung käme.

Den kompletten Code kann ich leider nicht posten, ist ein geschäftliches Projekt und daher habe ich diese Einschränkung.

Habe mir XML Web Service-Anwendungen mit Microsoft .NET mal bestellt.

Danke für den Tipp!