Willkommen auf myCSharp.de! Anmelden | kostenlos registrieren
 | Suche | FAQ

Hauptmenü
myCSharp.de
» Startseite
» Forum
» Suche
» Regeln
» Wie poste ich richtig?

Mitglieder
» Liste / Suche
» Wer ist online?

Ressourcen
» FAQ
» Artikel
» C#-Snippets
» Jobbörse
» Microsoft Docs

Team
» Kontakt
» Cookies
» Spenden
» Datenschutz
» Impressum

  • »
  • Portal
  • |
  • Mitglieder
Beiträge von Spyke
Thema: CefSharp aus Unterordner benutzen
Am im Forum: Rund um die Programmierung

schau dir mal das Ereignis
AppDomain.CurrentDomain.AssemblyResolve
an

so könntest du wenn eine DLL anefordert wird die noch von woanders herladen und dort zurück geben.

sowas ähnliches muss ich bei uns auch machen da wir eine dritt componente haben die in einer älteren und einer neueren Version laufen muss und der dateiname selbst sich zwischen den Versionen nicht geändert hat.

Thema: ListView VirtualMode - Wie debugge ich eine InvalidOperationException?
Am im Forum: GUI: Windows-Forms

abonnier die Ereignisse ThreadException und UnhandledException.
Eventuell bekomsmte da den richtigen fehler raus.

kurz beispiel

        static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.ThreadException += new ThreadExceptionEventHandler(Program.Application_ThreadException);
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Program.CurrentDomain_UnhandledException);

        ...
        }

        private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
        {
            MeineMsgBox.Show(e.Exception, "Ein unbehandelter Fehler ist aufgetreten!", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
        }

        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            if (e.ExceptionObject is Exception)
            {
                MeineMsgBox.Show(e.ExceptionObject as Exception, "Ein unbehandelter Fehler ist aufgetreten!", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1);
            }
        }

P.S.: MeineMsgBox ist eine eigene MessageBox (nicht vom Framework)

Thema: Verweise auf .net Dll bringt Versionsfehler - Wie mache ich das Versionsunabhängig?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

dll als strongname erstellen bringt auch schonmal eine kleine sicherheit

Thema: Verweise auf .net Dll bringt Versionsfehler - Wie mache ich das Versionsunabhängig?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Ich vermute mal du hast die AssemblyVersion erhöht.
Erhöhe nur dei Dateiversion dann sollte ein austausch/aktualisierung problemlos möglich sein.

Thema: Variable größe eines Spielfelds durch einzelne PictureBox oder Panel etc. möglich? >Wie Screenshot<
Am im Forum: GUI: Windows-Forms

Über das Paint Ereignis des Controls welches das Spielfeld darstellen soll (z.B. PictureBox, Panel etc) selber zeichnen.

Über das PaintEventArgs des Paint Ereignis kommst du auf das Graphics objekt mit diesem eifnach mittels FillRectangle oder DrawRetangle die einzelnen Felder zeichnen.

Da du feste größen hast ist das zeichnen eigentlich auch ziemlich einfach (das ermitteln der X, Y Koordinaten eines Feldes).
Horizontal FeldNr * 16
Vertikale FeldNr * 16

Thema: TextBox ControlStyles.UserPaint with TextAlign?
Am im Forum: GUI: Windows-Forms

Use the DrawString Methode with parameter for rectangle and StringFormat.
With StringFormat you can set the alignment.
https://msdn.microsoft.com/de-de/library/21kdfbzs%28v=vs.110%29.aspxhttps://msdn.microsoft.com/de-de/library/system.drawing.stringformat.alignment%28v=vs.110%29.aspx

Thema: C# CSV auslesen und in der Console als Tabelle anzeigen
Am im Forum: Grundlagen von C#

Zum auslesen einer CSV aus dem .Net Framework die Klasse TextFieldParser.

Assembly: Microsoft.VisualBasic
Namespace: Microsoft.VisualBasic.FileIO

zum zeichnen einer Tabelle in der Console zum Beispiel mittels SetCursorPositionhttps://msdn.microsoft.com/de-de/library/system.console.cursorleft%28v=vs.110%29.aspx?cs-save-lang=1&cs-lang=csharp#code-snippet-2

Thema: Hashtable stürzt bei Abfrage eines bestimmten Keys ab
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Logischer Schluss.
artikel braucht als Key shape
kracht aber nicht mehr wenn punkt und komma ausgetauscht wird.

Im gezeigten Code schiens erstmal die einzige logische stelle zu sein bei der es krachen könnte.

Die einzige unbekannte war der Typ von artikel, ob dieser einfach null liefert (bei unbekannten Keys) (was er wohl macht) oder ArgumentException/IndexOutOfRangeException etc. schmeißt

Thema: Hashtable stürzt bei Abfrage eines bestimmten Keys ab
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Könnte hier das Problem sein:

shapes_not_checked.Rows.Add(shape,artikel[shape].ToString());

und zwar das
artikel[shape]
null liefert, gerade da du dort die Einträge als Punkt drin hast und mit Komma entsprechend nixs gefunden wurde ???

(Würd mich nur grad so interessiern obs das is)

Thema: Einlesen von CSV über OleDb mit Anführungszeichen
Am im Forum: Grundlagen von C#

Ich verwende für CSV eigentlich immer aus dem .Net Framework den TextFieldParser.

Assembly: Microsoft.VisualBasic
Namespace: Microsoft.VisualBasic.FileIO

Vielleicht klappts mit dem.

Thema: PropertyGrid UserControl mit Custom Property
Am im Forum: GUI: Windows-Forms

Deine Log Klasse hat nur Felder.
PropertyGrid geht auf Eigenschaften.

Nachtrag:
Wenn man standard verhalten des PropertyGrid nutzen will ohne mit TypeConverter etc. das händisch nach zu bilden.

Thema: Best Practice um Dokumente oder Reports zu erstellen
Am im Forum: Rund um die Programmierung

Erstmal vorweg, eine Fibu programmiert man nicht einfach so ich würde raten bestehende Software von entsprechende Anbieter zu nehmen.
Wenn ich dran denke was es für unterschiedliche Steuerschlüssel gibt und je nach Ist- oder Solversteuerung wird die Steuer entsprechend anders berechnet.

Darüber hinaus müsste ja auch noch irgendwie die E-Bilanz übertragen werden, das heißt man bräuchte auch noch ein Abschlussprogramm (was eigentlich wie Fibu läuft aber doch andere ansätze hat).
Und die E-Bilanz Umsetzung, ist auch kein Pappenspiel, mal davon abgesehen das die Finanzverwaltung gerne mal an den Keys rumspielt, und es gibt so kleinigkeiten wie ev. Kapitalkontenentwicklung (jetzt für Wirtschaftsjahre 2015 neu, mit entsprechender Rechtsform).

Oder aber du müsstest entsprechend die Datensätze für deinen Steuerberater bereitstellen das er das dann in seine Software die Erfassungen übernehmen kann (oder entsprechend bereitstellen für ev selbst gekaufte "weiterführende" Software)

Da es hier um deine Firma geht, überleg dir besser ob du das wagen willst.

Ich persönlich verwende für normalen Druck C1PrintDocument von ComponentOne.
Für einen RTF/Word ähnlich Bericht wird alles dann eher mit TXTextControl gerendert.
(Beides kostenpflichtig)

(Öfters mal auch beides kombiniert)

Thema: Debugger Breakpoints haben keine Wirkung
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Laufen eventuell noch andere externe debugger, verifier oder so?

Thema: [erledigt]Roter Rahmen um TextBox nach fehlgeschlagener Validierung
Am im Forum: GUI: Windows-Forms

Per NativeWindow an die WndProc der TextBox hängen.

bissel abgespeckte Version meines NativeWindow


        internal sealed class NativeTextPaint : NativeWindow, IDisposable
        {
            internal NativeTextPaint(TextBox textBox)
            {
                this.textBox = textBox;

                this.AssignHandle(textBox.Handle);
            }

            protected override void WndProc(ref Message m)
            {
                if (isDisposed)
                    base.WndProc(ref m);
                else
                {
                    switch (m.Msg)
                    {
                        case 15: // this is the WM_PAINT message
                            //textBox.Invalidate();
                            // call the default win32 Paint method for the TextBox first
                            base.WndProc(ref m);
                            // draw extra stuff over the TextBox
                            this.Paint();
                            break;
                        default:
                            base.WndProc(ref m);
                            break;
                    }
                }
            }

            private void Paint()
            {
                using (Graphics textBoxGraphics = Graphics.FromHwnd(textBox.Handle))
                {
                   // --- hier zeichnen ---
                }
            }


            public void Dispose()
            {
                if (!isDisposed)
                {
                    ReleaseHandle();

                    textBox = null;

                    GC.SuppressFinalize(this);

                    isDisposed = true;
                }
            }

            private TextBox textBox;
            private bool isDisposed;
        }

Thema: Wie erzeuge ich Referenz auf Value-Typ?
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

Meistens wird ja der ValueType in einer extra Methode entsprechend angepasst
und da reicht ja die einfache ref Angabe im Parameter

Thema: Nach Zeilenumbruch in RichTextBox suchen
Am im Forum: GUI: Windows-Forms

Vielleicht liefert dir die Eigenschaft Lines auch schon das was du genau benötigst:https://msdn.microsoft.com/de-de/library/system.windows.forms.textboxbase.lines%28v=vs.110%29.aspx

Thema: WinForms: (Re)use BindingSource
Am im Forum: GUI: Windows-Forms

Du darst die DataSource der BindingSource nicht auf null setzen, dadurch gehen bindungen verloren.
Zum zurücksetzen dann am besten

bindingSource.DataSource = typeof(meineKlasse);

Thema: Umstieg von 2010 auf 2013 -> Toolbox -> Controls deaktiviert.
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Wenn du in Visual Studio den Windows Forms Designer aufrufst.
Hast du ja die Toolbox von der du aus Controls auf den Designer ziehen kannst.

Wenn ich in dieser Toolbox nun einen neuen Tab Anlegen
und dort dann meine DLLs auswähle (Choose Items).
Sollte ich ja jetzt in der Toolbox meine eigenen geschrieben Controls zur Verfügung haben.

Diese tauchen aber dort nicht auf, erst über "Show All" (im ContextMenü der Toolbox).
Dort sieht man dann das meine Controls inaktiv sind (werden so leicht gräulich dargestellt).

Und ich erkenne nicht was andere anders machen das deren Controls normal in der Toolbox zur Verfügung stehen.

Und diese DLLs wurden alle noch mit VS 2010 erstellt,
einige schon mit VS 2013 neu compiliert, aber selbst da sind die Controls noch inaktiv.

Irgendwie überseh ich da gerade irgendwas.

Und wie gesagt bei Kollegen bei dennen VS 2010 und VS 2013 auf dem Rechner installiert ist besteht das problem nicht.
Nur anscheinend wenn man nur noch VS 2013 installiert hat.

Thema: Umstieg von 2010 auf 2013 -> Toolbox -> Controls deaktiviert.
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Vielleicht hat ja jetzt jemand ne Idee.

Das komische ist Drittanbieter Controls haben anscheinend nicht so diese Probleme,
ich konnte jetzt aber im Reflector nicht erkennen was die anders machen.

Zur Zeit lege ich die Controls händig in der Designer.cs an.

Thema: Umstieg von 2010 auf 2013 -> Toolbox -> Controls deaktiviert.
Am im Forum: Entwicklungs- und Laufzeitumgebung (Infrastruktur)

Hi,

ich hab bei mir 2010 deinstalliert und 2013 installiert.

Wenn ich jetzt in 2013 in die Toolbox DLL's in den designer reinziehe, die ich damals mit 2010 erstellt habe, werden diese Controls in der Toolbox deaktiviert (sind nicht auswählbar, sieht man auch erst über "Show All").

Es komt auch eine Meldung beim hinzufügen der DLL in die Toolbox:

Zitat
make sure the controls to add are compatible with the current designer and .net framework version

Hab ich die Projekte der entsprechenden DLL's direkt in der Solution mit drinne, kann ich die dortigen Controls auch normal aus der Toolbox in den designer ziehen.

Ich kann die Controls auch normal händisch per Code anlegen, und läuft auch alles.

Nur in der Toolbox selber sind diese aus irgendeinem Grund deaktiviert,
wenn ich dort die DLL über über den lokalen Pfad anhefte.

Ein andere Kollege hat das gleiche Problem und er hat bei sich auch 2010 deinstalliert.
Bei Kollegen bei dennen VS 2010 und VS 2013 parallel läuft scheint dieses Problem nicht aufzutreten.

Weiß irgendwer wie ich es schaffen kann das meine 2010 DLL's in 2013 laufen ohne direkt die Projekte der Solution hinzufügen zu müssen?

Alle Projekte und DLL's (auch die 2013er) sind in .Net 2.0 kompiliert.
Es handelt sich um Windows Forms DLL's/Projekte.

Thema: PostgreSQL - Verbindung zur Datenbank
Am im Forum: Grundlagen von C#

Such mal nach npgsql, das verwenden wir auch für postgre Zugriff.

Thema: TextBox "Beispieltext" in hellgrau, verschwindet wenn man die TextBox anklickt?
Am im Forum: GUI: Windows-Forms

Im Link von Coffeebean die Antwort mit CueBanner ist das was du suchst.
(EM_SETCUEBANNER)

Thema: Exception aus BackgroundWork an Hauptanwendung
Am im Forum: Basistechnologien und allgemeine .NET-Klassen

in deinem Beispielcode befindest du dich immer noch im MainThread
(ich seh da erstmal keine Background Thread)
du solltest wenn möglich die Exception in FormApl abfangen

ansosnten ev. noch folgende Events abonnieren für Exceptions die dir durch die lappen gehen:

Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

Thema: Rechteck farbig per Mouseclick
Am im Forum: GUI: Windows-Forms

Springt der Debugger den in das Click Ereignis wenn du dort einen Breakpoint setzt?
Hat dein Formular Steuerelemente?
Denn dann werten diese das Click Ereignis aus und dein Formular bekommt erstmal nixs mit davon.

Thema: Rechteck farbig per Mouseclick
Am im Forum: GUI: Windows-Forms

private void Form1_MouseClick(object sender, MouseEventArgs f, System.Windows.Forms.PaintEventArgs e)

Ist keine standard methode von .Net die für Ereignisse aufrufe hergenommen wird/werden kann.

Du musst dir den Mausbereich im MouseCklick merken.
Invalidate aufrufen, damit das Formular weiß das es sich neu zeichnen soll.
Und im Paint Ereignis mit den germerkten Bereichen zeichnen.

Thema: Würfel-Zufall macht zu oft "1"
Am im Forum: GUI: Windows-Forms

Instanziiere nur einmal dice1 (dein Random Objekt) (z.B. als privates Feld in deiner Form) und nimm immer dieses Objekt zum liefern der Zufallszahl her.

Ist glaube ich ein bekanntes problem von Random, wenn es zu oft hintereinander neu angefordert wird das dann immer der gleiche Wert geliefert wird.

Thema: PropertyGrid: Editor auch per Klick öffnen
Am im Forum: GUI: Windows-Forms

Wie meinst du das mit beim Click ausführen?
Ich hab mal ein propertyGrid mittels C1FlexGrid selbst gebastelt, und dafür folgende Klassen angelegt:

Basisklasse für TypceConverter und UITypeEditor Handling

   /// <summary>
    /// Basisklasse für <see cref="PropertiesControlTypeConverter"/> und <see cref="PropertiesControlUITypeEditor"/>
    /// </summary>
    internal class PropertiesControlTypeDescriptorContext : ITypeDescriptorContext, IServiceProvider, IDisposable
    {
        protected PropertiesControlTypeDescriptorContext(object instance)
        {
            this.instance = instance;

            this.propertyDescriptors = new Dictionary<string, PropertyDescriptor>();
            foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(instance))
                propertyDescriptors.Add(pd.Name, pd);
        }

        /// <summary>
        /// wechselt akt. zu bearbeitende Eigenschaft
        /// </summary>
        /// <param name="propertyName">name der Eigenschaft die jetzt bearbeitet werden soll</param>
        internal void SetCurrentProperty(string propertyName)
        {
            propertyDescriptors.TryGetValue(propertyName, out propertyDescriptor);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                propertyDescriptors.Clear();

                propertyDescriptor = null;

                GC.SuppressFinalize(this);
            }
        }

        #region IDisposable Members

        /// <summary>
        /// Ressourcen freigeben
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
        }

        #endregion

        #region Statische Methoden

        /// <summary>
        /// liefert <see cref="PropertyDescriptor"/> für angegebene Eigenschaft
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft kommt</param>
        /// <param name="propertyName">name der Eigenschaft für das <see cref="PropertyDescriptor"/> geliefert werden soll</param>
        /// <returns><see cref="PropertyDescriptor"/> wenn gefunden, sonst null</returns>
        protected static PropertyDescriptor GetPropertyDescriptor(object instance, string propertyName)
        {
            PropertyDescriptorCollection pdc = TypeDescriptor.GetProperties(instance);
            foreach (PropertyDescriptor pd in pdc)
            {
                if (string.Equals(propertyName, pd.Name, StringComparison.OrdinalIgnoreCase))
                    return pd;
            }
            return null;
        }

        #endregion

        #region ITypeDescriptorContext Members

        /// <summary>
        /// Gets the container representing this System.ComponentModel.TypeDescriptor  { get; }
        /// </summary>
        public IContainer Container
        {
            get { return null; }
        }

        /// <summary>
        /// Gets the object that is connected with this type descriptor request  { get; }
        /// </summary>
        public object Instance
        {
            get { return instance; }
        }

        /// <summary>
        /// Not Implemented
        /// </summary>
        public void OnComponentChanged()
        {
            throw new NotImplementedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// Not Implemented
        /// </summary>
        /// <returns></returns>
        public bool OnComponentChanging()
        {
            throw new NotImplementedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// Gets the System.ComponentModel.PropertyDescriptor that is associated with the given context item.  { get; }
        /// </summary>
        public PropertyDescriptor PropertyDescriptor
        {
            get { return propertyDescriptor; }
        }

        #endregion

        #region IServiceProvider Members

        /// <summary>
        /// Gets the service object of the specified type.
        /// </summary>
        /// <param name="serviceType">An object that specifies the type of service object to get.</param>
        /// <returns>A service object of type serviceType.-or- null if there is no service object of type serviceType.</returns>
        public virtual object GetService(Type serviceType)
        {
            if (serviceType == this.GetType())
                return this;

            return null;
        }

        #endregion

        private readonly object instance;
        private readonly Dictionary<string, PropertyDescriptor> propertyDescriptors;

        private PropertyDescriptor propertyDescriptor;
    }

Für UITypeEditor dann:

    internal class PropertiesControlUITypeEditor : PropertiesControlTypeDescriptorContext
    {
        public PropertiesControlUITypeEditor(Control parent, object instance)
            : base(instance)
        {
            this.uiTypeEditors = new Dictionary<string, UITypeEditor>();

            this.parent = parent;
        }

        /// <summary>
        /// liefert akt. <see cref="UITypeEditor"/>
        /// </summary>
        /// <returns></returns>
        private UITypeEditor GetEditor()
        {
            UITypeEditor uite;
            if (!uiTypeEditors.TryGetValue(PropertyDescriptor.Name, out uite))
            {
                uite = GetEditor(Instance, PropertyDescriptor);
                uiTypeEditors.Add(PropertyDescriptor.Name, uite);
            }

            return uite;
        }

        /// <summary>
        /// prüft ob akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>) <see cref="UITypeEditor"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="UITypeEditor"/> ist gesetzt</returns>
        public bool HasEditor()
        {
            return (GetEditor() != null);
        }

        /// <summary>
        /// ruft Editor auf und liefert Wert für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <returns>neue Eigenschaftenwert</returns>
        public object EditValue()
        {
            return GetEditor().EditValue(this, this, PropertyDescriptor.GetValue(Instance));
        }

        public override object GetService(Type serviceType)
        {
            object o = base.GetService(serviceType);
            if (o == null)
            {
                if (serviceType == typeof(System.Windows.Forms.Design.IWindowsFormsEditorService))
                {
                    if (windowsFormsEditorService == null)
                        windowsFormsEditorService = new WindowsFormsEditorService(parent);
                    return windowsFormsEditorService;
                }
            }
            return null;
        }

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

                uiTypeEditors.Clear();
            }

            base.Dispose(disposing);
        }

        #region Statische Methoden

        /// <summary>
        /// liefert <see cref="UITypeEditor"/> wenn gesetzt oder der Type der Eigenschaft dies gesetzt hat sonst null
        /// </summary>
        private static UITypeEditor GetEditor(object instance, PropertyDescriptor propertyDescriptor)
        {
            //EditorAttribute ea = null;
            //foreach (Attribute attr in propertyDescriptor.Attributes)
            //{
            //    if (attr is EditorAttribute)
            //    {
            //        ea = (EditorAttribute)attr;
            //        break;
            //    }
            //}

            //if (ea == null)
            //{
            //    object[] attrs = propertyDescriptor.PropertyType.GetCustomAttributes(typeof(EditorAttribute), true);
            //    if (attrs.GetLength(0) > 0)
            //        ea = (EditorAttribute)attrs[0];
            //}

            //if (ea != null)
            //    return (UITypeEditor)Activator.CreateInstance(Type.GetType(ea.EditorTypeName));

            //return TypeDescriptor.GetEditor(propertyDescriptor.PropertyType, typeof(UITypeEditor)) as UITypeEditor;

            return propertyDescriptor.GetEditor(typeof(UITypeEditor)) as UITypeEditor;
        }

        /// <summary>
        /// prüft ob angegebene Eigenschaft <see cref="TypeConverterAttribute"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="TypeConverterAttribute"/> ist gesetzt</returns>
        public static bool HasEditor(object instance, string propertyName)
        {
            return (GetEditor(instance, GetPropertyDescriptor(instance, propertyName)) != null);
        }

        #endregion

        /// <summary>
        /// <see cref="IWindowsFormsEditorService"/> Klasse zum behandeln des <see cref="UITypeEditor"/>
        /// </summary>
        private class WindowsFormsEditorService : System.Windows.Forms.Design.IWindowsFormsEditorService, IDisposable
        {
            internal WindowsFormsEditorService(Control parent)
            {
                this.parent = parent;
            }

            #region IWindowsFormsEditorService Members

            public void CloseDropDown()
            {
                if (dropDownControl != null)
                {
                    dropDownControl.Leave -= new EventHandler(control_Leave);

                    parent.Controls.Remove(dropDownControl);
                    dropDownControl = null;
                }
            }

            public void DropDownControl(System.Windows.Forms.Control control)
            {
                CloseDropDown();

                dropDownControl = control;

                parent.Controls.Add(control);

                control.BringToFront();
                control.Location = parent.PointToClient(Control.MousePosition);

                System.Drawing.Rectangle recParent = new System.Drawing.Rectangle(parent.Location, parent.Size);
                System.Drawing.Rectangle recControl = new System.Drawing.Rectangle(control.Location, control.Size);

                while (recParent.Bottom<recControl.Bottom)
                    recControl.Y--;
                while (recParent.Right < recControl.Right)
                    recControl.X--;

                control.Location = recControl.Location;
                control.Focus();

                control.Leave += new EventHandler(control_Leave);

                while (true) //Schleife damit Control nicht sofort wieder verschwindet
                {
                    Application.DoEvents();
                    if (dropDownControl == null)
                        break;
                }
            }

            void control_Leave(object sender, EventArgs e)
            {
                CloseDropDown();
            }

            public System.Windows.Forms.DialogResult ShowDialog(System.Windows.Forms.Form dialog)
            {
                return dialog.ShowDialog();
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
                CloseDropDown();
            }

            #endregion

            private readonly Control parent;
            private Control dropDownControl;
        }

        private readonly Control parent;
        private readonly Dictionary<string, UITypeEditor> uiTypeEditors;

        private WindowsFormsEditorService windowsFormsEditorService;
    }

Für TypeConverter:

   /// <summary>
    /// behandelt die TypeConverter der generierten Eigenschaften für das <see cref="PropertiesControl"/>
    /// </summary>
    internal class PropertiesControlTypeConverter : PropertiesControlTypeDescriptorContext
    {
        internal PropertiesControlTypeConverter(object instance)
            : base(instance)
        {
            this.typeConverters = new Dictionary<string, TypeConverter>();
        }

        /// <summary>
        /// liefert <see cref="TypeConverter"/> für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        private TypeConverter GetConverter()
        {
            TypeConverter tc;
            if (!typeConverters.TryGetValue(PropertyDescriptor.Name, out tc))
            {
                tc = GetConverter(Instance, PropertyDescriptor);
                typeConverters.Add(PropertyDescriptor.Name, tc);
            }
            return tc;
        }


        /// <summary>
        /// prüft ob akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>) <see cref="TypeConverter"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <returns>true - <see cref="TypeConverter"/> ist gesetzt</returns>
        public bool HasConverter()
        {
            return (GetConverter() != null);
        }

        /// <summary>
        /// liefert Wert wie er angezeigt werden muss für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <param name="value">akt. Wert aus Eigenschaft</param>
        /// <returns>Wert für Anzeige</returns>
        public virtual string GetPropertyTextValue(object value)
        {
            string str = null;
            try
            {
                str = GetConverter().ConvertToString(this, value);
            }
            catch (Exception)
            {
                //Exception durchfallen lassen kommt von Microsoft (aus: System.Windows.Forms.PropertyGridInternal.GridEntry.GetPropertyTextValue)
            }
            if (str == null)
            {
                str = string.Empty;
            }
            return str;
        }

        /// <summary>
        /// liefert Wert wie er in die Eigenschaft zurück geschrieben werden muss für akt. Eigenschaft (Eigenschaft wird gesetzt über <see cref="PropertiesControlTypeDescriptorContext.SetCurrentProperty"/>)
        /// </summary>
        /// <param name="str">akt. Wert laut Anzeige</param>
        /// <returns>Wert für Eigenschaft</returns>
        public virtual object SetPropertyTextValue(string str)
        {
            TypeConverter tc = GetConverter();
            if (tc.CanConvertFrom(this, typeof(string)))
            {
                return tc.ConvertFromString(this, str);
            }
            return str;
        }

        /// <summary>
        /// Returns whether this object supports a standard set of values that can be picked from a list, using the specified context.
        /// </summary>
        /// <returns>true if System.ComponentModel.TypeConverter.GetStandardValues() should be called to find a common set of values the object supports; otherwise, false.</returns>
        public bool GetStandardValuesSupported()
        {
            return GetConverter().GetStandardValuesSupported(this);
        }

        /// <summary>
        /// Returns a collection of standard values for the data type this type converter is designed for when provided with a format context.
        /// </summary>
        /// <returns>A ICollection that holds a standard set of valid values, or null if the data type does not support a standard set of values.</returns>
        public ICollection GetStandardValues()
        {
            return GetConverter().GetStandardValues(this);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
                typeConverters.Clear();

            base.Dispose(disposing);
        }

        #region Statische Methoden

        /// <summary>
        /// liefert eine <see cref="TypeConverterAttribute"/> wenn gesetzt oder der Type der Eigenschaft dies gesetzt hat sonst null
        /// </summary>
        private static TypeConverter GetConverter(object instance, PropertyDescriptor propertyDescriptor)
        {
            //TypeConverterAttribute tca = null;
            //foreach (Attribute attr in propertyDescriptor.Attributes)
            //{
            //    if (attr is TypeConverterAttribute)
            //    {
            //        tca = (TypeConverterAttribute)attr;
            //        break;
            //    }
            //}

            //if (tca == null)
            //{
            //    object[] attrs = propertyDescriptor.PropertyType.GetCustomAttributes(typeof(TypeConverterAttribute), true);
            //    if (attrs.GetLength(0) > 0)
            //        tca = (TypeConverterAttribute)attrs[0];
            //}

            //if (tca != null)
            //{
            //    try
            //    {
            //        return (TypeConverter)Activator.CreateInstance(Type.GetType(tca.ConverterTypeName));
            //    }
            //    catch (MissingMethodException) //wenn kein Parameterloser Konstruktor (nur Parameter Type erlaubt)
            //    {
            //        return (TypeConverter)Activator.CreateInstance(Type.GetType(tca.ConverterTypeName), propertyDescriptor.PropertyType);
            //    }
            //}

            //return null;

            return propertyDescriptor.Converter;
        }

        /// <summary>
        /// prüft ob angegebene Eigenschaft <see cref="TypeConverterAttribute"/> gesetzt hat oder dessen Type
        /// </summary>
        /// <param name="instance">Instance aus der Eigenschaft stammt</param>
        /// <param name="propertyName">name der zu prüfenden Eigenschaft</param>
        /// <returns>true - <see cref="TypeConverterAttribute"/> ist gesetzt</returns>
        public static bool HasConverter(object instance, string propertyName)
        {
            return (GetConverter(instance, GetPropertyDescriptor(instance, propertyName)) != null);
        }

        #endregion

        private readonly Dictionary<string, TypeConverter> typeConverters;
    }

Im Prinzip dann nur SetCurrentProperty aufrufen mit HasEditor prüfen ob Editor angegeben wurde und mit EditValue kommt dann der Editor

Thema: Wie löscht die BindingSouce Listenelemente?
Am im Forum: Datentechnologien

du hast die Remove Methode mit new neu angelegt.

Die BindingSource kennt aber höchstens die Remove Methoden der List<T>,
deshalb wurden deine nie ausgelöst.

Thema: Seltsames Verhalten bei Aufruf eines Fensters in externer Assembly
Am im Forum: GUI: Windows-Forms

du musst in ZeigeFenster nicht zwingend Application.Run aufrufen
ein einfaches aufrufen von ShowDialog der form tuts auch.

.Net schaut intern ob schon eine Nachrichtenschleife läuft, wenn nicht wird intern entsprechend eine gestartet.

Thema: Text in TextBox bei Focus markieren
Am im Forum: GUI: Windows-Forms

Das Enter Ereignis beachte ich natürlich auch mit.

Bei meinem Code gings nur noch um das Problem mit dem Mausklick das dort alles selektiert wird und nur wenn vorher noch kein Focus auf der Textbox vorhanden war.

Sry hat ich vergessen mit zu erwähnen.

P.S.: Die Gelbe Schrift ging bissl unter hab auch nicht gemerkt das der Thread schon 8 Jahre oder so alt ist, hatte mich mehr auf die Posts konzentriert.