Laden...
Avatar #avatar-1651.gif
Programmierhans myCSharp.de - Experte
Coden was das Zeug hält Zentralschweiz Dabei seit 05.04.2005 4.221 Beiträge
Benutzerbeschreibung

Forenbeiträge von Programmierhans Ingesamt 4.221 Beiträge

25.12.2010 - 13:46 Uhr

friend gibts in VB ebenso.. weiss aber nicht ob dies dieselbe Bedeutung hat wie in c++ in C# ist das internal.

Wenn die Methode allerdings nur von einer Klasse aufgerufen werden soll, dann ist private richtig... wenn vererbte Klassen diese Methode auch aufrufen können, dann protected.

23.12.2010 - 13:12 Uhr

Schon mal so probiert ?

UnmanagedType.LPWStr

23.12.2010 - 10:49 Uhr

Im folgenden Post findest Du einen TypeConverter mit dessen Hilfe man Interface-implementierende Klassen auswählen kann.

Die Klasse wird automatisch instanziert.
Die Properties der instanzierten Klasse können im PropertyGrid gesetzt werden.

Designer Support für User-Control mit Interfaces

Gruss
Programmierhans

23.12.2010 - 10:40 Uhr

Es ist auch nicht so ganz einfach 😃

Hier ein Beispiel welches funktioniert.

Das ganze ist hier in einem UserControl.

Interface IDraw mit 2 Properties.
Davon abgeleitet die Klasse DrawBase (damit das Sample kürzer wird).
Davon abgeleitet DrawA und DrawB

DrawA und DrawB haben unterschiedliche Constructoren (damit es nicht zu einfach wird).

Der TypeConverter unterstützt sowohl die Liste der Typen (sofern im selben Assembly wie das Interface).

Expanded die Properties der implementierenden Klassen (natürlich auch unterschiedliche Anzahl).

Und erstellt auch selber die Instanz (mit unterschiedlichen Ctor's).

Das Sample ist in 1.1 geschrieben (da gab es noch keine Generics)... dies nur um motzenden Kollegen vorzugreifen welche mich darauf hinweisen wollen dass man ArrayList nicht mehr verwenden sollte...

Gruss Programmierhans



using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Reflection;
using System.Drawing;
using System.Data;
using System.Windows.Forms;
using System.Globalization;
using System.Runtime.InteropServices;

namespace SampleTypeConverter
{

	public class UcSample : System.Windows.Forms.UserControl
	{
		private IDraw _MyDraw;
		private System.ComponentModel.Container components = null;

		public UcSample()
		{
			InitializeComponent();
		}

		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if(components != null)
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}

		#region Component Designer generated code
		/// <summary> 
		/// Required method for Designer support - do not modify 
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
			components = new System.ComponentModel.Container();
		}
		#endregion

		public IDraw MyDraw
		{
			get{return this._MyDraw;}
			set{this._MyDraw=value;}
		}
	
	}

	[TypeConverter(typeof(DrawTypeConverter))]
	public interface IDraw
	{
		Point DrawPoint{get;set;}
		Point DrawPoint2{get;set;}
	}

	[Serializable]
	public class DrawBase:IDraw
	{
		[NonSerialized]
		private Point _DrawPoint;
		[NonSerialized]
		private Point _DrawPoint2;
	
		public DrawBase(Point pDrawPoint, Point pDrawPoint2)
		{
			this._DrawPoint=pDrawPoint;
			this._DrawPoint2=pDrawPoint2;
		}
		#region IDraw Members
		
		
		
		public Point DrawPoint
		{
			get
			{
				return this._DrawPoint;
			}
			set
			{
				this._DrawPoint=value;
			}
		}
		public Point DrawPoint2
		{
			get
			{
				return this._DrawPoint2;
			}
			set
			{
				this._DrawPoint2=value;
			}
		}

		#endregion

	}




	[Serializable]
	public class DrawA:DrawBase
	{
		public DrawA(Point pDrawPoint,Point pDrawPoint2):base(pDrawPoint,pDrawPoint2)
		{}
	}
	[Serializable]
	public class DrawB:DrawBase
	{
		private bool _AdditionalPropertyOnlyInB;
		
		public DrawB(Point pDrawPoint,Point pDrawPoint2,bool pAdditionalPropertyOnlyInB):base(pDrawPoint,pDrawPoint2)
		{
			this._AdditionalPropertyOnlyInB=pAdditionalPropertyOnlyInB;
		}

		[DefaultValue(false)]
		public bool AdditionalPropertyOnlyInB
		{
			get{return this._AdditionalPropertyOnlyInB;}
			set{this._AdditionalPropertyOnlyInB=value;}
		}
	}

	


	public class DrawTypeConverter:System.ComponentModel.TypeConverter
	{
		public override System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
		{
			System.Collections.ArrayList arr=new ArrayList();
			foreach (Type t in typeof(IDraw).Assembly.GetTypes())
			{
				if (t.GetInterface("IDraw")!=null)
				{
					arr.Add(t.FullName);
				}
			}
			
			return new StandardValuesCollection(arr);
		}
	
		public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
		{
			return true;
		}
	

		public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
		{
			if (value is string)
			{
				IDraw ret=null;
				Type t=Type.GetType((string)value);
				ConstructorInfo ctor = t.GetConstructors()[0]; //jede Klasse hat nur einen Constructor

				int paramCount=ctor.GetParameters().Length;
				switch (paramCount)
				{
					case 3:
						ret=(IDraw)Activator.CreateInstance(t,new object[]{new Point(0,0),new Point(0,0),false});
						break;
					case 2:
						ret=(IDraw)Activator.CreateInstance(t,new object[]{new Point(0,0),new Point(0,0)});
						break;
				}
				return ret;
			}
			return base.ConvertFrom (context, culture, value);
		}

		public override bool CanConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Type sourceType)
		{
			if (sourceType ==typeof(string))
			{
				return true;
			}
			return base.CanConvertFrom(context, sourceType);
		}

	
		public override bool GetPropertiesSupported(ITypeDescriptorContext context)
		{
			return true;
		}

		public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes)
		{
			return TypeDescriptor.GetProperties(value.GetType());
		}

	

		public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) 
		{
			if (destinationType == typeof(InstanceDescriptor)) 
			{
				return true;
			}
			return base.CanConvertTo(context, destinationType);
		}

		public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) 
		{
			if (destinationType == typeof(InstanceDescriptor) && (value is IDraw))
			{
				IDraw draw=(IDraw)value;
				ConstructorInfo ctor = value.GetType().GetConstructors()[0]; //jede Klasse hat nur einen Constructor
				if (ctor != null) 
				{
					int paramCount=ctor.GetParameters().Length;
					switch (paramCount)
					{
						case 3:
							DrawB b=(DrawB)value;
							return new InstanceDescriptor(ctor, new object[] {draw.DrawPoint,draw.DrawPoint2,b.AdditionalPropertyOnlyInB});
						case 2:
							return new InstanceDescriptor(ctor, new object[] {draw.DrawPoint,draw.DrawPoint2});
					}
				}
			}
			return base.ConvertTo(context, culture, value, destinationType);      
		} 




	}
}

21.12.2010 - 21:49 Uhr

Such in diesem Thread mal nach GetStandardValues und nach InstanceDescriptor... ev. verstehst Du es dann.

http://www.codeproject.com/KB/architecture/components.aspx

21.12.2010 - 14:06 Uhr

@herbivore

Hmm den würde ich per Try-Catch abfangen... dies, da die Wahrscheinlichkeit doch sehr klein ist (ein volatile-bool ist atomar).... aber Grundsätzlich hast Du natürlich recht.

Gruss
Programmierhans

20.12.2010 - 23:06 Uhr

Der Invoke im void RP6PortWrapper_DataAvailable(string obj) kommt nicht in den UI-Thread rein da das Form gerade geschlossen wird.

Probier mal folgendes:

Als erstes im void RP6PortWrapper_DataAvailable(string obj) eine volatile bool setzen um zu signalisieren dass Du schon im DataAvailable drin bist.... dieses Flag nach dem Invoke wieder clearen.

Im TerminalForm_FormClosing den Event abhängen und dann das volatile-Flag abfragen. Falls es gesetzt ist machst du ein e.Cancel=true (damit der DataAvailalble noch verarbeitet werden kann) und dann ein BeginInvoke auf this.Close.

Müsste gemäss meinem Verständnis das Problem lösen.

Gruss
Programmierhans

20.12.2010 - 15:04 Uhr

ProgrammierHans hat dafür auch die richtigen Stichworte fallen lassen -

😃 dies war auch der Grund wieso ich dazu nichts mehr geschrieben hatte....

Allerdings würde ich es sogar ohne eigenen Editor und ohne Collection bauen.

Meiner Meinung nach müsste ein TypeConverter reichen.

Mit GetStandardValues die möglichen Typen anzeigen (entweder fix oder durch auslesen der Typen und Filterung nach den Typen welche das Interface unterstützen).

Die Erstellung des Objektes passiert ebenfalls im TypeConverter (entweder mit dem Default-Constructor oder mittels InstanceDescriptor) (siehe den Link von mir)

Anschliessend hast Du die Instanz und kannst dann noch die Parameter einstellen.

Gruss
Programmierhans

17.12.2010 - 20:27 Uhr

Stichworte für Deine Suche:

TypeConverter
GetStandardValues
Assembly.GetTypes

Nachtrag: Gewusst wie: Implementieren eines Typkonverters

13.12.2010 - 20:06 Uhr

Code angepasst (siehe oben) damit auch selektierte Items richtig gezeichnet werden.

13.12.2010 - 08:51 Uhr

Ich habe immer Ideen 😃

Aber das kriegt ihr auch ohne meine Hilfe zum Laufen

Gruss
Programmierhans

12.12.2010 - 20:58 Uhr

Weiterer interessanter Link wie extrahiere ich Icon's aus Dll's.

StolenIcon

Programmierhans

10.12.2010 - 15:20 Uhr

Verstehe eh nicht wieso Leute Console.WriteLine verwenden...

Wieso nicht System.Diagnostics.Debug.WriteLine ... dann hast Du nie solche Problems.

10.12.2010 - 15:19 Uhr

@Th69:

Probleme gibt es nur noch bei der SetModified()-Methode. Er markiert die betreffenden Datenzeilen zwar, aber schreibt diese Datenzeilen bzw. die Änderungen nicht in die zweite Datenbank.

Stimmen die Keys überein ?... Du musst gut aufpassen... falls in beiden DB's modifiziert werden kann, dann stimmen diese ev. nicht... Zudem was soll passieren wenn ein Record auf einer Seite gelöscht wird ? usw.

Es wird ein Update - Statement abgesetzt und das kann nichts updaten wenn er den record nicht findet...

10.12.2010 - 13:17 Uhr

Benutz die Suchfunktion (wurde schon oft diskutiert) und poste die besten Treffer hier.

Gruss
Programmierhans

10.12.2010 - 11:39 Uhr

Ein Workaround wäre natürlich periodisch GC.Collect() aufzurufen. Was haltet ihr davon?

Sollte man nicht tun (ausser beim Testen damit Du schneller siehst ob Du ein Leak hast... resp. damit Du es eingrenzen kannst).

Nachtrag: Hast Du in den .Net-Proxies IDisposable implementiert ?

09.12.2010 - 13:45 Uhr

Die aus der anderen DB kommende DataTable enthält laut der "Prüfung" mit GetChanges() keine Änderungen. Nun ist die Frage, ob man die irgendwie Markieren oder ein Flag setzten kann, sodass diese auch als Änderung angesehen werden und somit auch in die DB geschrieben werden.

DataRow.BeginEdit / DataRow.EndEdit schon probiert ?

09.12.2010 - 09:57 Uhr

Mach es doch im Tile-Modus.

Nur als kurzes Beispiel damit Du weisst was ich meine.


this.listView1.TileSize=new Size(300,300);
this.listView1.View=View.Tile;


   private void listView1_DrawItem(object sender, DrawListViewItemEventArgs e)
        {
            if (this.listView1.View == View.Tile)
            {
                e.Graphics.DrawImage(Image.FromFile(e.Item.Text), e.Bounds);
            }
            else
            {
                e.DrawDefault = true;
            }
        }


08.12.2010 - 21:31 Uhr

Ich habe selber noch nie mit der ListView gearbeitet.

Gemäss Doku hast Du im DrawItem-Event ein DrawListViewItemEventArgs.

Mit e.Bounds kriegst Du die Grösse in welcher Du zeichnen darfst (Bereich für genau dieses Item).

Jetzt hast Du nur noch die Wahl die Bilder entweder verzerrt darzustellen oder mit einem passenden Verhältnis aber leeren Rand.

Müsste eigentlich ganz einfach sein dies auch in der ListView zu implementieren.

Den Link auf mein Beispiel welches aber auf der ListBox basiert hast Du ja schon.

Gruss
Programmierhans

08.12.2010 - 17:01 Uhr

In meinem Beispiel wird in der ListBox in fixer Grösse gezeichnet... Die Bilder werden dynamisch auf diese Grösse skaliert...

Wenn Du es nicht anschauen willst.... Deine Entscheidung.

Gruss
Programmierhans

08.12.2010 - 16:49 Uhr

es geht um ein control in einer fremden applikation

Hmm steht das irgendwo ? falls ja, dann habe ich es überlesen.

Gruss
Programmierhans

08.12.2010 - 16:41 Uhr

an alle anderen die mich auf die faq hinweisen wollen, lasst es einfach

Werden wir sicher nicht lassen 😃

Wenn Du schon an so einfachen Sachen scheiterst, dann solltest Du Dich vielleicht ein wenig mehr anstrengen und Dir die Grundlagen selber erarbeiten... Wenn Dir die Motivation dazu fehlt, dann hinterfrage mal ob Du wirklich die richtige Ausbildung machst .

Gruss
Programmierhans

08.12.2010 - 16:31 Uhr

Nur noch am Rande erwähnt:

Wenn ein Form mit ShowDialog angezeigt wird, dann disposed es sich NICHT selber... somit muss so was theoretisch nur dann implementiert werden wenn die Forms NICHT modal angezeigt werden.

08.12.2010 - 16:24 Uhr

Habe ich mal für eine ListBox geschrieben... kannst entweder diese verwenden oder Code daraus verwenden.

ImageListBox

Gruss
Programmierhans

08.12.2010 - 16:17 Uhr

Formular/Control drucken oder als Bitmap speichern

Der unsichtbare Bereich wird aber natürlich nicht übernommen ... .Net rendert meines Wissens immer nur den sichtbaren Bereich.

08.12.2010 - 13:09 Uhr

Bitte erst mal FAQ lesen !!

[Hinweis] Wie poste ich richtig?

z.B: verstösst Du mindestens gegen 4a,4c,5

08.12.2010 - 11:28 Uhr

Häng dich in den FormClosing-Event des Forms.

Könnte in etwa so funktionieren..


if (e.CloseReason==CloseReason.UserClosing)
{
   this.Hide();
   e.Cancel=true;
}

PS: Halte ich für einen Bad-Style

Gruss
Programmierhans

07.12.2010 - 19:57 Uhr

Du erstellst auf der ersten Zeile in Form1 ein Instanz der Klasse...

Hast darin aber die Werte statisch definiert...

Sorry das sind Grundlagen...

Dieser Thread wird eh gleich geschlossen 😃

07.12.2010 - 19:55 Uhr

Bemühe mal die Suche... such nach "PropertyGrid TypeConverter"

03.12.2010 - 20:52 Uhr

Mach vor dem Update mal ein GetChanges der Tabelle um zu sehen ob da überhaupt Aenderungen drin sind.

03.12.2010 - 16:11 Uhr

Verwendest Du ev. ein AcceptChanges vor dem Update (dann ist nix mehr mit updaten ...)

02.12.2010 - 22:31 Uhr

Du hast einen Link auf ein einfaches Sample und auf die FAQ.

Schau es Dir an (im Debugger) und zieh Deine Schlüsse daraus...

30.11.2010 - 20:38 Uhr

Ansonsten schau Dir den Link mal an... dann hast Du ein lauffähiges Sample und wirst dann sicher schnell allfällige Differenzen erkennen.

[FAQ] TcpClient einfaches Beispiel

30.11.2010 - 17:11 Uhr

Wieso ziehst Du Dir im LaufendeSimulationen die Liste der Files zweimal ?

ein simples return di.GetFiles().Length würde doch auch reichen.

30.11.2010 - 16:51 Uhr

MoveFile (Directory.Move ruft den intern auf) könnte dies eigentlich auch... sehr schräg dass das in .Net abgefangen und mit einem Raise quittiert wird.

30.11.2010 - 15:23 Uhr
System.IO.Directory.Move(sourcePath, destinationPath);

Nächstes mal schaust Du bitte selber in die Doku !!

Edit: Ups kann sein dass dies wirklich nicht funzt...Da war ich wohl vorlaut (schäm). Hätte ich jetzt selber nicht erwartet (macht auch keinen Sinn).... jedenfalls ist im MSDN-Beispiel die IOException abgefangen mit dem Text:" An attempt was made to move a direcotry to a different volume... " usw...

30.11.2010 - 11:42 Uhr

Im Grunde wäre mein Favorit der 30 Zöller mit 2560x1600 von Programmierhans. Ich liebäugele schon lange mit einer solchen Lösung. Den gegenüber zwei 24 Zöllern höheren Preis würde ich sogar in Kauf nehmen. Nur will ich mir als Gelegenheitsspieler nicht unbedingt eine Highend-Grafikkarte in den Rechner stecken, nur um die hohe Auflösung bedienen zu können. Uns selbst mit der Highend-Karte ist nicht gesagt, dass - insbesondere altere - Spiele diese Auflösung überhaupt unterstützen. Die Alternative, auf einem so großen Schirm mit einer niedrigeren als der physischen Auslösung zu spielen, sähe vermutlich alles andere als prickelnd aus, oder man müsste zumindest einen riesigen schwarzen Rand/Rahmen in Kauf nehmen.

Habe auch nur eine 9600GT von NVIDIA drin die reicht mir für alle Anwendungen (3 verschiedene Modellflug-Simulatoren)... Und ja wenn man mal z.B: 1280*800 runter muss, dann sieht es echt Scheisse aus.

29.11.2010 - 21:03 Uhr

Ich arbeite auf einem 30" mit 2560*1600. Hätte so auch gar keinen Platz für einen weiteren Monitor.

25.11.2010 - 17:50 Uhr

Genau.

Und falls trotzdem per Reflection, dann richtig.

XY.GetMethod("ToString",new object[]{});
oder so ev. auch (kanns nicht testen)
XY.GetMethod("ToString",Type.EmptyTypes);

25.11.2010 - 15:29 Uhr

@gfoidl

Das Problem bei prozentualen Updates ist, dass auch dann irgendwo der Invoke gemacht werden muss... dieser Invoke bremst dann den calling-Thread trotzdem aus (wenn auch nur 1 mal pro Prozent... ausser natürlich bei einem BeginInvoke).... deshalb habe ich da nicht differenziert. Zudem muss dann natürlich im calling-Context berechnet werden ob geuppt werden soll ... beim Timer fallen alle diese Restrictions weg.

Daher kann es sein, dass die Timer-Variante bei sehr hohem Event-Aufkommen (bei wildem Geballer) ein besseres Verhalten zeigt.

Gruss
Programmierhans

25.11.2010 - 10:58 Uhr

Und du wirst wohl dann nicht drumrum kommen, für deine Fälle das entsprechende Replace zu machen.

Oder er ersetzt alle "\" durch "&quot;

Gruss
Programmierhans

25.11.2010 - 09:32 Uhr

Das mit dem Timer ist zwar eine schöne Idee finde ich aber nicht nötig wenn die Aktualisierung der ProgressBar nur dann stattfindet wenn sich der Prozentwert geändert hat (siehe oben). Das kannst du auch noch anpassen dass zB nur alle 5% eine Aktualisierung durchgeführt wird. Warum willst du also mit dem Timer das ganze noch verkomplizieren (wenn es dir so schon zu kompliziert ist wie du schreibst)?

@gfoidl

Ich habe ihn auf die Idee gebracht mit dem Timer... Der Timer hat nur den Vorteil, dass nicht in jedem call geprüft werden muss ob jetzt die Progressbar geuppt werden soll...

24.11.2010 - 11:12 Uhr
  
DataRow[] drowArray = dataTable.Select(parameter.Name + " = " + parameter.Value.ToString());   
  

Da fehlen meiner Meinung nach die Hochkommas.


DataRow[] drowArray = dataTable.Select(string.Format("{0}='{1}'",parameter.Name,parameter.Value.ToString())); 

23.11.2010 - 16:05 Uhr

Bitte beachte [Hinweis] Wie poste ich richtig? Punkt 1.1.1

Schau Dir die Klassen DateTime und TimeSpan an dann hast Du alles was Du brauchst.

22.11.2010 - 20:11 Uhr

Vermutlich hattest Du einen Error Creating Window-Handle gekriegt.... ganz übler Fehler

Wenn es zwingend nach TextBox aussehen MUSS, dann schau Dir System.Windows.Forms.ControlPaint an.

21.11.2010 - 20:18 Uhr

Der Code läuft aber nur wenn die Sonne scheint (Schönwettercode).

Wenn du theoretisch als Antwort 2 Pakete erwarten darfst, dann heisst dies noch nicht, dass Du dann auch direkt beide erhälst. UDP ist verbindungslos... du erhälst entweder nichts oder beide oder auch nur ein Paket... wobei dieses eine entweder das erste oder das zweite erwartete Paket sein kann.... halt je nach Last auf dem Weg von deinem Rechner zum Zielrechner.

Statt 1 oder 2 Pakete gezielt abzufangen kannst du so was in einer Schlaufe bauen.
Eingegangene Daten z.B: an eine List<Byte> anhängen. Anschliessend kannst Du den erhaltenen Inhalt der List<Byte> in einen String umwandeln (Clear der Liste aufrufen wenn Du die Daten sauber verabeiten kannst).

Der Code wird kürzer lesbarer und weniger anfällig für Fehler.

20.11.2010 - 23:14 Uhr

Eine Möglichkeit habe ich ja schon beschrieben.

Es gibt natürlich auch noch andere Alternativen wie z.B:

Erstelle eine von Progressbar abgeleitete Klasse. Diese verwendet intern einen Timer welcher z.B: alle 200 ms tickt.

Dazu eine interne Variable für den aktuellen Value. Diese Variable kann von aussen per Property aus jedem Thread gesetzt werden (Variable kann als volatile angelegt werden)).

Der Timer liest sich zyklisch den Wert der Variable und schreibt diesen in den base.Value.

Auch bei einem Event-Geballer aktualisiert sich die Progressbar nur 5 mal pro Sekunde. Die Anzeige ist jeweils maximal 200 ms hinter der aktuellen Berechnung aktualisiert... müsste passen.

Dieses Vorgehen hat den Vorteil, dass der Setter der Variable NIE den aufrufenden Thread blockt (ich persönlich würde sogar auf eine Thread-Synch verzichten). Somit ist die ganze Spassbremse weg und die Progressbar bremst den Aufrufer nicht aus.

Programmierhans